diff --git a/Cargo.toml b/Cargo.toml
index 28d909aaf3..8b8cd5f994 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -2,7 +2,6 @@
 members = [
     "c2rust",
     "c2rust-transpile",
-    "c2rust-refactor",
     "c2rust-ast-builder",
     "c2rust-ast-exporter",
     "c2rust-ast-printer",
diff --git a/LICENSE b/LICENSE
index 3c28b39d79..47983398f5 100644
--- a/LICENSE
+++ b/LICENSE
@@ -14,3 +14,4 @@ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 Portions of C2Rust are derived from packages written by third parties. The following third party packages are included, and carry their own copyright notices and license terms:
 
 * c2rust-ast-printer. Dual-licensed under Apache 2.0 and MIT, see c2rust-ast-printer/COPYRIGHT for details.
+* prettyplease. Dual-licensed under Apache 2.0 and MIT, see prettyplease/LICENSE-* for details.
diff --git a/c2rust-ast-builder/Cargo.toml b/c2rust-ast-builder/Cargo.toml
index bb71722cce..0c45c56610 100644
--- a/c2rust-ast-builder/Cargo.toml
+++ b/c2rust-ast-builder/Cargo.toml
@@ -11,3 +11,5 @@ repository = "https://github.com/immunant/c2rust"
 description = "Rust AST builder support crate for the C2Rust project"
 
 [dependencies]
+proc-macro2 = { version = "1.0", features = ["span-locations"]}
+syn = { version = "1.0", features = ["full", "proc-macro", "printing"] }
diff --git a/c2rust-ast-builder/src/builder.rs b/c2rust-ast-builder/src/builder.rs
index c7e54a725b..f9cd8598f5 100644
--- a/c2rust-ast-builder/src/builder.rs
+++ b/c2rust-ast-builder/src/builder.rs
@@ -1,17 +1,157 @@
 //! Helpers for building AST nodes.  Normally used by calling `mk().some_node(args...)`.
-use rustc::hir;
-use rustc_target::spec::abi::{self, Abi};
-use std::rc::Rc;
 use std::str;
-use syntax::ast::*;
-use syntax::attr::mk_attr_inner;
-use syntax::token::{self, TokenKind, Token};
-use syntax::ptr::P;
-use syntax::source_map::{dummy_spanned, Span, Spanned, DUMMY_SP};
-use syntax::tokenstream::{DelimSpan, TokenStream, TokenStreamBuilder, TokenTree};
-use syntax::ThinVec;
 
-use into_symbol::IntoSymbol;
+use proc_macro2::{Span, TokenStream, TokenTree};
+use std::default::Default;
+use syn::{*, __private::ToTokens, punctuated::Punctuated};
+use std::iter::FromIterator;
+
+/// a MetaItem that has already been turned into tokens in preparation for being added as an attribute
+pub struct PreparedMetaItem {
+    pub path: Path,
+    pub tokens: TokenStream,
+}
+
+pub mod properties {
+    pub trait ToToken {
+        type Token;
+        fn to_token(&self) -> Option<Self::Token>;
+    }
+    
+#[derive(Debug, Clone)]
+    pub enum Mutability {
+        Mutable,
+        Immutable,
+    }
+    impl ToToken for Mutability {
+        type Token = syn::token::Mut;
+        fn to_token(&self) -> Option<Self::Token> {
+            match self {
+                Mutability::Mutable => Some(Default::default()),
+                Mutability::Immutable => None,
+            }
+        }
+    }
+
+    #[derive(Debug, Clone)]
+    pub enum Unsafety {
+        Normal,
+        Unsafe,
+    }
+    impl ToToken for Unsafety {
+        type Token = syn::token::Unsafe;
+        fn to_token(&self) -> Option<Self::Token> {
+            match self {
+                Unsafety::Normal => None,
+                Unsafety::Unsafe => Some(Default::default()),
+            }
+        }
+    }
+
+    #[derive(Debug, Clone)]
+    pub enum Constness {
+        Const,
+        NotConst,
+    }
+    impl ToToken for Constness {
+        type Token = syn::token::Const;
+        fn to_token(&self) -> Option<Self::Token> {
+            match self {
+                Constness::NotConst => None,
+                Constness::Const => Some(Default::default()),
+            }
+        }
+    }
+
+    #[derive(Debug, Clone)]
+    pub enum Movability {
+        Movable,
+        Immovable,
+    }
+    impl ToToken for Movability {
+        type Token = syn::token::Static;
+        fn to_token(&self) -> Option<Self::Token> {
+            match self {
+                Movability::Immovable => Some(Default::default()),
+                Movability::Movable => None,
+            }
+        }
+    }
+
+    #[derive(Debug, Clone)]
+    pub enum IsAsync {
+        Async,
+        NotAsync,
+    }
+    impl ToToken for IsAsync {
+        type Token = syn::token::Async;
+        fn to_token(&self) -> Option<Self::Token> {
+            match self {
+                IsAsync::NotAsync => None,
+                IsAsync::Async => Some(Default::default()),
+            }
+        }
+    }
+
+    #[derive(Debug, Clone)]
+    pub enum Defaultness {
+        Final,
+        Default,
+    }
+    impl ToToken for Defaultness {
+        type Token = syn::token::Default;
+        fn to_token(&self) -> Option<Self::Token> {
+            match self {
+                Defaultness::Final => None,
+                Defaultness::Default => Some(Default::default()),
+            }
+        }
+    }
+}
+
+use self::properties::*;
+
+pub type FnDecl = (Ident, Vec<FnArg>, Option<Variadic>, ReturnType);
+pub type BareFnTyParts = (Vec<BareFnArg>, Option<Variadic>, ReturnType);
+
+pub enum CaptureBy {
+    Value,
+    Ref,
+}
+
+#[derive(Debug, Clone)]
+pub enum Extern {
+    None,
+    Implicit,
+    Explicit(String),
+}
+
+//const Async : IsAsync = Some(Default::default());
+
+pub enum SelfKind {
+    Value(Mutability),
+    Region(Lifetime, Mutability),
+}
+
+fn use_tree_with_prefix(prefix: Path, leaf: UseTree) -> UseTree {
+    let mut out = leaf;
+    for seg in prefix.segments.into_iter().rev() {
+        out = UseTree::Path(UsePath {
+            ident: seg.ident,
+            colon2_token: Default::default(),
+            tree: Box::new(out),
+        });
+    }
+    out
+}
+
+fn punct<T, P: Default>(x: Vec<T>) -> Punctuated<T, P> {
+    Punctuated::from_iter(x.into_iter())
+}
+
+fn punct_box<T, P: Default>(x: Vec<Box<T>>) -> Punctuated<T, P> {
+    Punctuated::from_iter(x.into_iter().map(|x| *x))
+}
 
 pub trait Make<T> {
     fn make(self, mk: &Builder) -> T;
@@ -29,58 +169,90 @@ impl<'a, T: Clone> Make<T> for &'a T {
     }
 }
 
-impl<S: IntoSymbol> Make<Ident> for S {
-    fn make(self, _mk: &Builder) -> Ident {
-        Ident::with_dummy_span(self.into_symbol())
+impl Make<Ident> for &str {
+    fn make(self, mk: &Builder) -> Ident {
+        Ident::new(self, mk.span)
+    }
+}
+
+impl Make<Ident> for String {
+    fn make(self, mk: &Builder) -> Ident {
+        Ident::new(&*self, mk.span)
+    }
+}
+
+impl Make<Ident> for &String {
+    fn make(self, mk: &Builder) -> Ident {
+        Ident::new(&*self, mk.span)
     }
 }
 
 impl<L: Make<Ident>> Make<Label> for L {
     fn make(self, mk: &Builder) -> Label {
         Label {
-            ident: self.make(mk),
+            name: Lifetime {
+                apostrophe: mk.span,
+                ident: self.make(mk),
+            },
+            colon_token: token::Colon(mk.span),
         }
     }
 }
 
 impl<'a> Make<Path> for &'a str {
     fn make(self, mk: &Builder) -> Path {
-        vec![self].make(mk)
+        let v = vec![self];
+        Make::<Path>::make(v, mk)
     }
 }
 
 impl<'a> Make<Visibility> for &'a str {
-    fn make(self, _mk: &Builder) -> Visibility {
+    fn make(self, mk_: &Builder) -> Visibility {
         let kind = match self {
-            "pub" => VisibilityKind::Public,
-            "priv" | "" | "inherit" => VisibilityKind::Inherited,
-            "crate" => VisibilityKind::Crate(CrateSugar::JustCrate),
-            "pub(crate)" => VisibilityKind::Crate(CrateSugar::PubCrate),
-            "pub(super)" => VisibilityKind::Restricted {
-                path: P(mk().path("super")),
-                id: DUMMY_NODE_ID,
-            },
+            "pub" => Visibility::Public(VisPublic {
+                pub_token: token::Pub(mk_.span),
+            }),
+            "priv" | "" | "inherit" => Visibility::Inherited,
+            "crate" => Visibility::Crate(VisCrate {
+                crate_token: token::Crate(mk_.span),
+            }),
+            "pub(crate)" => Visibility::Restricted(VisRestricted {
+                pub_token: token::Pub(mk_.span),
+                paren_token: token::Paren(mk_.span),
+                in_token: None,
+                path: Box::new(mk().path("crate")),
+            }),
+            "pub(super)" => Visibility::Restricted(VisRestricted {
+                pub_token: token::Pub(mk_.span),
+                paren_token: token::Paren(mk_.span),
+                in_token: None,
+                path: Box::new(mk().path("super")),
+            }),
             _ => panic!("unrecognized string for Visibility: {:?}", self),
         };
-        dummy_spanned(kind)
+        kind
     }
 }
 
 impl<'a> Make<Abi> for &'a str {
-    fn make(self, _mk: &Builder) -> Abi {
-        abi::lookup(self).expect(&format!("unrecognized string for Abi: {:?}", self))
+    fn make(self, mk: &Builder) -> Abi {
+        Abi {
+            extern_token: token::Extern(mk.span),
+            name: Some(LitStr::new(self, mk.span)),
+        }
+        // TODO: validate string: format!("unrecognized string for Abi: {:?}", self))
     }
 }
 
 impl<'a> Make<Extern> for &'a str {
-    fn make(self, mk: &Builder) -> Extern {
-        Extern::from_abi(Some(mk.clone().str_lit(self)))
+    fn make(self, _mk: &Builder) -> Extern {
+        Extern::Explicit(self.to_owned())
     }
 }
 
 impl<'a> Make<Extern> for Abi {
-    fn make(self, mk: &Builder) -> Extern {
-        Extern::from_abi(Some(mk.clone().str_lit(self.name())))
+    fn make(self, _mk: &Builder) -> Extern {
+        Extern::Explicit(self.name.to_token_stream().to_string())
     }
 }
 
@@ -117,211 +289,182 @@ impl<'a> Make<Constness> for &'a str {
 impl<'a> Make<UnOp> for &'a str {
     fn make(self, _mk: &Builder) -> UnOp {
         match self {
-            "deref" | "*" => UnOp::Deref,
-            "not" | "!" => UnOp::Not,
-            "neg" | "-" => UnOp::Neg,
+            "deref" | "*" => UnOp::Deref(Default::default()),
+            "not" | "!" => UnOp::Not(Default::default()),
+            "neg" | "-" => UnOp::Neg(Default::default()),
             _ => panic!("unrecognized string for UnOp: {:?}", self),
         }
     }
 }
 
-impl<'a> Make<LitIntType> for &'a str {
-    fn make(self, _mk: &Builder) -> LitIntType {
-        match self {
-            "is" | "isize" => LitIntType::Signed(IntTy::Isize),
-            "i8" => LitIntType::Signed(IntTy::I8),
-            "i16" => LitIntType::Signed(IntTy::I16),
-            "i32" => LitIntType::Signed(IntTy::I32),
-            "i64" => LitIntType::Signed(IntTy::I64),
-            "i128" => LitIntType::Signed(IntTy::I128),
-
-            "us" | "usize" => LitIntType::Unsigned(UintTy::Usize),
-            "u8" => LitIntType::Unsigned(UintTy::U8),
-            "u16" => LitIntType::Unsigned(UintTy::U16),
-            "u32" => LitIntType::Unsigned(UintTy::U32),
-            "u64" => LitIntType::Unsigned(UintTy::U64),
-            "u128" => LitIntType::Unsigned(UintTy::U128),
-
-            "" | "unsuffixed" => LitIntType::Unsuffixed,
-
-            _ => panic!("unrecognized string for LitIntType: {:?}", self),
-        }
-    }
-}
-
 impl<I: Make<Ident>> Make<Lifetime> for I {
     fn make(self, mk: &Builder) -> Lifetime {
         Lifetime {
-            id: DUMMY_NODE_ID,
+            apostrophe: mk.span,
             ident: self.make(mk),
         }
     }
 }
 
-impl<'a> Make<LitIntType> for IntTy {
-    fn make(self, _mk: &Builder) -> LitIntType {
-        LitIntType::Signed(self)
-    }
-}
-
-impl<'a> Make<LitIntType> for UintTy {
-    fn make(self, _mk: &Builder) -> LitIntType {
-        LitIntType::Unsigned(self)
-    }
-}
-
-impl Make<Lit> for hir::Lit {
-    fn make(self, _mk: &Builder) -> Lit {
-        Lit {
-            token: self.node.to_lit_token(),
-            kind: self.node,
-            span: self.span,
-        }
-    }
-}
-
 impl<I: Make<Ident>> Make<PathSegment> for I {
     fn make(self, mk: &Builder) -> PathSegment {
         PathSegment {
-            id: DUMMY_NODE_ID,
             ident: self.make(mk),
-            args: None,
+            arguments: PathArguments::None,
         }
     }
 }
 
 impl<S: Make<PathSegment>> Make<Path> for Vec<S> {
     fn make(self, mk: &Builder) -> Path {
+        let mut segments = Punctuated::new();
+        for s in self {
+            let segment = s.make(mk);
+            let has_params = !segment.arguments.is_empty();
+            segments.push(segment);
+            // separate params from their segment with ::
+            if has_params {
+                segments.push_punct(Default::default());
+            }
+        }
         Path {
-            span: DUMMY_SP,
-            segments: self.into_iter().map(|s| s.make(mk)).collect(),
+            leading_colon: None,
+            segments,
         }
     }
 }
 
-//impl Make<TokenStream> for TokenStream {
-//    fn make(self, _mk: &Builder) -> TokenStream {
-//        self.into()
-//    }
-//}
-
 impl Make<TokenStream> for Vec<TokenTree> {
     fn make(self, _mk: &Builder) -> TokenStream {
         self.into_iter().collect::<TokenStream>().into()
     }
 }
 
-impl Make<TokenTree> for Token {
-    fn make(self, _mk: &Builder) -> TokenTree {
-        TokenTree::Token(self)
+impl Make<PathArguments> for AngleBracketedGenericArguments {
+    fn make(self, _mk: &Builder) -> PathArguments {
+        PathArguments::AngleBracketed(self)
     }
 }
 
-impl Make<GenericArgs> for AngleBracketedArgs {
-    fn make(self, _mk: &Builder) -> GenericArgs {
-        AngleBracketed(self)
+impl Make<PathArguments> for ParenthesizedGenericArguments {
+    fn make(self, _mk: &Builder) -> PathArguments {
+        PathArguments::Parenthesized(self)
     }
 }
 
-impl Make<GenericArgs> for ParenthesizedArgs {
-    fn make(self, _mk: &Builder) -> GenericArgs {
-        Parenthesized(self)
+impl Make<GenericArgument> for Box<Type> {
+    fn make(self, _mk: &Builder) -> GenericArgument {
+        GenericArgument::Type(*self)
     }
 }
 
-impl Make<GenericArg> for P<Ty> {
-    fn make(self, _mk: &Builder) -> GenericArg {
-        GenericArg::Type(self)
+impl Make<GenericArgument> for Lifetime {
+    fn make(self, _mk: &Builder) -> GenericArgument {
+        GenericArgument::Lifetime(self)
     }
 }
 
-impl Make<GenericArg> for Lifetime {
-    fn make(self, _mk: &Builder) -> GenericArg {
-        GenericArg::Lifetime(self)
+impl Make<NestedMeta> for Meta {
+    fn make(self, _mk: &Builder) -> NestedMeta {
+        NestedMeta::Meta(self)
     }
 }
 
-impl Make<NestedMetaItem> for MetaItem {
-    fn make(self, _mk: &Builder) -> NestedMetaItem {
-        NestedMetaItem::MetaItem(self)
+impl Make<NestedMeta> for Lit {
+    fn make(self, _mk: &Builder) -> NestedMeta {
+        NestedMeta::Lit(self)
     }
 }
 
-impl Make<NestedMetaItem> for Lit {
-    fn make(self, _mk: &Builder) -> NestedMetaItem {
-        NestedMetaItem::Literal(self)
+impl Make<Lit> for String
+{
+    fn make(self, mk: &Builder) -> Lit
+    {
+        Lit::Str(
+            LitStr::new(&*self, mk.span),
+        )
     }
 }
 
-impl<L: Make<Lit>> Make<MetaItemKind> for L {
-    fn make(self, mk: &Builder) -> MetaItemKind {
-        MetaItemKind::NameValue(self.make(mk))
+impl Make<Lit> for &String
+{
+    fn make(self, mk: &Builder) -> Lit
+    {
+        Lit::Str(
+            LitStr::new(&*self, mk.span),
+        )
     }
 }
 
-impl<'a, S> Make<Lit> for S
-    where S: IntoSymbol
+impl Make<Lit> for &str
 {
     fn make(self, mk: &Builder) -> Lit
     {
-        let s = self.into_symbol();
-        Lit::from_lit_kind(
-            LitKind::Str(s, StrStyle::Cooked),
-            mk.span
+        Lit::Str(
+            LitStr::new(self, mk.span),
         )
     }
 }
 
 impl Make<Lit> for Vec<u8> {
     fn make(self, mk: &Builder) -> Lit {
-        Lit::from_lit_kind(
-            LitKind::ByteStr(Rc::new(self)),
-            mk.span
-        )
+        Lit::ByteStr(LitByteStr::new(&self, mk.span))
     }
 }
 
 impl Make<Lit> for u8 {
     fn make(self, mk: &Builder) -> Lit {
-        Lit::from_lit_kind(
-            LitKind::Byte(self),
-            mk.span
-        )
+        Lit::Byte(LitByte::new(self, mk.span))
     }
 }
 
 impl Make<Lit> for char {
     fn make(self, mk: &Builder) -> Lit {
-        Lit::from_lit_kind(
-            LitKind::Char(self),
-            mk.span
-        )
+        Lit::Char(LitChar::new(self, mk.span))
     }
 }
 
 impl Make<Lit> for u128 {
     fn make(self, mk: &Builder) -> Lit {
-        Lit::from_lit_kind(
-            LitKind::Int(self, LitIntType::Unsuffixed),
-            mk.span
-        )
+        Lit::Int(LitInt::new(&self.to_string(), mk.span))
     }
 }
 
-impl Make<FnSig> for P<FnDecl> {
-    fn make(self, mk: &Builder) -> FnSig {
-        FnSig {
-            header: FnHeader {
-                unsafety: mk.unsafety,
-                asyncness: dummy_spanned(IsAsync::NotAsync),
-                constness: dummy_spanned(mk.constness),
-                ext: mk.ext,
-            },
-            decl: self,
+impl Make<Signature> for Box<FnDecl> {
+    fn make(self, mk: &Builder) -> Signature {
+        let (name, inputs, variadic, output) = *self;
+        Signature {
+            unsafety: mk.unsafety.to_token(),
+            asyncness: IsAsync::NotAsync.to_token(),
+            constness: mk.constness.to_token(),
+            fn_token: token::Fn(mk.span),
+            paren_token: Default::default(),
+            generics: mk.generics.clone(),
+            abi: mk.get_abi_opt(),
+            ident: name,
+            inputs: punct(inputs),
+            variadic,
+            output,
         }
     }
 }
 
+pub trait LitStringable {
+    fn lit_string(self, _: &Builder) -> String;
+}
+
+impl<T> LitStringable for T where T: Make<Type> {
+    fn lit_string(self, b: &Builder) -> String {
+        let ty: Type = self.make(b);
+        ty.to_token_stream().to_string()
+    }
+}
+
+impl LitStringable for &str {
+    fn lit_string(self, _: &Builder) -> String {
+        self.to_string()
+    }
+}
 #[derive(Clone, Debug)]
 pub struct Builder {
     // The builder holds a set of "modifiers", such as visibility and mutability.  Functions for
@@ -335,22 +478,20 @@ pub struct Builder {
     ext: Extern,
     attrs: Vec<Attribute>,
     span: Span,
-    id: NodeId,
 }
 
 #[allow(dead_code)]
 impl Builder {
     pub fn new() -> Builder {
         Builder {
-            vis: dummy_spanned(VisibilityKind::Inherited),
+            vis: Visibility::Inherited,
             mutbl: Mutability::Immutable,
             generics: Generics::default(),
             unsafety: Unsafety::Normal,
             constness: Constness::NotConst,
             ext: Extern::None,
             attrs: Vec::new(),
-            span: DUMMY_SP,
-            id: DUMMY_NODE_ID,
+            span: Span::call_site(),
         }
     }
 
@@ -362,7 +503,8 @@ impl Builder {
     }
 
     pub fn pub_(self) -> Self {
-        self.vis(dummy_spanned(VisibilityKind::Public))
+        let pub_token = token::Pub(self.span);
+        self.vis(Visibility::Public(VisPublic { pub_token }))
     }
 
     pub fn set_mutbl<M: Make<Mutability>>(self, mutbl: M) -> Self {
@@ -411,111 +553,124 @@ impl Builder {
         Builder { span: span, ..self }
     }
 
-    /// Set the `NodeId` of the constructed AST.
-    ///
-    /// **Warning**: Be careful with this option!  Parts of the rewriter expect nodes with matching
-    /// NodeIds to be identical in other ways as well.  For best results, only call this method
-    /// with fresh NodeIds, like those returned by `st.next_node_id()`.
-    pub fn id(self, id: NodeId) -> Self {
-        Builder { id: id, ..self }
+    pub fn prepare_meta_namevalue(&self, mnv: MetaNameValue) -> PreparedMetaItem {
+        let mut tokens = TokenStream::new();
+        mnv.eq_token.to_tokens(&mut tokens);
+        mnv.lit.to_tokens(&mut tokens);
+        
+        PreparedMetaItem {
+            path: mnv.path,
+            tokens,
+        }
+    }
+
+    pub fn prepare_meta_list(&self, list: MetaList) -> PreparedMetaItem {
+        let mut tokens = TokenStream::new();
+        let comma_token = token::Comma(self.span);
+        let mut it = list.nested.into_iter();
+        tokens.extend(Some(proc_macro2::TokenTree::Punct(proc_macro2::Punct::new('(', proc_macro2::Spacing::Alone))).into_iter());
+        if let Some(value) = it.next() {
+            value.to_tokens(&mut tokens);
+        }
+        for value in it {
+            comma_token.to_tokens(&mut tokens);
+            value.to_tokens(&mut tokens);
+        }
+        tokens.extend(Some(proc_macro2::TokenTree::Punct(proc_macro2::Punct::new(')', proc_macro2::Spacing::Alone))).into_iter());
+        PreparedMetaItem {
+            path: list.path,
+            tokens,
+        }
     }
 
-    pub fn str_attr<K, V>(self, key: K, value: V) -> Self
+    pub fn prepare_meta_path<I>(&self, path: I) -> PreparedMetaItem
     where
-        K: Make<Path>,
-        V: IntoSymbol,
+        I: Make<Path>,
     {
-        let key = key.make(&self);
+        let path = path.make(&self);
+        PreparedMetaItem {
+            path,
+            tokens: TokenStream::new(),
+        }
+    }
 
-        let mut attrs = self.attrs;
-        attrs.push(Attribute {
-            id: AttrId(0),
-            style: AttrStyle::Outer,
-            kind: AttrKind::Normal(AttrItem {
-                path: key,
-                args: MacArgs::Eq(
-                    DUMMY_SP,
-                    vec![TokenTree::token(
-                        TokenKind::Literal(token::Lit::new(token::LitKind::Str, value.into_symbol(), None)),
-                        DUMMY_SP
-                    )].into_iter()
-                        .collect(),
-                ),
-            }),
-            span: DUMMY_SP,
-        });
-        Builder {
-            attrs: attrs,
-            ..self
+    pub fn prepare_meta<K>(&self, kind: K) -> PreparedMetaItem
+    where
+        K: Make<Meta>,
+    {
+        let kind: Meta = kind.make(&self);
+        match kind {
+            Meta::List(ml) => self.prepare_meta_list(ml),
+            Meta::NameValue(mnv) => self.prepare_meta_namevalue(mnv),
+            Meta::Path(path) => self.prepare_meta_path(path),
         }
     }
 
-    pub fn single_attr<K>(self, key: K) -> Self
+    pub fn prepare_nested_meta_item<I, K>(&self, path: I, kind: K) -> PreparedMetaItem
     where
-        K: Make<PathSegment>,
+        I: Make<Path>,
+        K: Make<Meta>,
     {
-        let key: Path = vec![key].make(&self);
+        let path = path.make(&self);
+        let kind = kind.make(&self);
+        PreparedMetaItem {
+            path: path,
+            tokens: kind.to_token_stream(),
+        }
+    }
 
+    pub fn prepared_attr(self, prepared: PreparedMetaItem) -> Self {
+        let attr = self.clone().attribute(AttrStyle::Outer, prepared.path, prepared.tokens);
         let mut attrs = self.attrs;
-        attrs.push(Attribute {
-            id: AttrId(0),
-            style: AttrStyle::Outer,
-            kind: AttrKind::Normal(AttrItem {
-                path: key,
-                args: MacArgs::Empty,
-            }),
-            span: DUMMY_SP,
-        });
+        attrs.push(attr);
         Builder {
             attrs: attrs,
             ..self
         }
     }
 
+    pub fn str_attr<K, V>(self, key: K, value: V) -> Self
+    where
+        K: Make<Path>,
+        V: Make<Lit>,
+    {
+        let key = key.make(&self);
+        let value = value.make(&self);
+
+        let mnv = MetaNameValue {
+            path: key,
+            eq_token: token::Eq(self.span),
+            lit: value,
+        };
+        let prepared = self.prepare_meta_namevalue(mnv);
+        self.prepared_attr(prepared)
+    }
+
+    pub fn single_attr<K>(self, key: K) -> Self
+    where
+        K: Make<PathSegment>,
+    {
+        let prepared = self.prepare_meta_path(vec![key]);
+        self.prepared_attr(prepared)
+    }
+
     pub fn call_attr<K, V>(self, func: K, arguments: Vec<V>) -> Self
     where
         K: Make<PathSegment>,
         V: Make<Ident>,
     {
         let func: Path = vec![func].make(&self);
+        let arguments: Vec<_> = arguments.into_iter().map(|x| NestedMeta::Meta(Meta::Path(
+            vec![x.make(&self)].make(&self)
+        ))).collect();
 
-        let args = MacArgs::Delimited(
-            DelimSpan::dummy(),
-            MacDelimiter::Parenthesis,
-            {
-                let mut builder = TokenStreamBuilder::new();
-
-                let mut is_first = true;
-                for argument in arguments {
-                    if is_first {
-                        is_first = false;
-                    } else {
-                        builder.push(TokenTree::token(TokenKind::Comma, DUMMY_SP));
-                    }
-
-                    let argument: Ident = argument.make(&self);
-                    let token_kind = TokenKind::Ident(argument.name, argument.is_raw_guess());
-                    builder.push(TokenTree::token(token_kind, DUMMY_SP));
-                }
-
-                builder.build()
-            },
-        );
-
-        let mut attrs = self.attrs;
-        attrs.push(Attribute {
-            id: AttrId(0),
-            style: AttrStyle::Outer,
-            kind: AttrKind::Normal(AttrItem {
-                path: func,
-                args,
-            }),
-            span: DUMMY_SP,
-        });
-        Builder {
-            attrs: attrs,
-            ..self
-        }
+        let metalist = MetaList {
+            path: func,
+            paren_token: token::Paren(self.span),
+            nested: punct(arguments),
+        };
+        let prepared = self.prepare_meta_list(metalist);
+        self.prepared_attr(prepared)
     }
 
     // Path segments with parameters
@@ -523,44 +678,44 @@ impl Builder {
     pub fn path_segment_with_args<I, P>(self, identifier: I, args: P) -> PathSegment
     where
         I: Make<Ident>,
-        P: Make<GenericArgs>,
+        P: Make<PathArguments>,
     {
         let identifier = identifier.make(&self);
         let args = args.make(&self);
         PathSegment {
-            id: DUMMY_NODE_ID,
             ident: identifier,
-            args: Some(P(args)),
+            arguments: args,
         }
     }
 
-    pub fn parenthesized_args<Ts>(self, tys: Ts) -> ParenthesizedArgs
+    pub fn parenthesized_args<Ts>(self, tys: Ts) -> ParenthesizedGenericArguments
     where
-        Ts: Make<Vec<P<Ty>>>,
+        Ts: Make<Vec<Box<Type>>>,
     {
         let tys = tys.make(&self);
-        ParenthesizedArgs {
-            span: self.span,
-            inputs: tys,
-            output: None,
+        ParenthesizedGenericArguments {
+            paren_token: token::Paren(self.span),
+            inputs: punct_box(tys),
+            output: ReturnType::Default,
         }
     }
 
-    pub fn angle_bracketed_args<A>(self, args: Vec<A>) -> AngleBracketedArgs
+    pub fn angle_bracketed_args<A>(self, args: Vec<A>) -> AngleBracketedGenericArguments
     where
-        A: Make<GenericArg>,
+        A: Make<GenericArgument>,
     {
         let args = args.into_iter().map(|arg| arg.make(&self)).collect();
-        AngleBracketedArgs {
-            span: self.span,
+        AngleBracketedGenericArguments {
+            colon2_token: Some(token::Colon2(self.span)), // Always include a colon2 for turbofish
+            lt_token: token::Lt(self.span),
             args: args,
-            constraints: vec![],
+            gt_token: token::Gt(self.span),
         }
     }
 
-    pub fn generic_arg<A>(self, arg: A) -> GenericArg
+    pub fn generic_arg<A>(self, arg: A) -> GenericArgument
     where
-        A: Make<GenericArg>,
+        A: Make<GenericArgument>,
     {
         arg.make(&self)
     }
@@ -591,1113 +746,1093 @@ impl Builder {
     pub fn use_tree<Pa, K>(self, prefix: Pa, kind: K) -> UseTree
     where
         Pa: Make<Path>,
-        K: Make<UseTreeKind>,
-    {
-        UseTree {
-            span: DUMMY_SP,
-            prefix: prefix.make(&self),
-            kind: kind.make(&self),
-        }
-    }
-
-//    pub fn abs_path<Pa>(self, path: Pa) -> Path
-//    where
-//        Pa: Make<Path>,
-//    {
-//        let mut p = path.make(&self);
-//        if !p
-//            .segments
-//            .get(0)
-//            .map_or(false, |s| s.ident.name == kw::Crate)
-//        {
-//            p.segments.insert(0, kw::Crate.ident().make(&self));
-//        }
-//        p
-//    }
-
-    pub fn anon_const<E>(self, expr: E) -> AnonConst
-    where
-        E: Make<P<Expr>>,
-    {
-        AnonConst {
-            id: DUMMY_NODE_ID,
-            value: expr.make(&self),
+        K: Make<UseTree>,
+    {
+        let path: Path = prefix.make(&self);
+        let mut tree = kind.make(&self);
+        for seg in path.segments {
+            tree = UseTree::Path(UsePath {
+                ident: seg.ident,
+                colon2_token: token::Colon2(self.span),
+                tree: Box::new(tree),
+            });
         }
+        tree
     }
 
-    pub fn spanned<T, U: Make<T>>(self, x: U) -> Spanned<T> {
-        Spanned {
-            node: x.make(&self),
-            span: self.span,
-        }
+    pub fn abs_path<Pa>(self, path: Pa) -> Path
+    where
+        Pa: Make<Path>,
+    {
+        let mut path = path.make(&self);
+        path.leading_colon = Some(token::Colon2(self.span));
+        path
     }
 
     // Exprs
     // These are sorted in the same order as the corresponding ExprKind variants, with additional
     // variant-specific details following each variant.
 
-    pub fn array_expr<A>(self, args: Vec<A>) -> P<Expr>
+    pub fn array_expr<A>(self, args: Vec<A>) -> Box<Expr>
     where
-        A: Make<P<Expr>>,
+        A: Make<Box<Expr>>,
     {
-        let args = args.into_iter().map(|a| a.make(&self)).collect();
-        P(Expr {
-            id: self.id,
-            kind: ExprKind::Array(args),
-            span: self.span,
+        let args = args.into_iter().map(|a| *a.make(&self)).collect();
+        Box::new(Expr::Array(ExprArray {
             attrs: self.attrs.into(),
-        })
+            bracket_token: token::Bracket(self.span),
+            elems: args,
+        }))
     }
 
-    pub fn call_expr<F, A>(self, func: F, args: Vec<A>) -> P<Expr>
+    pub fn call_expr<F, A>(self, func: F, args: Vec<A>) -> Box<Expr>
     where
-        F: Make<P<Expr>>,
-        A: Make<P<Expr>>,
+        F: Make<Box<Expr>>,
+        A: Make<Box<Expr>>,
     {
         let func = func.make(&self);
-        let args = args.into_iter().map(|a| a.make(&self)).collect();
-        P(Expr {
-            id: self.id,
-            kind: ExprKind::Call(func, args),
-            span: self.span,
+        let args = args.into_iter().map(|a| *a.make(&self)).collect();
+        Box::new(parenthesize_if_necessary(Expr::Call(ExprCall {
             attrs: self.attrs.into(),
-        })
+            paren_token: token::Paren(self.span),
+            func,
+            args,
+        })))
     }
 
-    pub fn method_call_expr<E, S, A>(self, expr: E, seg: S, args: Vec<A>) -> P<Expr>
+    pub fn method_call_expr<E, S, A>(self, expr: E, seg: S, args: Vec<A>) -> Box<Expr>
     where
-        E: Make<P<Expr>>,
+        E: Make<Box<Expr>>,
         S: Make<PathSegment>,
-        A: Make<P<Expr>>,
+        A: Make<Box<Expr>>,
     {
         let expr = expr.make(&self);
         let seg = seg.make(&self);
 
-        let mut all_args = Vec::with_capacity(args.len() + 1);
-        all_args.push(expr);
+        let mut arg_vals = Vec::with_capacity(args.len());
         for arg in args {
-            all_args.push(arg.make(&self));
+            arg_vals.push(arg.make(&self));
+        }
+
+        // Convert ::<> if present in seg
+        fn generic_arg_to_method_generic_arg(a: GenericArgument) -> GenericMethodArgument {
+            match a {
+                GenericArgument::Type(t) => GenericMethodArgument::Type(t),
+                GenericArgument::Const(c) => GenericMethodArgument::Const(c),
+                _ => panic!("non-type-or-const generic argument found in method arguments: {:?}", a),
+            }
         }
+        let turbofish = match seg.arguments {
+            PathArguments::None => None,
+            PathArguments::AngleBracketed(ab) => Some(MethodTurbofish {
+                colon2_token: ab.colon2_token.unwrap_or_default(),
+                lt_token: ab.lt_token,
+                args: ab.args.into_iter().map(generic_arg_to_method_generic_arg).collect(),
+                gt_token: ab.gt_token,
+            }),
+            PathArguments::Parenthesized(_) => panic!("Found parenthesized arguments on path segment for method call"),
+        };
 
-        P(Expr {
-            id: self.id,
-            kind: ExprKind::MethodCall(seg, all_args),
-            span: self.span,
+        Box::new(parenthesize_if_necessary(Expr::MethodCall(ExprMethodCall {
             attrs: self.attrs.into(),
-        })
+            dot_token: token::Dot(self.span),
+            paren_token: token::Paren(self.span),
+            turbofish,
+            receiver: expr,
+            method: seg.ident,
+            args: punct_box(arg_vals),
+        })))
     }
 
-    pub fn tuple_expr<E>(self, exprs: Vec<E>) -> P<Expr>
+    pub fn tuple_expr<E>(self, exprs: Vec<E>) -> Box<Expr>
     where
-        E: Make<P<Expr>>,
+        E: Make<Box<Expr>>,
     {
-        let exprs: Vec<P<Expr>> = exprs.into_iter().map(|x| x.make(&self)).collect();
-        P(Expr {
-            id: self.id,
-            kind: ExprKind::Tup(exprs),
-            span: self.span,
+        let exprs: Vec<Box<Expr>> = exprs.into_iter().map(|x| x.make(&self)).collect();
+        Box::new(Expr::Tuple(ExprTuple {
             attrs: self.attrs.into(),
-        })
+            paren_token: token::Paren(self.span),
+            elems: punct_box(exprs),
+        }))
     }
 
-    pub fn binary_expr<O, E>(self, op: O, lhs: E, rhs: E) -> P<Expr>
+    pub fn binary_expr<O, E>(self, op: O, lhs: E, rhs: E) -> Box<Expr>
     where
-        O: Make<BinOpKind>,
-        E: Make<P<Expr>>,
+        O: Make<BinOp>,
+        E: Make<Box<Expr>>,
     {
         let op = op.make(&self);
-        let op_ = mk().spanned(op);
+        // FIXME: set span for op
         let mut lhs = lhs.make(&self);
         let rhs = rhs.make(&self);
 
         match op {
-            BinOpKind::Lt | BinOpKind::Shl if has_rightmost_cast(&*lhs) => {
-                lhs = mk().paren_expr(lhs)
-            }
+            BinOp::Lt(_) | BinOp::Shl(_) if has_rightmost_cast(&*lhs) => lhs = mk().paren_expr(lhs),
             _ => {}
         }
 
-        P(Expr {
-            id: self.id,
-            kind: ExprKind::Binary(op_, lhs, rhs),
-            span: self.span,
+        Box::new(parenthesize_if_necessary(Expr::Binary(ExprBinary {
             attrs: self.attrs.into(),
-        })
+            left: lhs,
+            op,
+            right: rhs,
+        })))
     }
 
-    pub fn unary_expr<O, E>(self, op: O, a: E) -> P<Expr>
+    pub fn unary_expr<O, E>(self, op: O, a: E) -> Box<Expr>
     where
         O: Make<UnOp>,
-        E: Make<P<Expr>>,
+        E: Make<Box<Expr>>,
     {
         let op = op.make(&self);
+        // FIXME: set span for op
         let a = a.make(&self);
-        P(Expr {
-            id: self.id,
-            kind: ExprKind::Unary(op, a),
-            span: self.span,
+        Box::new(parenthesize_if_necessary(Expr::Unary(ExprUnary {
             attrs: self.attrs.into(),
-        })
+            op,
+            expr: a,
+        })))
     }
 
-    pub fn lit_expr<L>(self, lit: L) -> P<Expr>
+    pub fn lit_expr<L>(self, lit: L) -> Box<Expr>
     where
         L: Make<Lit>,
     {
-        let lit = lit.make(&self);
-        P(Expr {
-            id: self.id,
-            kind: ExprKind::Lit(lit),
-            span: self.span,
+        let mut lit = lit.make(&self);
+        lit.set_span(self.span);
+        Box::new(Expr::Lit(ExprLit {
             attrs: self.attrs.into(),
-        })
+            lit,
+        }))
     }
 
-    pub fn cast_expr<E, T>(self, e: E, t: T) -> P<Expr>
+    pub fn cast_expr<E, T>(self, e: E, t: T) -> Box<Expr>
     where
-        E: Make<P<Expr>>,
-        T: Make<P<Ty>>,
+        E: Make<Box<Expr>>,
+        T: Make<Box<Type>>,
     {
         let e = e.make(&self);
         let t = t.make(&self);
 
-        P(Expr {
-            id: self.id,
-            kind: ExprKind::Cast(e, t),
-            span: self.span,
+        Box::new(parenthesize_if_necessary(Expr::Cast(ExprCast {
             attrs: self.attrs.into(),
-        })
+            as_token: token::As(self.span),
+            expr: e,
+            ty: t,
+        })))
     }
 
-    pub fn type_expr<E, T>(self, e: E, t: T) -> P<Expr>
+    pub fn type_expr<E, T>(self, e: E, t: T) -> Box<Expr>
     where
-        E: Make<P<Expr>>,
-        T: Make<P<Ty>>,
+        E: Make<Box<Expr>>,
+        T: Make<Box<Type>>,
     {
         let e = e.make(&self);
         let t = t.make(&self);
-        P(Expr {
-            id: self.id,
-            kind: ExprKind::Type(e, t),
-            span: self.span,
+        Box::new(Expr::Type(ExprType {
             attrs: self.attrs.into(),
-        })
+            colon_token: token::Colon(self.span),
+            expr: e,
+            ty: t,
+        }))
+    }
+
+    pub fn unsafe_block_expr<B>(self, unsafe_blk: B) -> Box<Expr>
+    where
+        B: Make<ExprUnsafe>,
+    {
+        let unsafe_blk = unsafe_blk.make(&self);
+        Box::new(Expr::Unsafe(unsafe_blk))
     }
 
-    pub fn block_expr<B>(self, blk: B) -> P<Expr>
+    pub fn block_expr<B>(self, blk: B) -> Box<Expr>
     where
-        B: Make<P<Block>>,
+        B: Make<Box<Block>>,
     {
         let blk = blk.make(&self);
-        P(Expr {
-            id: self.id,
-            kind: ExprKind::Block(blk, None),
-            span: self.span,
+        Box::new(Expr::Block(ExprBlock {
             attrs: self.attrs.into(),
-        })
+            block: *blk,
+            label: None,
+        }))
     }
 
-    pub fn labelled_block_expr<B, L>(self, blk: B, lbl: L) -> P<Expr>
+    pub fn labelled_block_expr<B, L>(self, blk: B, lbl: L) -> Box<Expr>
     where
-        B: Make<P<Block>>,
+        B: Make<Box<Block>>,
         L: Make<Label>,
     {
         let blk = blk.make(&self);
         let lbl = lbl.make(&self);
-        P(Expr {
-            id: DUMMY_NODE_ID,
-            kind: ExprKind::Block(blk, Some(lbl)),
-            span: DUMMY_SP,
+        Box::new(Expr::Block(ExprBlock {
             attrs: self.attrs.into(),
-        })
+            block: *blk,
+            label: Some(lbl),
+        }))
     }
 
-    pub fn assign_expr<E1, E2>(self, lhs: E1, rhs: E2) -> P<Expr>
+    pub fn assign_expr<E1, E2>(self, lhs: E1, rhs: E2) -> Box<Expr>
     where
-        E1: Make<P<Expr>>,
-        E2: Make<P<Expr>>,
+        E1: Make<Box<Expr>>,
+        E2: Make<Box<Expr>>,
     {
         let lhs = lhs.make(&self);
         let rhs = rhs.make(&self);
-        P(Expr {
-            id: self.id,
-            kind: ExprKind::Assign(lhs, rhs),
-            span: self.span,
+        Box::new(Expr::Assign(ExprAssign {
             attrs: self.attrs.into(),
-        })
+            eq_token: token::Eq(self.span),
+            left: lhs,
+            right: rhs,
+        }))
     }
 
-    pub fn assign_op_expr<O, E1, E2>(self, op: O, lhs: E1, rhs: E2) -> P<Expr>
+    pub fn assign_op_expr<O, E1, E2>(self, op: O, lhs: E1, rhs: E2) -> Box<Expr>
     where
-        O: Make<BinOpKind>,
-        E1: Make<P<Expr>>,
-        E2: Make<P<Expr>>,
+        O: Make<BinOp>,
+        E1: Make<Box<Expr>>,
+        E2: Make<Box<Expr>>,
     {
-        let op = dummy_spanned(op.make(&self));
+        let op = op.make(&self);
+        // FIXME: set span for op
         let lhs = lhs.make(&self);
         let rhs = rhs.make(&self);
-        P(Expr {
-            id: self.id,
-            kind: ExprKind::AssignOp(op, lhs, rhs),
-            span: self.span,
+        Box::new(Expr::AssignOp(ExprAssignOp {
             attrs: self.attrs.into(),
-        })
+            op,
+            left: lhs,
+            right: rhs,
+        }))
     }
 
-    pub fn index_expr<E1, E2>(self, lhs: E1, rhs: E2) -> P<Expr>
+    pub fn index_expr<E1, E2>(self, lhs: E1, rhs: E2) -> Box<Expr>
     where
-        E1: Make<P<Expr>>,
-        E2: Make<P<Expr>>,
+        E1: Make<Box<Expr>>,
+        E2: Make<Box<Expr>>,
     {
         let lhs = lhs.make(&self);
         let rhs = rhs.make(&self);
-        P(Expr {
-            id: self.id,
-            kind: ExprKind::Index(lhs, rhs),
-            span: self.span,
+        Box::new(parenthesize_if_necessary(Expr::Index(ExprIndex {
             attrs: self.attrs.into(),
-        })
+            bracket_token: token::Bracket(self.span),
+            expr: lhs,
+            index: rhs,
+        })))
+    }
+
+    pub fn abs_path_expr<Pa>(self, path: Pa) -> Box<Expr>
+    where
+        Pa: Make<Path>,
+    {
+        let path = mk().abs_path(path);
+        self.path_expr(path)
     }
 
-    pub fn path_expr<Pa>(self, path: Pa) -> P<Expr>
+    pub fn path_expr<Pa>(self, path: Pa) -> Box<Expr>
     where
         Pa: Make<Path>,
     {
         self.qpath_expr(None, path)
     }
 
-    pub fn qpath_expr<Pa>(self, qself: Option<QSelf>, path: Pa) -> P<Expr>
+    pub fn qpath_expr<Pa>(self, qself: Option<QSelf>, path: Pa) -> Box<Expr>
     where
         Pa: Make<Path>,
     {
         let path = path.make(&self);
-        P(Expr {
-            id: self.id,
-            kind: ExprKind::Path(qself, path),
-            span: self.span,
+        Box::new(Expr::Path(ExprPath {
             attrs: self.attrs.into(),
-        })
+            qself,
+            path,
+        }))
     }
 
     /// An array literal constructed from one repeated element.
     /// `[expr; n]`
-    pub fn repeat_expr<E, N>(self, expr: E, n: N) -> P<Expr>
+    pub fn repeat_expr<E, N>(self, expr: E, n: N) -> Box<Expr>
     where
-        E: Make<P<Expr>>,
-        N: Make<P<Expr>>,
+        E: Make<Box<Expr>>,
+        N: Make<Box<Expr>>,
     {
         let expr = expr.make(&self);
-        let n = mk().anon_const(n.make(&self));
-        P(Expr {
-            id: self.id,
-            kind: ExprKind::Repeat(expr, n),
-            span: self.span,
+        let n = n.make(&self);
+        Box::new(Expr::Repeat(ExprRepeat {
             attrs: self.attrs.into(),
-        })
+            bracket_token: token::Bracket(self.span),
+            semi_token: token::Semi(self.span),
+            expr,
+            len: n,
+        }))
     }
 
-    pub fn paren_expr<E>(self, e: E) -> P<Expr>
+    pub fn paren_expr<E>(self, e: E) -> Box<Expr>
     where
-        E: Make<P<Expr>>,
+        E: Make<Box<Expr>>,
     {
         let e = e.make(&self);
-        P(Expr {
-            id: self.id,
-            kind: ExprKind::Paren(e),
-            span: self.span,
+        Box::new(Expr::Paren(ExprParen {
             attrs: self.attrs.into(),
-        })
+            paren_token: token::Paren(self.span),
+            expr: e,
+        }))
     }
 
     // Special case of path_expr
-    pub fn ident_expr<I>(self, name: I) -> P<Expr>
+    pub fn ident_expr<I>(self, name: I) -> Box<Expr>
     where
         I: Make<Ident>,
     {
         self.path_expr(vec![name])
     }
 
-    pub fn addr_of_expr<E>(self, e: E) -> P<Expr>
+    pub fn addr_of_expr<E>(self, e: E) -> Box<Expr>
     where
-        E: Make<P<Expr>>,
+        E: Make<Box<Expr>>,
     {
         let e = e.make(&self);
-        P(Expr {
-            id: self.id,
-            kind: ExprKind::AddrOf(BorrowKind::Ref, self.mutbl, e),
-            span: self.span,
+        Box::new(Expr::Reference(ExprReference {
             attrs: self.attrs.into(),
-        })
+            and_token: token::And(self.span),
+            raw: Default::default(),
+            mutability: self.mutbl.to_token(),
+            expr: e,
+        }))
     }
 
-    pub fn mac_expr<M>(self, mac: M) -> P<Expr>
+    pub fn mac_expr<M>(self, mac: M) -> Box<Expr>
     where
-        M: Make<Mac>,
+        M: Make<Macro>,
     {
         let mac = mac.make(&self);
-        P(Expr {
-            id: self.id,
-            kind: ExprKind::Mac(mac),
-            span: self.span,
+        Box::new(Expr::Macro(ExprMacro {
             attrs: self.attrs.into(),
-        })
+            mac,
+        }))
     }
 
-    pub fn struct_expr<Pa>(self, path: Pa, fields: Vec<Field>) -> P<Expr>
+    pub fn struct_expr<Pa>(self, path: Pa, fields: Vec<FieldValue>) -> Box<Expr>
     where
         Pa: Make<Path>,
     {
         let path = path.make(&self);
-        P(Expr {
-            id: self.id,
-            kind: ExprKind::Struct(path, fields, None),
-            span: self.span,
+        Box::new(Expr::Struct(ExprStruct {
             attrs: self.attrs.into(),
-        })
+            brace_token: token::Brace(self.span),
+            dot2_token: None,
+            path,
+            fields: punct(fields),
+            rest: None,
+        }))
     }
 
     // struct_expr, but with optional base expression
-    pub fn struct_expr_base<Pa, E>(self, path: Pa, fields: Vec<Field>, base: Option<E>) -> P<Expr>
+    pub fn struct_expr_base<Pa, E>(
+        self,
+        path: Pa,
+        fields: Vec<FieldValue>,
+        base: Option<E>,
+    ) -> Box<Expr>
     where
         Pa: Make<Path>,
-        E: Make<P<Expr>>,
+        E: Make<Box<Expr>>,
     {
         let path = path.make(&self);
         let base = base.map(|e| e.make(&self));
-        P(Expr {
-            id: self.id,
-            kind: ExprKind::Struct(path, fields, base),
-            span: self.span,
+        Box::new(Expr::Struct(ExprStruct {
             attrs: self.attrs.into(),
-        })
+            brace_token: token::Brace(self.span),
+            dot2_token: Some(token::Dot2(self.span)),
+            path,
+            fields: punct(fields),
+            rest: base,
+        }))
     }
 
-    pub fn field_expr<E, F>(self, val: E, field: F) -> P<Expr>
+    pub fn field_expr<E, F>(self, val: E, field: F) -> Box<Expr>
     where
-        E: Make<P<Expr>>,
+        E: Make<Box<Expr>>,
         F: Make<Ident>,
     {
         let val = val.make(&self);
         let field = field.make(&self);
-        P(Expr {
-            id: self.id,
-            kind: ExprKind::Field(val, field),
-            span: self.span,
+        Box::new(parenthesize_if_necessary(Expr::Field(ExprField {
             attrs: self.attrs.into(),
-        })
+            dot_token: token::Dot(self.span),
+            base: val,
+            member: Member::Named(field),
+        })))
+    }
+
+    pub fn anon_field_expr<E>(self, val: E, field: u32) -> Box<Expr>
+    where
+        E: Make<Box<Expr>>,
+    {
+        let val = val.make(&self);
+        let field = field.make(&self);
+        Box::new(Expr::Field(ExprField {
+            attrs: self.attrs.into(),
+            dot_token: token::Dot(self.span),
+            base: val,
+            member: Member::Unnamed(Index { index: field, span: self.span }),
+        }))
     }
 
-    pub fn field<I, E>(self, ident: I, expr: E) -> Field
+    pub fn field<I, E>(self, ident: I, expr: E) -> FieldValue
     where
         I: Make<Ident>,
-        E: Make<P<Expr>>,
+        E: Make<Box<Expr>>,
     {
         let ident = ident.make(&self);
         let expr = expr.make(&self);
-        Field {
-            ident,
-            expr: expr,
-            span: self.span,
-            is_shorthand: false,
+        FieldValue {
+            member: Member::Named(ident),
+            expr: *expr,
+            colon_token: Some(token::Colon(self.span)),
             attrs: self.attrs.into(),
-            id: self.id,
-            is_placeholder: false,
         }
     }
 
-    pub fn match_expr<E>(self, cond: E, arms: Vec<Arm>) -> P<Expr>
+    pub fn match_expr<E>(self, cond: E, arms: Vec<Arm>) -> Box<Expr>
     where
-        E: Make<P<Expr>>,
+        E: Make<Box<Expr>>,
     {
         let cond = cond.make(&self);
         let arms = arms.into_iter().map(|arm| arm.make(&self)).collect();
-        P(Expr {
-            id: self.id,
-            kind: ExprKind::Match(cond, arms),
-            span: self.span,
+        Box::new(Expr::Match(ExprMatch {
             attrs: self.attrs.into(),
-        })
+            match_token: token::Match(self.span),
+            brace_token: token::Brace(self.span),
+            expr: cond,
+            arms,
+        }))
     }
 
     pub fn arm<Pa, E>(self, pat: Pa, guard: Option<E>, body: E) -> Arm
     where
-        E: Make<P<Expr>>,
-        Pa: Make<P<Pat>>,
+        E: Make<Box<Expr>>,
+        Pa: Make<Box<Pat>>,
     {
-        let pat = pat.make(&self);
-        let guard = guard.map(|g| g.make(&self));
+        let pat = *pat.make(&self);
+        let guard = guard.map(|g| (token::If(self.span), g.make(&self)));
         let body = body.make(&self);
         Arm {
-            id: self.id,
             attrs: self.attrs,
             pat,
             guard,
             body,
-            span: DUMMY_SP,
-            is_placeholder: false,
+            fat_arrow_token: token::FatArrow(self.span),
+            comma: Some(token::Comma(self.span)),
         }
     }
 
     // Literals
 
-    pub fn str_lit<S>(self, s: S) -> StrLit
+    pub fn int_lit<T>(self, i: u128, ty: T) -> Lit
     where
-        S: IntoSymbol,
+        T: LitStringable,
     {
-        let symbol = s.into_symbol();
-        StrLit {
-            style: StrStyle::Cooked,
-            suffix: None,
-            span: self.span,
-            symbol_unescaped: symbol.clone(),
-            symbol,
-        }
+        Lit::Int(LitInt::new(&format!("{}{}", i, ty.lit_string(&self)), self.span))
     }
 
-    pub fn int_lit<T>(self, i: u128, ty: T) -> Lit
-    where
-        T: Make<LitIntType>,
+    pub fn int_unsuffixed_lit(self, i: u128) -> Lit
     {
-        let ty = ty.make(&self);
-        Lit::from_lit_kind(
-            LitKind::Int(i, ty),
-            self.span
-        )
+        Lit::Int(LitInt::new(&format!("{}", i), self.span))
     }
 
-    pub fn float_lit<S, T>(self, s: S, ty: T) -> Lit
+    pub fn float_lit<T>(self, s: &str, ty: T) -> Lit
     where
-        S: IntoSymbol,
-        T: Make<FloatTy>,
+        T: LitStringable,
     {
-        let s = s.into_symbol();
-        let ty = ty.make(&self);
-        Lit::from_lit_kind(
-            LitKind::Float(s, LitFloatType::Suffixed(ty)),
-            self.span
-        )
+        Lit::Float(LitFloat::new(&format!("{}{}", s, ty.lit_string(&self)), self.span))
     }
 
-    pub fn float_unsuffixed_lit<S>(self, s: S) -> Lit
-    where
-        S: IntoSymbol,
+    pub fn float_unsuffixed_lit(self, s: &str) -> Lit
     {
-        let s = s.into_symbol();
-        Lit::from_lit_kind(
-            LitKind::Float(s, LitFloatType::Unsuffixed),
-            self.span
-        )
+        Lit::Float(LitFloat::new(s, self.span))
     }
 
     pub fn bool_lit(self, b: bool) -> Lit {
-        Lit::from_lit_kind(
-            LitKind::Bool(b),
-            self.span
-        )
+        Lit::Bool(LitBool { value: b, span: self.span })
     }
 
-    pub fn ifte_expr<C, T, E>(self, cond: C, then_case: T, else_case: Option<E>) -> P<Expr>
+    pub fn ifte_expr<C, T, E>(self, cond: C, then_case: T, else_case: Option<E>) -> Box<Expr>
     where
-        C: Make<P<Expr>>,
-        T: Make<P<Block>>,
-        E: Make<P<Expr>>,
+        C: Make<Box<Expr>>,
+        T: Make<Box<Block>>,
+        E: Make<Box<Expr>>,
     {
         let cond = cond.make(&self);
-        let then_case = then_case.make(&self);
+        let then_case = *then_case.make(&self);
         let else_case = else_case.map(|x| {
             let e = x.make(&self);
 
             // The else branch in libsyntax must be one of these three cases,
             // otherwise we have to manually add the block around the else expression
-            match e.kind {
-                ExprKind::If { .. } | ExprKind::Block(_, None) => e,
+            (token::Else(self.span), match &*e {
+                Expr::If(..)
+                | Expr::Block(ExprBlock {
+                    attrs: _,
+                    label: None,
+                    block: _,
+                }) => e,
                 _ => mk().block_expr(mk().block(vec![mk().expr_stmt(e)])),
-            }
+            })
         });
 
-        P(Expr {
-            id: self.id,
-            kind: ExprKind::If(cond, then_case, else_case),
-            span: self.span,
+        Box::new(Expr::If(ExprIf {
             attrs: self.attrs.into(),
-        })
+            if_token: token::If(self.span),
+            cond,
+            then_branch: then_case,
+            else_branch: else_case,
+        }))
     }
 
-    pub fn while_expr<C, B, I>(self, cond: C, body: B, label: Option<I>) -> P<Expr>
+    pub fn while_expr<C, B, I>(self, cond: C, body: B, label: Option<I>) -> Box<Expr>
     where
-        C: Make<P<Expr>>,
-        B: Make<P<Block>>,
+        C: Make<Box<Expr>>,
+        B: Make<Box<Block>>,
         I: Make<Ident>,
     {
         let cond = cond.make(&self);
-        let body = body.make(&self);
+        let body = *body.make(&self);
         let label = label.map(|l| Label {
-            ident: l.make(&self),
+            name: Lifetime { ident: l.make(&self), apostrophe: self.span },
+            colon_token: token::Colon(self.span),
         });
 
-        P(Expr {
-            id: self.id,
-            kind: ExprKind::While(cond, body, label),
-            span: self.span,
+        Box::new(Expr::While(ExprWhile {
             attrs: self.attrs.into(),
-        })
+            while_token: token::While(self.span),
+            cond,
+            body,
+            label,
+        }))
     }
 
-    pub fn loop_expr<B, I>(self, body: B, label: Option<I>) -> P<Expr>
+    pub fn loop_expr<B, I>(self, body: B, label: Option<I>) -> Box<Expr>
     where
-        B: Make<P<Block>>,
+        B: Make<Box<Block>>,
         I: Make<Ident>,
     {
-        let body = body.make(&self);
+        let body = *body.make(&self);
         let label = label.map(|l| Label {
-            ident: l.make(&self),
+            name: Lifetime { ident: l.make(&self), apostrophe: self.span },
+            colon_token: token::Colon(self.span),
         });
 
-        P(Expr {
-            id: self.id,
-            kind: ExprKind::Loop(body, label),
-            span: self.span,
+        Box::new(Expr::Loop(ExprLoop {
             attrs: self.attrs.into(),
-        })
+            loop_token: token::Loop(self.span),
+            body,
+            label,
+        }))
     }
 
-    pub fn for_expr<Pa, E, B, I>(self, pat: Pa, expr: E, body: B, label: Option<I>) -> P<Expr>
+    pub fn for_expr<Pa, E, B, I>(self, pat: Pa, expr: E, body: B, label: Option<I>) -> Box<Expr>
     where
-        Pa: Make<P<Pat>>,
-        E: Make<P<Expr>>,
-        B: Make<P<Block>>,
+        Pa: Make<Box<Pat>>,
+        E: Make<Box<Expr>>,
+        B: Make<Box<Block>>,
         I: Make<Ident>,
     {
-        let pat = pat.make(&self);
+        let pat = *pat.make(&self);
         let expr = expr.make(&self);
-        let body = body.make(&self);
+        let body = *body.make(&self);
         let label = label.map(|l| Label {
-            ident: l.make(&self),
+            name: Lifetime { ident: l.make(&self), apostrophe: self.span },
+            colon_token: token::Colon(self.span),
         });
 
-        P(Expr {
-            id: self.id,
-            kind: ExprKind::ForLoop(pat, expr, body, label),
-            span: self.span,
+        Box::new(Expr::ForLoop(ExprForLoop {
             attrs: self.attrs.into(),
-        })
+            for_token: token::For(self.span),
+            in_token: token::In(self.span),
+            pat,
+            expr,
+            body,
+            label,
+        }))
     }
 
     // Patterns
 
-    pub fn ident_pat<I>(self, name: I) -> P<Pat>
+    pub fn ident_pat<I>(self, name: I) -> Box<Pat>
     where
         I: Make<Ident>,
     {
         let name = name.make(&self);
-        P(Pat {
-            id: self.id,
-            kind: PatKind::Ident(BindingMode::ByValue(self.mutbl), name, None),
-            span: self.span,
-        })
+        Box::new(Pat::Ident(PatIdent {
+            attrs: self.attrs.into(),
+            mutability: self.mutbl.to_token(),
+            by_ref: None,
+            ident: name,
+            subpat: None,
+        }))
     }
 
-    pub fn tuple_pat<Pa>(self, pats: Vec<Pa>) -> P<Pat>
+    pub fn tuple_pat<Pa>(self, pats: Vec<Pa>) -> Box<Pat>
     where
-        Pa: Make<P<Pat>>,
+        Pa: Make<Box<Pat>>,
     {
-        let pats: Vec<P<Pat>> = pats.into_iter().map(|x| x.make(&self)).collect();
-        P(Pat {
-            id: self.id,
-            kind: PatKind::Tuple(pats),
-            span: self.span,
-        })
+        let pats: Vec<Box<Pat>> = pats.into_iter().map(|x| x.make(&self)).collect();
+        Box::new(Pat::Tuple(PatTuple {
+            attrs: self.attrs.into(),
+            paren_token: token::Paren(self.span),
+            elems: punct_box(pats),
+        }))
     }
 
-    pub fn qpath_pat<Pa>(self, qself: Option<QSelf>, path: Pa) -> P<Pat>
+    pub fn qpath_pat<Pa>(self, qself: Option<QSelf>, path: Pa) -> Box<Pat>
     where
         Pa: Make<Path>,
     {
         let path = path.make(&self);
-        P(Pat {
-            id: self.id,
-            kind: PatKind::Path(qself, path),
-            span: self.span,
-        })
+        Box::new(Pat::Path(PatPath {
+            attrs: self.attrs.into(),
+            qself,
+            path,
+        }))
     }
 
-    pub fn wild_pat(self) -> P<Pat> {
-        P(Pat {
-            id: self.id,
-            kind: PatKind::Wild,
-            span: self.span,
-        })
+    pub fn wild_pat(self) -> Box<Pat> {
+        Box::new(Pat::Wild(PatWild {
+            attrs: self.attrs.into(),
+            underscore_token: token::Underscore(self.span),
+        }))
     }
 
-    pub fn lit_pat<L>(self, lit: L) -> P<Pat>
+    pub fn lit_pat<L>(self, lit: L) -> Box<Pat>
     where
-        L: Make<P<Expr>>,
+        L: Make<Box<Expr>>,
     {
         let lit = lit.make(&self);
-        P(Pat {
-            id: self.id,
-            kind: PatKind::Lit(lit),
-            span: self.span,
-        })
+        Box::new(Pat::Lit(PatLit {
+            attrs: self.attrs.into(),
+            expr: lit,
+        }))
     }
 
-    pub fn mac_pat<M>(self, mac: M) -> P<Pat>
+    pub fn mac_pat<M>(self, mac: M) -> Box<Pat>
     where
-        M: Make<Mac>,
+        M: Make<Macro>,
     {
         let mac = mac.make(&self);
-        P(Pat {
-            id: self.id,
-            kind: PatKind::Mac(mac),
-            span: self.span,
-        })
+        Box::new(Pat::Macro(PatMacro {
+            attrs: self.attrs ,
+            mac,
+        }))
     }
 
-    pub fn ident_ref_pat<I>(self, name: I) -> P<Pat>
+    pub fn ident_ref_pat<I>(self, name: I) -> Box<Pat>
     where
         I: Make<Ident>,
     {
         let name = name.make(&self);
-        P(Pat {
-            id: self.id,
-            kind: PatKind::Ident(BindingMode::ByRef(self.mutbl), name, None),
-            span: self.span,
-        })
+        Box::new(Pat::Ident(PatIdent {
+            attrs: self.attrs.into(),
+            by_ref: Some(token::Ref(self.span)),
+            mutability: self.mutbl.to_token(),
+            ident: name,
+            subpat: None,
+        }))
     }
 
-    pub fn or_pat<Pa>(self, pats: Vec<Pa>) -> P<Pat>
+    pub fn or_pat<Pa>(self, pats: Vec<Pa>) -> Box<Pat>
     where
-        Pa: Make<P<Pat>>,
+        Pa: Make<Box<Pat>>,
     {
-        let pats: Vec<P<Pat>> = pats.into_iter().map(|p| p.make(&self)).collect();
-        P(Pat {
-            id: self.id,
-            kind: PatKind::Or(pats),
-            span: self.span,
-        })
+        let pats: Vec<Box<Pat>> = pats.into_iter().map(|p| p.make(&self)).collect();
+        Box::new(Pat::Or(PatOr {
+            attrs: self.attrs.into(),
+            leading_vert: None, // Untested
+            cases: punct_box(pats),
+        }))
     }
 
     // Types
 
-    pub fn barefn_ty<T>(self, decl: T) -> P<Ty>
+    pub fn barefn_ty<T>(self, decl: T) -> Box<Type>
     where
-        T: Make<P<FnDecl>>,
+        T: Make<Box<BareFnTyParts>>,
     {
         let decl = decl.make(&self);
-
-        let barefn = BareFnTy {
-            unsafety: self.unsafety,
-            ext: self.ext,
-            generic_params: vec![],
-            decl,
+        let (inputs, variadic, output) = *decl;
+        let abi = self.get_abi_opt();
+
+        let barefn = TypeBareFn {
+            fn_token: token::Fn(self.span),
+            paren_token: token::Paren(self.span),
+            unsafety: self.unsafety.to_token(),
+            abi,
+            inputs: punct(inputs),
+            output,
+            variadic,
+            lifetimes: None,
         };
 
-        P(Ty {
-            id: self.id,
-            kind: TyKind::BareFn(P(barefn)),
-            span: self.span,
-        })
+        Box::new(Type::BareFn(barefn))
     }
 
-    pub fn array_ty<T, E>(self, ty: T, len: E) -> P<Ty>
+    pub fn array_ty<T, E>(self, ty: T, len: E) -> Box<Type>
     where
-        T: Make<P<Ty>>,
-        E: Make<P<Expr>>,
+        T: Make<Box<Type>>,
+        E: Make<Box<Expr>>,
     {
         let ty = ty.make(&self);
-        let len = mk().anon_const(len.make(&self));
-        P(Ty {
-            id: self.id,
-            kind: TyKind::Array(ty, len),
-            span: self.span,
-        })
+        let len = *len.make(&self);
+        Box::new(Type::Array(TypeArray {
+            bracket_token: token::Bracket(self.span),
+            semi_token: token::Semi(self.span),
+            elem: ty,
+            len,
+        }))
     }
 
-    pub fn slice_ty<T>(self, ty: T) -> P<Ty>
+    pub fn slice_ty<T>(self, ty: T) -> Box<Type>
     where
-        T: Make<P<Ty>>,
+        T: Make<Box<Type>>,
     {
         let ty = ty.make(&self);
-        P(Ty {
-            id: self.id,
-            kind: TyKind::Slice(ty),
-            span: self.span,
-        })
+        Box::new(Type::Slice(TypeSlice {
+            elem: ty,
+            bracket_token: token::Bracket(self.span),
+        }))
     }
 
-    pub fn ptr_ty<T>(self, ty: T) -> P<Ty>
+    pub fn ptr_ty<T>(self, ty: T) -> Box<Type>
     where
-        T: Make<P<Ty>>,
+        T: Make<Box<Type>>,
     {
         let ty = ty.make(&self);
-        P(Ty {
-            id: self.id,
-            kind: TyKind::Ptr(MutTy {
-                ty: ty,
-                mutbl: self.mutbl,
-            }),
-            span: self.span,
-        })
+        let const_token = if self.mutbl.to_token().is_none() {
+            Some(token::Const(self.span))
+        } else {
+            None
+        };
+        Box::new(Type::Ptr(TypePtr {
+            elem: ty,
+            mutability: self.mutbl.to_token(),
+            const_token,
+            star_token: token::Star(self.span),
+        }))
     }
 
-    pub fn ref_ty<T>(self, ty: T) -> P<Ty>
+    pub fn ref_ty<T>(self, ty: T) -> Box<Type>
     where
-        T: Make<P<Ty>>,
+        T: Make<Box<Type>>,
     {
         let ty = ty.make(&self);
-        P(Ty {
-            id: self.id,
-            kind: TyKind::Rptr(
-                None,
-                MutTy {
-                    ty: ty,
-                    mutbl: self.mutbl,
-                },
-            ),
-            span: self.span,
-        })
+        Box::new(Type::Reference(TypeReference {
+            lifetime: None,
+            elem: ty,
+            mutability: self.mutbl.to_token(),
+            and_token: token::And(self.span),
+        }))
     }
 
-    pub fn ref_lt_ty<L, T>(self, lt: L, ty: T) -> P<Ty>
+    pub fn ref_lt_ty<L, T>(self, lt: L, ty: T) -> Box<Type>
     where
         L: Make<Lifetime>,
-        T: Make<P<Ty>>,
+        T: Make<Box<Type>>,
     {
         let lt = lt.make(&self);
         let ty = ty.make(&self);
-        P(Ty {
-            id: self.id,
-            kind: TyKind::Rptr(
-                Some(lt),
-                MutTy {
-                    ty: ty,
-                    mutbl: self.mutbl,
-                },
-            ),
-            span: self.span,
-        })
+        Box::new(Type::Reference(TypeReference {
+            and_token: token::And(self.span),
+            lifetime: Some(lt),
+            mutability: self.mutbl.to_token(),
+            elem: ty,
+        }))
     }
 
-    pub fn never_ty(self) -> P<Ty> {
-        P(Ty {
-            id: self.id,
-            kind: TyKind::Never,
-            span: self.span,
-        })
+    pub fn never_ty(self) -> Box<Type> {
+        Box::new(Type::Never(TypeNever {
+            bang_token: token::Bang(self.span),
+        }))
     }
 
-    pub fn tuple_ty<T>(self, elem_tys: Vec<T>) -> P<Ty>
+    pub fn tuple_ty<T>(self, elem_tys: Vec<T>) -> Box<Type>
     where
-        T: Make<P<Ty>>,
+        T: Make<Box<Type>>,
     {
-        let elem_tys = elem_tys.into_iter().map(|ty| ty.make(&self)).collect();
-        P(Ty {
-            id: self.id,
-            kind: TyKind::Tup(elem_tys),
-            span: self.span,
-        })
+        let elem_tys = punct(elem_tys.into_iter().map(|ty| *ty.make(&self)).collect());
+        Box::new(Type::Tuple(TypeTuple {
+            paren_token: token::Paren(self.span),
+            elems: elem_tys,
+        }))
     }
 
-    pub fn path_ty<Pa>(self, path: Pa) -> P<Ty>
+    pub fn path_ty<Pa>(self, path: Pa) -> Box<Type>
     where
         Pa: Make<Path>,
     {
         self.qpath_ty(None, path)
     }
 
-    pub fn qpath_ty<Pa>(self, qself: Option<QSelf>, path: Pa) -> P<Ty>
+    pub fn qpath_ty<Pa>(self, qself: Option<QSelf>, path: Pa) -> Box<Type>
     where
         Pa: Make<Path>,
     {
         let path = path.make(&self);
-        P(Ty {
-            id: self.id,
-            kind: TyKind::Path(qself, path),
-            span: self.span,
-        })
+        Box::new(Type::Path(TypePath {qself, path}))
     }
 
-    pub fn ident_ty<I>(self, name: I) -> P<Ty>
+    pub fn ident_ty<I>(self, name: I) -> Box<Type>
     where
         I: Make<Ident>,
     {
         self.path_ty(vec![name])
     }
 
-    pub fn infer_ty(self) -> P<Ty> {
-        P(Ty {
-            id: self.id,
-            kind: TyKind::Infer,
-            span: self.span,
-        })
+    pub fn infer_ty(self) -> Box<Type> {
+        Box::new(Type::Infer(TypeInfer{ underscore_token: token::Underscore(self.span) }))
     }
 
-    pub fn mac_ty<M>(self, mac: M) -> P<Ty>
+    pub fn mac_ty<M>(self, mac: M) -> Box<Type>
     where
-        M: Make<Mac>,
+        M: Make<Macro>,
     {
         let mac = mac.make(&self);
-        P(Ty {
-            id: self.id,
-            kind: TyKind::Mac(mac),
-            span: self.span,
-        })
+        Box::new(Type::Macro(TypeMacro { mac }))
     }
 
-    pub fn cvar_args_ty(self) -> P<Ty> {
-        P(Ty {
-            id: self.id,
-            kind: TyKind::CVarArgs,
-            span: self.span,
-        })
+    pub fn cvar_args_ty(self) -> Box<Type> {
+        let dot = TokenTree::Punct(proc_macro2::Punct::new('.', proc_macro2::Spacing::Joint));
+        let dots = vec![dot.clone(), dot.clone(), dot];
+        Box::new(Type::Verbatim(TokenStream::from_iter(dots.into_iter())))
     }
 
     // Stmts
 
     pub fn local_stmt<L>(self, local: L) -> Stmt
     where
-        L: Make<P<Local>>,
+        L: Make<Box<Local>>,
     {
-        let local = local.make(&self);
-        Stmt {
-            id: self.id,
-            kind: StmtKind::Local(local),
-            span: self.span,
-        }
+        let local = *local.make(&self);
+        Stmt::Local(local)
     }
 
     pub fn expr_stmt<E>(self, expr: E) -> Stmt
     where
-        E: Make<P<Expr>>,
+        E: Make<Box<Expr>>,
     {
-        let expr = expr.make(&self);
-        Stmt {
-            id: self.id,
-            kind: StmtKind::Expr(expr),
-            span: self.span,
-        }
+        let expr = *expr.make(&self);
+        Stmt::Expr(expr)
     }
 
     pub fn semi_stmt<E>(self, expr: E) -> Stmt
     where
-        E: Make<P<Expr>>,
+        E: Make<Box<Expr>>,
     {
-        let expr = expr.make(&self);
-        Stmt {
-            id: self.id,
-            kind: StmtKind::Semi(expr),
-            span: self.span,
-        }
+        let expr = *expr.make(&self);
+        Stmt::Semi(expr, token::Semi(self.span))
     }
 
     pub fn item_stmt<I>(self, item: I) -> Stmt
     where
-        I: Make<P<Item>>,
+        I: Make<Box<Item>>,
     {
-        let item = item.make(&self);
-        Stmt {
-            id: self.id,
-            kind: StmtKind::Item(item),
-            span: self.span,
-        }
+        let item = *item.make(&self);
+        Stmt::Item(item)
     }
 
     pub fn mac_stmt<M>(self, mac: M) -> Stmt
     where
-        M: Make<Mac>,
+        M: Make<Macro>,
     {
         let mac = mac.make(&self);
-        Stmt {
-            id: self.id,
-            kind: StmtKind::Mac(P((mac, MacStmtStyle::Semicolon, ThinVec::new()))),
-            span: self.span,
-        }
+        self.semi_stmt(mk().mac_expr(mac))
     }
 
     // Items
 
-    fn item(
-        name: Ident,
-        attrs: Vec<Attribute>,
-        vis: Visibility,
-        span: Span,
-        id: NodeId,
-        kind: ItemKind,
-    ) -> P<Item> {
-        P(Item {
-            ident: name,
-            attrs: attrs,
-            id: id,
-            kind: kind,
-            vis: vis,
-            span: span,
-            tokens: None,
-        })
-    }
-
-    pub fn static_item<I, T, E>(self, name: I, ty: T, init: E) -> P<Item>
+    pub fn static_item<I, T, E>(self, name: I, ty: T, init: E) -> Box<Item>
     where
         I: Make<Ident>,
-        T: Make<P<Ty>>,
-        E: Make<P<Expr>>,
+        T: Make<Box<Type>>,
+        E: Make<Box<Expr>>,
     {
         let name = name.make(&self);
         let ty = ty.make(&self);
         let init = init.make(&self);
-        Self::item(
-            name,
-            self.attrs,
-            self.vis,
-            self.span,
-            self.id,
-            ItemKind::Static(ty, self.mutbl, init),
-        )
+        Box::new(Item::Static(ItemStatic {
+            attrs: self.attrs,
+            vis: self.vis,
+            mutability: self.mutbl.to_token(),
+            ident: name,
+            static_token: token::Static(self.span),
+            colon_token: token::Colon(self.span),
+            eq_token: token::Eq(self.span),
+            semi_token: token::Semi(self.span),
+            expr: init,
+            ty,
+        }))
     }
 
-    pub fn const_item<I, T, E>(self, name: I, ty: T, init: E) -> P<Item>
+    pub fn const_item<I, T, E>(self, name: I, ty: T, init: E) -> Box<Item>
     where
         I: Make<Ident>,
-        T: Make<P<Ty>>,
-        E: Make<P<Expr>>,
+        T: Make<Box<Type>>,
+        E: Make<Box<Expr>>,
     {
         let name = name.make(&self);
         let ty = ty.make(&self);
         let init = init.make(&self);
-        Self::item(
-            name,
-            self.attrs,
-            self.vis,
-            self.span,
-            self.id,
-            ItemKind::Const(ty, init),
-        )
+        Box::new(Item::Const(ItemConst {
+            attrs: self.attrs,
+            vis: self.vis,
+            const_token: token::Const(self.span),
+            colon_token: token::Colon(self.span),
+            eq_token: token::Eq(self.span),
+            semi_token: token::Semi(self.span),
+            ident: name,
+            ty,
+            expr: init,
+        }))
     }
 
-    pub fn fn_item<I, S, B>(self, name: I, sig: S, block: B) -> P<Item>
+    pub fn fn_item<S, B>(self, sig: S, block: B) -> Box<Item>
     where
-        I: Make<Ident>,
-        S: Make<FnSig>,
-        B: Make<P<Block>>,
+        S: Make<Signature>,
+        B: Make<Box<Block>>,
     {
-        let name = name.make(&self);
         let sig = sig.make(&self);
         let block = block.make(&self);
-        Self::item(
-            name,
-            self.attrs,
-            self.vis,
-            self.span,
-            self.id,
-            ItemKind::Fn(sig, self.generics, block),
-        )
+        Box::new(Item::Fn(ItemFn {
+            attrs: self.attrs,
+            vis: self.vis,
+            sig,
+            block,
+        }))
     }
 
-    pub fn fn_decl(self, inputs: Vec<Param>, output: FunctionRetTy) -> P<FnDecl> {
-        P(FnDecl {
-            inputs,
-            output,
-        })
+    pub fn variadic_arg(self, variadic_attrs: Vec<Attribute>) -> Variadic {
+        Variadic {
+            dots: token::Dot3(self.span),
+            attrs: variadic_attrs,
+        }
     }
 
-    pub fn struct_item<I>(self, name: I, fields: Vec<StructField>, tuple: bool) -> P<Item>
+    pub fn fn_decl<I>(self, name: I, inputs: Vec<FnArg>, variadic: Option<Variadic>, output: ReturnType) -> Box<FnDecl>
+        where
+            I: Make<Ident>,
+    {
+        let name = name.make(&self);
+        Box::new((name, inputs, variadic, output))
+    }
+
+    pub fn struct_item<I>(self, name: I, fields: Vec<Field>, is_tuple: bool) -> Box<Item>
     where
         I: Make<Ident>,
     {
         let name = name.make(&self);
-        let variant_data = if tuple {
-            VariantData::Tuple(fields, DUMMY_NODE_ID)
+        let fields = if is_tuple {
+            Fields::Unnamed(FieldsUnnamed { paren_token: token::Paren(self.span), unnamed: fields.into_iter().collect(), })
         } else {
-            VariantData::Struct(fields, false)
+            Fields::Named(FieldsNamed { brace_token: token::Brace(self.span), named: fields.into_iter().collect(), })
         };
-        Self::item(
-            name,
-            self.attrs,
-            self.vis,
-            self.span,
-            self.id,
-            ItemKind::Struct(variant_data, self.generics),
-        )
+        Box::new(Item::Struct(ItemStruct {
+            attrs: self.attrs,
+            vis: self.vis,
+            struct_token: token::Struct(self.span),
+            semi_token: None,
+            ident: name,
+            generics: self.generics,
+            fields,
+        }))
     }
 
-    pub fn union_item<I>(self, name: I, fields: Vec<StructField>) -> P<Item>
+    pub fn union_item<I>(self, name: I, fields: Vec<Field>) -> Box<Item>
     where
         I: Make<Ident>,
     {
         let name = name.make(&self);
-        Self::item(
-            name,
-            self.attrs,
-            self.vis,
-            self.span,
-            self.id,
-            ItemKind::Union(VariantData::Struct(fields, false), self.generics),
-        )
+        let fields = FieldsNamed {
+            brace_token: token::Brace(self.span),
+            named: punct(fields),
+        };
+        Box::new(Item::Union(ItemUnion {
+            attrs: self.attrs,
+            vis: self.vis,
+            ident: name,
+            fields,
+            union_token: token::Union(self.span),
+            generics: self.generics,
+        }))
     }
 
-    pub fn enum_item<I>(self, name: I, fields: Vec<Variant>) -> P<Item>
+    pub fn enum_item<I>(self, name: I, fields: Vec<Variant>) -> Box<Item>
     where
         I: Make<Ident>,
     {
         let name = name.make(&self);
-        Self::item(
-            name,
-            self.attrs,
-            self.vis,
-            self.span,
-            self.id,
-            ItemKind::Enum(EnumDef { variants: fields }, self.generics),
-        )
+        Box::new(Item::Enum(ItemEnum {
+            attrs: self.attrs,
+            vis: self.vis,
+            ident: name,
+            enum_token: token::Enum(self.span),
+            brace_token: token::Brace(self.span),
+            variants: punct(fields),
+            generics: self.generics,
+        }))
     }
 
-    pub fn type_item<I, T>(self, name: I, ty: T) -> P<Item>
+    pub fn type_item<I, T>(self, name: I, ty: T) -> Box<Item>
     where
         I: Make<Ident>,
-        T: Make<P<Ty>>,
+        T: Make<Box<Type>>,
     {
         let ty = ty.make(&self);
         let name = name.make(&self);
-        let kind = ItemKind::TyAlias(ty, self.generics);
-        Self::item(name, self.attrs, self.vis, self.span, self.id, kind)
+        Box::new(Item::Type(ItemType {
+            attrs: self.attrs,
+            vis: self.vis,
+            ident: name,
+            generics: self.generics,
+            type_token: token::Type(self.span),
+            eq_token: token::Eq(self.span),
+            semi_token: token::Semi(self.span),
+            ty,
+        }))
     }
 
-    pub fn mod_item<I>(self, name: I, m: Mod) -> P<Item>
+    pub fn mod_item<I>(self, name: I, items: Option<Vec<Item>>) -> Box<Item>
     where
         I: Make<Ident>,
     {
+        let items = items.map(|i| (token::Brace(self.span), i));
         let name = name.make(&self);
-        let kind = ItemKind::Mod(m);
-        Self::item(name, self.attrs, self.vis, self.span, self.id, kind)
+        Box::new(Item::Mod(ItemMod {
+            attrs: self.attrs,
+            vis: self.vis,
+            ident: name,
+            mod_token: token::Mod(self.span),
+            semi: None,
+            content: items,
+        }))
     }
 
-    pub fn mod_<I>(self, items: Vec<I>) -> Mod
+    pub fn mod_<I>(self, items: Vec<I>) -> Vec<Item>
     where
-        I: Make<P<Item>>,
+        I: Make<Box<Item>>,
     {
-        let items = items.into_iter().map(|i| i.make(&self)).collect();
-        Mod {
-            inner: self.span,
-            items,
-            inline: true,
-        }
+        items.into_iter().map(|i| *i.make(&self)).collect()
     }
 
-    pub fn mac_item<M>(self, mac: M) -> P<Item>
+    pub fn mac_item<M>(self, mac: M) -> Box<Item>
     where
-        M: Make<Mac>,
+        M: Make<Macro>,
     {
         let mac = mac.make(&self);
-        let kind = ItemKind::Mac(mac);
-        Self::item(
-            Ident::invalid(),
-            self.attrs,
-            self.vis,
-            self.span,
-            self.id,
-            kind,
-        )
+        Box::new(Item::Macro(ItemMacro {
+            attrs: self.attrs,
+            semi_token: Some(token::Semi(self.span)), // Untested
+            ident: None,
+            mac,
+        }))
     }
 
-    pub fn variant<I>(self, name: I, dat: VariantData) -> Variant
+    pub fn variant<I>(self, name: I, fields: Fields) -> Variant
     where
         I: Make<Ident>,
     {
@@ -1705,115 +1840,116 @@ impl Builder {
         Variant {
             ident: name,
             attrs: self.attrs,
-            id: DUMMY_NODE_ID,
-            data: dat,
-            disr_expr: None,
-            span: self.span,
-            vis: self.vis,
-            is_placeholder: false,
+            fields,
+            discriminant: None,
         }
     }
 
     pub fn unit_variant<I, E>(self, name: I, disc: Option<E>) -> Variant
     where
         I: Make<Ident>,
-        E: Make<P<Expr>>,
+        E: Make<Box<Expr>>,
     {
         let name = name.make(&self);
-        let disc = disc.map(|d| AnonConst {
-            id: DUMMY_NODE_ID,
-            value: d.make(&self),
-        });
         Variant {
             ident: name,
+            fields: Fields::Unit,
+            discriminant: disc.map(|e| (token::Eq(self.span), *e.make(&self),)),
             attrs: self.attrs,
-            id: DUMMY_NODE_ID,
-            data: VariantData::Unit(self.id),
-            disr_expr: disc,
-            span: self.span,
-            vis: self.vis,
-            is_placeholder: false,
         }
     }
 
-    pub fn impl_item<T>(self, ty: T, items: Vec<ImplItem>) -> P<Item>
+    pub fn impl_item<T>(self, ty: T, items: Vec<ImplItem>) -> Box<Item>
     where
-        T: Make<P<Ty>>,
+        T: Make<Box<Type>>,
     {
         let ty = ty.make(&self);
-        Self::item(
-            Ident::invalid(),
-            self.attrs,
-            self.vis,
-            self.span,
-            self.id,
-            ItemKind::Impl(
-                self.unsafety,
-                ImplPolarity::Positive,
-                Defaultness::Final,
-                self.generics,
-                None, // not a trait implementation
-                ty,
-                items,
-            ),
-        )
+        Box::new(Item::Impl(ItemImpl {
+            attrs: self.attrs,
+            unsafety: self.unsafety.to_token(),
+            defaultness: Defaultness::Final.to_token(),
+            generics: self.generics,
+            trait_: None, // not a trait implementation, no ! on said trait name
+            self_ty: ty,
+            impl_token: token::Impl(self.span),
+            brace_token: token::Brace(self.span),
+            items,
+        }))
     }
 
-    pub fn extern_crate_item<I>(self, name: I, rename: Option<I>) -> P<Item>
+    pub fn extern_crate_item<I>(self, name: I, rename: Option<I>) -> Box<Item>
     where
         I: Make<Ident>,
     {
         let name = name.make(&self);
-        let rename = rename.map(|n| n.make(&self).name);
-        Self::item(
-            name,
-            self.attrs,
-            self.vis,
-            self.span,
-            self.id,
-            ItemKind::ExternCrate(rename),
-        )
+        let rename = rename.map(|n| (token::As(self.span), n.make(&self)));
+        Box::new(Item::ExternCrate(ItemExternCrate {
+            attrs: self.attrs,
+            vis: self.vis,
+            crate_token: token::Crate(self.span),
+            extern_token: token::Extern(self.span),
+            semi_token: token::Semi(self.span),
+            ident: name,
+            rename,
+        }))
     }
 
-    pub fn use_item<U>(self, tree: U) -> P<Item>
+    pub fn use_item<U>(self, tree: U) -> Box<Item>
     where
         U: Make<UseTree>,
     {
-        let use_tree = tree.make(&self);
-        Self::item(
-            Ident::invalid(),
-            self.attrs,
-            self.vis,
-            self.span,
-            self.id,
-            ItemKind::Use(P(use_tree)),
-        )
+        let tree = tree.make(&self);
+        Box::new(Item::Use(ItemUse {
+            attrs: self.attrs,
+            vis: self.vis,
+            use_token: token::Use(self.span),
+            leading_colon: None,
+            semi_token: token::Semi(self.span),
+            tree,
+        }))
     }
 
     // `use <path>;` item
-    pub fn use_simple_item<Pa, I>(self, path: Pa, rename: Option<I>) -> P<Item>
+    pub fn use_simple_item<Pa, I>(self, path: Pa, rename: Option<I>) -> Box<Item>
     where
         Pa: Make<Path>,
         I: Make<Ident>,
     {
         let path = path.make(&self);
         let rename = rename.map(|n| n.make(&self));
-        let use_tree = UseTree {
-            span: DUMMY_SP,
-            prefix: path,
-            kind: UseTreeKind::Simple(rename, DUMMY_NODE_ID, DUMMY_NODE_ID),
+
+        fn split_path(mut p: Path) -> (Path, Option<Ident>) {
+            if let Some(punct) = p.segments.pop() {
+                (p, Some(punct.into_value().ident))
+            } else {
+                (p, None)
+            }
+        }
+        let leading_colon = path.leading_colon;
+        let (prefix, ident) = split_path(path);
+        let ident = ident.expect("use_simple_item called with path `::`");
+        let tree = if let Some(rename) = rename {
+            use_tree_with_prefix(prefix, UseTree::Rename(UseRename {
+                ident,
+                as_token: token::As(self.span),
+                rename: rename,
+            }))
+        } else {
+            use_tree_with_prefix(prefix, UseTree::Name(UseName {
+                ident,
+            }))
         };
-        Self::item(
-            Ident::invalid(),
-            self.attrs,
-            self.vis,
-            self.span,
-            self.id,
-            ItemKind::Use(P(use_tree)),
-        )
+        Box::new(Item::Use(ItemUse {
+            attrs: self.attrs,
+            vis: self.vis,
+            use_token: token::Use(self.span),
+            leading_colon,
+            semi_token: token::Semi(self.span),
+            tree,
+        }))
     }
 
-    pub fn use_multiple_item<Pa, I, It>(self, path: Pa, inner: It) -> P<Item>
+    pub fn use_multiple_item<Pa, I, It>(self, path: Pa, inner: It) -> Box<Item>
     where
         Pa: Make<Path>,
         I: Make<Ident>,
@@ -1822,206 +1958,150 @@ impl Builder {
         let path = path.make(&self);
         let inner_trees = inner
             .map(|i| {
-                (
-                    UseTree {
-                        span: DUMMY_SP,
-                        prefix: Path::from_ident(i.make(&self)),
-                        kind: UseTreeKind::Simple(None, DUMMY_NODE_ID, DUMMY_NODE_ID),
-                    },
-                    DUMMY_NODE_ID,
-                )
+                UseTree::Name(UseName {
+                    ident: i.make(&self),
+                })
             })
             .collect();
-        let use_tree = UseTree {
-            span: DUMMY_SP,
-            prefix: path,
-            kind: UseTreeKind::Nested(inner_trees),
-        };
-        Self::item(
-            Ident::invalid(),
-            self.attrs,
-            self.vis,
-            self.span,
-            self.id,
-            ItemKind::Use(P(use_tree)),
-        )
+        let leading_colon = path.leading_colon;
+        let tree = use_tree_with_prefix(
+            path,
+            UseTree::Group(UseGroup {
+                brace_token: token::Brace(self.span),
+                items: inner_trees,
+            }),
+        );
+        Box::new(Item::Use(ItemUse {
+            attrs: self.attrs,
+            vis: self.vis,
+            use_token: token::Use(self.span),
+            leading_colon,
+            semi_token: token::Semi(self.span),
+            tree,
+        }))
     }
 
-    pub fn use_glob_item<Pa>(self, path: Pa) -> P<Item>
+    pub fn use_glob_item<Pa>(self, path: Pa) -> Box<Item>
     where
         Pa: Make<Path>,
     {
         let path = path.make(&self);
-        let use_tree = UseTree {
-            span: DUMMY_SP,
-            prefix: path,
-            kind: UseTreeKind::Glob,
-        };
-        Self::item(
-            Ident::invalid(),
-            self.attrs,
-            self.vis,
-            self.span,
-            self.id,
-            ItemKind::Use(P(use_tree)),
-        )
+        let leading_colon = path.leading_colon;
+        let tree = use_tree_with_prefix(
+            path,
+            UseTree::Glob(UseGlob {
+                star_token: token::Star(self.span),
+            }),
+        );
+        Box::new(Item::Use(ItemUse {
+            attrs: self.attrs,
+            vis: self.vis,
+            use_token: token::Use(self.span),
+            leading_colon,
+            semi_token: token::Semi(self.span),
+            tree,
+        }))
     }
 
-    pub fn foreign_items(self, items: Vec<ForeignItem>) -> P<Item> {
-        let fgn_mod = ForeignMod {
-            abi: match self.ext {
+    pub fn foreign_items(self, items: Vec<ForeignItem>) -> Box<Item> {
+        let abi = self.get_abi();
+
+        Box::new(Item::ForeignMod(ItemForeignMod {
+            attrs: self.attrs,
+            brace_token: token::Brace(self.span),
+            items,
+            abi,
+        }))
+    }
+
+    pub fn get_abi(&self) -> Abi {
+        Abi {
+            extern_token: token::Extern(self.span),
+            name: match self.ext {
                 Extern::None | Extern::Implicit => None,
-                Extern::Explicit(s) => Some(s),
+                Extern::Explicit(ref s) => Some(LitStr::new(s, self.span)),
             },
-            items,
+        }
+    }
+
+    pub fn get_abi_opt(&self) -> Option<Abi> {
+        let name: Option<LitStr> = match self.ext {
+            Extern::None => return None,
+            Extern::Implicit => None,
+            Extern::Explicit(ref s) => Some(LitStr::new(s, self.span)),
         };
-        Self::item(
-            Ident::invalid(),
-            self.attrs,
-            self.vis,
-            self.span,
-            self.id,
-            ItemKind::ForeignMod(fgn_mod),
-        )
+        Some(Abi {
+            extern_token: token::Extern(self.span),
+            name,
+        })
     }
 
     // Impl Items
 
-    /// Called `impl_item_` because `impl_item` is already used for "Item, of ItemKind::Impl".
-    fn impl_item_(
-        ident: Ident,
-        attrs: Vec<Attribute>,
-        vis: Visibility,
-        defaultness: Defaultness,
-        generics: Generics,
-        span: Span,
-        id: NodeId,
-        kind: ImplItemKind,
-    ) -> ImplItem {
-        ImplItem {
-            id,
-            ident,
-            vis,
-            defaultness,
-            attrs,
-            generics,
-            kind,
-            span,
-            tokens: None,
-        }
-    }
-
     pub fn mac_impl_item<M>(self, mac: M) -> ImplItem
     where
-        M: Make<Mac>,
+        M: Make<Macro>,
     {
         let mac = mac.make(&self);
-        let kind = ImplItemKind::Macro(mac);
-        Self::impl_item_(
-            Ident::invalid(),
-            self.attrs,
-            self.vis,
-            Defaultness::Final,
-            self.generics,
-            self.span,
-            self.id,
-            kind,
-        )
+        ImplItem::Macro(ImplItemMacro {
+            attrs: self.attrs,
+            semi_token: None,
+            mac,
+        })
     }
 
     // Trait Items
 
-    /// Called `trait_item_` because `trait_item` is already used for "Item, of ItemKind::Trait".
-    fn trait_item_(
-        ident: Ident,
-        attrs: Vec<Attribute>,
-        generics: Generics,
-        span: Span,
-        vis: Visibility,
-        id: NodeId,
-        kind: TraitItemKind,
-    ) -> TraitItem {
-        TraitItem {
-            id,
-            ident,
-            attrs,
-            generics,
-            kind,
-            span,
-            vis,
-            tokens: None,
-        }
-    }
-
     pub fn mac_trait_item<M>(self, mac: M) -> TraitItem
     where
-        M: Make<Mac>,
+        M: Make<Macro>,
     {
         let mac = mac.make(&self);
-        let kind = TraitItemKind::Macro(mac);
-        Self::trait_item_(
-            Ident::invalid(),
-            self.attrs,
-            self.generics,
-            self.span,
-            self.vis,
-            self.id,
-            kind,
-        )
+        TraitItem::Macro(TraitItemMacro {
+            attrs: self.attrs,
+            semi_token: None,
+            mac,
+        })
     }
 
     // Foreign Items
 
-    fn foreign_item(
-        name: Ident,
-        attrs: Vec<Attribute>,
-        vis: Visibility,
-        span: Span,
-        id: NodeId,
-        kind: ForeignItemKind,
-    ) -> ForeignItem {
-        ForeignItem {
-            ident: name,
-            attrs: attrs,
-            id: id,
-            kind: kind,
-            vis: vis,
-            span: span,
-        }
-    }
-
-    pub fn fn_foreign_item<I, D>(self, name: I, decl: D) -> ForeignItem
+    pub fn fn_foreign_item<D>(self, decl: D) -> ForeignItem
     where
-        I: Make<Ident>,
-        D: Make<P<FnDecl>>,
+        D: Make<Box<FnDecl>>,
     {
-        let name = name.make(&self);
         let decl = decl.make(&self);
-        Self::foreign_item(
-            name,
-            self.attrs,
-            self.vis,
-            self.span,
-            self.id,
-            ForeignItemKind::Fn(decl, self.generics),
-        )
+        let sig = Signature {
+            constness: None,
+            asyncness: None,
+            generics: self.generics.clone(),
+            ..decl.make(&self)
+        };
+        ForeignItem::Fn(ForeignItemFn {
+            attrs: self.attrs,
+            vis: self.vis,
+            sig,
+            semi_token: token::Semi(self.span),
+        })
     }
 
     pub fn static_foreign_item<I, T>(self, name: I, ty: T) -> ForeignItem
     where
         I: Make<Ident>,
-        T: Make<P<Ty>>,
+        T: Make<Box<Type>>,
     {
         let name = name.make(&self);
         let ty = ty.make(&self);
-        Self::foreign_item(
-            name,
-            self.attrs,
-            self.vis,
-            self.span,
-            self.id,
-            ForeignItemKind::Static(ty, self.mutbl),
-        )
+        ForeignItem::Static(ForeignItemStatic {
+            attrs: self.attrs,
+            vis: self.vis,
+            mutability: self.mutbl.to_token(),
+            ident: name,
+            ty,
+            static_token: token::Static(self.span),
+            colon_token: token::Colon(self.span),
+            semi_token: token::Semi(self.span),
+        })
     }
 
     pub fn ty_foreign_item<I>(self, name: I) -> ForeignItem
@@ -2029,83 +2109,85 @@ impl Builder {
         I: Make<Ident>,
     {
         let name = name.make(&self);
-        Self::foreign_item(
-            name,
-            self.attrs,
-            self.vis,
-            self.span,
-            self.id,
-            ForeignItemKind::Ty,
-        )
+        ForeignItem::Type(ForeignItemType {
+            attrs: self.attrs,
+            vis: self.vis,
+            ident: name,
+            type_token: token::Type(self.span),
+            semi_token: token::Semi(self.span),
+        })
     }
 
     pub fn mac_foreign_item<M>(self, mac: M) -> ForeignItem
     where
-        M: Make<Mac>,
+        M: Make<Macro>,
     {
         let mac = mac.make(&self);
-        let kind = ForeignItemKind::Macro(mac);
-        Self::foreign_item(
-            Ident::invalid(),
-            self.attrs,
-            self.vis,
-            self.span,
-            self.id,
-            kind,
-        )
+        ForeignItem::Macro(ForeignItemMacro {
+            attrs: self.attrs,
+            mac,
+            semi_token: None,
+        })
     }
 
     // struct fields
 
-    pub fn struct_field<I, T>(self, ident: I, ty: T) -> StructField
+    pub fn struct_field<I, T>(self, ident: I, ty: T) -> Field
     where
         I: Make<Ident>,
-        T: Make<P<Ty>>,
+        T: Make<Box<Type>>,
     {
         let ident = ident.make(&self);
-        let ty = ty.make(&self);
-        StructField {
-            span: self.span,
+        let ty = *ty.make(&self);
+        Field {
             ident: Some(ident),
             vis: self.vis,
-            id: self.id,
-            ty: ty,
             attrs: self.attrs,
-            is_placeholder: false,
+            ty,
+            colon_token: Some(token::Colon(self.span)),
         }
     }
 
-    pub fn enum_field<T>(self, ty: T) -> StructField
+    pub fn enum_field<T>(self, ty: T) -> Field
     where
-        T: Make<P<Ty>>,
+        T: Make<Box<Type>>,
     {
-        let ty = ty.make(&self);
-        StructField {
-            span: self.span,
+        let ty = *ty.make(&self);
+        Field {
             ident: None,
             vis: self.vis,
-            id: self.id,
-            ty: ty,
+            ty,
             attrs: self.attrs,
-            is_placeholder: false,
+            colon_token: None,
         }
     }
 
     // Misc nodes
 
-    pub fn block<S>(self, stmts: Vec<S>) -> P<Block>
+    pub fn unsafe_block<S>(self, stmts: Vec<S>) -> ExprUnsafe
     where
         S: Make<Stmt>,
     {
         let stmts = stmts.into_iter().map(|s| s.make(&self)).collect();
-        P(Block {
+        let blk = Block {
             stmts: stmts,
-            id: self.id,
-            rules: match self.unsafety {
-                Unsafety::Unsafe => BlockCheckMode::Unsafe(UnsafeSource::UserProvided),
-                Unsafety::Normal => BlockCheckMode::Default,
-            },
-            span: self.span,
+            brace_token: token::Brace(self.span),
+        };
+        ExprUnsafe {
+            attrs: self.attrs.into(),
+            unsafe_token: token::Unsafe(self.span),
+            block: blk,
+        }
+    }
+
+    pub fn block<S>(self, stmts: Vec<S>) -> Box<Block>
+    where
+        S: Make<Stmt>,
+    {
+        let stmts = stmts.into_iter().map(|s| s.make(&self)).collect();
+        Box::new(Block {
+            stmts: stmts,
+            brace_token: token::Brace(self.span),
         })
     }
 
@@ -2116,46 +2198,66 @@ impl Builder {
         lbl.make(&self)
     }
 
-    pub fn break_expr_value<L, E>(self, label: Option<L>, value: Option<E>) -> P<Expr>
+    pub fn break_expr_value<L, E>(self, label: Option<L>, value: Option<E>) -> Box<Expr>
     where
         L: Make<Label>,
-        E: Make<P<Expr>>,
+        E: Make<Box<Expr>>,
     {
-        let label = label.map(|l| l.make(&self));
+        let label = label.map(|l| l.make(&self).name);
         let value = value.map(|v| v.make(&self));
-        P(Expr {
-            id: DUMMY_NODE_ID,
-            kind: ExprKind::Break(label, value),
-            span: DUMMY_SP,
+        Box::new(Expr::Break(ExprBreak {
             attrs: self.attrs.into(),
-        })
+            break_token: token::Break(self.span),
+            label,
+            expr: value,
+        }))
+    }
+
+    pub fn bare_arg<T, I>(self, ty: T, name: Option<I>) -> BareFnArg
+    where
+        T: Make<Box<Type>>,
+        I: Make<Box<Ident>>,
+    {
+        let ty = *ty.make(&self);
+        let name = name.map(|n| (*n.make(&self), token::Colon(self.span)));
+        BareFnArg {
+            attrs: Vec::new(),
+            name,
+            ty,
+        }
     }
 
-    pub fn arg<T, Pt>(self, ty: T, pat: Pt) -> Param
+    pub fn arg<T, Pt>(self, ty: T, pat: Pt) -> FnArg
     where
-        T: Make<P<Ty>>,
-        Pt: Make<P<Pat>>,
+        T: Make<Box<Type>>,
+        Pt: Make<Box<Pat>>,
     {
         let ty = ty.make(&self);
         let pat = pat.make(&self);
-        Param {
-            attrs: ThinVec::new(),
+        FnArg::Typed(PatType {
+            attrs: Vec::new(),
             ty: ty,
             pat: pat,
-            id: self.id,
-            span: DUMMY_SP,
-            is_placeholder: false,
-        }
+            colon_token: token::Colon(self.span),
+        })
     }
 
-    pub fn self_arg<S>(self, kind: S) -> Param
+    pub fn self_arg<S>(self, kind: S) -> FnArg
     where
         S: Make<SelfKind>,
     {
-        let eself = dummy_spanned(kind.make(&self));
-        let ident = "self".make(&self);
-        let attrs = ThinVec::new();
-        Param::from_self(attrs, eself, ident)
+        let eself = kind.make(&self);
+        let (reference, mutability) = match eself {
+            SelfKind::Value(mutability) => (None, mutability),
+            SelfKind::Region(lt, mutability) => (Some((token::And(self.span), Some(lt))), mutability),
+        };
+        let attrs = Vec::new();
+        FnArg::Receiver(Receiver {
+            attrs,
+            reference,
+            mutability: mutability.to_token(),
+            self_token: token::SelfValue(self.span),
+        })
     }
 
     pub fn ty_param<I>(self, ident: I) -> GenericParam
@@ -2163,66 +2265,83 @@ impl Builder {
         I: Make<Ident>,
     {
         let ident = ident.make(&self);
-        GenericParam {
+        GenericParam::Type(TypeParam {
             attrs: self.attrs.into(),
             ident: ident,
-            id: self.id,
-            bounds: vec![],
-            kind: GenericParamKind::Type { default: None },
-            is_placeholder: false,
-        }
+            bounds: punct(vec![]),
+            colon_token: None,
+            eq_token: None,
+            default: None,
+        })
     }
 
-    pub fn ty<T>(self, kind: TyKind) -> Ty {
-        Ty {
-            id: self.id,
-            kind,
-            span: self.span,
-        }
+    pub fn ty<T>(self, kind: Type) -> Type {
+        kind
     }
 
     pub fn attribute<Pa, Ma>(self, style: AttrStyle, path: Pa, args: Ma) -> Attribute
     where
         Pa: Make<Path>,
-        Ma: Make<MacArgs>,
+        Ma: Make<TokenStream>,
     {
         let path = path.make(&self);
         let args = args.make(&self).into();
         Attribute {
-            id: AttrId(0),
             style,
-            kind: AttrKind::Normal(AttrItem {
-                path,
-                args,
-            }),
-            span: self.span,
+            path,
+            tokens: args,
+            pound_token: token::Pound(self.span),
+            bracket_token: token::Bracket(self.span),
         }
     }
 
-    pub fn meta_item_attr(mut self, style: AttrStyle, meta_item: MetaItem) -> Self {
-        let mut attr = mk_attr_inner(meta_item);
-        attr.style = style;
+    pub fn meta_item_attr(mut self, style: AttrStyle, meta_item: Meta) -> Self {
+        let prepared = self.prepare_meta(meta_item);
+        let attr = self.clone().attribute(style, prepared.path, prepared.tokens);
         self.attrs.push(attr);
         self
     }
 
-    pub fn meta_item<I, K>(self, path: I, kind: K) -> MetaItem
+    pub fn meta_path<Pa>(self, path: Pa) -> Meta
+    where
+        Pa: Make<Path>,
+    {
+        let path = path.make(&self);
+        Meta::Path(path)
+    }
+
+    pub fn meta_list<I, N>(self, path: I, args: N) -> Meta
     where
         I: Make<Path>,
-        K: Make<MetaItemKind>,
+        N: Make<Vec<NestedMeta>>,
     {
         let path = path.make(&self);
-        let kind = kind.make(&self);
-        MetaItem {
+        let args = args.make(&self);
+        Meta::List(MetaList {
             path: path,
-            kind: kind,
-            span: DUMMY_SP,
-        }
+            paren_token: token::Paren(self.span),
+            nested: punct(args)
+        })
     }
 
-    pub fn nested_meta_item<K>(self, kind: K) -> NestedMetaItem
+    pub fn meta_namevalue<K, V>(self, key: K, value: V) -> Meta
     where
-        K: Make<NestedMetaItem>,
+        K: Make<Path>,
+        V: Make<Lit>,
+    {
+        let key = key.make(&self);
+        let value = value.make(&self);
+
+        Meta::NameValue(MetaNameValue {
+            path: key,
+            eq_token: token::Eq(self.span),
+            lit: value,
+        })
+    }
+
+    pub fn nested_meta_item<K>(self, kind: K) -> NestedMeta
+    where
+        K: Make<NestedMeta>,
     {
         kind.make(&self)
     }
@@ -2234,7 +2353,7 @@ impl Builder {
         self.attrs
             .into_iter()
             .map(|outer_attr| Attribute {
-                style: AttrStyle::Inner,
+                style: AttrStyle::Inner(Default::default()),
                 ..outer_attr
             })
             .collect::<Vec<Attribute>>()
@@ -2244,101 +2363,106 @@ impl Builder {
         self.attrs
     }
 
-    pub fn empty_mac<Pa>(self, path: Pa) -> Mac
+    pub fn empty_mac<Pa>(self, path: Pa, delim: MacroDelimiter) -> Macro
     where
         Pa: Make<Path>,
     {
         let path = path.make(&self);
-        Mac {
-            path: path,
-            args: P(MacArgs::Empty),
-            prior_type_ascription: None,
+        Macro {
+            path,
+            tokens: TokenStream::new(),
+            bang_token: token::Bang(self.span),
+            delimiter: delim,
         }
     }
 
-    pub fn mac<Pa, Ts>(self, func: Pa, arguments: Ts, delim: MacDelimiter) -> Mac
+    pub fn mac<Pa, Ts>(self, func: Pa, arguments: Ts, delim: MacroDelimiter) -> Macro
     where
         Pa: Make<Path>,
         Ts: Make<TokenStream>,
     {
         let func: Path = func.make(&self);
-
-        let args = MacArgs::Delimited(
-            DelimSpan::dummy(),
-            delim,
-            arguments.make(&self),
-        );
-
-        Mac {
+        let tokens = arguments.make(&self);
+        Macro {
             path: func,
-            args: P(args),
-            prior_type_ascription: None,
+            tokens,
+            bang_token: token::Bang(self.span),
+            delimiter: delim,
         }
     }
 
     /// Create a local variable
     pub fn local<V, T, E>(self, pat: V, ty: Option<T>, init: Option<E>) -> Local
     where
-        V: Make<P<Pat>>,
-        T: Make<P<Ty>>,
-        E: Make<P<Expr>>,
+        V: Make<Box<Pat>>,
+        T: Make<Box<Type>>,
+        E: Make<Box<Expr>>,
     {
         let pat = pat.make(&self);
         let ty = ty.map(|x| x.make(&self));
-        let init = init.map(|x| x.make(&self));
+        let init = init.map(|x| (Default::default(), x.make(&self)));
+        let pat = if let Some(ty) = ty {
+            Pat::Type(PatType {
+                attrs: vec![],
+                pat,
+                colon_token: token::Colon(self.span),
+                ty,
+            })
+        } else {
+            *pat
+        };
         Local {
+            attrs: self.attrs.into(),
+            let_token: token::Let(self.span),
+            semi_token: token::Semi(self.span),
             pat,
-            ty,
             init,
-            id: self.id,
-            span: self.span,
-            attrs: self.attrs.into(),
         }
     }
 
-    pub fn return_expr<E>(self, val: Option<E>) -> P<Expr>
+    pub fn return_expr<E>(self, val: Option<E>) -> Box<Expr>
     where
-        E: Make<P<Expr>>,
+        E: Make<Box<Expr>>,
     {
         let val = val.map(|x| x.make(&self));
-        P(Expr {
-            id: self.id,
-            kind: ExprKind::Ret(val),
-            span: self.span,
+        Box::new(Expr::Return(ExprReturn {
             attrs: self.attrs.into(),
-        })
+            return_token: token::Return(self.span),
+            expr: val,
+        }))
     }
 
-    pub fn continue_expr<I>(self, label: Option<I>) -> P<Expr>
+    pub fn continue_expr<I>(self, label: Option<I>) -> Box<Expr>
     where
         I: Make<Ident>,
     {
-        let label = label.map(|l| Label {
+        let label = label.map(|l| Lifetime {
             ident: l.make(&self),
+            apostrophe: self.span,
         });
 
-        P(Expr {
-            id: self.id,
-            kind: ExprKind::Continue(label),
-            span: self.span,
+        Box::new(Expr::Continue(ExprContinue {
             attrs: self.attrs.into(),
-        })
+            continue_token: token::Continue(self.span),
+            label,
+        }))
     }
 
-    pub fn break_expr<I>(self, label: Option<I>) -> P<Expr>
+    pub fn break_expr<I>(self, label: Option<I>) -> Box<Expr>
     where
         I: Make<Ident>,
     {
-        let label = label.map(|l| Label {
+        let label = label.map(|l| Lifetime {
             ident: l.make(&self),
+            apostrophe: self.span,
         });
 
-        P(Expr {
-            id: self.id,
-            kind: ExprKind::Break(label, None),
-            span: self.span,
+        Box::new(Expr::Break(ExprBreak {
             attrs: self.attrs.into(),
-        })
+            break_token: token::Break(self.span),
+            label,
+            expr: None,
+        }))
     }
 
     pub fn closure_expr<D, E>(
@@ -2347,19 +2471,33 @@ impl Builder {
         mov: Movability,
         decl: D,
         body: E,
-    ) -> P<Expr>
+    ) -> Box<Expr>
     where
-        D: Make<P<FnDecl>>,
-        E: Make<P<Expr>>,
+        D: Make<Box<FnDecl>>,
+        E: Make<Box<Expr>>,
     {
         let decl = decl.make(&self);
         let body = body.make(&self);
-        P(Expr {
-            id: self.id,
-            kind: ExprKind::Closure(capture, IsAsync::NotAsync, mov, decl, body, DUMMY_SP),
-            span: self.span,
+        let (_name, inputs, _variadic, output) = *decl;
+        let inputs = inputs.into_iter().map(|e| match e {
+            FnArg::Receiver(_s) => panic!("found 'self' in closure arguments"),
+            FnArg::Typed(PatType { pat, .. }) => *pat,
+        }).collect();
+        let capture = match capture {
+            CaptureBy::Ref => None,
+            CaptureBy::Value => Some(Default::default()),
+        };
+        Box::new(Expr::Closure(ExprClosure {
             attrs: self.attrs.into(),
-        })
+            or1_token: token::Or(self.span),
+            or2_token: token::Or(self.span),
+            capture,
+            asyncness: IsAsync::NotAsync.to_token(),
+            movability: mov.to_token(),
+            body,
+            inputs: inputs,
+            output,
+        }))
     }
 }
 
@@ -2371,10 +2509,127 @@ pub fn mk() -> Builder {
 /// argument to a less-than operator. This is a work-around for an upstream
 /// libsyntax bug.
 fn has_rightmost_cast(expr: &Expr) -> bool {
-    match &expr.kind {
-        &ExprKind::Cast(..) => true,
-        &ExprKind::Unary(_, ref arg) => has_rightmost_cast(&**arg),
-        &ExprKind::Binary(_, _, ref rhs) => has_rightmost_cast(&**rhs),
+    match &expr {
+        &Expr::Cast(..) => true,
+        &Expr::Unary(ExprUnary {attrs: _, op: _, ref expr}) => has_rightmost_cast(&**expr),
+        &Expr::Binary(ExprBinary{attrs: _, left: _, op: _, ref right}) => has_rightmost_cast(&**right),
         _ => false,
     }
 }
+
+fn expr_precedence(e: &Expr) -> u8 {
+    match e {
+        Expr::Path(_ep) => 18,
+        Expr::MethodCall(_emc) => 17,
+        Expr::Field(_ef) => 16,
+        Expr::Call(_) | Expr::Index(_) => 15,
+        Expr::Try(_et) => 14,
+        Expr::Unary(_eu) => 13,
+        Expr::Cast(_ec) => 12,
+        Expr::Binary(eb) => 2 + binop_precedence(&eb.op),
+        Expr::Assign(_) | Expr::AssignOp(_) => 1,
+        Expr::Return(_) | Expr::Closure(_) => 0,
+        _ => 255,
+    }
+}
+
+/// See https://doc.rust-lang.org/reference/expressions.html
+fn binop_precedence(b: &BinOp) -> u8 {
+    match b {
+        BinOp::Add(_) => 8,
+        BinOp::Sub(_) => 8,
+        BinOp::Mul(_) => 9,
+        BinOp::Div(_) => 9,
+        BinOp::Rem(_) => 9,
+        BinOp::And(_) => 2,
+        BinOp::Or(_) => 1,
+        BinOp::BitXor(_) => 5,
+        BinOp::BitAnd(_) => 6,
+        BinOp::BitOr(_) => 4,
+        BinOp::Shl(_) => 7,
+        BinOp::Shr(_) => 7,
+        BinOp::Eq(_) => 3,
+        BinOp::Lt(_) => 3,
+        BinOp::Le(_) => 3,
+        BinOp::Ne(_) => 3,
+        BinOp::Ge(_) => 3,
+        BinOp::Gt(_) => 3,
+        BinOp::AddEq(_) => 0,
+        BinOp::SubEq(_) => 0,
+        BinOp::MulEq(_) => 0,
+        BinOp::DivEq(_) => 0,
+        BinOp::RemEq(_) => 0,
+        BinOp::BitXorEq(_) => 0,
+        BinOp::BitAndEq(_) => 0,
+        BinOp::BitOrEq(_) => 0,
+        BinOp::ShlEq(_) => 0,
+        BinOp::ShrEq(_) => 0,
+    }
+}
+
+/// Wrap an expression in parentheses
+fn parenthesize_mut(e: &mut Box<Expr>) {
+    let mut temp = mk().tuple_expr(Vec::<Box<Expr>>::new());
+    std::mem::swap(e, &mut temp);
+    *e = Box::new(Expr::Paren(ExprParen {
+        attrs: vec![],
+        paren_token: Default::default(),
+        expr: temp,
+    }))
+}
+
+/// Wrap an expression's subexpressions in an explicit ExprParen if the
+/// pretty-printed form of the expression would otherwise reparse differently
+fn parenthesize_if_necessary(mut outer: Expr) -> Expr {
+    // If outer operation has higher precedence, parenthesize inner operation
+    let outer_precedence = expr_precedence(&outer);
+    let parenthesize_if_gte = |inner: &mut Box<Expr>| {
+        if expr_precedence(&*inner) <= outer_precedence {
+            parenthesize_mut(inner);
+        }
+    };
+    let parenthesize_if_gt = |inner: &mut Box<Expr>| {
+        if expr_precedence(&*inner) < outer_precedence {
+            parenthesize_mut(inner);
+        }
+    };
+    match outer {
+        Expr::Field(ref mut ef) => {
+            if let Expr::Index(_) = *ef.base {
+                /* we do not need to parenthesize the indexing in a[b].c */
+            } else {
+            /*if let Expr::Unary(_) = *ef.base {
+                parenthesize_mut(&mut ef.base);
+            } else { */
+                parenthesize_if_gt(&mut ef.base);
+            }
+        }
+        Expr::MethodCall(ref mut emc) => {
+            parenthesize_if_gt(&mut emc.receiver);
+        }
+        Expr::Call(ref mut ec) => {
+            parenthesize_if_gt(&mut ec.func);
+        }
+        Expr::Cast(ref mut ec) => {
+            if let Expr::If(_) = *ec.expr {
+                parenthesize_mut(&mut ec.expr);
+            } else {
+                parenthesize_if_gt(&mut ec.expr);
+            }
+        }
+        Expr::Unary(ref mut eu) => {
+            parenthesize_if_gt(&mut eu.expr);
+        }
+        Expr::Binary(ref mut eb) => {
+            parenthesize_if_gt(&mut eb.left);
+            // Because binops associate right, parenthesize same-precedence RHS
+            // (e.g. `5 - (6 - 7)`).
+            parenthesize_if_gte(&mut eb.right);
+        }
+        Expr::Index(ref mut ei) => {
+            parenthesize_if_gt(&mut ei.expr);
+        }
+        _ => (),
+    };
+    outer
+}
diff --git a/c2rust-ast-builder/src/lib.rs b/c2rust-ast-builder/src/lib.rs
index 7f8150dff1..74518af4be 100644
--- a/c2rust-ast-builder/src/lib.rs
+++ b/c2rust-ast-builder/src/lib.rs
@@ -1,11 +1,6 @@
-#![feature(rustc_private)]
-extern crate rustc;
-extern crate rustc_target;
-extern crate syntax;
-extern crate syntax_pos;
+extern crate proc_macro2;
+extern crate syn;
+//extern crate quote;
 
 mod builder;
-pub use builder::{mk, Builder, Make};
-
-mod into_symbol;
-pub use into_symbol::IntoSymbol;
+pub use builder::{mk, Builder, Make, properties};
diff --git a/c2rust-ast-exporter/src/CMakeLists.txt b/c2rust-ast-exporter/src/CMakeLists.txt
index d57162bc75..9657a21572 100644
--- a/c2rust-ast-exporter/src/CMakeLists.txt
+++ b/c2rust-ast-exporter/src/CMakeLists.txt
@@ -15,7 +15,8 @@ ExternalProject_Add(tinycbor_build
             INSTALL_DIR ${CMAKE_BINARY_DIR}
             URL ${TINYCBOR_URL}
             URL_HASH MD5=${TINYCBOR_MD5}
-            CONFIGURE_COMMAND ""
+            # the fd redirection here fails when the build run inside Cargo
+            CONFIGURE_COMMAND sed -i -r -e "s:'>&9':>$@:" -e "s:9>::" Makefile
             BUILD_COMMAND make --quiet prefix=<INSTALL_DIR> CFLAGS=-fPIC
             INSTALL_COMMAND make --quiet prefix=<INSTALL_DIR> install            
             BUILD_IN_SOURCE 1
diff --git a/c2rust-ast-printer/Cargo.toml b/c2rust-ast-printer/Cargo.toml
index c2b36b20cf..1fc417d65c 100644
--- a/c2rust-ast-printer/Cargo.toml
+++ b/c2rust-ast-printer/Cargo.toml
@@ -9,3 +9,6 @@ description = "Customized version of libsyntax rust pretty-printer"
 
 [dependencies]
 log = "0.4"
+syn = { version = "1.0", features = ["full", "proc-macro", "printing"] }
+proc-macro2 = "1.0"
+prettyplease = { path = "../prettyplease" } # = "0.1"
diff --git a/c2rust-ast-printer/src/lib.rs b/c2rust-ast-printer/src/lib.rs
index 2107cafea5..f539c6882b 100644
--- a/c2rust-ast-printer/src/lib.rs
+++ b/c2rust-ast-printer/src/lib.rs
@@ -1,12 +1,10 @@
-#![feature(rustc_private)]
 #![feature(crate_visibility_modifier)]
 
-extern crate rustc_target;
-extern crate syntax;
-extern crate syntax_pos;
+extern crate syn;
+extern crate proc_macro2;
 
 pub mod pprust;
-pub mod pp;
-mod helpers;
+//pub mod pp;
+//mod helpers;
 
-mod syntax_priv;
+//mod syntax_priv;
diff --git a/c2rust-ast-printer/src/pprust.rs b/c2rust-ast-printer/src/pprust.rs
index 6bca2cb1f4..6655afb5f2 100644
--- a/c2rust-ast-printer/src/pprust.rs
+++ b/c2rust-ast-printer/src/pprust.rs
@@ -1,65 +1,38 @@
-use syntax::ast::{self, BlockCheckMode, PatKind, RangeEnd, RangeSyntax};
-use syntax::ast::{SelfKind, GenericBound, TraitBoundModifier};
-use syntax::ast::{Attribute, MacDelimiter, GenericArg, MacArgs};
-use syntax::util::parser::{self, AssocOp, Fixity};
-use syntax::util::comments;
-use syntax::source_map::{self, SourceMap, Spanned};
-use syntax::token::{self, BinOpToken, DelimToken, Nonterminal, Token, TokenKind};
-use syntax::ptr::P;
-use syntax::symbol::kw;
-use syntax::tokenstream::{self, TokenStream, TokenTree};
-use syntax::util::classify;
-
-use syntax_pos::{self, BytePos, Span};
-
-use std::borrow::Cow;
-
-use crate::pp::{self, Breaks};
-use crate::pp::Breaks::{Consistent, Inconsistent};
-use crate::syntax_priv;
+use proc_macro2::{TokenStream, TokenTree};
 
 #[cfg(test)]
 mod tests;
 
-pub enum MacHeader<'a> {
-    Path(&'a ast::Path),
-    Keyword(&'static str),
-}
 
-pub enum AnnNode<'a> {
-    Ident(&'a ast::Ident),
-    Name(&'a ast::Name),
-    Block(&'a ast::Block),
-    Item(&'a ast::Item),
-    SubItem(ast::NodeId),
-    Expr(&'a ast::Expr),
-    Pat(&'a ast::Pat),
-    Crate(&'a ast::Crate),
-}
+#[derive(PartialEq, Eq, Debug, PartialOrd, Ord, Copy, Clone)]
+pub struct BytePos(pub u32);
 
-pub trait PpAnn {
-    fn pre(&self, _state: &mut State<'_>, _node: AnnNode<'_>) { }
-    fn post(&self, _state: &mut State<'_>, _node: AnnNode<'_>) { }
+pub mod comments {
+    #[derive(Clone)]
+    pub struct Comment {
+        pub lines: Vec<String>,
+        pub pos: super::BytePos,
+    }
 }
 
-#[derive(Copy, Clone)]
-pub struct NoAnn;
-
-impl PpAnn for NoAnn {}
+pub enum MacHeader<'a> {
+    Path(&'a syn::Path),
+    Keyword(&'static str),
+}
 
-pub struct Comments<'a> {
-    cm: &'a SourceMap,
+pub struct Comments {
+    //cm: &'a SourceMap,
     comments: Vec<comments::Comment>,
     current: usize,
 }
 
-impl<'a> Comments<'a> {
+impl Comments {
     pub fn new(
-        cm: &'a SourceMap,
+        //cm: &'a SourceMap,
         comments: Vec<comments::Comment>,
-    ) -> Comments<'a> {
+    ) -> Comments {
         Comments {
-            cm,
+            //cm,
             comments,
             current: 0,
         }
@@ -85,10 +58,10 @@ impl<'a> Comments<'a> {
 
     pub fn trailing_comment(
         &mut self,
-        span: syntax_pos::Span,
-        next_pos: Option<BytePos>,
-    ) -> Option<comments::Comment> {
-        if let Some(cmnt) = self.next() {
+        span: proc_macro2::Span,
+        next_pos: Option<usize>,
+    ) -> Option<String> {
+        /*if let Some(cmnt) = self.next() {
             if cmnt.style != comments::Trailing { return None; }
             let span_line = self.cm.lookup_char_pos(span.hi());
             let comment_line = self.cm.lookup_char_pos(cmnt.pos);
@@ -96,13 +69,13 @@ impl<'a> Comments<'a> {
             if span.hi() < cmnt.pos && cmnt.pos < next && span_line.line == comment_line.line {
                 return Some(cmnt);
             }
-        }
+        }*/
 
         None
     }
 }
 
-impl<'a> Extend<comments::Comment> for Comments<'a> {
+impl Extend<comments::Comment> for Comments {
     fn extend<I>(&mut self, iter: I)
         where I: IntoIterator<Item = comments::Comment>
     {
@@ -111,2855 +84,173 @@ impl<'a> Extend<comments::Comment> for Comments<'a> {
 }
     
 
-pub struct State<'a> {
-    pub s: pp::Printer,
-    comments: Option<Comments<'a>>,
-    ann: &'a (dyn PpAnn+'a),
+pub struct State {
+    pub s: prettyplease::Printer,
+    comments: Option<Comments>,
     is_expanded: bool
 }
 
-crate const INDENT_UNIT: usize = 4;
-
-/// Requires you to pass an input filename and reader so that
-/// it can scan the input text for comments to copy forward.
-// pub fn print_crate<'a>(cm: &'a SourceMap,
-//                        sess: &ParseSess,
-//                        krate: &ast::Crate,
-//                        filename: FileName,
-//                        input: String,
-//                        ann: &'a dyn PpAnn,
-//                        is_expanded: bool) -> String {
-//     let mut s = State {
-//         s: pp::mk_printer(),
-//         comments: Some(Comments::parse(cm, sess, filename, input)),
-//         ann,
-//         is_expanded,
-//     };
-
-//     if is_expanded && sess.injected_crate_name.try_get().is_some() {
-//         // We need to print `#![no_std]` (and its feature gate) so that
-//         // compiling pretty-printed source won't inject libstd again.
-//         // However, we don't want these attributes in the AST because
-//         // of the feature gate, so we fake them up here.
-
-//         // `#![feature(prelude_import)]`
-//         let pi_nested = attr::mk_nested_word_item(ast::Ident::with_dummy_span(sym::prelude_import));
-//         let list = attr::mk_list_item(ast::Ident::with_dummy_span(sym::feature), vec![pi_nested]);
-//         let fake_attr = attr::mk_attr_inner(list);
-//         s.print_attribute(&fake_attr);
-
-//         // Currently, in Rust 2018 we don't have `extern crate std;` at the crate
-//         // root, so this is not needed, and actually breaks things.
-//         if sess.edition == syntax_pos::edition::Edition::Edition2015 {
-//             // `#![no_std]`
-//             let no_std_meta = attr::mk_word_item(ast::Ident::with_dummy_span(sym::no_std));
-//             let fake_attr = attr::mk_attr_inner(no_std_meta);
-//             s.print_attribute(&fake_attr);
-//         }
-//     }
-
-//     s.print_mod(&krate.module, &krate.attrs);
-//     s.print_remaining_comments();
-//     s.ann.post(&mut s, AnnNode::Crate(krate));
-//     s.s.eof()
-// }
-
 pub fn to_string<F>(f: F) -> String where
-    F: FnOnce(&mut State<'_>),
+    F: FnOnce(&mut State),
 {
     let mut printer = State {
-        s: pp::mk_printer(),
+        s: prettyplease::Printer::new(),
         comments: None,
-        ann: &NoAnn,
         is_expanded: false
     };
     f(&mut printer);
     printer.s.eof()
 }
 
-pub fn to_string_with_comments<'a, F>(comments: Comments<'a>, f: F) -> String where
-    F: FnOnce(&mut State<'_>)
+pub fn to_string_with_comments<F>(comments: Comments, f: F) -> String where
+    F: FnOnce(&mut State)
 {
     let mut printer = State {
-        s: pp::mk_printer(),
+        s: prettyplease::Printer::new(),
         comments: Some(comments),
-        ann: &NoAnn,
         is_expanded: false
     };
     f(&mut printer);
     printer.s.eof()
 }
 
-
-// This makes comma-separated lists look slightly nicer,
-// and also addresses a specific regression described in issue #63896.
-fn tt_prepend_space(tt: &TokenTree) -> bool {
-    match tt {
-        TokenTree::Token(token) => match token.kind {
-            token::Comma => false,
-            _ => true,
-        }
-        _ => true,
-    }
-}
-
-fn binop_to_string(op: BinOpToken) -> &'static str {
-    match op {
-        token::Plus     => "+",
-        token::Minus    => "-",
-        token::Star     => "*",
-        token::Slash    => "/",
-        token::Percent  => "%",
-        token::Caret    => "^",
-        token::And      => "&",
-        token::Or       => "|",
-        token::Shl      => "<<",
-        token::Shr      => ">>",
-    }
-}
-
-pub fn literal_to_string(lit: token::Lit) -> String {
-    let token::Lit { kind, symbol, suffix } = lit;
-    let mut out = match kind {
-        token::Byte          => format!("b'{}'", symbol),
-        token::Char          => format!("'{}'", symbol),
-        token::Str           => format!("\"{}\"", symbol),
-        token::StrRaw(n)     => format!("r{delim}\"{string}\"{delim}",
-                                        delim="#".repeat(n as usize),
-                                        string=symbol),
-        token::ByteStr       => format!("b\"{}\"", symbol),
-        token::ByteStrRaw(n) => format!("br{delim}\"{string}\"{delim}",
-                                        delim="#".repeat(n as usize),
-                                        string=symbol),
-        token::Integer       |
-        token::Float         |
-        token::Bool          |
-        token::Err           => symbol.to_string(),
-    };
-
-    if let Some(suffix) = suffix {
-        out.push_str(&suffix.as_str())
-    }
-
-    out
+pub fn literal_to_string(lit: syn::Lit) -> String {
+    let mut pr = prettyplease::Printer::new();
+    pr.lit(&lit);
+    pr.eof()
 }
 
 /// Print an ident from AST, `$crate` is converted into its respective crate name.
-pub fn ast_ident_to_string(ident: ast::Ident, is_raw: bool) -> String {
-    ident_to_string(ident.name, is_raw, Some(ident.span))
+pub fn ast_ident_to_string(ident: syn::Ident, is_raw: bool) -> String {
+    let mut pr = prettyplease::Printer::new();
+    pr.ident(&ident);
+    pr.eof()
 }
 
-// AST pretty-printer is used as a fallback for turning AST structures into token streams for
-// proc macros. Additionally, proc macros may stringify their input and expect it survive the
-// stringification (especially true for proc macro derives written between Rust 1.15 and 1.30).
-// So we need to somehow pretty-print `$crate` in a way preserving at least some of its
-// hygiene data, most importantly name of the crate it refers to.
-// As a result we print `$crate` as `crate` if it refers to the local crate
-// and as `::other_crate_name` if it refers to some other crate.
-// Note, that this is only done if the ident token is printed from inside of AST pretty-pringing,
-// but not otherwise. Pretty-printing is the only way for proc macros to discover token contents,
-// so we should not perform this lossy conversion if the top level call to the pretty-printer was
-// done for a token stream or a single token.
-fn ident_to_string(name: ast::Name, is_raw: bool, convert_dollar_crate: Option<Span>) -> String {
-    if is_raw {
-        format!("r#{}", name)
-    } else {
-        if name == kw::DollarCrate {
-            if let Some(span) = convert_dollar_crate {
-                let converted = span.ctxt().dollar_crate_name();
-                return if converted.is_path_segment_keyword() {
-                    converted.to_string()
-                } else {
-                    format!("::{}", converted)
-                }
-            }
-        }
-        name.to_string()
-    }
-}
-
-/// Print the token kind precisely, without converting `$crate` into its respective crate name.
-pub fn token_kind_to_string(tok: &TokenKind) -> String {
-    token_kind_to_string_ext(tok, None)
-}
-
-fn token_kind_to_string_ext(tok: &TokenKind, convert_dollar_crate: Option<Span>) -> String {
-    match *tok {
-        token::Eq                   => "=".to_string(),
-        token::Lt                   => "<".to_string(),
-        token::Le                   => "<=".to_string(),
-        token::EqEq                 => "==".to_string(),
-        token::Ne                   => "!=".to_string(),
-        token::Ge                   => ">=".to_string(),
-        token::Gt                   => ">".to_string(),
-        token::Not                  => "!".to_string(),
-        token::Tilde                => "~".to_string(),
-        token::OrOr                 => "||".to_string(),
-        token::AndAnd               => "&&".to_string(),
-        token::BinOp(op)            => binop_to_string(op).to_string(),
-        token::BinOpEq(op)          => format!("{}=", binop_to_string(op)),
-
-        /* Structural symbols */
-        token::At                   => "@".to_string(),
-        token::Dot                  => ".".to_string(),
-        token::DotDot               => "..".to_string(),
-        token::DotDotDot            => "...".to_string(),
-        token::DotDotEq             => "..=".to_string(),
-        token::Comma                => ",".to_string(),
-        token::Semi                 => ";".to_string(),
-        token::Colon                => ":".to_string(),
-        token::ModSep               => "::".to_string(),
-        token::RArrow               => "->".to_string(),
-        token::LArrow               => "<-".to_string(),
-        token::FatArrow             => "=>".to_string(),
-        token::OpenDelim(token::Paren) => "(".to_string(),
-        token::CloseDelim(token::Paren) => ")".to_string(),
-        token::OpenDelim(token::Bracket) => "[".to_string(),
-        token::CloseDelim(token::Bracket) => "]".to_string(),
-        token::OpenDelim(token::Brace) => "{".to_string(),
-        token::CloseDelim(token::Brace) => "}".to_string(),
-        token::OpenDelim(token::NoDelim) |
-        token::CloseDelim(token::NoDelim) => " ".to_string(),
-        token::Pound                => "#".to_string(),
-        token::Dollar               => "$".to_string(),
-        token::Question             => "?".to_string(),
-        token::SingleQuote          => "'".to_string(),
-
-        /* Literals */
-        token::Literal(lit) => literal_to_string(lit),
-
-        /* Name components */
-        token::Ident(s, is_raw)     => ident_to_string(s, is_raw, convert_dollar_crate),
-        token::Lifetime(s)          => s.to_string(),
-
-        /* Other */
-        token::DocComment(s)        => s.to_string(),
-        token::Eof                  => "<eof>".to_string(),
-        token::Whitespace           => " ".to_string(),
-        token::Comment              => "/* */".to_string(),
-        token::Shebang(s)           => format!("/* shebang: {}*/", s),
-        token::Unknown(s)           => s.to_string(),
-
-        token::Interpolated(ref nt) => nonterminal_to_string(nt),
-    }
-}
-
-/// Print the token precisely, without converting `$crate` into its respective crate name.
-pub fn token_to_string(token: &Token) -> String {
-    token_to_string_ext(token, false)
-}
-
-fn token_to_string_ext(token: &Token, convert_dollar_crate: bool) -> String {
-    let convert_dollar_crate = if convert_dollar_crate { Some(token.span) } else { None };
-    token_kind_to_string_ext(&token.kind, convert_dollar_crate)
-}
-
-pub fn nonterminal_to_string(nt: &Nonterminal) -> String {
-    match *nt {
-        token::NtExpr(ref e)        => expr_to_string(e),
-        token::NtMeta(ref e)        => attr_item_to_string(e),
-        token::NtTy(ref e)          => ty_to_string(e),
-        token::NtPath(ref e)        => path_to_string(e),
-        token::NtItem(ref e)        => item_to_string(e),
-        token::NtBlock(ref e)       => block_to_string(e),
-        token::NtStmt(ref e)        => stmt_to_string(e),
-        token::NtPat(ref e)         => pat_to_string(e),
-        token::NtIdent(e, is_raw)   => ast_ident_to_string(e, is_raw),
-        token::NtLifetime(e)        => e.to_string(),
-        token::NtLiteral(ref e)     => expr_to_string(e),
-        token::NtTT(ref tree)       => tt_to_string(tree.clone()),
-        token::NtImplItem(ref e)    => impl_item_to_string(e),
-        token::NtTraitItem(ref e)   => trait_item_to_string(e),
-        token::NtVis(ref e)         => vis_to_string(e),
-        token::NtForeignItem(ref e) => foreign_item_to_string(e),
-    }
-}
-
-pub fn ty_to_string(ty: &ast::Ty) -> String {
-    to_string(|s| s.print_type(ty))
-}
-
-pub fn bounds_to_string(bounds: &[ast::GenericBound]) -> String {
-    to_string(|s| s.print_type_bounds("", bounds))
+pub fn ty_to_string(ty: &syn::Type) -> String {
+    let mut pr = prettyplease::Printer::new();
+    pr.ty(ty);
+    pr.eof()
 }
 
-pub fn pat_to_string(pat: &ast::Pat) -> String {
-    to_string(|s| s.print_pat(pat))
+pub fn pat_to_string(pat: &syn::Pat) -> String {
+    let mut pr = prettyplease::Printer::new();
+    pr.pat(pat);
+    pr.eof()
 }
 
-pub fn expr_to_string(e: &ast::Expr) -> String {
-    to_string(|s| s.print_expr(e))
+pub fn expr_to_string(e: &syn::Expr) -> String {
+    let mut pr = prettyplease::Printer::new();
+    pr.expr(e);
+    pr.eof()
 }
 
-pub fn tt_to_string(tt: tokenstream::TokenTree) -> String {
-    to_string(|s| s.print_tt(tt, false))
+pub fn tt_to_string(tt: TokenTree) -> String {
+    let mut pr = prettyplease::Printer::new();
+    pr.single_token(tt.into(), |printer, stream| printer.macro_rules_tokens(stream, true));
+    pr.eof()
 }
 
 pub fn tts_to_string(tokens: TokenStream) -> String {
-    to_string(|s| s.print_tts(tokens, false))
-}
-
-pub fn stmt_to_string(stmt: &ast::Stmt) -> String {
-    to_string(|s| s.print_stmt(stmt))
-}
 
-pub fn item_to_string(i: &ast::Item) -> String {
-    to_string(|s| s.print_item(i))
+    //tokens.to_string()
+    let mut pr = prettyplease::Printer::new();
+    pr.macro_rules_tokens(tokens, true);
+    //pr.tts(tokens);
+    pr.eof()
 }
 
-pub fn impl_item_to_string(i: &ast::ImplItem) -> String {
-    to_string(|s| s.print_impl_item(i))
+pub fn stmt_to_string(stmt: &syn::Stmt) -> String {
+    let mut pr = prettyplease::Printer::new();
+    pr.stmt(stmt);
+    pr.eof()
 }
 
-pub fn trait_item_to_string(i: &ast::TraitItem) -> String {
-    to_string(|s| s.print_trait_item(i))
+pub fn item_to_string(i: &syn::Item) -> String {
+    let mut pr = prettyplease::Printer::new();
+    pr.item(i);
+    pr.eof()
 }
 
-pub fn generic_params_to_string(generic_params: &[ast::GenericParam]) -> String {
-    to_string(|s| s.print_generic_params(generic_params))
+pub fn impl_item_to_string(i: &syn::ImplItem) -> String {
+    let mut pr = prettyplease::Printer::new();
+    pr.impl_item(i);
+    pr.eof()
 }
 
-pub fn path_to_string(p: &ast::Path) -> String {
-    to_string(|s| s.print_path(p, false, 0))
+pub fn trait_item_to_string(i: &syn::TraitItem) -> String {
+    let mut pr = prettyplease::Printer::new();
+    pr.trait_item(i);
+    pr.eof()
 }
 
-pub fn path_segment_to_string(p: &ast::PathSegment) -> String {
-    to_string(|s| s.print_path_segment(p, false))
+pub fn generic_params_to_string(generic_params: &[syn::GenericParam]) -> String {
+    let mut pr = prettyplease::Printer::new();
+    for g in generic_params {
+        pr.generic_param(g);
+    }
+    pr.eof()
 }
 
-pub fn vis_to_string(v: &ast::Visibility) -> String {
-    to_string(|s| s.print_visibility(v))
+pub fn path_to_string(p: &syn::Path) -> String {
+    let mut pr = prettyplease::Printer::new();
+    pr.path(p);
+    pr.eof()
 }
 
-pub fn block_to_string(blk: &ast::Block) -> String {
-    to_string(|s| {
-        // Containing cbox, will be closed by `print_block` at `}`.
-        s.cbox(INDENT_UNIT);
-        // Head-ibox, will be closed by `print_block` after `{`.
-        s.ibox(0);
-        s.print_block(blk)
-    })
+pub fn path_segment_to_string(p: &syn::PathSegment) -> String {
+    let mut pr = prettyplease::Printer::new();
+    pr.path_segment(p);
+    pr.eof()
 }
 
-pub fn meta_list_item_to_string(li: &ast::NestedMetaItem) -> String {
-    to_string(|s| s.print_meta_list_item(li))
+pub fn vis_to_string(v: &syn::Visibility) -> String {
+    let mut pr = prettyplease::Printer::new();
+    pr.visibility(v);
+    pr.eof()
 }
 
-fn attr_item_to_string(ai: &ast::AttrItem) -> String {
-    to_string(|s| s.print_attr_item(ai, ai.path.span))
+pub fn block_to_string(blk: &syn::Block) -> String {
+    let mut pr = prettyplease::Printer::new();
+    pr.expr_block(&syn::ExprBlock {attrs: vec![], label: None, block: blk.clone()});
+    pr.eof()
 }
 
-pub fn attribute_to_string(attr: &ast::Attribute) -> String {
-    to_string(|s| s.print_attribute(attr))
+pub fn attribute_to_string(attr: &syn::Attribute) -> String {
+    let mut pr = prettyplease::Printer::new();
+    pr.attr(attr);
+    pr.eof()
 }
 
-pub fn param_to_string(arg: &ast::Param) -> String {
-    to_string(|s| s.print_param(arg, false))
+pub fn param_to_string(arg: &syn::FnArg) -> String {
+    let mut pr = prettyplease::Printer::new();
+    let _ = pr.maybe_variadic(arg);
+    pr.eof()
 }
 
-pub fn foreign_item_to_string(arg: &ast::ForeignItem) -> String {
-    to_string(|s| s.print_foreign_item(arg))
+pub fn foreign_item_to_string(arg: &syn::ForeignItem) -> String {
+    let mut pr = prettyplease::Printer::new();
+    pr.foreign_item(arg);
+    pr.eof()
 }
 
-pub fn visibility_qualified(vis: &ast::Visibility, s: &str) -> String {
-    format!("{}{}", to_string(|s| s.print_visibility(vis)), s)
+pub fn visibility_qualified(vis: &syn::Visibility, s: &str) -> String {
+    let mut pr = prettyplease::Printer::new();
+    pr.visibility(vis);
+    let mut out = pr.eof();
+    out += s;
+    out
 }
 
-impl std::ops::Deref for State<'_> {
-    type Target = pp::Printer;
+impl std::ops::Deref for State {
+    type Target = prettyplease::Printer;
     fn deref(&self) -> &Self::Target {
         &self.s
     }
 }
 
-impl std::ops::DerefMut for State<'_> {
+impl std::ops::DerefMut for State {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.s
     }
 }
-
-pub trait PrintState<'a>: std::ops::Deref<Target = pp::Printer> + std::ops::DerefMut {
-    fn comments(&mut self) -> &mut Option<Comments<'a>>;
-    fn print_ident(&mut self, ident: ast::Ident);
-    fn print_generic_args(&mut self, args: &ast::GenericArgs, colons_before_params: bool);
-
-    fn strsep<T, F>(&mut self, sep: &'static str, space_before: bool,
-                    b: Breaks, elts: &[T], mut op: F)
-        where F: FnMut(&mut Self, &T),
-    {
-        self.rbox(0, b);
-        if let Some((first, rest)) = elts.split_first() {
-            op(self, first);
-            for elt in rest {
-                if space_before {
-                    self.space();
-                }
-                self.word_space(sep);
-                op(self, elt);
-            }
-        }
-        self.end();
-    }
-
-    fn commasep<T, F>(&mut self, b: Breaks, elts: &[T], op: F)
-        where F: FnMut(&mut Self, &T),
-    {
-        self.strsep(",", false, b, elts, op)
-    }
-
-    fn maybe_print_comment(&mut self, pos: BytePos) {
-        while let Some(ref cmnt) = self.next_comment() {
-            if cmnt.pos < pos {
-                self.print_comment(cmnt);
-            } else {
-                break
-            }
-        }
-    }
-
-    fn print_comment(&mut self,
-                     cmnt: &comments::Comment) {
-        match cmnt.style {
-            comments::Mixed => {
-                assert_eq!(cmnt.lines.len(), 1);
-                self.zerobreak();
-                self.word(cmnt.lines[0].clone());
-                self.zerobreak()
-            }
-            comments::Isolated => {
-                self.hardbreak_if_not_bol();
-                for line in &cmnt.lines {
-                    // Don't print empty lines because they will end up as trailing
-                    // whitespace.
-                    if !line.is_empty() {
-                        self.word(line.clone());
-                    }
-                    self.hardbreak();
-                }
-            }
-            comments::Trailing => {
-                if !self.is_beginning_of_line() {
-                    self.word(" ");
-                }
-                if cmnt.lines.len() == 1 {
-                    self.word(cmnt.lines[0].clone());
-                    self.hardbreak()
-                } else {
-                    self.ibox(0);
-                    for line in &cmnt.lines {
-                        if !line.is_empty() {
-                            self.word(line.clone());
-                        }
-                        self.hardbreak();
-                    }
-                    self.end();
-                }
-            }
-            comments::BlankLine => {
-                // We need to do at least one, possibly two hardbreaks.
-                let twice = match self.last_token() {
-                    pp::Token::String(s) => ";" == s,
-                    pp::Token::Begin(_) => true,
-                    pp::Token::End => true,
-                    _ => false
-                };
-                if twice {
-                    self.hardbreak();
-                }
-                self.hardbreak();
-            }
-        }
-        if let Some(cm) = self.comments() {
-            cm.current += 1;
-        }
-    }
-
-    fn next_comment(&mut self) -> Option<comments::Comment> {
-        self.comments().as_mut().and_then(|c| c.next())
-    }
-
-    fn print_literal(&mut self, lit: &ast::Lit) {
-        self.maybe_print_comment(lit.span.lo());
-        self.word(lit.token.to_string())
-    }
-
-    fn print_string(&mut self, st: &str,
-                    style: ast::StrStyle) {
-        let st = match style {
-            ast::StrStyle::Cooked => {
-                (format!("\"{}\"", st.escape_debug()))
-            }
-            ast::StrStyle::Raw(n) => {
-                (format!("r{delim}\"{string}\"{delim}",
-                         delim="#".repeat(n as usize),
-                         string=st))
-            }
-        };
-        self.word(st)
-    }
-
-    fn print_inner_attributes(&mut self,
-                              attrs: &[ast::Attribute]) {
-        self.print_either_attributes(attrs, ast::AttrStyle::Inner, false, true)
-    }
-
-    fn print_inner_attributes_no_trailing_hardbreak(&mut self,
-                                                   attrs: &[ast::Attribute])
-                                                   {
-        self.print_either_attributes(attrs, ast::AttrStyle::Inner, false, false)
-    }
-
-    fn print_outer_attributes(&mut self,
-                              attrs: &[ast::Attribute]) {
-        self.print_either_attributes(attrs, ast::AttrStyle::Outer, false, true)
-    }
-
-    fn print_inner_attributes_inline(&mut self,
-                                     attrs: &[ast::Attribute]) {
-        self.print_either_attributes(attrs, ast::AttrStyle::Inner, true, true)
-    }
-
-    fn print_outer_attributes_inline(&mut self,
-                                     attrs: &[ast::Attribute]) {
-        self.print_either_attributes(attrs, ast::AttrStyle::Outer, true, true)
-    }
-
-    fn print_either_attributes(&mut self,
-                              attrs: &[ast::Attribute],
-                              kind: ast::AttrStyle,
-                              is_inline: bool,
-                              trailing_hardbreak: bool) {
-        let mut count = 0;
-        for attr in attrs {
-            if attr.style == kind {
-                self.print_attribute_inline(attr, is_inline);
-                if is_inline {
-                    self.nbsp();
-                }
-                count += 1;
-            }
-        }
-        if count > 0 && trailing_hardbreak && !is_inline {
-            self.hardbreak_if_not_bol();
-        }
-    }
-
-    fn print_attribute(&mut self, attr: &ast::Attribute) {
-        self.print_attribute_inline(attr, false)
-    }
-
-    fn print_attribute_inline(&mut self, attr: &ast::Attribute,
-                              is_inline: bool) {
-        if !is_inline {
-            self.hardbreak_if_not_bol();
-        }
-        self.maybe_print_comment(attr.span.lo());
-        match attr.kind {
-            ast::AttrKind::Normal(ref item) => {
-                match attr.style {
-                    ast::AttrStyle::Inner => self.word("#!["),
-                    ast::AttrStyle::Outer => self.word("#["),
-                }
-                self.print_attr_item(&item, attr.span);
-                self.word("]");
-            }
-            ast::AttrKind::DocComment(comment) => {
-                self.word(comment.to_string());
-                self.hardbreak()
-            }
-        }
-    }
-
-    fn print_attr_item(&mut self, item: &ast::AttrItem, span: Span) {
-        self.ibox(0);
-        match &item.args {
-            MacArgs::Delimited(_, delim, tokens) => {
-                let delim = match delim {
-                    MacDelimiter::Parenthesis => DelimToken::Paren,
-                    MacDelimiter::Bracket => DelimToken::Bracket,
-                    MacDelimiter::Brace => DelimToken::Brace,
-                };
-
-                self.print_mac_common(
-                    Some(MacHeader::Path(&item.path)),
-                    false,
-                    None,
-                    delim,
-                    tokens.clone(),
-                    true,
-                    span,
-                )
-            }
-            MacArgs::Empty | MacArgs::Eq(..) => {
-                self.print_path(&item.path, false, 0);
-                if let MacArgs::Eq(_, tokens) = &item.args {
-                    self.space();
-                    self.word_space("=");
-                    self.print_tts(tokens.clone(), true);
-                }
-            }
-        }
-        self.end();
-    }
-
-    fn print_meta_list_item(&mut self, item: &ast::NestedMetaItem) {
-        match item {
-            ast::NestedMetaItem::MetaItem(ref mi) => {
-                self.print_meta_item(mi)
-            },
-            ast::NestedMetaItem::Literal(ref lit) => {
-                self.print_literal(lit)
-            }
-        }
-    }
-
-    fn print_meta_item(&mut self, item: &ast::MetaItem) {
-        self.ibox(INDENT_UNIT);
-        match item.kind {
-            ast::MetaItemKind::Word => self.print_path(&item.path, false, 0),
-            ast::MetaItemKind::NameValue(ref value) => {
-                self.print_path(&item.path, false, 0);
-                self.space();
-                self.word_space("=");
-                self.print_literal(value);
-            }
-            ast::MetaItemKind::List(ref items) => {
-                self.print_path(&item.path, false, 0);
-                self.popen();
-                self.commasep(Consistent,
-                              &items[..],
-                              |s, i| s.print_meta_list_item(i));
-                self.pclose();
-            }
-        }
-        self.end();
-    }
-
-    /// This doesn't deserve to be called "pretty" printing, but it should be
-    /// meaning-preserving. A quick hack that might help would be to look at the
-    /// spans embedded in the TTs to decide where to put spaces and newlines.
-    /// But it'd be better to parse these according to the grammar of the
-    /// appropriate macro, transcribe back into the grammar we just parsed from,
-    /// and then pretty-print the resulting AST nodes (so, e.g., we print
-    /// expression arguments as expressions). It can be done! I think.
-    fn print_tt(&mut self, tt: tokenstream::TokenTree, convert_dollar_crate: bool) {
-        match tt {
-            TokenTree::Token(ref token) => {
-                self.word(token_to_string_ext(&token, convert_dollar_crate));
-                match token.kind {
-                    token::DocComment(..) => {
-                        self.hardbreak()
-                    }
-                    _ => {}
-                }
-            }
-            TokenTree::Delimited(dspan, delim, tts) => {
-                self.print_mac_common(
-                    None, false, None, delim, tts, convert_dollar_crate, dspan.entire()
-                );
-            }
-        }
-    }
-
-    fn print_tts(&mut self, tts: tokenstream::TokenStream, convert_dollar_crate: bool) {
-        for (i, tt) in tts.into_trees().enumerate() {
-            if i != 0 && tt_prepend_space(&tt) {
-                self.space();
-            }
-            self.print_tt(tt, convert_dollar_crate);
-        }
-    }
-
-    fn print_mac_common(
-        &mut self,
-        header: Option<MacHeader<'_>>,
-        has_bang: bool,
-        ident: Option<ast::Ident>,
-        delim: DelimToken,
-        tts: TokenStream,
-        convert_dollar_crate: bool,
-        span: Span,
-    ) {
-        if delim == DelimToken::Brace {
-            self.cbox(INDENT_UNIT);
-        }
-        match header {
-            Some(MacHeader::Path(path)) => self.print_path(path, false, 0),
-            Some(MacHeader::Keyword(kw)) => self.word(kw),
-            None => {}
-        }
-        if has_bang {
-            self.word("!");
-        }
-        if let Some(ident) = ident {
-            self.nbsp();
-            self.print_ident(ident);
-        }
-        match delim {
-            DelimToken::Brace => {
-                if header.is_some() || has_bang || ident.is_some() {
-                    self.nbsp();
-                }
-                self.word("{");
-                if !tts.is_empty() {
-                    self.space();
-                }
-            }
-            _ => self.word(token_kind_to_string(&token::OpenDelim(delim))),
-        }
-        self.ibox(0);
-        self.print_tts(tts, convert_dollar_crate);
-        self.end();
-        match delim {
-            DelimToken::Brace => self.bclose(span),
-            _ => self.word(token_kind_to_string(&token::CloseDelim(delim))),
-        }
-    }
-
-    fn print_path(&mut self, path: &ast::Path, colons_before_params: bool, depth: usize) {
-        self.maybe_print_comment(path.span.lo());
-
-        for (i, segment) in path.segments[..path.segments.len() - depth].iter().enumerate() {
-            if i > 0 {
-                self.word("::")
-            }
-            self.print_path_segment(segment, colons_before_params);
-        }
-    }
-
-    fn print_path_segment(&mut self, segment: &ast::PathSegment, colons_before_params: bool) {
-        if segment.ident.name != kw::PathRoot {
-            self.print_ident(segment.ident);
-            if let Some(ref args) = segment.args {
-                self.print_generic_args(args, colons_before_params);
-            }
-        }
-    }
-
-    fn head<S: Into<Cow<'static, str>>>(&mut self, w: S) {
-        let w = w.into();
-        // Outer-box is consistent.
-        self.cbox(INDENT_UNIT);
-        // Head-box is inconsistent.
-        self.ibox(w.len() + 1);
-        // Keyword that starts the head.
-        if !w.is_empty() {
-            self.word_nbsp(w);
-        }
-    }
-
-    fn bopen(&mut self) {
-        self.word("{");
-        self.end(); // Close the head-box.
-    }
-
-    fn bclose_maybe_open(&mut self, span: syntax_pos::Span, close_box: bool) {
-        self.maybe_print_comment(span.hi());
-        self.break_offset_if_not_bol(1, -(INDENT_UNIT as isize));
-        self.word("}");
-        if close_box {
-            self.end(); // Close the outer-box.
-        }
-    }
-
-    fn bclose(&mut self, span: syntax_pos::Span) {
-        self.bclose_maybe_open(span, true)
-    }
-
-    fn break_offset_if_not_bol(&mut self, n: usize, off: isize) {
-        if !self.is_beginning_of_line() {
-            self.break_offset(n, off)
-        } else {
-            if off != 0 && self.last_token().is_hardbreak_tok() {
-                // We do something pretty sketchy here: tuck the nonzero
-                // offset-adjustment we were going to deposit along with the
-                // break into the previous hardbreak.
-                self.replace_last_token(pp::Printer::hardbreak_tok_offset(off));
-            }
-        }
-    }
-}
-
-impl<'a> PrintState<'a> for State<'a> {
-    fn comments(&mut self) -> &mut Option<Comments<'a>> {
-        &mut self.comments
-    }
-
-    fn print_ident(&mut self, ident: ast::Ident) {
-        self.s.word(ast_ident_to_string(ident, ident.is_raw_guess()));
-        self.ann.post(self, AnnNode::Ident(&ident))
-    }
-
-    fn print_generic_args(&mut self, args: &ast::GenericArgs, colons_before_params: bool) {
-        if colons_before_params {
-            self.s.word("::")
-        }
-
-        match *args {
-            ast::GenericArgs::AngleBracketed(ref data) => {
-                self.s.word("<");
-
-                self.commasep(Inconsistent, &data.args, |s, generic_arg| {
-                    s.print_generic_arg(generic_arg)
-                });
-
-                let mut comma = data.args.len() != 0;
-
-                for constraint in data.constraints.iter() {
-                    if comma {
-                        self.word_space(",")
-                    }
-                    self.print_ident(constraint.ident);
-                    self.s.space();
-                    match constraint.kind {
-                        ast::AssocTyConstraintKind::Equality { ref ty } => {
-                            self.word_space("=");
-                            self.print_type(ty);
-                        }
-                        ast::AssocTyConstraintKind::Bound { ref bounds } => {
-                            self.print_type_bounds(":", &*bounds);
-                        }
-                    }
-                    comma = true;
-                }
-
-                self.s.word(">")
-            }
-
-            ast::GenericArgs::Parenthesized(ref data) => {
-                self.s.word("(");
-                self.commasep(
-                    Inconsistent,
-                    &data.inputs,
-                    |s, ty| s.print_type(ty));
-                self.s.word(")");
-
-                if let Some(ref ty) = data.output {
-                    self.space_if_not_bol();
-                    self.word_space("->");
-                    self.print_type(ty);
-                }
-            }
-        }
-    }
-}
-
-impl<'a> State<'a> {
-    // Synthesizes a comment that was not textually present in the original source
-    // file.
-    pub fn synth_comment(&mut self, text: String) {
-        self.s.word("/*");
-        self.s.space();
-        self.s.word(text);
-        self.s.space();
-        self.s.word("*/")
-    }
-
-    pub fn commasep_cmnt<T, F, G>(&mut self,
-                                  b: Breaks,
-                                  elts: &[T],
-                                  mut op: F,
-                                  mut get_span: G) where
-        F: FnMut(&mut State<'_>, &T),
-        G: FnMut(&T) -> syntax_pos::Span,
-    {
-        self.rbox(0, b);
-        let len = elts.len();
-        let mut i = 0;
-        for elt in elts {
-            self.maybe_print_comment(get_span(elt).hi());
-            op(self, elt);
-            i += 1;
-            if i < len {
-                self.s.word(",");
-                self.maybe_print_trailing_comment(get_span(elt),
-                                                  Some(get_span(&elts[i]).hi()));
-                self.space_if_not_bol();
-            }
-        }
-        self.end();
-    }
-
-    pub fn commasep_exprs(&mut self, b: Breaks,
-                            exprs: &[P<ast::Expr>]) {
-        self.commasep_cmnt(b, exprs, |s, e| s.print_expr(e), |e| e.span)
-    }
-
-    pub fn print_mod(
-        &mut self,
-        _mod: &ast::Mod,
-        attrs: &[ast::Attribute],
-    ) {
-       self.print_inner_attributes(attrs);
-        for item in &_mod.items {
-            self.print_item(item);
-        }
-    }
-
-    pub fn print_foreign_mod(&mut self, nmod: &ast::ForeignMod,
-                               attrs: &[ast::Attribute]) {
-        self.print_inner_attributes(attrs);
-        for item in &nmod.items {
-            self.print_foreign_item(item);
-        }
-    }
-
-    pub fn print_opt_lifetime(&mut self, lifetime: &Option<ast::Lifetime>) {
-        if let Some(lt) = *lifetime {
-            self.print_lifetime(lt);
-            self.nbsp();
-        }
-    }
-
-    pub fn print_generic_arg(&mut self, generic_arg: &GenericArg) {
-        match generic_arg {
-            GenericArg::Lifetime(lt) => self.print_lifetime(*lt),
-            GenericArg::Type(ty) => self.print_type(ty),
-            GenericArg::Const(ct) => self.print_expr(&ct.value),
-        }
-    }
-
-    pub fn print_type(&mut self, ty: &ast::Ty) {
-        self.maybe_print_comment(ty.span.lo());
-        self.ibox(0);
-        match ty.kind {
-            ast::TyKind::Slice(ref ty) => {
-                self.s.word("[");
-                self.print_type(ty);
-                self.s.word("]");
-            }
-            ast::TyKind::Ptr(ref mt) => {
-                self.s.word("*");
-                self.print_mt(mt, true);
-            }
-            ast::TyKind::Rptr(ref lifetime, ref mt) => {
-                self.s.word("&");
-                self.print_opt_lifetime(lifetime);
-                self.print_mt(mt, false);
-            }
-            ast::TyKind::Never => {
-                self.s.word("!");
-            },
-            ast::TyKind::Tup(ref elts) => {
-                self.popen();
-                self.commasep(Inconsistent, &elts[..],
-                              |s, ty| s.print_type(ty));
-                if elts.len() == 1 {
-                    self.s.word(",");
-                }
-                self.pclose();
-            }
-            ast::TyKind::Paren(ref typ) => {
-                self.popen();
-                self.print_type(typ);
-                self.pclose();
-            }
-            ast::TyKind::BareFn(ref f) => {
-                self.print_ty_fn(f.ext,
-                                 f.unsafety,
-                                 &f.decl,
-                                 None,
-                                 &f.generic_params);
-            }
-            ast::TyKind::Path(None, ref path) => {
-                self.print_path(path, false, 0);
-            }
-            ast::TyKind::Path(Some(ref qself), ref path) => {
-                self.print_qpath(path, qself, false)
-            }
-            ast::TyKind::TraitObject(ref bounds, syntax) => {
-                let prefix = if syntax == ast::TraitObjectSyntax::Dyn { "dyn" } else { "" };
-                self.print_type_bounds(prefix, &bounds[..]);
-            }
-            ast::TyKind::ImplTrait(_, ref bounds) => {
-                self.print_type_bounds("impl", &bounds[..]);
-            }
-            ast::TyKind::Array(ref ty, ref length) => {
-                self.s.word("[");
-                self.print_type(ty);
-                self.s.word("; ");
-                self.print_expr(&length.value);
-                self.s.word("]");
-            }
-            ast::TyKind::Typeof(ref e) => {
-                self.s.word("typeof(");
-                self.print_expr(&e.value);
-                self.s.word(")");
-            }
-            ast::TyKind::Infer => {
-                self.s.word("_");
-            }
-            ast::TyKind::Err => {
-                self.popen();
-                self.s.word("/*ERROR*/");
-                self.pclose();
-            }
-            ast::TyKind::ImplicitSelf => {
-                self.s.word("Self");
-            }
-            ast::TyKind::Mac(ref m) => {
-                self.print_mac(m);
-            }
-            ast::TyKind::CVarArgs => {
-                self.s.word("...");
-            }
-        }
-        self.end();
-    }
-
-    pub fn print_foreign_item(&mut self,
-                              item: &ast::ForeignItem) {
-        self.hardbreak_if_not_bol();
-        self.maybe_print_comment(item.span.lo());
-        self.print_outer_attributes(&item.attrs);
-        match item.kind {
-            ast::ForeignItemKind::Fn(ref decl, ref generics) => {
-                self.head("");
-                self.print_fn(decl, ast::FnHeader::default(),
-                              Some(item.ident),
-                              generics, &item.vis);
-                self.end(); // end head-ibox
-                self.s.word(";");
-                self.end(); // end the outer fn box
-            }
-            ast::ForeignItemKind::Static(ref t, m) => {
-                self.head(visibility_qualified(&item.vis, "static"));
-                if m == ast::Mutability::Mutable {
-                    self.word_space("mut");
-                }
-                self.print_ident(item.ident);
-                self.word_space(":");
-                self.print_type(t);
-                self.s.word(";");
-                self.end(); // end the head-ibox
-                self.end(); // end the outer cbox
-            }
-            ast::ForeignItemKind::Ty => {
-                self.head(visibility_qualified(&item.vis, "type"));
-                self.print_ident(item.ident);
-                self.s.word(";");
-                self.end(); // end the head-ibox
-                self.end(); // end the outer cbox
-            }
-            ast::ForeignItemKind::Macro(ref m) => {
-                self.print_mac(m);
-                if m.args.need_semicolon() {
-                    self.s.word(";");
-                }
-            }
-        }
-    }
-
-    fn print_associated_const(&mut self,
-                              ident: ast::Ident,
-                              ty: &ast::Ty,
-                              default: Option<&ast::Expr>,
-                              vis: &ast::Visibility)
-    {
-        self.s.word(visibility_qualified(vis, ""));
-        self.word_space("const");
-        self.print_ident(ident);
-        self.word_space(":");
-        self.print_type(ty);
-        if let Some(expr) = default {
-            self.s.space();
-            self.word_space("=");
-            self.print_expr(expr);
-        }
-        self.s.word(";")
-    }
-
-    fn print_associated_type(&mut self,
-                             ident: ast::Ident,
-                             bounds: Option<&ast::GenericBounds>,
-                             ty: Option<&ast::Ty>)
-                             {
-        self.word_space("type");
-        self.print_ident(ident);
-        if let Some(bounds) = bounds {
-            self.print_type_bounds(":", bounds);
-        }
-        if let Some(ty) = ty {
-            self.s.space();
-            self.word_space("=");
-            self.print_type(ty);
-        }
-        self.s.word(";")
-    }
-
-    /// Pretty-prints an item.
-    pub fn print_item(&mut self, item: &ast::Item) {
-        self.hardbreak_if_not_bol();
-        self.maybe_print_comment(item.span.lo());
-        self.print_outer_attributes(&item.attrs);
-        self.ann.pre(self, AnnNode::Item(item));
-        match item.kind {
-            ast::ItemKind::ExternCrate(orig_name) => {
-                self.head(visibility_qualified(&item.vis, "extern crate"));
-                if let Some(orig_name) = orig_name {
-                    self.print_name(orig_name);
-                    self.s.space();
-                    self.s.word("as");
-                    self.s.space();
-                }
-                self.print_ident(item.ident);
-                self.s.word(";");
-                self.end(); // end inner head-block
-                self.end(); // end outer head-block
-            }
-            ast::ItemKind::Use(ref tree) => {
-                self.head(visibility_qualified(&item.vis, "use"));
-                self.print_use_tree(tree);
-                self.s.word(";");
-                self.end(); // end inner head-block
-                self.end(); // end outer head-block
-            }
-            ast::ItemKind::Static(ref ty, m, ref expr) => {
-                self.head(visibility_qualified(&item.vis, "static"));
-                if m == ast::Mutability::Mutable {
-                    self.word_space("mut");
-                }
-                self.print_ident(item.ident);
-                self.word_space(":");
-                self.print_type(ty);
-                self.s.space();
-                self.end(); // end the head-ibox
-
-                self.word_space("=");
-                self.print_expr(expr);
-                self.s.word(";");
-                self.end(); // end the outer cbox
-            }
-            ast::ItemKind::Const(ref ty, ref expr) => {
-                self.head(visibility_qualified(&item.vis, "const"));
-                self.print_ident(item.ident);
-                self.word_space(":");
-                self.print_type(ty);
-                self.s.space();
-                self.end(); // end the head-ibox
-
-                self.word_space("=");
-                self.print_expr(expr);
-                self.s.word(";");
-                self.end(); // end the outer cbox
-            }
-            ast::ItemKind::Fn(ref sig, ref param_names, ref body) => {
-                self.head("");
-                self.print_fn(
-                    &sig.decl,
-                    sig.header,
-                    Some(item.ident),
-                    param_names,
-                    &item.vis
-                );
-                self.s.word(" ");
-                self.print_block_with_attrs(body, &item.attrs);
-            }
-            ast::ItemKind::Mod(ref _mod) => {
-                self.head(visibility_qualified(&item.vis, "mod"));
-                self.print_ident(item.ident);
-
-                if _mod.inline || self.is_expanded {
-                    self.nbsp();
-                    self.bopen();
-                    self.print_mod(_mod, &item.attrs);
-                    self.bclose(item.span);
-                } else {
-                    self.s.word(";");
-                    self.end(); // end inner head-block
-                    self.end(); // end outer head-block
-                }
-
-            }
-            ast::ItemKind::ForeignMod(ref nmod) => {
-                self.head("extern");
-                if let Some(abi) = nmod.abi {
-                    self.print_literal(&syntax_priv::as_lit(&abi));
-                    self.nbsp();
-                }
-                self.bopen();
-                self.print_foreign_mod(nmod, &item.attrs);
-                self.bclose(item.span);
-            }
-            ast::ItemKind::GlobalAsm(ref ga) => {
-                self.head(visibility_qualified(&item.vis, "global_asm!"));
-                self.s.word(ga.asm.to_string());
-                self.end();
-            }
-            ast::ItemKind::TyAlias(ref ty, ref generics) => {
-                self.head(visibility_qualified(&item.vis, "type"));
-                self.print_ident(item.ident);
-                self.print_generic_params(&generics.params);
-                self.end(); // end the inner ibox
-
-                self.print_where_clause(&generics.where_clause);
-                self.s.space();
-                self.word_space("=");
-                self.print_type(ty);
-                self.s.word(";");
-                self.end(); // end the outer ibox
-            }
-            ast::ItemKind::Enum(ref enum_definition, ref params) => {
-                self.print_enum_def(
-                    enum_definition,
-                    params,
-                    item.ident,
-                    item.span,
-                    &item.vis
-                );
-            }
-            ast::ItemKind::Struct(ref struct_def, ref generics) => {
-                self.head(visibility_qualified(&item.vis, "struct"));
-                self.print_struct(struct_def, generics, item.ident, item.span, true);
-            }
-            ast::ItemKind::Union(ref struct_def, ref generics) => {
-                self.head(visibility_qualified(&item.vis, "union"));
-                self.print_struct(struct_def, generics, item.ident, item.span, true);
-            }
-            ast::ItemKind::Impl(unsafety,
-                          polarity,
-                          defaultness,
-                          ref generics,
-                          ref opt_trait,
-                          ref ty,
-                          ref impl_items) => {
-                self.head("");
-                self.print_visibility(&item.vis);
-                self.print_defaultness(defaultness);
-                self.print_unsafety(unsafety);
-                self.word_nbsp("impl");
-
-                if !generics.params.is_empty() {
-                    self.print_generic_params(&generics.params);
-                    self.s.space();
-                }
-
-                if polarity == ast::ImplPolarity::Negative {
-                    self.s.word("!");
-                }
-
-                if let Some(ref t) = *opt_trait {
-                    self.print_trait_ref(t);
-                    self.s.space();
-                    self.word_space("for");
-                }
-
-                self.print_type(ty);
-                self.print_where_clause(&generics.where_clause);
-
-                self.s.space();
-                self.bopen();
-                self.print_inner_attributes(&item.attrs);
-                for impl_item in impl_items {
-                    self.print_impl_item(impl_item);
-                }
-                self.bclose(item.span);
-            }
-            ast::ItemKind::Trait(is_auto, unsafety, ref generics, ref bounds, ref trait_items) => {
-                self.head("");
-                self.print_visibility(&item.vis);
-                self.print_unsafety(unsafety);
-                self.print_is_auto(is_auto);
-                self.word_nbsp("trait");
-                self.print_ident(item.ident);
-                self.print_generic_params(&generics.params);
-                let mut real_bounds = Vec::with_capacity(bounds.len());
-                for b in bounds.iter() {
-                    if let GenericBound::Trait(ref ptr, ast::TraitBoundModifier::Maybe) = *b {
-                        self.s.space();
-                        self.word_space("for ?");
-                        self.print_trait_ref(&ptr.trait_ref);
-                    } else {
-                        real_bounds.push(b.clone());
-                    }
-                }
-                self.print_type_bounds(":", &real_bounds[..]);
-                self.print_where_clause(&generics.where_clause);
-                self.s.word(" ");
-                self.bopen();
-                for trait_item in trait_items {
-                    self.print_trait_item(trait_item);
-                }
-                self.bclose(item.span);
-            }
-            ast::ItemKind::TraitAlias(ref generics, ref bounds) => {
-                self.head("");
-                self.print_visibility(&item.vis);
-                self.word_nbsp("trait");
-                self.print_ident(item.ident);
-                self.print_generic_params(&generics.params);
-                let mut real_bounds = Vec::with_capacity(bounds.len());
-                // FIXME(durka) this seems to be some quite outdated syntax
-                for b in bounds.iter() {
-                    if let GenericBound::Trait(ref ptr, ast::TraitBoundModifier::Maybe) = *b {
-                        self.s.space();
-                        self.word_space("for ?");
-                        self.print_trait_ref(&ptr.trait_ref);
-                    } else {
-                        real_bounds.push(b.clone());
-                    }
-                }
-                self.nbsp();
-                self.print_type_bounds("=", &real_bounds[..]);
-                self.print_where_clause(&generics.where_clause);
-                self.s.word(";");
-            }
-            ast::ItemKind::Mac(ref mac) => {
-                self.print_mac(mac);
-                if mac.args.need_semicolon() {
-                    self.s.word(";");
-                }
-            }
-            ast::ItemKind::MacroDef(ref macro_def) => {
-                let (kw, has_bang) = if macro_def.legacy {
-                    ("macro_rules", true)
-                } else {
-                    self.print_visibility(&item.vis);
-                    ("macro", false)
-                };
-                self.print_mac_common(
-                    Some(MacHeader::Keyword(kw)),
-                    has_bang,
-                    Some(item.ident),
-                    macro_def.body.delim(),
-                    macro_def.body.inner_tokens(),
-                    true,
-                    item.span,
-                );
-            }
-        }
-        self.ann.post(self, AnnNode::Item(item))
-    }
-
-    fn print_trait_ref(&mut self, t: &ast::TraitRef) {
-        self.print_path(&t.path, false, 0)
-    }
-
-    fn print_formal_generic_params(
-        &mut self,
-        generic_params: &[ast::GenericParam]
-    ) {
-        if !generic_params.is_empty() {
-            self.s.word("for");
-            self.print_generic_params(generic_params);
-            self.nbsp();
-        }
-    }
-
-    fn print_poly_trait_ref(&mut self, t: &ast::PolyTraitRef) {
-        self.print_formal_generic_params(&t.bound_generic_params);
-        self.print_trait_ref(&t.trait_ref)
-    }
-
-    pub fn print_enum_def(&mut self, enum_definition: &ast::EnumDef,
-                          generics: &ast::Generics, ident: ast::Ident,
-                          span: syntax_pos::Span,
-                          visibility: &ast::Visibility) {
-        self.head(visibility_qualified(visibility, "enum"));
-        self.print_ident(ident);
-        self.print_generic_params(&generics.params);
-        self.print_where_clause(&generics.where_clause);
-        self.s.space();
-        self.print_variants(&enum_definition.variants, span)
-    }
-
-    pub fn print_variants(&mut self,
-                          variants: &[ast::Variant],
-                          span: syntax_pos::Span) {
-        self.bopen();
-        for v in variants {
-            self.space_if_not_bol();
-            self.maybe_print_comment(v.span.lo());
-            self.print_outer_attributes(&v.attrs);
-            self.ibox(INDENT_UNIT);
-            self.print_variant(v);
-            self.s.word(",");
-            self.end();
-            self.maybe_print_trailing_comment(v.span, None);
-        }
-        self.bclose(span)
-    }
-
-    pub fn print_visibility(&mut self, vis: &ast::Visibility) {
-        match vis.node {
-            ast::VisibilityKind::Public => self.word_nbsp("pub"),
-            ast::VisibilityKind::Crate(sugar) => match sugar {
-                ast::CrateSugar::PubCrate => self.word_nbsp("pub(crate)"),
-                ast::CrateSugar::JustCrate => self.word_nbsp("crate")
-            }
-            ast::VisibilityKind::Restricted { ref path, .. } => {
-                let path = to_string(|s| s.print_path(path, false, 0));
-                if path == "self" || path == "super" {
-                    self.word_nbsp(format!("pub({})", path))
-                } else {
-                    self.word_nbsp(format!("pub(in {})", path))
-                }
-            }
-            ast::VisibilityKind::Inherited => {}
-        }
-    }
-
-    pub fn print_defaultness(&mut self, defaultness: ast::Defaultness) {
-        if let ast::Defaultness::Default = defaultness {
-            self.word_nbsp("default");
-        }
-    }
-
-    pub fn print_struct(&mut self,
-                        struct_def: &ast::VariantData,
-                        generics: &ast::Generics,
-                        ident: ast::Ident,
-                        span: syntax_pos::Span,
-                        print_finalizer: bool) {
-        self.print_ident(ident);
-        self.print_generic_params(&generics.params);
-        match struct_def {
-            ast::VariantData::Tuple(..) | ast::VariantData::Unit(..) => {
-                if let ast::VariantData::Tuple(..) = struct_def {
-                    self.popen();
-                    self.commasep(
-                        Inconsistent, struct_def.fields(),
-                        |s, field| {
-                            s.maybe_print_comment(field.span.lo());
-                            s.print_outer_attributes(&field.attrs);
-                            s.print_visibility(&field.vis);
-                            s.print_type(&field.ty)
-                        }
-                    );
-                    self.pclose();
-                }
-                self.print_where_clause(&generics.where_clause);
-                if print_finalizer {
-                    self.s.word(";");
-                }
-                self.end();
-                self.end(); // Close the outer-box.
-            }
-            ast::VariantData::Struct(..) => {
-                self.print_where_clause(&generics.where_clause);
-                self.nbsp();
-                self.bopen();
-                self.hardbreak_if_not_bol();
-
-                for field in struct_def.fields() {
-                    self.hardbreak_if_not_bol();
-                    self.maybe_print_comment(field.span.lo());
-                    self.print_outer_attributes(&field.attrs);
-                    self.print_visibility(&field.vis);
-                    self.print_ident(field.ident.unwrap());
-                    self.word_nbsp(":");
-                    self.print_type(&field.ty);
-                    self.s.word(",");
-                }
-
-                self.bclose(span)
-            }
-        }
-    }
-
-    pub fn print_variant(&mut self, v: &ast::Variant) {
-        self.head("");
-        let generics = ast::Generics::default();
-        self.print_struct(&v.data, &generics, v.ident, v.span, false);
-        match v.disr_expr {
-            Some(ref d) => {
-                self.s.space();
-                self.word_space("=");
-                self.print_expr(&d.value)
-            }
-            _ => {}
-        }
-    }
-
-    pub fn print_method_sig(&mut self,
-                            ident: ast::Ident,
-                            generics: &ast::Generics,
-                            m: &ast::FnSig,
-                            vis: &ast::Visibility)
-                            {
-        self.print_fn(&m.decl,
-                      m.header,
-                      Some(ident),
-                      &generics,
-                      vis)
-    }
-
-    pub fn print_trait_item(&mut self, ti: &ast::TraitItem)
-                            {
-        self.ann.pre(self, AnnNode::SubItem(ti.id));
-        self.hardbreak_if_not_bol();
-        self.maybe_print_comment(ti.span.lo());
-        self.print_outer_attributes(&ti.attrs);
-        match ti.kind {
-            ast::TraitItemKind::Const(ref ty, ref default) => {
-                self.print_associated_const(
-                    ti.ident,
-                    ty,
-                    default.as_ref().map(|expr| &**expr),
-                    &source_map::respan(ti.span.shrink_to_lo(), ast::VisibilityKind::Inherited),
-                );
-            }
-            ast::TraitItemKind::Method(ref sig, ref body) => {
-                if body.is_some() {
-                    self.head("");
-                }
-                self.print_method_sig(
-                    ti.ident,
-                    &ti.generics,
-                    sig,
-                    &source_map::respan(ti.span.shrink_to_lo(), ast::VisibilityKind::Inherited),
-                );
-                if let Some(ref body) = *body {
-                    self.nbsp();
-                    self.print_block_with_attrs(body, &ti.attrs);
-                } else {
-                    self.s.word(";");
-                }
-            }
-            ast::TraitItemKind::Type(ref bounds, ref default) => {
-                self.print_associated_type(ti.ident, Some(bounds),
-                                           default.as_ref().map(|ty| &**ty));
-            }
-            ast::TraitItemKind::Macro(ref mac) => {
-                self.print_mac(mac);
-                if mac.args.need_semicolon() {
-                    self.s.word(";");
-                }
-            }
-        }
-        self.ann.post(self, AnnNode::SubItem(ti.id))
-    }
-
-    pub fn print_impl_item(&mut self, ii: &ast::ImplItem) {
-        self.ann.pre(self, AnnNode::SubItem(ii.id));
-        self.hardbreak_if_not_bol();
-        self.maybe_print_comment(ii.span.lo());
-        self.print_outer_attributes(&ii.attrs);
-        self.print_defaultness(ii.defaultness);
-        match ii.kind {
-            ast::ImplItemKind::Const(ref ty, ref expr) => {
-                self.print_associated_const(ii.ident, ty, Some(expr), &ii.vis);
-            }
-            ast::ImplItemKind::Method(ref sig, ref body) => {
-                self.head("");
-                self.print_method_sig(ii.ident, &ii.generics, sig, &ii.vis);
-                self.nbsp();
-                self.print_block_with_attrs(body, &ii.attrs);
-            }
-            ast::ImplItemKind::TyAlias(ref ty) => {
-                self.print_associated_type(ii.ident, None, Some(ty));
-            }
-            ast::ImplItemKind::Macro(ref mac) => {
-                self.print_mac(mac);
-                if mac.args.need_semicolon() {
-                    self.s.word(";");
-                }
-            }
-        }
-        self.ann.post(self, AnnNode::SubItem(ii.id))
-    }
-
-    pub fn print_stmt(&mut self, st: &ast::Stmt) {
-        self.maybe_print_comment(st.span.lo());
-        match st.kind {
-            ast::StmtKind::Local(ref loc) => {
-                self.print_outer_attributes(&loc.attrs);
-                self.space_if_not_bol();
-                self.ibox(INDENT_UNIT);
-                self.word_nbsp("let");
-
-                self.ibox(INDENT_UNIT);
-                self.print_local_decl(loc);
-                self.end();
-                if let Some(ref init) = loc.init {
-                    self.nbsp();
-                    self.word_space("=");
-                    self.print_expr(init);
-                }
-                self.s.word(";");
-                self.end();
-            }
-            ast::StmtKind::Item(ref item) => self.print_item(item),
-            ast::StmtKind::Expr(ref expr) => {
-                self.space_if_not_bol();
-                self.print_expr_outer_attr_style(expr, false);
-                if classify::expr_requires_semi_to_be_stmt(expr) {
-                    self.s.word(";");
-                }
-            }
-            ast::StmtKind::Semi(ref expr) => {
-                match expr.kind {
-                    // Filter out empty `Tup` exprs created for the `redundant_semicolon`
-                    // lint, as they shouldn't be visible and interact poorly
-                    // with proc macros.
-                    ast::ExprKind::Tup(ref exprs) if exprs.is_empty()
-                      && expr.attrs.is_empty() => (),
-                    _ => {
-                        self.space_if_not_bol();
-                        self.print_expr_outer_attr_style(expr, false);
-                        self.s.word(";");
-                    }
-                }
-            }
-            ast::StmtKind::Mac(ref mac) => {
-                let (ref mac, style, ref attrs) = **mac;
-                self.space_if_not_bol();
-                self.print_outer_attributes(attrs);
-                self.print_mac(mac);
-                if style == ast::MacStmtStyle::Semicolon {
-                    self.s.word(";");
-                }
-            }
-        }
-        self.maybe_print_trailing_comment(st.span, None)
-    }
-
-    pub fn print_block(&mut self, blk: &ast::Block) {
-        self.print_block_with_attrs(blk, &[])
-    }
-
-    pub fn print_block_unclosed_indent(&mut self, blk: &ast::Block) {
-        self.print_block_maybe_unclosed(blk, &[], false)
-    }
-
-    pub fn print_block_with_attrs(&mut self,
-                                  blk: &ast::Block,
-                                  attrs: &[ast::Attribute]) {
-        self.print_block_maybe_unclosed(blk, attrs, true)
-    }
-
-    pub fn print_block_maybe_unclosed(&mut self,
-                                      blk: &ast::Block,
-                                      attrs: &[ast::Attribute],
-                                      close_box: bool) {
-        match blk.rules {
-            BlockCheckMode::Unsafe(..) => self.word_space("unsafe"),
-            BlockCheckMode::Default => ()
-        }
-        self.maybe_print_comment(blk.span.lo());
-        self.ann.pre(self, AnnNode::Block(blk));
-        self.bopen();
-
-        self.print_inner_attributes(attrs);
-
-        for (i, st) in blk.stmts.iter().enumerate() {
-            match st.kind {
-                ast::StmtKind::Expr(ref expr) if i == blk.stmts.len() - 1 => {
-                    self.maybe_print_comment(st.span.lo());
-                    self.space_if_not_bol();
-                    self.print_expr_outer_attr_style(expr, false);
-                    self.maybe_print_trailing_comment(expr.span, Some(blk.span.hi()));
-                }
-                _ => self.print_stmt(st),
-            }
-        }
-
-        self.bclose_maybe_open(blk.span, close_box);
-        self.ann.post(self, AnnNode::Block(blk))
-    }
-
-    /// Print a `let pat = scrutinee` expression.
-    pub fn print_let(&mut self, pat: &ast::Pat, scrutinee: &ast::Expr) {
-        self.s.word("let ");
-
-        self.print_pat(pat);
-        self.s.space();
-
-        self.word_space("=");
-        self.print_expr_cond_paren(
-            scrutinee,
-            Self::cond_needs_par(scrutinee)
-            || syntax_priv::needs_par_as_let_scrutinee(scrutinee.precedence().order())
-        )
-    }
-
-    fn print_else(&mut self, els: Option<&ast::Expr>) {
-        if let Some(_else) = els {
-            match _else.kind {
-                // Another `else if` block.
-                ast::ExprKind::If(ref i, ref then, ref e) => {
-                    self.cbox(INDENT_UNIT - 1);
-                    self.ibox(0);
-                    self.s.word(" else if ");
-                    self.print_expr_as_cond(i);
-                    self.s.space();
-                    self.print_block(then);
-                    self.print_else(e.as_ref().map(|e| &**e))
-                }
-                // Final `else` block.
-                ast::ExprKind::Block(ref b, _) => {
-                    self.cbox(INDENT_UNIT - 1);
-                    self.ibox(0);
-                    self.s.word(" else ");
-                    self.print_block(b)
-                }
-                // Constraints would be great here!
-                _ => {
-                    panic!("print_if saw if with weird alternative");
-                }
-            }
-        }
-    }
-
-    pub fn print_if(&mut self, test: &ast::Expr, blk: &ast::Block,
-                    elseopt: Option<&ast::Expr>) {
-        self.head("if");
-
-        self.print_expr_as_cond(test);
-        self.s.space();
-
-        self.print_block(blk);
-        self.print_else(elseopt)
-    }
-
-    pub fn print_mac(&mut self, m: &ast::Mac) {
-        self.print_mac_common(
-            Some(MacHeader::Path(&m.path)),
-            true,
-            None,
-            m.args.delim(),
-            m.args.inner_tokens(),
-            true,
-            m.span(),
-        );
-    }
-
-    fn print_call_post(&mut self, args: &[P<ast::Expr>]) {
-        self.popen();
-        self.commasep_exprs(Inconsistent, args);
-        self.pclose()
-    }
-
-    pub fn print_expr_maybe_paren(&mut self, expr: &ast::Expr, prec: i8) {
-        self.print_expr_cond_paren(expr, expr.precedence().order() < prec)
-    }
-
-    /// Prints an expr using syntax that's acceptable in a condition position, such as the `cond` in
-    /// `if cond { ... }`.
-    pub fn print_expr_as_cond(&mut self, expr: &ast::Expr) {
-        self.print_expr_cond_paren(expr, Self::cond_needs_par(expr))
-    }
-
-    /// Does `expr` need parenthesis when printed in a condition position?
-    fn cond_needs_par(expr: &ast::Expr) -> bool {
-        match expr.kind {
-            // These cases need parens due to the parse error observed in #26461: `if return {}`
-            // parses as the erroneous construct `if (return {})`, not `if (return) {}`.
-            ast::ExprKind::Closure(..) |
-            ast::ExprKind::Ret(..) |
-            ast::ExprKind::Break(..) => true,
-
-            _ => parser::contains_exterior_struct_lit(expr),
-        }
-    }
-
-    /// Prints `expr` or `(expr)` when `needs_par` holds.
-    fn print_expr_cond_paren(&mut self, expr: &ast::Expr, needs_par: bool) {
-        if needs_par {
-            self.popen();
-        }
-        self.print_expr(expr);
-        if needs_par {
-            self.pclose();
-        }
-    }
-
-    fn print_expr_vec(&mut self, exprs: &[P<ast::Expr>],
-                      attrs: &[Attribute]) {
-        self.ibox(INDENT_UNIT);
-        self.s.word("[");
-        self.print_inner_attributes_inline(attrs);
-        self.commasep_exprs(Inconsistent, &exprs[..]);
-        self.s.word("]");
-        self.end();
-    }
-
-    fn print_expr_repeat(&mut self,
-                         element: &ast::Expr,
-                         count: &ast::AnonConst,
-                         attrs: &[Attribute]) {
-        self.ibox(INDENT_UNIT);
-        self.s.word("[");
-        self.print_inner_attributes_inline(attrs);
-        self.print_expr(element);
-        self.word_space(";");
-        self.print_expr(&count.value);
-        self.s.word("]");
-        self.end();
-    }
-
-    fn print_expr_struct(&mut self,
-                         path: &ast::Path,
-                         fields: &[ast::Field],
-                         wth: &Option<P<ast::Expr>>,
-                         attrs: &[Attribute]) {
-        self.print_path(path, true, 0);
-        self.s.word("{");
-        self.print_inner_attributes_inline(attrs);
-        self.commasep_cmnt(
-            Consistent,
-            &fields[..],
-            |s, field| {
-                s.ibox(INDENT_UNIT);
-                if !field.is_shorthand {
-                    s.print_ident(field.ident);
-                    s.word_space(":");
-                }
-                s.print_expr(&field.expr);
-                s.end();
-            },
-            |f| f.span);
-        match *wth {
-            Some(ref expr) => {
-                self.ibox(INDENT_UNIT);
-                if !fields.is_empty() {
-                    self.s.word(",");
-                    self.s.space();
-                }
-                self.s.word("..");
-                self.print_expr(expr);
-                self.end();
-            }
-            _ => if !fields.is_empty() {
-                self.s.word(",")
-            }
-        }
-        self.s.word("}");
-    }
-
-    fn print_expr_tup(&mut self, exprs: &[P<ast::Expr>],
-                      attrs: &[Attribute]) {
-        self.popen();
-        self.print_inner_attributes_inline(attrs);
-        self.commasep_exprs(Inconsistent, &exprs[..]);
-        if exprs.len() == 1 {
-            self.s.word(",");
-        }
-        self.pclose()
-    }
-
-    fn print_expr_call(&mut self,
-                       func: &ast::Expr,
-                       args: &[P<ast::Expr>]) {
-        let prec =
-            match func.kind {
-                ast::ExprKind::Field(..) => parser::PREC_FORCE_PAREN,
-                _ => parser::PREC_POSTFIX,
-            };
-
-        self.print_expr_maybe_paren(func, prec);
-        self.print_call_post(args)
-    }
-
-    fn print_expr_method_call(&mut self,
-                              segment: &ast::PathSegment,
-                              args: &[P<ast::Expr>]) {
-        let base_args = &args[1..];
-        self.print_expr_maybe_paren(&args[0], parser::PREC_POSTFIX);
-        self.s.word(".");
-        self.print_ident(segment.ident);
-        if let Some(ref args) = segment.args {
-            self.print_generic_args(args, true);
-        }
-        self.print_call_post(base_args)
-    }
-
-    fn print_expr_binary(&mut self,
-                         op: ast::BinOp,
-                         lhs: &ast::Expr,
-                         rhs: &ast::Expr,
-                         is_inline: bool) {
-        let assoc_op = AssocOp::from_ast_binop(op.node);
-        let prec = assoc_op.precedence() as i8;
-        let fixity = assoc_op.fixity();
-
-        let (left_prec, right_prec) = match fixity {
-            Fixity::Left => (prec, prec + 1),
-            Fixity::Right => (prec + 1, prec),
-            Fixity::None => (prec + 1, prec + 1),
-        };
-
-        let left_prec = match (&lhs.kind, op.node) {
-            // These cases need parens: `x as i32 < y` has the parser thinking that `i32 < y` is
-            // the beginning of a path type. It starts trying to parse `x as (i32 < y ...` instead
-            // of `(x as i32) < ...`. We need to convince it _not_ to do that.
-            (&ast::ExprKind::Cast { .. }, ast::BinOpKind::Lt) |
-            (&ast::ExprKind::Cast { .. }, ast::BinOpKind::Shl) => parser::PREC_FORCE_PAREN,
-            // We are given `(let _ = a) OP b`.
-            //
-            // - When `OP <= LAnd` we should print `let _ = a OP b` to avoid redundant parens
-            //   as the parser will interpret this as `(let _ = a) OP b`.
-            //
-            // - Otherwise, e.g. when we have `(let a = b) < c` in AST,
-            //   parens are required since the parser would interpret `let a = b < c` as
-            //   `let a = (b < c)`. To achieve this, we force parens.
-            (&ast::ExprKind::Let { .. }, _) if !syntax_priv::needs_par_as_let_scrutinee(prec) => {
-                parser::PREC_FORCE_PAREN
-            }
-            _ if !is_inline && classify::expr_requires_semi_to_be_stmt(lhs) => {
-                parser::PREC_FORCE_PAREN
-            }
-            _ => left_prec,
-        };
-
-        self.print_expr_maybe_paren(lhs, left_prec);
-        self.s.space();
-        self.word_space(op.node.to_string());
-        self.print_expr_maybe_paren(rhs, right_prec)
-    }
-
-    fn print_expr_unary(&mut self,
-                        op: ast::UnOp,
-                        expr: &ast::Expr) {
-        self.s.word(ast::UnOp::to_string(op));
-        self.print_expr_maybe_paren(expr, parser::PREC_PREFIX)
-    }
-
-    fn print_expr_addr_of(&mut self,
-                          kind: ast::BorrowKind,
-                          mutability: ast::Mutability,
-                          expr: &ast::Expr) {
-        self.s.word("&");
-        match kind {
-            ast::BorrowKind::Ref => self.print_mutability(mutability, false),
-            ast::BorrowKind::Raw => {
-                self.word_nbsp("raw");
-                self.print_mutability(mutability, true);
-            }
-        }
-        self.print_expr_maybe_paren(expr, parser::PREC_PREFIX)
-    }
-
-    pub fn print_expr(&mut self, expr: &ast::Expr) {
-        self.print_expr_outer_attr_style(expr, true)
-    }
-
-    fn print_expr_outer_attr_style(&mut self,
-                                  expr: &ast::Expr,
-                                  is_inline: bool) {
-        self.maybe_print_comment(expr.span.lo());
-
-        let attrs = &expr.attrs;
-        if is_inline {
-            self.print_outer_attributes_inline(attrs);
-        } else {
-            self.print_outer_attributes(attrs);
-        }
-
-        self.ibox(INDENT_UNIT);
-        self.ann.pre(self, AnnNode::Expr(expr));
-        match expr.kind {
-            ast::ExprKind::Box(ref expr) => {
-                self.word_space("box");
-                self.print_expr_maybe_paren(expr, parser::PREC_PREFIX);
-            }
-            ast::ExprKind::Array(ref exprs) => {
-                self.print_expr_vec(&exprs[..], attrs);
-            }
-            ast::ExprKind::Repeat(ref element, ref count) => {
-                self.print_expr_repeat(element, count, attrs);
-            }
-            ast::ExprKind::Struct(ref path, ref fields, ref wth) => {
-                self.print_expr_struct(path, &fields[..], wth, attrs);
-            }
-            ast::ExprKind::Tup(ref exprs) => {
-                self.print_expr_tup(&exprs[..], attrs);
-            }
-            ast::ExprKind::Call(ref func, ref args) => {
-                self.print_expr_call(func, &args[..]);
-            }
-            ast::ExprKind::MethodCall(ref segment, ref args) => {
-                self.print_expr_method_call(segment, &args[..]);
-            }
-            ast::ExprKind::Binary(op, ref lhs, ref rhs) => {
-                self.print_expr_binary(op, lhs, rhs, is_inline);
-            }
-            ast::ExprKind::Unary(op, ref expr) => {
-                self.print_expr_unary(op, expr);
-            }
-            ast::ExprKind::AddrOf(k, m, ref expr) => {
-                self.print_expr_addr_of(k, m, expr);
-            }
-            ast::ExprKind::Lit(ref lit) => {
-                self.print_literal(lit);
-            }
-            ast::ExprKind::Cast(ref expr, ref ty) => {
-                let prec = if !is_inline && !classify::expr_requires_semi_to_be_stmt(expr) {
-                    parser::PREC_FORCE_PAREN
-                } else {
-                    AssocOp::As.precedence() as i8
-                };
-                self.print_expr_maybe_paren(expr, prec);
-                self.s.space();
-                self.word_space("as");
-                self.print_type(ty);
-            }
-            ast::ExprKind::Type(ref expr, ref ty) => {
-                let prec = if !is_inline && !classify::expr_requires_semi_to_be_stmt(expr) {
-                    parser::PREC_FORCE_PAREN
-                } else {
-                    AssocOp::Colon.precedence() as i8
-                };
-                self.print_expr_maybe_paren(expr, prec);
-                self.word_space(":");
-                self.print_type(ty);
-            }
-            ast::ExprKind::Let(ref pat, ref scrutinee) => {
-                self.print_let(pat, scrutinee);
-            }
-            ast::ExprKind::If(ref test, ref blk, ref elseopt) => {
-                self.print_if(test, blk, elseopt.as_ref().map(|e| &**e));
-            }
-            ast::ExprKind::While(ref test, ref blk, opt_label) => {
-                if let Some(label) = opt_label {
-                    self.print_ident(label.ident);
-                    self.word_space(":");
-                }
-                self.head("while");
-                self.print_expr_as_cond(test);
-                self.s.space();
-                self.print_block_with_attrs(blk, attrs);
-            }
-            ast::ExprKind::ForLoop(ref pat, ref iter, ref blk, opt_label) => {
-                if let Some(label) = opt_label {
-                    self.print_ident(label.ident);
-                    self.word_space(":");
-                }
-                self.head("for");
-                self.print_pat(pat);
-                self.s.space();
-                self.word_space("in");
-                self.print_expr_as_cond(iter);
-                self.s.space();
-                self.print_block_with_attrs(blk, attrs);
-            }
-            ast::ExprKind::Loop(ref blk, opt_label) => {
-                if let Some(label) = opt_label {
-                    self.print_ident(label.ident);
-                    self.word_space(":");
-                }
-                self.head("loop");
-                self.s.space();
-                self.print_block_with_attrs(blk, attrs);
-            }
-            ast::ExprKind::Match(ref expr, ref arms) => {
-                self.cbox(INDENT_UNIT);
-                self.ibox(INDENT_UNIT);
-                self.word_nbsp("match");
-                self.print_expr_as_cond(expr);
-                self.s.space();
-                self.bopen();
-                self.print_inner_attributes_no_trailing_hardbreak(attrs);
-                for arm in arms {
-                    self.print_arm(arm);
-                }
-                self.bclose(expr.span);
-            }
-            ast::ExprKind::Closure(
-                capture_clause, asyncness, movability, ref decl, ref body, _) => {
-                self.print_movability(movability);
-                self.print_asyncness(asyncness);
-                self.print_capture_clause(capture_clause);
-
-                self.print_fn_block_params(decl);
-                self.s.space();
-                self.print_expr(body);
-                self.end(); // need to close a box
-
-                // a box will be closed by print_expr, but we didn't want an overall
-                // wrapper so we closed the corresponding opening. so create an
-                // empty box to satisfy the close.
-                self.ibox(0);
-            }
-            ast::ExprKind::Block(ref blk, opt_label) => {
-                if let Some(label) = opt_label {
-                    self.print_ident(label.ident);
-                    self.word_space(":");
-                }
-                // containing cbox, will be closed by print-block at }
-                self.cbox(INDENT_UNIT);
-                // head-box, will be closed by print-block after {
-                self.ibox(0);
-                self.print_block_with_attrs(blk, attrs);
-            }
-            ast::ExprKind::Async(capture_clause, _, ref blk) => {
-                self.word_nbsp("async");
-                self.print_capture_clause(capture_clause);
-                self.s.space();
-                // cbox/ibox in analogy to the `ExprKind::Block` arm above
-                self.cbox(INDENT_UNIT);
-                self.ibox(0);
-                self.print_block_with_attrs(blk, attrs);
-            }
-            ast::ExprKind::Await(ref expr) => {
-                self.print_expr_maybe_paren(expr, parser::PREC_POSTFIX);
-                self.s.word(".await");
-            }
-            ast::ExprKind::Assign(ref lhs, ref rhs) => {
-                let prec = if !is_inline && !classify::expr_requires_semi_to_be_stmt(lhs) {
-                    parser::PREC_FORCE_PAREN
-                } else {
-                    AssocOp::Assign.precedence() as i8
-                };
-                self.print_expr_maybe_paren(lhs, prec + 1);
-                self.s.space();
-                self.word_space("=");
-                self.print_expr_maybe_paren(rhs, prec);
-            }
-            ast::ExprKind::AssignOp(op, ref lhs, ref rhs) => {
-                let prec = if !is_inline && !classify::expr_requires_semi_to_be_stmt(lhs) {
-                    parser::PREC_FORCE_PAREN
-                } else {
-                    AssocOp::Assign.precedence() as i8
-                };
-                self.print_expr_maybe_paren(lhs, prec + 1);
-                self.s.space();
-                self.s.word(op.node.to_string());
-                self.word_space("=");
-                self.print_expr_maybe_paren(rhs, prec);
-            }
-            ast::ExprKind::Field(ref expr, ident) => {
-                self.print_expr_maybe_paren(expr, parser::PREC_POSTFIX);
-                self.s.word(".");
-                self.print_ident(ident);
-            }
-            ast::ExprKind::Index(ref expr, ref index) => {
-                self.print_expr_maybe_paren(expr, parser::PREC_POSTFIX);
-                self.s.word("[");
-                self.print_expr(index);
-                self.s.word("]");
-            }
-            ast::ExprKind::Range(ref start, ref end, limits) => {
-                // Special case for `Range`.  `AssocOp` claims that `Range` has higher precedence
-                // than `Assign`, but `x .. x = x` gives a parse error instead of `x .. (x = x)`.
-                // Here we use a fake precedence value so that any child with lower precedence than
-                // a "normal" binop gets parenthesized.  (`LOr` is the lowest-precedence binop.)
-                let fake_prec = AssocOp::LOr.precedence() as i8;
-                if let Some(ref e) = *start {
-                    self.print_expr_maybe_paren(e, fake_prec);
-                }
-                if limits == ast::RangeLimits::HalfOpen {
-                    self.s.word("..");
-                } else {
-                    self.s.word("..=");
-                }
-                if let Some(ref e) = *end {
-                    self.print_expr_maybe_paren(e, fake_prec);
-                }
-            }
-            ast::ExprKind::Path(None, ref path) => {
-                self.print_path(path, true, 0)
-            }
-            ast::ExprKind::Path(Some(ref qself), ref path) => {
-                self.print_qpath(path, qself, true)
-            }
-            ast::ExprKind::Break(opt_label, ref opt_expr) => {
-                self.s.word("break");
-                self.s.space();
-                if let Some(label) = opt_label {
-                    self.print_ident(label.ident);
-                    self.s.space();
-                }
-                if let Some(ref expr) = *opt_expr {
-                    self.print_expr_maybe_paren(expr, parser::PREC_JUMP);
-                    self.s.space();
-                }
-            }
-            ast::ExprKind::Continue(opt_label) => {
-                self.s.word("continue");
-                self.s.space();
-                if let Some(label) = opt_label {
-                    self.print_ident(label.ident);
-                    self.s.space()
-                }
-            }
-            ast::ExprKind::Ret(ref result) => {
-                self.s.word("return");
-                if let Some(ref expr) = *result {
-                    self.s.word(" ");
-                    self.print_expr_maybe_paren(expr, parser::PREC_JUMP);
-                }
-            }
-            ast::ExprKind::InlineAsm(ref a) => {
-                self.s.word("asm!");
-                self.popen();
-                self.print_string(&a.asm.as_str(), a.asm_str_style);
-                self.word_space(":");
-
-                self.commasep(Inconsistent, &a.outputs, |s, out| {
-                    let constraint = out.constraint.as_str();
-                    let mut ch = constraint.chars();
-                    match ch.next() {
-                        Some('=') if out.is_rw => {
-                            s.print_string(&format!("+{}", ch.as_str()),
-                                           ast::StrStyle::Cooked)
-                        }
-                        _ => s.print_string(&constraint, ast::StrStyle::Cooked)
-                    }
-                    s.popen();
-                    s.print_expr(&out.expr);
-                    s.pclose();
-                });
-                self.s.space();
-                self.word_space(":");
-
-                self.commasep(Inconsistent, &a.inputs, |s, &(co, ref o)| {
-                    s.print_string(&co.as_str(), ast::StrStyle::Cooked);
-                    s.popen();
-                    s.print_expr(o);
-                    s.pclose();
-                });
-                self.s.space();
-                self.word_space(":");
-
-                self.commasep(Inconsistent, &a.clobbers,
-                                   |s, co| {
-                    s.print_string(&co.as_str(), ast::StrStyle::Cooked);
-                });
-
-                let mut options = vec![];
-                if a.volatile {
-                    options.push("volatile");
-                }
-                if a.alignstack {
-                    options.push("alignstack");
-                }
-                if a.dialect == ast::AsmDialect::Intel {
-                    options.push("intel");
-                }
-
-                if !options.is_empty() {
-                    self.s.space();
-                    self.word_space(":");
-                    self.commasep(Inconsistent, &options,
-                                  |s, &co| {
-                                      s.print_string(co, ast::StrStyle::Cooked);
-                                  });
-                }
-
-                self.pclose();
-            }
-            ast::ExprKind::Mac(ref m) => self.print_mac(m),
-            ast::ExprKind::Paren(ref e) => {
-                self.popen();
-                self.print_inner_attributes_inline(attrs);
-                self.print_expr(e);
-                self.pclose();
-            },
-            ast::ExprKind::Yield(ref e) => {
-                self.s.word("yield");
-                match *e {
-                    Some(ref expr) => {
-                        self.s.space();
-                        self.print_expr_maybe_paren(expr, parser::PREC_JUMP);
-                    }
-                    _ => ()
-                }
-            }
-            ast::ExprKind::Try(ref e) => {
-                self.print_expr_maybe_paren(e, parser::PREC_POSTFIX);
-                self.s.word("?")
-            }
-            ast::ExprKind::TryBlock(ref blk) => {
-                self.head("try");
-                self.s.space();
-                self.print_block_with_attrs(blk, attrs)
-            }
-            ast::ExprKind::Err => {
-                self.popen();
-                self.s.word("/*ERROR*/");
-                self.pclose()
-            }
-        }
-        self.ann.post(self, AnnNode::Expr(expr));
-        self.end();
-    }
-
-    pub fn print_local_decl(&mut self, loc: &ast::Local) {
-        self.print_pat(&loc.pat);
-        if let Some(ref ty) = loc.ty {
-            self.word_space(":");
-            self.print_type(ty);
-        }
-    }
-
-    pub fn print_usize(&mut self, i: usize) {
-        self.s.word(i.to_string())
-    }
-
-    pub fn print_name(&mut self, name: ast::Name) {
-        self.s.word(name.to_string());
-        self.ann.post(self, AnnNode::Name(&name))
-    }
-
-    fn print_qpath(&mut self,
-                   path: &ast::Path,
-                   qself: &ast::QSelf,
-                   colons_before_params: bool)
-    {
-        self.s.word("<");
-        self.print_type(&qself.ty);
-        if qself.position > 0 {
-            self.s.space();
-            self.word_space("as");
-            let depth = path.segments.len() - qself.position;
-            self.print_path(path, false, depth);
-        }
-        self.s.word(">");
-        self.s.word("::");
-        let item_segment = path.segments.last().unwrap();
-        self.print_ident(item_segment.ident);
-        match item_segment.args {
-            Some(ref args) => self.print_generic_args(args, colons_before_params),
-            None => {},
-        }
-    }
-
-    pub fn print_pat(&mut self, pat: &ast::Pat) {
-        self.maybe_print_comment(pat.span.lo());
-        self.ann.pre(self, AnnNode::Pat(pat));
-        /* Pat isn't normalized, but the beauty of it
-         is that it doesn't matter */
-        match pat.kind {
-            PatKind::Wild => self.s.word("_"),
-            PatKind::Ident(binding_mode, ident, ref sub) => {
-                match binding_mode {
-                    ast::BindingMode::ByRef(mutbl) => {
-                        self.word_nbsp("ref");
-                        self.print_mutability(mutbl, false);
-                    }
-                    ast::BindingMode::ByValue(ast::Mutability::Immutable) => {}
-                    ast::BindingMode::ByValue(ast::Mutability::Mutable) => {
-                        self.word_nbsp("mut");
-                    }
-                }
-                self.print_ident(ident);
-                if let Some(ref p) = *sub {
-                    self.s.space();
-                    self.s.word_space("@");
-                    self.print_pat(p);
-                }
-            }
-            PatKind::TupleStruct(ref path, ref elts) => {
-                self.print_path(path, true, 0);
-                self.popen();
-                self.commasep(Inconsistent, &elts[..], |s, p| s.print_pat(p));
-                self.pclose();
-            }
-            PatKind::Or(ref pats) => {
-                self.strsep("|", true, Inconsistent, &pats[..], |s, p| s.print_pat(p));
-            }
-            PatKind::Path(None, ref path) => {
-                self.print_path(path, true, 0);
-            }
-            PatKind::Path(Some(ref qself), ref path) => {
-                self.print_qpath(path, qself, false);
-            }
-            PatKind::Struct(ref path, ref fields, etc) => {
-                self.print_path(path, true, 0);
-                self.nbsp();
-                self.word_space("{");
-                self.commasep_cmnt(
-                    Consistent, &fields[..],
-                    |s, f| {
-                        s.cbox(INDENT_UNIT);
-                        if !f.is_shorthand {
-                            s.print_ident(f.ident);
-                            s.word_nbsp(":");
-                        }
-                        s.print_pat(&f.pat);
-                        s.end();
-                    },
-                    |f| f.pat.span);
-                if etc {
-                    if !fields.is_empty() { self.word_space(","); }
-                    self.s.word("..");
-                }
-                self.s.space();
-                self.s.word("}");
-            }
-            PatKind::Tuple(ref elts) => {
-                self.popen();
-                self.commasep(Inconsistent, &elts[..], |s, p| s.print_pat(p));
-                if elts.len() == 1 {
-                    self.s.word(",");
-                }
-                self.pclose();
-            }
-            PatKind::Box(ref inner) => {
-                self.s.word("box ");
-                self.print_pat(inner);
-            }
-            PatKind::Ref(ref inner, mutbl) => {
-                self.s.word("&");
-                if mutbl == ast::Mutability::Mutable {
-                    self.s.word("mut ");
-                }
-                self.print_pat(inner);
-            }
-            PatKind::Lit(ref e) => self.print_expr(&**e),
-            PatKind::Range(ref begin, ref end, Spanned { node: ref end_kind, .. }) => {
-                self.print_expr(begin);
-                self.s.space();
-                match *end_kind {
-                    RangeEnd::Included(RangeSyntax::DotDotDot) => self.s.word("..."),
-                    RangeEnd::Included(RangeSyntax::DotDotEq) => self.s.word("..="),
-                    RangeEnd::Excluded => self.s.word(".."),
-                }
-                self.print_expr(end);
-            }
-            PatKind::Slice(ref elts) => {
-                self.s.word("[");
-                self.commasep(Inconsistent, &elts[..], |s, p| s.print_pat(p));
-                self.s.word("]");
-            }
-            PatKind::Rest => self.s.word(".."),
-            PatKind::Paren(ref inner) => {
-                self.popen();
-                self.print_pat(inner);
-                self.pclose();
-            }
-            PatKind::Mac(ref m) => self.print_mac(m),
-        }
-        self.ann.post(self, AnnNode::Pat(pat))
-    }
-
-    fn print_arm(&mut self, arm: &ast::Arm) {
-        // Note, I have no idea why this check is necessary, but here it is.
-        if arm.attrs.is_empty() {
-            self.s.space();
-        }
-        self.cbox(INDENT_UNIT);
-        self.ibox(0);
-        self.maybe_print_comment(arm.pat.span.lo());
-        self.print_outer_attributes(&arm.attrs);
-        self.print_pat(&arm.pat);
-        self.s.space();
-        if let Some(ref e) = arm.guard {
-            self.word_space("if");
-            self.print_expr(e);
-            self.s.space();
-        }
-        self.word_space("=>");
-
-        match arm.body.kind {
-            ast::ExprKind::Block(ref blk, opt_label) => {
-                if let Some(label) = opt_label {
-                    self.print_ident(label.ident);
-                    self.word_space(":");
-                }
-
-                // The block will close the pattern's ibox.
-                self.print_block_unclosed_indent(blk);
-
-                // If it is a user-provided unsafe block, print a comma after it.
-                if let BlockCheckMode::Unsafe(ast::UserProvided) = blk.rules {
-                    self.s.word(",");
-                }
-            }
-            _ => {
-                self.end(); // Close the ibox for the pattern.
-                self.print_expr(&arm.body);
-                self.s.word(",");
-            }
-        }
-        self.end(); // Close enclosing cbox.
-    }
-
-    fn print_explicit_self(&mut self, explicit_self: &ast::ExplicitSelf) {
-        match explicit_self.node {
-            SelfKind::Value(m) => {
-                self.print_mutability(m, false);
-                self.s.word("self")
-            }
-            SelfKind::Region(ref lt, m) => {
-                self.s.word("&");
-                self.print_opt_lifetime(lt);
-                self.print_mutability(m, false);
-                self.s.word("self")
-            }
-            SelfKind::Explicit(ref typ, m) => {
-                self.print_mutability(m, false);
-                self.s.word("self");
-                self.word_space(":");
-                self.print_type(typ)
-            }
-        }
-    }
-
-    pub fn print_fn(&mut self,
-                    decl: &ast::FnDecl,
-                    header: ast::FnHeader,
-                    name: Option<ast::Ident>,
-                    generics: &ast::Generics,
-                    vis: &ast::Visibility) {
-        self.print_fn_header_info(header, vis);
-
-        if let Some(name) = name {
-            self.nbsp();
-            self.print_ident(name);
-        }
-        self.print_generic_params(&generics.params);
-        self.print_fn_params_and_ret(decl);
-        self.print_where_clause(&generics.where_clause)
-    }
-
-    pub fn print_fn_params_and_ret(&mut self, decl: &ast::FnDecl) {
-        self.popen();
-        self.commasep(Inconsistent, &decl.inputs, |s, param| s.print_param(param, false));
-        self.pclose();
-
-        self.print_fn_output(decl)
-    }
-
-    pub fn print_fn_block_params(&mut self, decl: &ast::FnDecl) {
-        self.s.word("|");
-        self.commasep(Inconsistent, &decl.inputs, |s, param| s.print_param(param, true));
-        self.s.word("|");
-
-        if let ast::FunctionRetTy::Default(..) = decl.output {
-            return;
-        }
-
-        self.space_if_not_bol();
-        self.word_space("->");
-        match decl.output {
-            ast::FunctionRetTy::Ty(ref ty) => {
-                self.print_type(ty);
-                self.maybe_print_comment(ty.span.lo())
-            }
-            ast::FunctionRetTy::Default(..) => unreachable!(),
-        }
-    }
-
-    pub fn print_movability(&mut self, movability: ast::Movability) {
-        match movability {
-            ast::Movability::Static => self.word_space("static"),
-            ast::Movability::Movable => {},
-        }
-    }
-
-    pub fn print_asyncness(&mut self, asyncness: ast::IsAsync) {
-        if asyncness.is_async() {
-            self.word_nbsp("async");
-        }
-    }
-
-    pub fn print_capture_clause(&mut self, capture_clause: ast::CaptureBy) {
-        match capture_clause {
-            ast::CaptureBy::Value => self.word_space("move"),
-            ast::CaptureBy::Ref => {},
-        }
-    }
-
-    pub fn print_type_bounds(&mut self, prefix: &'static str, bounds: &[ast::GenericBound]) {
-        if !bounds.is_empty() {
-            self.s.word(prefix);
-            let mut first = true;
-            for bound in bounds {
-                if !(first && prefix.is_empty()) {
-                    self.nbsp();
-                }
-                if first {
-                    first = false;
-                } else {
-                    self.word_space("+");
-                }
-
-                match bound {
-                    GenericBound::Trait(tref, modifier) => {
-                        if modifier == &TraitBoundModifier::Maybe {
-                            self.s.word("?");
-                        }
-                        self.print_poly_trait_ref(tref);
-                    }
-                    GenericBound::Outlives(lt) => self.print_lifetime(*lt),
-                }
-            }
-        }
-    }
-
-    pub fn print_lifetime(&mut self, lifetime: ast::Lifetime) {
-        self.print_name(lifetime.ident.name)
-    }
-
-    pub fn print_lifetime_bounds(
-        &mut self, lifetime: ast::Lifetime, bounds: &ast::GenericBounds) {
-        self.print_lifetime(lifetime);
-        if !bounds.is_empty() {
-            self.s.word(": ");
-            for (i, bound) in bounds.iter().enumerate() {
-                if i != 0 {
-                    self.s.word(" + ");
-                }
-                match bound {
-                    ast::GenericBound::Outlives(lt) => self.print_lifetime(*lt),
-                    _ => panic!(),
-                }
-            }
-        }
-    }
-
-    pub fn print_generic_params(&mut self, generic_params: &[ast::GenericParam]) {
-        if generic_params.is_empty() {
-            return;
-        }
-
-        self.s.word("<");
-
-        self.commasep(Inconsistent, &generic_params, |s, param| {
-            s.print_outer_attributes_inline(&param.attrs);
-
-            match param.kind {
-                ast::GenericParamKind::Lifetime => {
-                    let lt = ast::Lifetime { id: param.id, ident: param.ident };
-                    s.print_lifetime_bounds(lt, &param.bounds)
-                }
-                ast::GenericParamKind::Type { ref default } => {
-                    s.print_ident(param.ident);
-                    s.print_type_bounds(":", &param.bounds);
-                    if let Some(ref default) = default {
-                        s.s.space();
-                        s.word_space("=");
-                        s.print_type(default)
-                    }
-                }
-                ast::GenericParamKind::Const { ref ty } => {
-                    s.word_space("const");
-                    s.print_ident(param.ident);
-                    s.s.space();
-                    s.word_space(":");
-                    s.print_type(ty);
-                    s.print_type_bounds(":", &param.bounds)
-                }
-            }
-        });
-
-        self.s.word(">");
-    }
-
-    pub fn print_where_clause(&mut self, where_clause: &ast::WhereClause) {
-        if where_clause.predicates.is_empty() {
-            return;
-        }
-
-        self.s.space();
-        self.word_space("where");
-
-        for (i, predicate) in where_clause.predicates.iter().enumerate() {
-            if i != 0 {
-                self.word_space(",");
-            }
-
-            match *predicate {
-                ast::WherePredicate::BoundPredicate(ast::WhereBoundPredicate {
-                    ref bound_generic_params,
-                    ref bounded_ty,
-                    ref bounds,
-                    ..
-                }) => {
-                    self.print_formal_generic_params(bound_generic_params);
-                    self.print_type(bounded_ty);
-                    self.print_type_bounds(":", bounds);
-                }
-                ast::WherePredicate::RegionPredicate(ast::WhereRegionPredicate{ref lifetime,
-                                                                               ref bounds,
-                                                                               ..}) => {
-                    self.print_lifetime_bounds(*lifetime, bounds);
-                }
-                ast::WherePredicate::EqPredicate(ast::WhereEqPredicate{ref lhs_ty,
-                                                                       ref rhs_ty,
-                                                                       ..}) => {
-                    self.print_type(lhs_ty);
-                    self.s.space();
-                    self.word_space("=");
-                    self.print_type(rhs_ty);
-                }
-            }
-        }
-    }
-
-    pub fn print_use_tree(&mut self, tree: &ast::UseTree) {
-        match tree.kind {
-            ast::UseTreeKind::Simple(rename, ..) => {
-                self.print_path(&tree.prefix, false, 0);
-                if let Some(rename) = rename {
-                    self.s.space();
-                    self.word_space("as");
-                    self.print_ident(rename);
-                }
-            }
-            ast::UseTreeKind::Glob => {
-                if !tree.prefix.segments.is_empty() {
-                    self.print_path(&tree.prefix, false, 0);
-                    self.s.word("::");
-                }
-                self.s.word("*");
-            }
-            ast::UseTreeKind::Nested(ref items) => {
-                if tree.prefix.segments.is_empty() {
-                    self.s.word("{");
-                } else {
-                    self.print_path(&tree.prefix, false, 0);
-                    self.s.word("::{");
-                }
-                self.commasep(Inconsistent, &items[..], |this, &(ref tree, _)| {
-                    this.print_use_tree(tree)
-                });
-                self.s.word("}");
-            }
-        }
-    }
-
-    pub fn print_mutability(&mut self, mutbl: ast::Mutability, print_const: bool) {
-        match mutbl {
-            ast::Mutability::Mutable => self.word_nbsp("mut"),
-            ast::Mutability::Immutable => if print_const { self.word_nbsp("const"); },
-        }
-    }
-
-    pub fn print_mt(&mut self, mt: &ast::MutTy, print_const: bool) {
-        self.print_mutability(mt.mutbl, print_const);
-        self.print_type(&mt.ty)
-    }
-
-    pub fn print_param(&mut self, input: &ast::Param, is_closure: bool) {
-        self.ibox(INDENT_UNIT);
-
-        self.print_outer_attributes_inline(&input.attrs);
-
-        match input.ty.kind {
-            ast::TyKind::Infer if is_closure => self.print_pat(&input.pat),
-            _ => {
-                if let Some(eself) = input.to_self() {
-                    self.print_explicit_self(&eself);
-                } else {
-                    let invalid = if let PatKind::Ident(_, ident, _) = input.pat.kind {
-                        ident.name == kw::Invalid
-                    } else {
-                        false
-                    };
-                    if !invalid {
-                        self.print_pat(&input.pat);
-                        self.s.word(":");
-                        self.s.space();
-                    }
-                    self.print_type(&input.ty);
-                }
-            }
-        }
-        self.end();
-    }
-
-    pub fn print_fn_output(&mut self, decl: &ast::FnDecl) {
-        if let ast::FunctionRetTy::Default(..) = decl.output {
-            return;
-        }
-
-        self.space_if_not_bol();
-        self.ibox(INDENT_UNIT);
-        self.word_space("->");
-        match decl.output {
-            ast::FunctionRetTy::Default(..) => unreachable!(),
-            ast::FunctionRetTy::Ty(ref ty) =>
-                self.print_type(ty),
-        }
-        self.end();
-
-        match decl.output {
-            ast::FunctionRetTy::Ty(ref output) => self.maybe_print_comment(output.span.lo()),
-            _ => {}
-        }
-    }
-
-    pub fn print_ty_fn(&mut self,
-                       ext: ast::Extern,
-                       unsafety: ast::Unsafety,
-                       decl: &ast::FnDecl,
-                       name: Option<ast::Ident>,
-                       generic_params: &[ast::GenericParam])
-                       {
-        self.ibox(INDENT_UNIT);
-        if !generic_params.is_empty() {
-            self.s.word("for");
-            self.print_generic_params(generic_params);
-        }
-        let generics = ast::Generics {
-            params: Vec::new(),
-            where_clause: ast::WhereClause {
-                predicates: Vec::new(),
-                span: syntax_pos::DUMMY_SP,
-            },
-            span: syntax_pos::DUMMY_SP,
-        };
-        self.print_fn(decl,
-                      ast::FnHeader { unsafety, ext, ..ast::FnHeader::default() },
-                      name,
-                      &generics,
-                      &source_map::dummy_spanned(ast::VisibilityKind::Inherited));
-        self.end();
-    }
-
-    pub fn maybe_print_trailing_comment(&mut self, span: syntax_pos::Span,
-                                        next_pos: Option<BytePos>)
-    {
-        if let Some(cmnts) = self.comments() {
-            if let Some(cmnt) = cmnts.trailing_comment(span, next_pos) {
-                self.print_comment(&cmnt);
-            }
-        }
-    }
-
-    pub fn print_remaining_comments(&mut self) {
-        // If there aren't any remaining comments, then we need to manually
-        // make sure there is a line break at the end.
-        if self.next_comment().is_none() {
-            self.s.hardbreak();
-        }
-        while let Some(ref cmnt) = self.next_comment() {
-            self.print_comment(cmnt);
-        }
-    }
-
-    pub fn print_fn_header_info(&mut self,
-                                header: ast::FnHeader,
-                                vis: &ast::Visibility) {
-        self.s.word(visibility_qualified(vis, ""));
-
-        match header.constness.node {
-            ast::Constness::NotConst => {}
-            ast::Constness::Const => self.word_nbsp("const")
-        }
-
-        self.print_asyncness(header.asyncness.node);
-        self.print_unsafety(header.unsafety);
-
-        match header.ext {
-            ast::Extern::None => {}
-            ast::Extern::Implicit => {
-                self.word_nbsp("extern");
-            }
-            ast::Extern::Explicit(abi) => {
-                self.word_nbsp("extern");
-                self.print_literal(&syntax_priv::as_lit(&abi));
-                self.nbsp();
-            }
-        }
-
-        self.s.word("fn")
-    }
-
-    pub fn print_unsafety(&mut self, s: ast::Unsafety) {
-        match s {
-            ast::Unsafety::Normal => {},
-            ast::Unsafety::Unsafe => self.word_nbsp("unsafe"),
-        }
-    }
-
-    pub fn print_is_auto(&mut self, s: ast::IsAuto) {
-        match s {
-            ast::IsAuto::Yes => self.word_nbsp("auto"),
-            ast::IsAuto::No => {}
-        }
-    }
-}
diff --git a/c2rust-ast-printer/src/pprust/tests.rs b/c2rust-ast-printer/src/pprust/tests.rs
index d7725acb5d..1551174aaf 100644
--- a/c2rust-ast-printer/src/pprust/tests.rs
+++ b/c2rust-ast-printer/src/pprust/tests.rs
@@ -1,11 +1,8 @@
 use super::*;
 
-use crate::ast;
-use crate::source_map;
-use crate::with_default_globals;
-use syntax_pos;
+use crate::syn;
 
-fn fun_to_string(
+/*fn fun_to_string(
     decl: &ast::FnDecl, header: ast::FnHeader, name: ast::Ident, generics: &ast::Generics
 ) -> String {
     to_string(|s| {
@@ -15,22 +12,22 @@ fn fun_to_string(
         s.end(); // Close the head box.
         s.end(); // Close the outer box.
     })
-}
+}*/
 
-fn variant_to_string(var: &ast::Variant) -> String {
-    to_string(|s| s.print_variant(var))
+fn variant_to_string(var: &syn::Variant) -> String {
+    todo!()//to_string(|s| s.print_variant(var))
 }
 
 #[test]
 fn test_fun_to_string() {
-    with_default_globals(|| {
-        let abba_ident = ast::Ident::from_str("abba");
+    //with_default_globals(|| {
+        /*let abba_ident = syn::Ident::new("abba", proc_macro2::Span::call_site());
 
-        let decl = ast::FnDecl {
+        let decl = FnDecl {
             inputs: Vec::new(),
-            output: ast::FunctionRetTy::Default(syntax_pos::DUMMY_SP),
+            output: syn::ReturnType::Default,
         };
-        let generics = ast::Generics::default();
+        let generics = syn::Generics::default();
         assert_eq!(
             fun_to_string(
                 &decl,
@@ -39,27 +36,23 @@ fn test_fun_to_string() {
                 &generics
             ),
             "fn abba()"
-        );
-    })
+        );*/
+    //})
 }
 
 #[test]
 fn test_variant_to_string() {
-    with_default_globals(|| {
-        let ident = ast::Ident::from_str("principal_skinner");
+    //with_default_globals(|| {
+        let ident = syn::Ident::new("principal_skinner", proc_macro2::Span::call_site());
 
-        let var = ast::Variant {
+        let var = syn::Variant {
+            attrs: vec![],
+            discriminant: None,
+            fields: todo!(),
             ident,
-            vis: source_map::respan(syntax_pos::DUMMY_SP, ast::VisibilityKind::Inherited),
-            attrs: Vec::new(),
-            id: ast::DUMMY_NODE_ID,
-            data: ast::VariantData::Unit(ast::DUMMY_NODE_ID),
-            disr_expr: None,
-            span: syntax_pos::DUMMY_SP,
-            is_placeholder: false,
         };
 
         let varstr = variant_to_string(&var);
         assert_eq!(varstr, "principal_skinner");
-    })
+    //})
 }
diff --git a/c2rust-ast-printer/src/syntax_priv.rs b/c2rust-ast-printer/src/syntax_priv.rs
index 15123fea55..1c3af0e201 100644
--- a/c2rust-ast-printer/src/syntax_priv.rs
+++ b/c2rust-ast-printer/src/syntax_priv.rs
@@ -1,6 +1,6 @@
 //! Crate-local helpers from libsyntax needed for the pretty-printer
 
-use syntax::ast::{Lit, LitKind, StrLit, StrStyle};
+use syn::{Lit, LitKind, StrLit, StrStyle};
 use syntax::token;
 use syntax::util::parser::{AssocOp};
 
diff --git a/c2rust-refactor/tests/ownership_upgrade_ptrs/new.rs b/c2rust-refactor/tests/ownership_upgrade_ptrs/new.rs
index 9818182287..9a67190d93 100644
--- a/c2rust-refactor/tests/ownership_upgrade_ptrs/new.rs
+++ b/c2rust-refactor/tests/ownership_upgrade_ptrs/new.rs
@@ -13,53 +13,33 @@
 extern crate libc;
 
 extern "C" {
-    #[no_mangle]
     fn malloc(_: libc::c_ulong) -> *mut libc::c_void;
-    #[no_mangle]
     #[ownership_constraints(le(WRITE, _0), le(_0, WRITE))]
     fn memset(_: *mut libc::c_void, _: libc::c_int, _: libc::c_ulong);
-    #[no_mangle]
     fn free(_: *mut libc::c_void);
-    #[no_mangle]
     fn fabs(_: libc::c_double) -> libc::c_double;
-    #[no_mangle]
     fn cosh(_: libc::c_double) -> libc::c_double;
-    #[no_mangle]
     fn sinh(_: libc::c_double) -> libc::c_double;
-    #[no_mangle]
     fn exp(_: libc::c_double) -> libc::c_double;
-    #[no_mangle]
     #[ownership_constraints(le(WRITE, _0), le(_0, WRITE))]
     fn takes_ptrs(_: *mut u32, _: *const u32);
-    #[no_mangle]
     fn takeswint(_: wint_t) -> wint_t;
-    #[no_mangle]
     fn strlen(_: *const libc::c_char) -> size_t;
-    #[no_mangle]
     fn memcpy(_: *mut libc::c_void, _: *const libc::c_void, _: size_t) -> *mut libc::c_void;
-    #[no_mangle]
     fn strdup(_: *const libc::c_char) -> *mut libc::c_char;
-    #[no_mangle]
     fn strsep(_: *mut *mut libc::c_char, _: *const libc::c_char) -> *mut libc::c_char;
-    #[no_mangle]
     fn __chk_fail() -> !;
-    #[no_mangle]
     fn vsprintf(_: *mut libc::c_char, _: *const libc::c_char, _: ::std::ffi::VaList)
         -> libc::c_int;
-    #[no_mangle]
     fn vsnprintf(
         _: *mut libc::c_char,
         _: size_t,
         _: *const libc::c_char,
         _: ::std::ffi::VaList,
     ) -> libc::c_int;
-    #[no_mangle]
     fn get_ptr() -> *mut u32;
-    #[no_mangle]
     fn get_struct_ptr() -> *mut Ctx;
-    #[no_mangle]
     type _reent;
-    #[no_mangle]
     static mut _impure_ptr: *mut _reent;
 }
 
diff --git a/c2rust-refactor/tests/ownership_upgrade_ptrs/old.rs b/c2rust-refactor/tests/ownership_upgrade_ptrs/old.rs
index 94516c1c47..baa9fd7dde 100644
--- a/c2rust-refactor/tests/ownership_upgrade_ptrs/old.rs
+++ b/c2rust-refactor/tests/ownership_upgrade_ptrs/old.rs
@@ -13,51 +13,31 @@
 extern crate libc;
 
 extern "C" {
-    #[no_mangle]
     fn malloc(_: libc::c_ulong) -> *mut libc::c_void;
-    #[no_mangle]
     #[ownership_constraints(le(WRITE, _0), le(_0, WRITE))]
     fn memset(_: *mut libc::c_void, _: libc::c_int, _: libc::c_ulong);
-    #[no_mangle]
     fn free(_: *mut libc::c_void);
-    #[no_mangle]
     fn fabs(_: libc::c_double) -> libc::c_double;
-    #[no_mangle]
     fn cosh(_: libc::c_double) -> libc::c_double;
-    #[no_mangle]
     fn sinh(_: libc::c_double) -> libc::c_double;
-    #[no_mangle]
     fn exp(_: libc::c_double) -> libc::c_double;
-    #[no_mangle]
     #[ownership_constraints(le(WRITE, _0), le(_0, WRITE))]
     fn takes_ptrs(_: *mut u32, _: *const u32);
-    #[no_mangle]
     fn takeswint(_: wint_t) -> wint_t;
-    #[no_mangle]
     fn strlen(_: *const libc::c_char) -> size_t;
-    #[no_mangle]
     fn memcpy(_: *mut libc::c_void, _: *const libc::c_void, _: size_t)
      -> *mut libc::c_void;
-    #[no_mangle]
     fn strdup(_: *const libc::c_char) -> *mut libc::c_char;
-    #[no_mangle]
     fn strsep(_: *mut *mut libc::c_char, _: *const libc::c_char)
      -> *mut libc::c_char;
-    #[no_mangle]
     fn __chk_fail() -> !;
-    #[no_mangle]
     fn vsprintf(_: *mut libc::c_char, _: *const libc::c_char,
                 _: ::std::ffi::VaList) -> libc::c_int;
-    #[no_mangle]
     fn vsnprintf(_: *mut libc::c_char, _: size_t, _: *const libc::c_char,
                  _: ::std::ffi::VaList) -> libc::c_int;
-    #[no_mangle]
     fn get_ptr() -> *mut u32;
-    #[no_mangle]
     fn get_struct_ptr() -> *mut Ctx;
-    #[no_mangle]
     type _reent;
-    #[no_mangle]
     static mut _impure_ptr: *mut _reent;
 }
 
diff --git a/c2rust-refactor/tests/retype_str/new.rs b/c2rust-refactor/tests/retype_str/new.rs
index 0a66b7165e..a51e48b467 100644
--- a/c2rust-refactor/tests/retype_str/new.rs
+++ b/c2rust-refactor/tests/retype_str/new.rs
@@ -5,11 +5,8 @@ extern crate libc;
 use std::slice;
 
 extern "C" {
-    #[no_mangle]
     fn strlen(_: *const u8) -> libc::c_ulong;
-    #[no_mangle]
     fn printf(_: *const u8, ...) -> libc::c_int;
-    #[no_mangle]
     fn test_mut(_: *mut u8) -> libc::c_ulong;
 }
 
diff --git a/c2rust-refactor/tests/retype_str/old.rs b/c2rust-refactor/tests/retype_str/old.rs
index 66dfcf6108..5f4cd9eb02 100644
--- a/c2rust-refactor/tests/retype_str/old.rs
+++ b/c2rust-refactor/tests/retype_str/old.rs
@@ -5,11 +5,8 @@ extern crate libc;
 use std::slice;
 
 extern "C" {
-    #[no_mangle]
     fn strlen(_: *const libc::c_char) -> libc::c_ulong;
-    #[no_mangle]
     fn printf(_: *const libc::c_char, ...) -> libc::c_int;
-    #[no_mangle]
     fn test_mut(_: *mut libc::c_char) -> libc::c_ulong;
 }
 
diff --git a/c2rust-refactor/tests/upgrade_ptr_to_ref/new.rs b/c2rust-refactor/tests/upgrade_ptr_to_ref/new.rs
index c8df8966d9..082fcc6bab 100644
--- a/c2rust-refactor/tests/upgrade_ptr_to_ref/new.rs
+++ b/c2rust-refactor/tests/upgrade_ptr_to_ref/new.rs
@@ -2,7 +2,6 @@
 extern crate libc;
 
 extern "C" {
-    #[no_mangle]
     fn malloc(_: libc::c_ulong) -> *mut libc::c_void;
 }
 
@@ -155,7 +154,6 @@ struct HashHDR {
 }
 
 extern "C" {
-    #[no_mangle]
     fn memset(_: *mut libc::c_void, _: libc::c_int, _: libc::c_ulong);
 }
 
diff --git a/c2rust-refactor/tests/upgrade_ptr_to_ref/old.rs b/c2rust-refactor/tests/upgrade_ptr_to_ref/old.rs
index bfd3213392..15e72786fa 100644
--- a/c2rust-refactor/tests/upgrade_ptr_to_ref/old.rs
+++ b/c2rust-refactor/tests/upgrade_ptr_to_ref/old.rs
@@ -2,7 +2,6 @@
 extern crate libc;
 
 extern "C" {
-    #[no_mangle]
     fn malloc(_: libc::c_ulong) -> *mut libc::c_void;
 }
 
@@ -146,7 +145,6 @@ struct HashHDR {
 }
 
 extern "C" {
-    #[no_mangle]
     fn memset(_: *mut libc::c_void, _: libc::c_int, _: libc::c_ulong);
 }
 
diff --git a/c2rust-transpile/Cargo.toml b/c2rust-transpile/Cargo.toml
index 12ae29d1d2..734ba41516 100644
--- a/c2rust-transpile/Cargo.toml
+++ b/c2rust-transpile/Cargo.toml
@@ -20,6 +20,8 @@ serde_json = "1.0"
 serde_derive = "1.0.80"
 serde_bytes = "0.11"
 serde_bencode = "0.2"
+syn = { version = "1.0", features = ["full", "parsing", "printing"]}
+proc-macro2 = "1.0"
 indexmap = { version = "1.0.1", features = ["serde-1"] }
 c2rust-ast-builder = { version = "0.15.0", path = "../c2rust-ast-builder" }
 libc = "0.2"
diff --git a/c2rust-transpile/src/cfg/inc_cleanup.rs b/c2rust-transpile/src/cfg/inc_cleanup.rs
index c259e17758..81d4bd0b14 100644
--- a/c2rust-transpile/src/cfg/inc_cleanup.rs
+++ b/c2rust-transpile/src/cfg/inc_cleanup.rs
@@ -1,6 +1,7 @@
 //! This module provides support for removing the extraneous break statements
 //! generated by the incremental relooper.
 use super::*;
+use syn::{ExprIf, ExprMatch, ExprBlock, ExprReturn, ExprLit, ExprBreak, Expr, Lit};
 
 pub struct IncCleanup {
     in_tail: Option<ImplicitReturnType>,
@@ -28,24 +29,24 @@ impl IncCleanup {
 
             let mut removed_tail_expr = false;
 
-            if let StmtKind::Expr(ref mut expr) = stmt.kind {
-                match expr.kind {
-                    ExprKind::If(_, ref mut body, ref mut sels) => {
+            if let Stmt::Expr(ref mut expr) = stmt {
+                match expr {
+                    Expr::If(ExprIf{cond: _, then_branch: ref mut body, else_branch: ref mut sels, ..}) => {
                         removed_tail_expr =
                             removed_tail_expr || self.remove_tail_expr(&mut body.stmts);
-                        if let Some(els) = sels {
-                            if let ExprKind::Block(ref mut blk, _) = els.kind {
+                        if let Some((_token, els)) = sels {
+                            if let Expr::Block(ExprBlock {block: ref mut blk, ..}) = **els {
                                 removed_tail_expr =
                                     removed_tail_expr || self.remove_tail_expr(&mut blk.stmts)
                             }
                         }
                     }
 
-                    ExprKind::Match(_, ref mut cases) => {
+                    Expr::Match(ExprMatch { arms: ref mut cases, ..}) => {
                         // Block label can be removed from any arm
                         for case in cases {
-                            match case.body.kind {
-                                ExprKind::Block(ref mut blk, _) => {
+                            match *case.body {
+                                Expr::Block(ExprBlock {block: ref mut blk, ..}) => {
                                     removed_tail_expr =
                                         removed_tail_expr || self.remove_tail_expr(&mut blk.stmts)
                                 }
@@ -70,10 +71,7 @@ impl IncCleanup {
     }
 
     fn is_idempotent_tail_expr(&self, stmt: &Stmt) -> bool {
-        let tail_expr = if let Stmt {
-            kind: StmtKind::Semi(ref expr),
-            ..
-        } = *stmt
+        let tail_expr = if let Stmt::Semi(ref expr, _token) = *stmt
         {
             expr
         } else {
@@ -81,20 +79,14 @@ impl IncCleanup {
         };
         match self.in_tail {
             Some(ImplicitReturnType::Main) => {
-                if let Expr {
-                    kind: ExprKind::Ret(Some(ref zero)),
+                if let Expr::Return(ExprReturn {
+                    expr: Some(ref zero),
                     ..
-                } = **tail_expr
+                }) = *tail_expr
                 {
-                    if let Expr {
-                        kind: ExprKind::Lit(ref lit),
-                        ..
-                    } = **zero
+                    if let Expr::Lit(ExprLit { lit: Lit::Int(ref lit), .. }) = **zero
                     {
-                        if let Lit {
-                            kind: LitKind::Int(0, LitIntType::Unsuffixed),
-                            ..
-                        } = *lit
+                        if let "0" = lit.base10_digits()
                         {
                             return true;
                         }
@@ -104,10 +96,7 @@ impl IncCleanup {
             }
 
             Some(ImplicitReturnType::Void) => {
-                if let Expr {
-                    kind: ExprKind::Ret(None),
-                    ..
-                } = **tail_expr
+                if let Expr::Return(ExprReturn { expr: None, .. }) = *tail_expr
                 {
                     return true;
                 }
@@ -115,12 +104,9 @@ impl IncCleanup {
             }
 
             _ => {
-                if let Expr {
-                    kind: ExprKind::Break(Some(ref blbl), None),
-                    ..
-                } = **tail_expr
+                if let Expr::Break(ExprBreak { label: Some(ref blbl), expr: None, ..}) = *tail_expr
                 {
-                    if blbl.ident == mk().label(self.brk_lbl.pretty_print()).ident {
+                    if blbl.ident == mk().label(self.brk_lbl.pretty_print()).name.ident {
                         return true;
                     }
                 }
@@ -133,30 +119,21 @@ impl IncCleanup {
 /// Remove empty else clauses from if expressions that can arise from
 /// removing idempotent statements.
 fn cleanup_if(stmt: Stmt) -> Stmt {
-    if let Stmt {
-        kind: StmtKind::Expr(ref expr),
-        ..
-    } = &stmt
+    if let Stmt::Expr(ref expr) = &stmt
     {
-        if let Expr {
-            kind: ExprKind::If(ref cond, ref body, ref els),
-            ..
-        } = **expr
+        if let Expr::If(ExprIf { ref cond, then_branch: ref body, else_branch: ref els, ..}) = *expr
         {
-            if let Some(ref els) = els {
-                if let Expr {
-                    kind: ExprKind::Block(ref blk, None),
-                    ..
-                } = **els
+            if let Some((_token, ref els)) = *els {
+                if let Expr::Block(ExprBlock { block: ref blk, label: None, ..}) = **els
                 {
                     if blk.stmts.is_empty() {
-                        return Stmt {
-                            kind: StmtKind::Expr(P(Expr {
-                                kind: ExprKind::If(cond.clone(), body.clone(), None),
-                                ..(**expr).clone()
-                            })),
-                            ..stmt
-                        };
+                        return Stmt::Expr(Expr::If(ExprIf {
+                                attrs: vec![],
+                                if_token: Default::default(),
+                                cond: cond.clone(),
+                                then_branch: body.clone(),
+                                else_branch: None
+                        }))
                     }
                 }
             }
diff --git a/c2rust-transpile/src/cfg/mod.rs b/c2rust-transpile/src/cfg/mod.rs
index 7a916cc8a2..5cbff21d79 100644
--- a/c2rust-transpile/src/cfg/mod.rs
+++ b/c2rust-transpile/src/cfg/mod.rs
@@ -17,6 +17,9 @@
 
 use crate::c_ast::iterators::{DFExpr, SomeId};
 use crate::c_ast::CLabelId;
+use crate::rust_ast::{SpanExt, DUMMY_SP};
+use c2rust_ast_printer::pprust;
+use proc_macro2::Span;
 use std::collections::hash_map::DefaultHasher;
 use std::collections::BTreeSet;
 use std::fs::File;
@@ -26,11 +29,7 @@ use std::io;
 use std::io::Write;
 use std::ops::Deref;
 use std::ops::Index;
-use syntax;
-use syntax::ast::{Arm, Expr, ExprKind, Lit, LitIntType, LitKind, Pat, Stmt, StmtKind};
-use syntax::print::pprust;
-use syntax::ptr::P;
-use syntax_pos::{DUMMY_SP, Span};
+use syn::{Arm, Expr, Pat, Stmt, spanned::Spanned};
 
 use indexmap::{IndexMap, IndexSet};
 
@@ -69,8 +68,8 @@ pub enum Label {
 impl Label {
     pub fn pretty_print(&self) -> String {
         match self {
-            &Label::FromC(CStmtId(label_id)) => format!("'c_{}", label_id),
-            &Label::Synthetic(syn_id) => format!("'s_{}", syn_id),
+            &Label::FromC(CStmtId(label_id)) => format!("c_{}", label_id),
+            &Label::Synthetic(syn_id) => format!("s_{}", syn_id),
         }
     }
 
@@ -78,7 +77,7 @@ impl Label {
         String::from(self.pretty_print().trim_start_matches('\''))
     }
 
-    fn to_num_expr(&self) -> P<Expr> {
+    fn to_num_expr(&self) -> Box<Expr> {
         let mut s = DefaultHasher::new();
         self.hash(&mut s);
         let as_num = s.finish();
@@ -86,7 +85,7 @@ impl Label {
         mk().lit_expr(as_num as u128)
     }
 
-    fn to_string_expr(&self) -> P<Expr> {
+    fn to_string_expr(&self) -> Box<Expr> {
         mk().lit_expr(self.debug_print())
     }
 }
@@ -310,12 +309,12 @@ pub enum GenTerminator<Lbl> {
 
     /// Conditional branch to another block. The expression is expected to be a boolean Rust
     /// expression
-    Branch(P<Expr>, Lbl, Lbl),
+    Branch(Box<Expr>, Lbl, Lbl),
 
     /// Multi-way branch. The patterns are expected to match the type of the expression.
     Switch {
-        expr: P<Expr>,
-        cases: Vec<(P<Pat>, Lbl)>, // TODO: support ranges of expressions
+        expr: Box<Expr>,
+        cases: Vec<(Box<Pat>, Lbl)>, // TODO: support ranges of expressions
     },
 }
 
@@ -434,7 +433,7 @@ impl GenTerminator<StructureLabel<StmtOrDecl>> {
 /// been seen which translating the body of the switch.
 #[derive(Clone, Debug, Default)]
 pub struct SwitchCases {
-    cases: Vec<(P<Pat>, Label)>,
+    cases: Vec<(Box<Pat>, Label)>,
     default: Option<Label>,
 }
 
@@ -598,19 +597,19 @@ impl Cfg<Label, StmtOrDecl> {
                 // Add in what to do after control-flow exits the statement
                 match ret {
                     ImplicitReturnType::Main => {
-                        let ret_expr: Option<P<Expr>> = Some(mk().lit_expr(mk().int_lit(0, "")));
+                        let ret_expr: Option<Box<Expr>> = Some(mk().lit_expr(mk().int_lit(0, "")));
                         wip.body
                             .push(StmtOrDecl::Stmt(mk().semi_stmt(mk().return_expr(ret_expr))));
                     }
                     ImplicitReturnType::Void => {
                         wip.body.push(StmtOrDecl::Stmt(
-                            mk().semi_stmt(mk().return_expr(None as Option<P<Expr>>)),
+                            mk().semi_stmt(mk().return_expr(None as Option<Box<Expr>>)),
                         ));
                     }
                     ImplicitReturnType::NoImplicitReturnType => {
                         // NOTE: emitting `ret_expr` is not necessarily an error. For instance,
                         // this statement exit may be dominated by one or more return statements.
-                        let ret_expr: P<Expr> =
+                        let ret_expr: Box<Expr> =
                             translator.panic("Reached end of non-void function without returning");
                         wip.body.push(StmtOrDecl::Stmt(mk().semi_stmt(ret_expr)));
                     }
@@ -1768,8 +1767,8 @@ impl CfgBuilder {
                                 .convert_expr(ctx.used(), resolved.0)?
                                 .to_pure_expr()
                             {
-                                Some(expr) => match expr.kind {
-                                    ExprKind::Lit(..) | ExprKind::Path(..) => Some(expr),
+                                Some(expr) => match *expr {
+                                    Expr::Lit(..) | Expr::Path(..) => Some(expr),
                                     _ => None,
                                 }
                                 _ => None,
@@ -1951,10 +1950,10 @@ impl CfgBuilder {
                 false,
             ),
 
-            Some(ImplicitReturnType::Void) => (mk().return_expr(None as Option<P<Expr>>), false),
+            Some(ImplicitReturnType::Void) => (mk().return_expr(None as Option<Box<Expr>>), false),
 
             _ => (
-                mk().break_expr_value(Some(brk_lbl.pretty_print()), None as Option<P<Expr>>),
+                mk().break_expr_value(Some(brk_lbl.pretty_print()), None as Option<Box<Expr>>),
                 true,
             ),
         };
@@ -1991,7 +1990,7 @@ impl CfgBuilder {
             false,
         )?;
 
-        let inner_span = stmts.first().map(|stmt| stmt.span);
+        let inner_span = stmts.first().map(|stmt| stmt.span());
 
         // Remove unnecessary break statements. We only need a break statement if we failed to
         // remove the tail expr.
@@ -2001,7 +2000,7 @@ impl CfgBuilder {
         if has_fallthrough && need_block && use_brk_lbl {
             translator.use_feature("label_break_value");
             let block_body = mk().block(stmts);
-            let block: P<Expr> = mk().labelled_block_expr(block_body, brk_lbl.pretty_print());
+            let block: Box<Expr> = mk().labelled_block_expr(block_body, brk_lbl.pretty_print());
             stmts = vec![mk().expr_stmt(block)]
         }
 
diff --git a/c2rust-transpile/src/cfg/relooper.rs b/c2rust-transpile/src/cfg/relooper.rs
index 1626dd7855..938ae5c822 100644
--- a/c2rust-transpile/src/cfg/relooper.rs
+++ b/c2rust-transpile/src/cfg/relooper.rs
@@ -559,8 +559,8 @@ fn simplify_structure<Stmt: Clone>(structures: Vec<Structure<Stmt>>) -> Vec<Stru
                 } = terminator
                 {
                     // Here, we group patterns by the label they go to.
-                    let mut merged_goto: IndexMap<Label, Vec<P<Pat>>> = IndexMap::new();
-                    let mut merged_exit: IndexMap<Label, Vec<P<Pat>>> = IndexMap::new();
+                    let mut merged_goto: IndexMap<Label, Vec<Box<Pat>>> = IndexMap::new();
+                    let mut merged_exit: IndexMap<Label, Vec<Box<Pat>>> = IndexMap::new();
 
                     for &(ref pat, ref lbl) in cases {
                         match lbl {
diff --git a/c2rust-transpile/src/cfg/structures.rs b/c2rust-transpile/src/cfg/structures.rs
index 3f48cf71b5..edddc877b6 100644
--- a/c2rust-transpile/src/cfg/structures.rs
+++ b/c2rust-transpile/src/cfg/structures.rs
@@ -1,21 +1,20 @@
 //! This modules handles converting `Vec<Structure>` into `Vec<Stmt>`.
 
-use syntax::source_map::{dummy_spanned, Spanned};
-use syntax_pos::BytePos;
-
 use super::*;
+use syn::{ExprReturn, ExprIf, ExprBreak, ExprParen, ExprUnary, Stmt, spanned::Spanned as _};
+use std::result::Result;
 
-use crate::rust_ast::comment_store;
+use crate::rust_ast::{comment_store, BytePos, SpanExt, set_span::SetSpan};
 
 /// Convert a sequence of structures produced by Relooper back into Rust statements
 pub fn structured_cfg(
     root: &Vec<Structure<Stmt>>,
     comment_store: &mut comment_store::CommentStore,
-    current_block: P<Expr>,
+    current_block: Box<Expr>,
     debug_labels: bool,
     cut_out_trailing_ret: bool,
 ) -> Result<Vec<Stmt>, TranslationError> {
-    let ast: StructuredAST<P<Expr>, P<Pat>, Label, Stmt> =
+    let ast: StructuredAST<Box<Expr>, Box<Pat>, Label, Stmt> =
         structured_cfg_help(vec![], &IndexSet::new(), root, &mut IndexSet::new())?;
 
     let s = StructureState {
@@ -28,23 +27,12 @@ pub fn structured_cfg(
     // it with the returned value.
     if cut_out_trailing_ret {
         match stmts.last().cloned() {
-            Some(Stmt {
-                kind: StmtKind::Expr(ref ret),
-                ..
-            })
-            | Some(Stmt {
-                kind: StmtKind::Semi(ref ret),
-                ..
-            }) => {
-                match ret.kind {
-                    ExprKind::Ret(None) => {
+            Some(Stmt::Expr(ref ret))
+            | Some(Stmt::Semi(ref ret, _)) => {
+                match ret {
+                    Expr::Return(ExprReturn { expr: None, .. }) => {
                         stmts.pop();
                     }
-                    // TODO: why does libsyntax print a ';' after this even if it is 'Expr' and not 'Semi'
-                    //                ExprKind::Ret(Some(ref e)) => {
-                    //                    stmts.pop();
-                    //                    stmts.push(mk().expr_stmt(e));
-                    //                }
                     _ => {}
                 }
             }
@@ -118,8 +106,21 @@ pub trait StructuredStatement: Sized {
     fn extend_span(&mut self, span: Span);
 }
 
+#[derive(Debug, Clone)]
+pub struct Spanned<T> {
+    pub node: T,
+    pub span: Span,
+}
+
 pub type StructuredAST<E, P, L, S> = Spanned<StructuredASTKind<E, P, L, S>>;
 
+fn dummy_spanned<T>(inner: T) -> Spanned<T> {
+    Spanned {
+        node: inner,
+        span: Span::dummy(),
+    }
+}
+
 /// Defunctionalized version of `StructuredStatement` trait
 #[allow(missing_docs)]
 #[derive(Debug)]
@@ -203,7 +204,7 @@ impl<E, P, L, S> StructuredStatement for StructuredAST<E, P, L, S> {
 ///
 /// TODO: move this into `structured_cfg`?
 fn structured_cfg_help<
-    S: StructuredStatement<E = P<Expr>, P = P<Pat>, L = Label, S = Stmt>,
+    S: StructuredStatement<E = Box<Expr>, P = Box<Pat>, L = Label, S = Stmt>,
 >(
     exits: Vec<(Label, IndexMap<Label, (IndexSet<Label>, ExitStyle)>)>,
     next: &IndexSet<Label>,
@@ -296,10 +297,10 @@ fn structured_cfg_help<
                             ref expr,
                             ref cases,
                         } => {
-                            let branched_cases: Vec<(P<Pat>, S)> = cases
+                            let branched_cases: Vec<(Box<Pat>, S)> = cases
                                 .iter()
                                 .map(|&(ref pat, ref slbl)| Ok((pat.clone(), branch(slbl)?)))
-                                .collect::<Result<Vec<(P<Pat>, S)>, TranslationError>>()?;
+                                .collect::<Result<Vec<(Box<Pat>, S)>, TranslationError>>()?;
 
                             S::mk_match(expr.clone(), branched_cases)
                         }
@@ -385,7 +386,7 @@ pub fn has_multiple<Stmt>(root: &Vec<Structure<Stmt>>) -> bool {
 
 struct StructureState {
     debug_labels: bool,
-    current_block: P<Expr>,
+    current_block: Box<Expr>,
 }
 
 /// Returns a `Span` between the beginning of `span` or `other`, whichever is
@@ -419,7 +420,7 @@ fn span_subst_hi(span: Span, other: Span) -> Option<Span> {
 impl StructureState {
     pub fn into_stmt(
         &self,
-        ast: StructuredAST<P<Expr>, P<Pat>, Label, Stmt>,
+        ast: StructuredAST<Box<Expr>, Box<Pat>, Label, Stmt>,
         comment_store: &mut comment_store::CommentStore,
     ) -> (Vec<Stmt>, Span) {
         use crate::cfg::structures::StructuredASTKind::*;
@@ -430,8 +431,8 @@ impl StructureState {
             Empty => return (vec![], ast.span),
 
             Singleton(mut s) => {
-                let span = s.span.substitute_dummy(ast.span);
-                s.span = span;
+                let span = s.span().substitute_dummy(ast.span);
+                s.set_span(span);
                 return (vec![s], span);
             }
 
@@ -448,13 +449,13 @@ impl StructureState {
                 // Adjust the first and last elements of the block if this AST
                 // node has a span.
                 if let Some(stmt) = stmts.first_mut() {
-                    stmt.span = span_subst_lo(stmt.span, span).unwrap_or_else(|| {
-                        comment_store.move_comments(stmt.span.lo(), span.lo());
-                        stmt.span.with_lo(span.lo())
-                    });
+                    stmt.set_span(span_subst_lo(stmt.span(), span).unwrap_or_else(|| {
+                        comment_store.move_comments(stmt.span().lo(), span.lo());
+                        stmt.span().with_lo(span.lo())
+                    }));
                 }
                 if let Some(stmt) = stmts.last_mut() {
-                    stmt.span = span_subst_hi(stmt.span, span).unwrap_or(stmt.span);
+                    stmt.set_span(span_subst_hi(stmt.span(), span).unwrap_or(stmt.span()));
                 }
                 return (stmts, span);
             }
@@ -472,13 +473,13 @@ impl StructureState {
                 // Adjust the first and last elements of the block if this AST
                 // node has a span.
                 if let Some(stmt) = stmts.first_mut() {
-                    stmt.span = span_subst_lo(stmt.span, span).unwrap_or_else(|| {
-                        comment_store.move_comments(stmt.span.lo(), span.lo());
-                        stmt.span.with_lo(span.lo())
-                    });
+                    stmt.set_span(span_subst_lo(stmt.span(), span).unwrap_or_else(|| {
+                        comment_store.move_comments(stmt.span().lo(), span.lo());
+                        stmt.span().with_lo(span.lo())
+                    }));
                 }
                 if let Some(stmt) = stmts.last_mut() {
-                    stmt.span = span_subst_hi(stmt.span, span).unwrap_or(stmt.span);
+                    stmt.set_span(span_subst_hi(stmt.span(), span).unwrap_or(stmt.span()));
                 }
                 return (stmts, span);
             }
@@ -504,7 +505,7 @@ impl StructureState {
                         let (stmts, span) = self.into_stmt(stmts, comment_store);
 
                         let body = mk().block_expr(mk().span(span).block(stmts));
-                        mk().arm(pat, None as Option<P<Expr>>, body)
+                        mk().arm(pat, None as Option<Box<Expr>>, body)
                     })
                     .collect();
 
@@ -529,40 +530,40 @@ impl StructureState {
                     (true, true) => mk().semi_stmt(cond),
                     (false, true) => {
                         let if_expr =
-                            mk().ifte_expr(cond, mk().span(then_span).block(then_stmts), None as Option<P<Expr>>);
+                            mk().ifte_expr(cond, mk().span(then_span).block(then_stmts), None as Option<Box<Expr>>);
                         mk().expr_stmt(if_expr)
                     }
                     (true, false) => {
                         let negated_cond = not(&cond);
                         let if_expr =
-                            mk().ifte_expr(negated_cond, mk().span(els_span).block(els_stmts), None as Option<P<Expr>>);
+                            mk().ifte_expr(negated_cond, mk().span(els_span).block(els_stmts), None as Option<Box<Expr>>);
                         mk().expr_stmt(if_expr)
                     }
                     (false, false) => {
-                        fn is_expr(kind: &StmtKind) -> bool {
+                        fn is_expr(kind: &Stmt) -> bool {
                             match &kind {
-                                StmtKind::Expr(expr) => match &expr.kind {
-                                    ExprKind::If(..) | ExprKind::Block(..) => true,
+                                Stmt::Expr(expr) => match &expr {
+                                    Expr::If(..) | Expr::Block(..) => true,
                                     _ => false,
                                 },
                                 _ => false,
                             }
                         }
 
-                        // Do the else statemtents contain a single If, IfLet or
+                        // Do the else statements contain a single If, IfLet or
                         // Block expression? The pretty printer handles only
                         // these kinds of expressions for the else case.
-                        let is_els_expr = els_stmts.len() == 1 && is_expr(&els_stmts[0].kind);
+                        let is_els_expr = els_stmts.len() == 1 && is_expr(&els_stmts[0]);
 
                         let els_branch = if is_els_expr {
                             let stmt_expr = els_stmts.swap_remove(0);
-                            let stmt_expr_span = stmt_expr.span;
-                            let mut els_expr = match stmt_expr.kind {
-                                StmtKind::Expr(e) => e,
+                            let stmt_expr_span = stmt_expr.span();
+                            let mut els_expr = match stmt_expr {
+                                Stmt::Expr(e) => e,
                                 _ => panic!("is_els_expr out of sync"),
                             };
-                            els_expr.span = stmt_expr_span;
-                            els_expr
+                            els_expr.set_span(stmt_expr_span);
+                            Box::new(els_expr)
                         } else {
                             mk().block_expr(mk().span(els_span).block(els_stmts))
                         };
@@ -572,7 +573,7 @@ impl StructureState {
                     }
                 };
 
-                if_stmt.span = span;
+                if_stmt.set_span(span);
                 if_stmt
             }
 
@@ -591,7 +592,7 @@ impl StructureState {
                         };
                         let pat = mk().lit_pat(lbl_expr);
                         let body = mk().block_expr(mk().span(stmts_span).block(stmts));
-                        mk().arm(pat, None as Option<P<Expr>>, body)
+                        mk().arm(pat, None as Option<Box<Expr>>, body)
                     })
                     .collect();
 
@@ -599,7 +600,7 @@ impl StructureState {
 
                 arms.push(mk().arm(
                     mk().wild_pat(),
-                    None as Option<P<Expr>>,
+                    None as Option<Box<Expr>>,
                     mk().block_expr(mk().span(then_span).block(then)),
                 ));
 
@@ -617,27 +618,17 @@ impl StructureState {
                 let (body, body_span) = self.into_stmt(*body, comment_store);
 
                 // TODO: this is ugly but it needn't be. We are just pattern matching on particular ASTs.
-                if let Some(&Stmt {
-                    kind: syntax::ast::StmtKind::Expr(ref expr),
-                    span: stmt_span,
-                    ..
-                }) = body.first()
+                if let Some(stmt @ &Stmt::Expr(ref expr)) = body.first()
                 {
+                    let stmt_span = stmt.span();
                     let span = if !stmt_span.is_dummy() { stmt_span } else { span };
-                    if let syntax::ast::ExprKind::If(ref cond, ref thn, None) = expr.kind {
-                        if let &syntax::ast::Block {
-                            ref stmts,
-                            rules: syntax::ast::BlockCheckMode::Default,
-                            ..
-                        } = thn.deref()
+                    if let syn::Expr::If(ExprIf {ref cond, ref then_branch, else_branch: None, ..}) = expr {
+                        let stmts = &then_branch.stmts;
                         {
                             if stmts.len() == 1 {
-                                if let Some(&Stmt {
-                                    kind: syntax::ast::StmtKind::Semi(ref expr),
-                                    ..
-                                }) = stmts.iter().nth(0)
+                                if let Some(&Stmt::Semi(ref expr, _token)) = stmts.iter().nth(0)
                                 {
-                                    if let syntax::ast::ExprKind::Break(None, None) = expr.kind {
+                                    if let syn::Expr::Break(ExprBreak { label: None, expr: None, ..}) = expr {
                                         let e = mk().while_expr(
                                             not(cond),
                                             mk().span(body_span).block(body.iter().skip(1).cloned().collect()),
@@ -677,9 +668,15 @@ impl StructureState {
 ///
 ///   * Negating something of the form `!<expr>` produces `<expr>`
 ///
-fn not(bool_expr: &P<Expr>) -> P<Expr> {
-    match bool_expr.kind {
-        ExprKind::Unary(syntax::ast::UnOp::Not, ref e) => e.clone(),
+fn not(bool_expr: &Box<Expr>) -> Box<Expr> {
+    fn unparen(expr: &Box<Expr>) -> &Box<Expr> {
+        match **expr {
+            Expr::Paren(ExprParen { ref expr, .. }) => expr,
+            _ => expr,
+        }
+    }
+    match **bool_expr {
+        Expr::Unary(ExprUnary { op: syn::UnOp::Not(_), ref expr, .. }) => unparen(expr).clone(),
         _ => mk().unary_expr("!", bool_expr.clone()),
     }
 }
diff --git a/c2rust-transpile/src/convert_type.rs b/c2rust-transpile/src/convert_type.rs
index 3a176d9b56..8889b77cb6 100644
--- a/c2rust-transpile/src/convert_type.rs
+++ b/c2rust-transpile/src/convert_type.rs
@@ -2,11 +2,11 @@ use crate::c_ast::CDeclId;
 use crate::c_ast::*;
 use crate::renamer::*;
 use crate::diagnostics::TranslationError;
-use c2rust_ast_builder::mk;
+use c2rust_ast_builder::{mk, properties::*};
 use std::collections::{HashMap, HashSet};
 use std::ops::Index;
-use syntax::ast::*;
-use syntax::ptr::P;
+use syn::*;
+use std::result::Result;
 
 #[derive(Debug, Hash, PartialEq, Eq, Clone)]
 enum FieldKey {
@@ -238,23 +238,22 @@ impl TypeConverter {
         ret: Option<CQualTypeId>,
         params: &Vec<CQualTypeId>,
         is_variadic: bool,
-    ) -> Result<P<Ty>, TranslationError> {
-        let mut inputs = params
+    ) -> Result<Box<Type>, TranslationError> {
+        let barefn_inputs = params
             .iter()
-            .map(|x| mk().arg(self.convert(ctxt, x.ctype).unwrap(), mk().wild_pat()))
-            .collect::<Vec<_>>();
+            .map(|x| mk().bare_arg(self.convert(ctxt, x.ctype).unwrap(), None::<Box<Ident>>))
+            .collect::<Vec<BareFnArg>>();
 
         let output = match ret {
             None => mk().never_ty(),
             Some(ret) => self.convert(ctxt, ret.ctype)?,
         };
 
-        if is_variadic {
-            // For variadic functions, we need to add `_: ...` as an explicit argument
-            inputs.push(mk().arg(mk().cvar_args_ty(), mk().wild_pat()))
-        };
+        let variadic = is_variadic.then(||
+            mk().variadic_arg(vec![])
+        );
 
-        let fn_ty = mk().fn_decl(inputs, FunctionRetTy::Ty(output));
+        let fn_ty = Box::new((barefn_inputs, variadic, ReturnType::Type(Default::default(), output)));
         return Ok(mk().unsafe_().extern_("C").barefn_ty(fn_ty));
     }
 
@@ -262,7 +261,7 @@ impl TypeConverter {
         &mut self,
         ctxt: &TypedAstContext,
         qtype: CQualTypeId,
-    ) -> Result<P<Ty>, TranslationError> {
+    ) -> Result<Box<Type>, TranslationError> {
         let mutbl = if qtype.qualifiers.is_const {
             Mutability::Immutable
         } else {
@@ -307,16 +306,16 @@ impl TypeConverter {
         &mut self,
         ctxt: &TypedAstContext,
         ctype: CTypeId,
-    ) -> Result<P<Ty>, TranslationError> {
+    ) -> Result<Box<Type>, TranslationError> {
         if self.translate_valist && ctxt.is_va_list(ctype) {
             let std_or_core = if self.emit_no_std { "core" } else { "std" };
-            let path = vec!["", std_or_core, "ffi", "VaList"];
-            let ty = mk().path_ty(path);
+            let path = vec![std_or_core, "ffi", "VaList"];
+            let ty = mk().path_ty(mk().abs_path(path));
             return Ok(ty);
         }
 
         match ctxt.index(ctype).kind {
-            CTypeKind::Void => Ok(mk().tuple_ty(vec![] as Vec<P<Ty>>)),
+            CTypeKind::Void => Ok(mk().tuple_ty(vec![] as Vec<Box<Type>>)),
             CTypeKind::Bool => Ok(mk().path_ty(mk().path(vec!["bool"]))),
             CTypeKind::Short => Ok(mk().path_ty(mk().path(vec!["libc", "c_short"]))),
             CTypeKind::Int => Ok(mk().path_ty(mk().path(vec!["libc", "c_int"]))),
@@ -367,13 +366,13 @@ impl TypeConverter {
                 let ty = self.convert(ctxt, element)?;
                 Ok(mk().array_ty(
                     ty,
-                    mk().lit_expr(mk().int_lit(count as u128, LitIntType::Unsuffixed)),
+                    mk().lit_expr(mk().int_unsuffixed_lit(count as u128)),
                 ))
             }
 
             CTypeKind::IncompleteArray(element) => {
                 let ty = self.convert(ctxt, element)?;
-                let zero_lit = mk().int_lit(0, LitIntType::Unsuffixed);
+                let zero_lit = mk().int_unsuffixed_lit(0);
                 let zero = mk().lit_expr(zero_lit);
                 Ok(mk().array_ty(ty, zero))
             }
@@ -415,7 +414,7 @@ impl TypeConverter {
         ctxt: &TypedAstContext,
         ctype: CTypeId,
         params: &Vec<CParamId>
-    ) -> Result<Option<P<Ty>>, TranslationError> {
+    ) -> Result<Option<Box<Type>>, TranslationError> {
         match ctxt.index(ctype).kind {
             // ANSI/ISO C-style function
             CTypeKind::Function(.., true) => Ok(None),
diff --git a/c2rust-transpile/src/lib.rs b/c2rust-transpile/src/lib.rs
index 9e7bb68b34..51c6992acc 100644
--- a/c2rust-transpile/src/lib.rs
+++ b/c2rust-transpile/src/lib.rs
@@ -4,9 +4,7 @@
 
 extern crate colored;
 extern crate dtoa;
-extern crate rustc_parse;
-extern crate syntax;
-extern crate syntax_pos;
+extern crate syn;
 #[macro_use]
 extern crate indexmap;
 extern crate serde;
@@ -61,7 +59,6 @@ use crate::compile_cmds::get_compile_commands;
 use crate::convert_type::RESERVED_NAMES;
 pub use crate::translator::ReplaceMode;
 use std::prelude::v1::Vec;
-use syntax_pos::edition::Edition;
 
 type PragmaVec = Vec<(&'static str, Vec<&'static str>)>;
 type PragmaSet = indexmap::IndexSet<(&'static str, &'static str)>;
@@ -384,42 +381,7 @@ fn get_extra_args_macos() -> Vec<String> {
 }
 
 fn invoke_refactor(build_dir: &PathBuf) -> Result<(), Error> {
-    // Make sure the crate builds cleanly
-    let status = process::Command::new("cargo")
-        .args(&["check"])
-        .env("RUSTFLAGS", "-Awarnings")
-        .current_dir(build_dir)
-        .status()?;
-    if !status.success() {
-        return Err(format_err!("Crate does not compile."));
-    }
-
-    // Assumes the subcommand executable is in the same directory as this program.
-    let cmd_path = std::env::current_exe().expect("Cannot get current executable path");
-    let mut cmd_path = cmd_path.as_path().canonicalize().unwrap();
-    cmd_path.pop(); // remove current executable
-    cmd_path.push(format!("c2rust-refactor"));
-    assert!(cmd_path.exists(), format!("{:?} is missing", cmd_path));
-    let args = [
-        "--cargo",
-        "--rewrite-mode",
-        "inplace",
-        "rename_unnamed",
-        ";",
-        "reorganize_definitions",
-    ];
-    let status = process::Command::new(cmd_path.into_os_string())
-        .args(&args)
-        .current_dir(build_dir)
-        .status()?;
-    if status.success() {
-        Ok(())
-    } else {
-        Err(format_err!(
-            "Refactoring failed. Please fix errors above and re-run:\n    c2rust refactor {}",
-            args.join(" "),
-        ))
-    }
+    return Ok(());
 }
 
 fn reorganize_definitions(
@@ -517,9 +479,7 @@ fn transpile_single(
 
     // Perform the translation
     let (translated_string, pragmas, crates) =
-        syntax::with_globals(Edition::Edition2018, move || {
-            translator::translate(typed_context, &tcfg, input_path)
-        });
+        translator::translate(typed_context, &tcfg, input_path);
 
     let mut file = match File::create(&output_path) {
         Ok(file) => file,
diff --git a/c2rust-transpile/src/rust_ast/comment_store.rs b/c2rust-transpile/src/rust_ast/comment_store.rs
index ff2ceead87..b5301f98d4 100644
--- a/c2rust-transpile/src/rust_ast/comment_store.rs
+++ b/c2rust-transpile/src/rust_ast/comment_store.rs
@@ -1,30 +1,12 @@
 //! This module handles accumulating / re-arranging comments for the Rust AST.
 //!
-//! The only way we have found to have comments inserted into the pretty-printed Rust output is via
-//! a comment vector. The Rust pretty-printer accepts a vector of comments and, before printing
-//! any AST node, it dumps out the prefix of comments whose position is less than the span of the
-//! AST node.
-//!
-//! The logic for creating/storing a comment vector is in `CommentStore`. For example, if you want
-//! to add a comment to a match arm:
-//!
-//! ```rust
-//!   let sp: Span = cmmt_store.add_comment_lines(vec!["Some comment on an arm"]);
-//!   let arm = mk().span(sp).arm(pats, None, body);
-//!   ...
-//! ```
-//!
-//! Right before printing the output, it is a good idea to use the `CommentTraverser` to make sure
-//! that the comment vector is in the right order. That just means doing something like this:
+//! Comments are stored as attributes on the AST node immediately following the comment.
 //!
 //! ```rust
-//!   let trav: CommentTraverser = cmmt_store.into_comment_traverser();
-//!   let updated_module: Mod = trav.traverse_mod(module);
-//!   let updated_cmmt_store = trav.into_comment_store();
+//!   insert_comments(&mut expr.attrs, vec!["Some comment on an arm"]);
 //! ```
 //!
 //! Comments can currently be attached and printed in the following positions
-//! (see pprust.rs for current details):
 //!
 //! Before the following AST elements:
 //! - Lit
@@ -41,20 +23,18 @@
 //! - Path
 //! - Arm
 //!
-//! Trailing comments can be printed after the following elements hi pos, but on
-//! the same line:
-//! - Stmt
-//! - Comma separated Expr (struct initializer, tuples literals, etc.)
-//!
-//! Before the close of a Block
+//! Comments cannot currently be attached before the close of a Block, or after all Items in a File.
 
-use crate::rust_ast::{pos_to_span, traverse};
+use crate::rust_ast::{pos_to_span, traverse, SpanExt, DUMMY_SP, BytePos, set_span::SetSpan};
 use itertools::Itertools;
 use smallvec::{smallvec, SmallVec};
 use std::collections::BTreeMap;
-use syntax::ast::*;
-use syntax::util::comments;
-use syntax_pos::{BytePos, Span};
+use std::default::Default;
+use syn::spanned::Spanned as _;
+use syn::__private::ToTokens;
+use proc_macro2::{Span, TokenStream};
+use syn::*;
+use c2rust_ast_printer::pprust::comments;
 
 pub struct CommentStore {
     /// The `BytePos` keys do _not_ correspond to the comment position. Instead, they refer to the
@@ -106,22 +86,22 @@ impl CommentStore {
         // The position of isolated comments have to be LESS than the span of
         // the AST node it annotates.
         for cmmt in &mut new_comments {
-            if let comments::CommentStyle::Isolated = cmmt.style {
+            //if let comments::CommentStyle::Isolated = cmmt.style {
                 cmmt.pos = BytePos(self.current_position);
                 self.current_position += 1;
-            }
+            //}
         }
 
         let new_pos = BytePos(self.current_position);
 
         // The position of trailing comments have to be GREATER than the span of
         // the AST node it follows.
-        for cmmt in &mut new_comments {
+        /*for cmmt in &mut new_comments {
             if let comments::CommentStyle::Trailing = cmmt.style {
                 self.current_position += 1;
                 cmmt.pos = BytePos(self.current_position);
             }
-        }
+        }*/
 
         self.output_comments.insert(new_pos, new_comments);
         new_pos
@@ -130,7 +110,7 @@ impl CommentStore {
     /// Add an isolated comment at the current position, then return the `Span`
     /// that should be given to something we want associated with this comment.
     pub fn add_comments(&mut self, lines: &[String]) -> Option<BytePos> {
-        self.extend_existing_comments(lines, None, comments::CommentStyle::Isolated)
+        self.extend_existing_comments(lines, None)//, comments::CommentStyle::Isolated)
     }
 
     /// Add a comment at the specified position, then return the `BytePos` that
@@ -140,7 +120,7 @@ impl CommentStore {
         &mut self,
         lines: &[String],
         pos: Option<BytePos>,
-        style: comments::CommentStyle,
+        //style: comments::CommentStyle,
     ) -> Option<BytePos> {
         fn translate_comment(comment: &String) -> String {
             comment
@@ -167,7 +147,7 @@ impl CommentStore {
             None
         } else {
             let new_comment = comments::Comment {
-                style,
+                //style,
                 lines: lines,
                 pos: BytePos(0), // overwritten in `add_comment`
             };
@@ -192,8 +172,13 @@ impl CommentStore {
             if span.lo() == BytePos(0) {
                 span.shrink_to_hi()
             } else {
-                let new_comments = self.output_comments.remove(&span.hi())
-                    .unwrap_or_else(|| panic!("Expected comments attached to the high end of span {:?}", span));
+                let new_comments = match self.output_comments.remove(&span.hi()) {
+                    Some(nc) => nc,
+                    None => {
+                        warn!("Expected comments attached to the high end of span {:?}", span);
+                        return span
+                    },
+                };
                 self.output_comments.entry(span.lo()).or_insert(SmallVec::new()).extend(new_comments);
                 span.shrink_to_lo()
             }
@@ -201,12 +186,12 @@ impl CommentStore {
             span
         };
 
-        // All comments attached to this span should become isolated.
+        /*// All comments attached to this span should become isolated.
         if let Some(comments) = self.output_comments.get_mut(&span.lo()) {
             for comment in comments {
                 comment.style = comments::CommentStyle::Isolated;
             }
-        }
+        }*/
 
         span
     }
@@ -240,12 +225,12 @@ impl CommentTraverser {
 macro_rules! reinsert_and_traverse {
     ($fn:ident, $ty:ty, $traverse:path) => {
         fn $fn(&mut self, mut x: $ty) -> $ty {
-            let orig = x.span.data();
-            x.span = pos_to_span(self.reinsert_comment_at(orig.lo).unwrap_or(BytePos(0)));
+            let (lo, hi) = x.span().inner();
+            x.set_span(pos_to_span(self.reinsert_comment_at(BytePos(lo)).unwrap_or(BytePos(0))));
             x = $traverse(self, x);
-            if orig.lo != orig.hi {
-                if let Some(new_hi) = self.reinsert_comment_at(orig.hi) {
-                    x.span = x.span.with_hi(new_hi);
+            if lo != hi {
+                if let Some(new_hi) = self.reinsert_comment_at(BytePos(hi)) {
+                    x.set_span(x.span().with_hi(new_hi));
                 }
             }
             x
@@ -260,11 +245,42 @@ impl traverse::Traversal for CommentTraverser {
     reinsert_and_traverse!(traverse_impl_item, ImplItem, traverse::traverse_impl_item_def);
     reinsert_and_traverse!(traverse_block, Block, traverse::traverse_block_def);
     reinsert_and_traverse!(traverse_local, Local, traverse::traverse_local_def);
-    reinsert_and_traverse!(traverse_field, Field, traverse::traverse_field_def);
+    reinsert_and_traverse!(traverse_field, FieldValue, traverse::traverse_field_def);
     reinsert_and_traverse!(traverse_item, Item, traverse::traverse_item_def);
 
     fn traverse_foreign_item(&mut self, mut i: ForeignItem) -> ForeignItem {
-        i.span = pos_to_span(self.reinsert_comment_at(i.span.lo()).unwrap_or(BytePos(0)));
+        i.set_span(pos_to_span(self.reinsert_comment_at(i.span().lo()).unwrap_or(BytePos(0))));
         i
     }
 }
+
+pub fn insert_comment_attrs(attrs: &mut Vec<Attribute>, new_comments: SmallVec<[&str; 1]>) {
+    attrs.reserve(new_comments.len());
+    let eq: syn::Token![=] = Default::default();
+    fn make_comment_path() -> Path {
+        let mut segments = punctuated::Punctuated::new();
+        segments.push(PathSegment {
+            ident: Ident::new("comment", DUMMY_SP),
+            arguments: PathArguments::None,
+        });
+        Path {
+            leading_colon: None,
+            segments,
+        }
+    }
+
+    for c in new_comments {
+        let lit = Lit::new(proc_macro2::Literal::string(&*c));
+        let mut tokens = TokenStream::new();
+        eq.to_tokens(&mut tokens);
+        lit.to_tokens(&mut tokens);
+        let attr = Attribute {
+            pound_token: Default::default(),
+            style: AttrStyle::Inner(Default::default()),
+            bracket_token: Default::default(),
+            path: make_comment_path(),
+            tokens,
+        };
+        attrs.push(attr);
+    }
+}
diff --git a/c2rust-transpile/src/rust_ast/item_store.rs b/c2rust-transpile/src/rust_ast/item_store.rs
index 8d02eb54aa..a4d706b348 100644
--- a/c2rust-transpile/src/rust_ast/item_store.rs
+++ b/c2rust-transpile/src/rust_ast/item_store.rs
@@ -1,7 +1,6 @@
 use c2rust_ast_builder::{mk, Builder};
 use indexmap::{IndexMap, IndexSet};
-use syntax::ast::{ForeignItem, Ident, Item};
-use syntax::ptr::P;
+use syn::{ForeignItem, Ident, Item};
 
 use std::borrow::Cow;
 use std::mem::swap;
@@ -48,8 +47,8 @@ impl PathedMultiImports {
         self.0.entry(path).or_insert(MultiImport::new())
     }
 
-    pub fn into_items(self) -> Vec<P<Item>> {
-        fn build_items((mut path, imports): (Vec<String>, MultiImport)) -> P<Item> {
+    pub fn into_items(self) -> Vec<Box<Item>> {
+        fn build_items((mut path, imports): (Vec<String>, MultiImport)) -> Box<Item> {
             let mut leaves = imports.leaves;
             let attrs = imports
                 .attrs
@@ -70,7 +69,7 @@ impl PathedMultiImports {
 
 #[derive(Debug)]
 pub struct ItemStore {
-    items: Vec<P<Item>>,
+    items: Vec<Box<Item>>,
     foreign_items: Vec<ForeignItem>,
     uses: PathedMultiImports,
 }
@@ -84,7 +83,7 @@ impl ItemStore {
         }
     }
 
-    pub fn add_item(&mut self, item: P<Item>) {
+    pub fn add_item(&mut self, item: Box<Item>) {
         self.items.push(item);
     }
 
@@ -100,7 +99,7 @@ impl ItemStore {
         self.uses.get_mut(path).insert_with_attr(ident, attrs)
     }
 
-    pub fn drain(&mut self) -> (Vec<P<Item>>, Vec<ForeignItem>, PathedMultiImports) {
+    pub fn drain(&mut self) -> (Vec<Box<Item>>, Vec<ForeignItem>, PathedMultiImports) {
         let mut items = Vec::new();
         let mut foreign_items = Vec::new();
         let mut uses = PathedMultiImports::new();
diff --git a/c2rust-transpile/src/rust_ast/mod.rs b/c2rust-transpile/src/rust_ast/mod.rs
index e65b43095f..b398ea08ff 100644
--- a/c2rust-transpile/src/rust_ast/mod.rs
+++ b/c2rust-transpile/src/rust_ast/mod.rs
@@ -1,11 +1,239 @@
 pub mod comment_store;
 pub mod item_store;
 pub mod traverse;
+pub mod set_span;
 
-use syntax_pos::{BytePos, Span};
-use syntax_pos::hygiene::SyntaxContext;
+pub use c2rust_ast_printer::pprust::BytePos;
+use proc_macro2::Span;
+
+use std::sync::atomic::{AtomicU32, Ordering};
+
+static SPAN_LIMIT: AtomicU32 = AtomicU32::new(0);
+
+fn raise_span_limit(new_limit: u32) {
+    let limit = SPAN_LIMIT.load(Ordering::Relaxed);
+    let new_limit = 0x2000000;
+    if new_limit >= limit {
+        let delta = new_limit - limit;
+        let s = str::repeat("        ", (delta as usize + 7) / 8);
+        use std::str::FromStr;
+        /* used only for its side-effect of expanding the source map */
+        let _ = proc_macro2::TokenStream::from_str(&s);
+        SPAN_LIMIT.store(new_limit, Ordering::Relaxed);
+    }
+}
 
 /// Make a new span at `pos`
 pub fn pos_to_span(pos: BytePos) -> Span {
-    Span::new(pos, pos, SyntaxContext::root())
+    SpanExt::new(pos.0, pos.0)
+}
+
+pub const DUMMY_SP: Span = unsafe {
+    std::mem::transmute(SpanRepr { compiler_or_fallback: 1, lo: 0, hi: 0, })
+};
+
+pub trait SpanExt: Sized {
+    fn is_dummy(&self) -> bool;
+
+    fn dummy() -> Self;
+
+    fn eq(&self, other: &Self) -> bool;
+
+    fn new(lo: u32, hi: u32) -> Self;
+
+    fn inner(&self) -> (u32, u32);
+
+    fn inner_mut(&mut self) -> (&mut u32, &mut u32);
+
+    #[inline(always)]
+    fn lo(&self) -> BytePos {
+        BytePos(self.inner().0)
+    }
+
+    #[inline(always)]
+    fn hi(&self) -> BytePos {
+        BytePos(self.inner().1)
+    }
+
+    #[inline(always)]
+    fn with_lo(&self, lo: BytePos) -> Self {
+        SpanExt::new(lo.0, self.hi().0)
+    }
+
+    #[inline(always)]
+    fn with_hi(&self, hi: BytePos) -> Self {
+        SpanExt::new(self.lo().0, hi.0)
+    }
+
+    #[inline(always)]
+    fn shrink_to_lo(&self) -> Self {
+        SpanExt::new(self.lo().0, self.lo().0)
+    }
+
+    #[inline(always)]
+    fn shrink_to_hi(&self) -> Self {
+        SpanExt::new(self.hi().0, self.hi().0)
+    }
+
+    #[inline(always)]
+    fn between(&self, end: Self) -> Self {
+        SpanExt::new(self.hi().0, end.lo().0)
+    }
+
+    fn substitute_dummy(self, other: Self) -> Self {
+        if self.is_dummy() { other } else { self }
+    }
+}
+
+#[repr(C)]
+struct SpanRepr {
+	compiler_or_fallback: u32,
+	lo: u32,
+	hi: u32,
+}
+
+/** safety: proc_macro2::Span is (unless compiled with `--cfg proc_macro2_semver_exempt`) the
+below enum:
+
+```rust
+enum Span {
+    Compiler(proc_macro::Span),
+    Fallback(fallback::Span),
+}
+```
+Unfortunately its ABI is not stable because rustc makes no such guarantees on `repr(Rust)` enums,
+but we need to get at its guts anyway. So the best we can do is a runtime assertion that a value
+looks like we expect. The only `Span` value we can synthesize is `Span::call_site()`, so we compare
+that against what its in-memory representation looked like at development time.
+
+gdb gives us this debug representation:
+```rust
+proc_macro2::Span {
+    inner: proc_macro2::imp::Span::Fallback(proc_macro2::fallback::Span {
+        lo: 0,
+        hi: 0
+    }),
+    _marker: core::marker::PhantomData<proc_macro2::marker::ProcMacroAutoTraits>
+}
+```
+...which looks like `[1u32, 0u32, 0u32]` in memory.
+
+We can't do anything useful or meaningful with the `Compiler` side, and if ABI changes enough that
+`[1u32, 0u32, 0u32]` actually represents an instance of the Compiler variant (and `Span::call_site()`
+chooses to return such an instance), we're in trouble.
+
+But hopefully if such circumstances do befall us, we'll at least know what went wrong.
+
+On the plus side, the `fallback::Span` payload is a POD pair of two u32s, so that case is trivial.
+*/
+fn validate_repr() {
+    let repr: SpanRepr = unsafe {
+        std::mem::transmute(Span::call_site())
+    };
+    assert!(repr.compiler_or_fallback == 1);
+    assert!(repr.lo == 0);
+    assert!(repr.hi == 0);
+}
+
+/** return a pair of mutable references to s.lo and s.hi */
+fn get_inner_mut(s: &mut Span) -> (&mut u32, &mut u32) {
+    validate_repr();
+    /* safety: safe if it is safe to transmute between `Span` and `SpanRepr`;
+    we call `validate_repr` to verify this. see doc comment on `validare_repr` */
+    let repr: &mut SpanRepr = unsafe {
+        std::mem::transmute(s)
+    };
+    (&mut repr.lo, &mut repr.hi)
+}
+
+/** return (s.lo, s.hi) */
+fn get_inner(s: &Span) -> (u32, u32) {
+    validate_repr();
+    /* safety: safe if it is safe to transmute between `Span` and `SpanRepr`;
+    we call `validate_repr` to verify this. see doc comment on `validare_repr` */
+    let repr: &SpanRepr = unsafe {
+        std::mem::transmute(s)
+    };
+    (repr.lo & 0xffffff, repr.hi & 0xffffff)
+}
+
+/** return a span with the given bounds */
+fn synthesize(lo: u32, hi: u32) -> Span {
+    /* we must raise the span limit by creating dummy sourcemap entries when
+    synthesizing a span; otherwise we hit assertions on some span methods */
+    raise_span_limit(hi);
+    validate_repr();
+    /* safety: safe if it is safe to transmute between `Span` and `SpanRepr`;
+    we call `validate_repr` to verify this. see doc comment on `validare_repr` */
+    let repr = SpanRepr {
+        compiler_or_fallback: 1,
+        lo: lo | 0x1000000,
+        hi: hi | 0x1000000,
+    };
+    unsafe {
+        std::mem::transmute(repr)
+    }
+}
+
+impl SpanExt for Span {
+    fn is_dummy(&self) -> bool {
+        self.eq(&Self::dummy())
+    }
+
+    fn dummy() -> Self {
+        //Span::call_site()
+        synthesize(0, 0)
+    }
+
+    fn eq(&self, other: &Self) -> bool {
+        get_inner(self) == get_inner(other)
+    }
+
+    fn new(lo: u32, hi: u32) -> Self {
+        synthesize(lo, hi)
+    }
+
+    fn inner(&self) -> (u32, u32) {
+        get_inner(self)
+    }
+
+    fn inner_mut(&mut self) -> (&mut u32, &mut u32) {
+        get_inner_mut(self)
+    }
+}
+
+#[derive(PartialEq, Eq, Debug, Clone)]
+pub struct MySpan {
+    pub lo: u32,
+    pub hi: u32,
+}
+
+
+impl SpanExt for MySpan {
+    fn is_dummy(&self) -> bool {
+        self.lo == 0 && self.hi == 0
+    }
+
+    fn dummy() -> Self {
+        MySpan {
+            lo: 0,
+            hi: 0,
+        }
+    }
+
+    fn eq(&self, other: &Self) -> bool {
+        self == other
+    }
+
+    fn new(lo: u32, hi: u32) -> Self {
+        MySpan { lo, hi, }
+    }
+
+    fn inner(&self) -> (u32, u32) {
+        (self.lo, self.hi)
+    }
+
+    fn inner_mut(&mut self) -> (&mut u32, &mut u32) {
+        (&mut self.lo, &mut self.hi)
+    }
 }
diff --git a/c2rust-transpile/src/rust_ast/set_span.rs b/c2rust-transpile/src/rust_ast/set_span.rs
new file mode 100644
index 0000000000..d26e9a316a
--- /dev/null
+++ b/c2rust-transpile/src/rust_ast/set_span.rs
@@ -0,0 +1,217 @@
+pub use c2rust_ast_printer::pprust::BytePos;
+use proc_macro2::Span;
+use syn::*;
+
+/// Set the span of an AST node.
+pub trait SetSpan {
+    fn set_span(&mut self, s: Span);
+}
+
+macro_rules! set_span_impl {
+    ( enum $spanned_ty:ident, $span_ident:ident via $( ( $variant_name:ident => $($where:tt)+ ) ) , + $(,)? ) => {
+        impl SetSpan for $spanned_ty {
+            fn set_span(&mut self, $span_ident: Span) {
+                use $spanned_ty::*;
+                match self {
+                    $(
+                        $variant_name(inner) => inner.$($where)+,
+                    )+
+                    #[allow(unreachable_patterns)]
+                    _ => panic!("could not set span on {} {:?}", stringify!($spanned_ty), self),
+                }
+            }
+        }
+    };
+    ( enum $spanned_ty:ident, punct $( $variant_name:ident ) , + ) => {
+        impl SetSpan for $spanned_ty {
+            fn set_span(&mut self, s: Span) {
+                use $spanned_ty::*;
+                match self {
+                    $(
+                        $variant_name(inner) => inner.spans[0] = s,
+                    )+
+                    #[allow(unreachable_patterns)]
+                    _ => panic!("could not set span on {} {:?}", stringify!($spanned_ty), self),
+                }
+            }
+        }
+    };
+    ( enum $spanned_ty:ident, $( $variant_name:ident ) , + ) => {
+        impl SetSpan for $spanned_ty {
+            fn set_span(&mut self, s: Span) {
+                use $spanned_ty::*;
+                match self {
+                    $(
+                        $variant_name(inner) => inner.set_span(s),
+                    )+
+                    #[allow(unreachable_patterns)]
+                    _ => panic!("could not set span on {} {:?}", stringify!($spanned_ty), self),
+                }
+            }
+        }
+    };
+    ( struct $spanned_ty:ident, punct $field:ident ) => {
+        impl SetSpan for $spanned_ty {
+            fn set_span(&mut self, s: Span) {
+                self.$field.spans[0] = s;
+            }
+        }
+    };
+    ( struct $spanned_ty:ident, kw $field:ident ) => {
+        impl SetSpan for $spanned_ty {
+            fn set_span(&mut self, s: Span) {
+                self.$field.span = s;
+            }
+        }
+    };
+    ( struct $spanned_ty:ident, field $field:ident ) => {
+        impl SetSpan for $spanned_ty {
+            fn set_span(&mut self, s: Span) {
+                self.$field.set_span(s)
+            }
+        }
+    };
+    ( struct $spanned_ty:ident, via $($where:tt) + ) => {
+        impl SetSpan for $spanned_ty {
+            fn set_span(&mut self, s: Span) {
+                self.$($where)+ = s
+            }
+        }
+    };
+}
+
+/* required impls:
+syn::Stmt
+syn::Expr
+syn::TraitItem
+syn::ImplItem
+syn::Block
+syn::Local
+syn::FieldValue
+syn::Item
+syn::ForeignItem
+*/
+
+impl SetSpan for Stmt {
+    fn set_span(&mut self, s: Span) {
+        match self {
+            Stmt::Expr(e) => e.set_span(s),
+            Stmt::Local(l) => l.set_span(s),
+            Stmt::Item(i) => i.set_span(s),
+            Stmt::Semi(e, _) => e.set_span(s),
+        }
+    }
+}
+
+set_span_impl!(enum Expr, s via
+    (Array => bracket_token.span = s),
+    (Assign => eq_token.spans[0] = s),
+    (AssignOp => op.set_span(s)),
+    (Await => await_token.span = s),
+    (Binary => op.set_span(s)),
+    (Block => block.set_span(s)),
+    (Box => box_token.span = s),
+    (Break => break_token.span = s),
+    (Call => paren_token.span = s),
+    (Cast => as_token.span = s),
+    (Closure => or1_token.spans[0] = s),
+    (Continue => continue_token.span = s),
+    (Field => dot_token.spans[0] = s),
+    (ForLoop => for_token.span = s),
+    (Group => group_token.span = s),
+    (If => if_token.span = s),
+    (Index => bracket_token.span = s),
+    (Let => let_token.span = s),
+    (Lit => lit.set_span(s)),
+    (Loop => loop_token.span = s),
+    (Macro => mac.bang_token.spans[0] = s),
+    (Match => match_token.span = s),
+    (MethodCall => dot_token.spans[0] = s),
+    (Paren => paren_token.span = s),
+    (Path => path.set_span(s)),
+    (Range => limits.set_span(s)),
+    (Reference => and_token.spans[0] = s),
+    (Repeat => bracket_token.span = s),
+    (Return => return_token.span = s),
+    (Struct => brace_token.span = s),
+    (Try => question_token.spans[0] = s),
+    (TryBlock => try_token.span = s),
+    (Tuple => paren_token.span = s),
+    (Type => colon_token.spans[0] = s),
+    (Unary => op.set_span(s)),
+    (Unsafe => unsafe_token.span = s),
+    (While => while_token.span = s),
+    (Yield => yield_token.span = s),
+);
+
+impl SetSpan for Path {
+    fn set_span(&mut self, s: Span) {
+        if let Some(mut tok) = self.leading_colon {
+            tok.spans[0] = s;
+        } else if let Some(tok) = self.segments.first_mut() {
+            tok.ident.set_span(s)
+        }
+    }
+}
+
+set_span_impl!(enum RangeLimits, s via
+    (HalfOpen => spans[0] = s),
+    (Closed => spans[0] = s),
+);
+
+set_span_impl!(struct Signature, kw fn_token);
+
+set_span_impl!(enum TraitItem, s via
+    (Const => const_token.span = s),
+    (Method => sig.set_span(s)),
+    (Type => type_token.span = s),
+    (Macro => mac.bang_token.spans[0] = s),
+);
+
+set_span_impl!(enum ImplItem, s via
+    (Const => const_token.span = s),
+    (Method => sig.set_span(s)),
+    (Type => type_token.span = s),
+    (Macro => mac.bang_token.spans[0] = s),
+);
+
+set_span_impl!(struct Block, kw brace_token);
+set_span_impl!(struct Local, kw let_token);
+
+set_span_impl!(enum Member, s via
+    (Named => set_span(s)),
+    (Unnamed => span = s),
+);
+
+set_span_impl!(struct FieldValue, field member);
+
+set_span_impl!(enum Item, s via
+    (Const => const_token.span = s),
+    (Enum => enum_token.span = s),
+    (ExternCrate => extern_token.span = s),
+    (Fn => sig.set_span(s)),
+    (ForeignMod => brace_token.span = s),
+    (Impl => impl_token.span = s),
+    (Macro => mac.bang_token.spans[0] = s),
+    (Macro2 => macro_token.span = s),
+    (Mod => mod_token.span = s),
+    (Static => static_token.span = s),
+    (Struct => struct_token.span = s),
+    (Trait => trait_token.span = s),
+    (TraitAlias => trait_token.span = s),
+    (Type => type_token.span = s),
+    (Union => union_token.span = s),
+    (Use => use_token.span = s),
+);
+
+set_span_impl!(enum ForeignItem, s via
+    (Fn => sig.set_span(s)),
+    (Static => static_token.span = s),
+    (Type => type_token.span = s),
+    (Macro => mac.bang_token.spans[0] = s),
+);
+
+//lit required for expr
+
+set_span_impl!(enum BinOp, punct Add, Sub, Mul, Div, Rem, And, Or, BitXor, BitAnd, BitOr, Shl, Shr, Eq, Lt, Le, Ne, Ge, Gt, AddEq, SubEq, MulEq, DivEq, RemEq, BitXorEq, BitAndEq, BitOrEq, ShlEq, ShrEq);
+set_span_impl!(enum UnOp, punct Deref, Not, Neg);
diff --git a/c2rust-transpile/src/rust_ast/traverse.rs b/c2rust-transpile/src/rust_ast/traverse.rs
index 37b1fb4ea5..5d7b0042c1 100644
--- a/c2rust-transpile/src/rust_ast/traverse.rs
+++ b/c2rust-transpile/src/rust_ast/traverse.rs
@@ -1,5 +1,4 @@
-use syntax::ast::*;
-use syntax::ptr;
+use syn::*;
 
 /// Traverse the AST in pre-order, which also happens to be the order of subtrees in the
 /// pretty-printed output.
@@ -32,15 +31,15 @@ pub trait Traversal: Sized {
         traverse_arm_def(self, a)
     }
 
-    fn traverse_field(&mut self, f: Field) -> Field {
+    fn traverse_field(&mut self, f: FieldValue) -> FieldValue {
         traverse_field_def(self, f)
     }
 
-    fn traverse_mod(&mut self, m: Mod) -> Mod {
+    fn traverse_mod(&mut self, m: ItemMod) -> ItemMod {
         traverse_mod_def(self, m)
     }
 
-    fn traverse_foreign_mod(&mut self, m: ForeignMod) -> ForeignMod {
+    fn traverse_foreign_mod(&mut self, m: ItemForeignMod) -> ItemForeignMod {
         traverse_foreign_mod_def(self, m)
     }
 
@@ -75,9 +74,9 @@ traversable_impl!(ImplItem, traverse_impl_item);
 traversable_impl!(Block, traverse_block);
 traversable_impl!(Local, traverse_local);
 traversable_impl!(Arm, traverse_arm);
-traversable_impl!(Field, traverse_field);
-traversable_impl!(Mod, traverse_mod);
-traversable_impl!(ForeignMod, traverse_foreign_mod);
+traversable_impl!(FieldValue, traverse_field);
+traversable_impl!(ItemMod, traverse_mod);
+traversable_impl!(ItemForeignMod, traverse_foreign_mod);
 traversable_impl!(Item, traverse_item);
 traversable_impl!(ForeignItem, traverse_foreign_item);
 
@@ -87,104 +86,119 @@ impl<A: Traversable> Traversable for Vec<A> {
     }
 }
 
+impl<A: Clone + Traversable, B> Traversable for syn::punctuated::Punctuated<A, B> {
+    fn traverse<T: Traversal>(mut self, t: &mut T) -> Self {
+        self.iter_mut().for_each(|x| *x = x.clone().traverse(t)); self
+    }
+}
+
 impl<A: Traversable> Traversable for Option<A> {
     fn traverse<T: Traversal>(self, t: &mut T) -> Self {
         self.map(|x| x.traverse(t))
     }
 }
 
-impl<A: Traversable + 'static> Traversable for ptr::P<A> {
+impl<A, B: Traversable> Traversable for Option<(A, B)> {
     fn traverse<T: Traversal>(self, t: &mut T) -> Self {
-        self.map(|x| x.traverse(t))
+        self.map(|x| (x.0, x.1.traverse(t)))
     }
 }
 
-pub fn traverse_stmt_def<W: Traversal>(walk: &mut W, mut s: Stmt) -> Stmt {
-    s.kind = match s.kind {
-        StmtKind::Local(p_local) => StmtKind::Local(p_local.traverse(walk)),
-        StmtKind::Item(p_item) => StmtKind::Item(p_item.traverse(walk)),
-        StmtKind::Expr(p_expr) => StmtKind::Expr(p_expr.traverse(walk)),
-        StmtKind::Semi(p_expr) => StmtKind::Semi(p_expr.traverse(walk)),
-        StmtKind::Mac(m) => StmtKind::Mac(m),
-    };
-    s
-}
-
-pub fn traverse_expr_def<W: Traversal>(walk: &mut W, mut e: Expr) -> Expr {
-    e.kind = match e.kind {
-        ExprKind::Box(p_expr) => ExprKind::Box(p_expr.map(|expr| walk.traverse_expr(expr))),
-        ExprKind::Array(elems) => ExprKind::Array(elems.traverse(walk)),
-        ExprKind::Call(func, args) => ExprKind::Call(func.traverse(walk), args.traverse(walk)),
-        ExprKind::MethodCall(meth, args) => ExprKind::MethodCall(meth, args.traverse(walk)),
-        ExprKind::Tup(elems) => ExprKind::Tup(elems.traverse(walk)),
-        ExprKind::Binary(op, lhs, rhs) => {
-            ExprKind::Binary(op, lhs.traverse(walk), rhs.traverse(walk))
+impl<A: Traversable + 'static> Traversable for Box<A> {
+    fn traverse<T: Traversal>(self, t: &mut T) -> Self {
+        Box::new((*self).traverse(t))
+    }
+}
+
+pub fn traverse_stmt_def<W: Traversal>(walk: &mut W, s: Stmt) -> Stmt {
+    match s {
+        Stmt::Local(p_local) => Stmt::Local(p_local.traverse(walk)),
+        Stmt::Item(p_item) => Stmt::Item(p_item.traverse(walk)),
+        Stmt::Expr(p_expr) => Stmt::Expr(p_expr.traverse(walk)),
+        Stmt::Semi(p_expr, semi) => Stmt::Semi(p_expr.traverse(walk), semi),
+    }
+}
+
+pub fn traverse_expr_def<W: Traversal>(walk: &mut W, e: Expr) -> Expr {
+    match e {
+        Expr::Box(e) => Expr::Box(ExprBox {expr: Box::new(walk.traverse_expr(*e.expr)), ..e}),
+        Expr::Array(e) => Expr::Array(ExprArray { elems: e.elems.traverse(walk), ..e }),
+        Expr::Call(e) => Expr::Call(ExprCall { func: e.func.traverse(walk), args: e.args.traverse(walk), ..e }),
+        Expr::MethodCall(e) => {
+            Expr::MethodCall(ExprMethodCall { receiver: e.receiver.traverse(walk), args: e.args.traverse(walk), ..e })
+        },
+        Expr::Tuple(e) => Expr::Tuple(ExprTuple { elems: e.elems.traverse(walk), ..e }),
+        Expr::Binary(e) => {
+            Expr::Binary(ExprBinary { left: e.left.traverse(walk), right: e.right.traverse(walk), ..e })
         }
-        ExprKind::Unary(op, arg) => ExprKind::Unary(op, arg.traverse(walk)),
-        ExprKind::Cast(arg, t) => ExprKind::Cast(arg.traverse(walk), t),
-        ExprKind::Type(arg, t) => ExprKind::Type(arg.traverse(walk), t),
-        ExprKind::Let(pat, e) => ExprKind::Let(pat, e.traverse(walk)),
-        ExprKind::If(cond, thn, els) => {
-            ExprKind::If(cond.traverse(walk), thn.traverse(walk), els.traverse(walk))
+        Expr::Unary(e) => Expr::Unary(ExprUnary { expr: e.expr.traverse(walk), ..e }),
+        Expr::Cast(e) => Expr::Cast(ExprCast { expr: e.expr.traverse(walk), ..e }),
+        Expr::Type(e) => Expr::Type(ExprType { expr: e.expr.traverse(walk), ..e }),
+        Expr::Let(e) => Expr::Let(ExprLet { expr: e.expr.traverse(walk), ..e }),
+        Expr::If(e) => {
+            Expr::If(ExprIf { cond: e.cond.traverse(walk), then_branch: e.then_branch.traverse(walk),
+                else_branch: e.else_branch.traverse(walk), ..e
+            })
         }
-        ExprKind::While(cond, block, lbl) => {
-            ExprKind::While(cond.traverse(walk), block.traverse(walk), lbl)
+        Expr::While(e) => {
+            Expr::While(ExprWhile { cond: e.cond.traverse(walk), body: e.body.traverse(walk), ..e })
         }
-        ExprKind::ForLoop(pat, cond, block, lbl) => {
-            ExprKind::ForLoop(pat, cond.traverse(walk), block.traverse(walk), lbl)
+        Expr::ForLoop(e) => {
+            Expr::ForLoop(ExprForLoop { expr: e.expr.traverse(walk), body: e.body.traverse(walk), ..e })
         }
-        ExprKind::Loop(block, lbl) => ExprKind::Loop(block.traverse(walk), lbl),
-        ExprKind::Match(cond, arm) => ExprKind::Match(cond.traverse(walk), arm.traverse(walk)),
-        ExprKind::Closure(cap, isasync, mov, fn_decl, expr, s) => {
-            ExprKind::Closure(cap, isasync, mov, fn_decl, expr.traverse(walk), s)
+        Expr::Loop(e) => Expr::Loop(ExprLoop { body: e.body.traverse(walk), ..e }),
+        Expr::Match(e) => Expr::Match(ExprMatch { expr: e.expr.traverse(walk), arms: e.arms.traverse(walk), ..e }),
+        Expr::Closure(e) => {
+            Expr::Closure(ExprClosure { body: e.body.traverse(walk), ..e })
         }
-        ExprKind::Block(block, lbl) => ExprKind::Block(block.traverse(walk), lbl),
-        ExprKind::Assign(lhs, rhs) => ExprKind::Assign(lhs.traverse(walk), rhs.traverse(walk)),
-        ExprKind::AssignOp(op, lhs, rhs) => {
-            ExprKind::AssignOp(op, lhs.traverse(walk), rhs.traverse(walk))
+        Expr::Block(e) => Expr::Block(ExprBlock { block: e.block.traverse(walk), ..e }),
+        Expr::Assign(e) => Expr::Assign(ExprAssign { left: e.left.traverse(walk), right: e.right.traverse(walk), ..e }),
+        Expr::AssignOp(e) => {
+            Expr::AssignOp(ExprAssignOp { left: e.left.traverse(walk), right: e.right.traverse(walk), ..e })
         }
-        ExprKind::Field(expr, f) => ExprKind::Field(expr.traverse(walk), f),
-        ExprKind::Index(lhs, rhs) => ExprKind::Index(lhs.traverse(walk), rhs.traverse(walk)),
-        ExprKind::Range(lhs, rhs, l) => ExprKind::Range(lhs.traverse(walk), rhs.traverse(walk), l),
-        ExprKind::Path(qself, p) => ExprKind::Path(qself, p),
-        ExprKind::AddrOf(borrow, m, expr) => ExprKind::AddrOf(borrow, m, expr.traverse(walk)),
-        ExprKind::Break(lbl, arg) => ExprKind::Break(lbl, arg.traverse(walk)),
-        ExprKind::Continue(lbl) => ExprKind::Continue(lbl),
-        ExprKind::Ret(expr) => ExprKind::Ret(expr.traverse(walk)),
-        ExprKind::InlineAsm(asm) => ExprKind::InlineAsm(asm),
-        ExprKind::Mac(mac) => ExprKind::Mac(mac),
-        ExprKind::Struct(p, flds, d) => ExprKind::Struct(p, flds.traverse(walk), d.traverse(walk)),
-        ExprKind::Repeat(expr, c) => ExprKind::Repeat(expr.traverse(walk), c),
-        ExprKind::Paren(arg) => ExprKind::Paren(arg.traverse(walk)),
-        ExprKind::Try(arg) => ExprKind::Try(arg.traverse(walk)),
-        ExprKind::Yield(arg) => ExprKind::Yield(arg.traverse(walk)),
-        ExprKind::Lit(l) => ExprKind::Lit(l),
-        ExprKind::Async(cap, nod, block) => ExprKind::Async(cap, nod, block.traverse(walk)),
-        ExprKind::TryBlock(blk) => ExprKind::TryBlock(blk.traverse(walk)),
-        ExprKind::Err => unimplemented!(),
-        ExprKind::Await(_) => unimplemented!(),
-    };
-    e
+        Expr::Field(e) => Expr::Field(ExprField { base: e.base.traverse(walk), ..e }),
+        Expr::Index(e) => Expr::Index(ExprIndex { expr: e.expr.traverse(walk), index: e.index.traverse(walk), ..e }),
+        Expr::Range(e) => Expr::Range(ExprRange { from: e.from.traverse(walk), to: e.to.traverse(walk), ..e }),
+        Expr::Path(e) => Expr::Path(ExprPath { ..e }),
+        Expr::Reference(e) => Expr::Reference(ExprReference { expr: e.expr.traverse(walk), ..e }),
+        Expr::Break(e) => Expr::Break(ExprBreak { expr: e.expr.traverse(walk), ..e }),
+        Expr::Continue(e) => Expr::Continue(ExprContinue { ..e }),
+        Expr::Return(e) => Expr::Return(ExprReturn { expr: e.expr.traverse(walk), ..e }),
+        //Expr::InlineAsm(e) => Expr::InlineAsm(ExprInlineAsm { asm, ..e }),
+        Expr::Macro(e) => Expr::Macro(ExprMacro { ..e }),
+        Expr::Struct(e) => Expr::Struct(ExprStruct { fields: e.fields.traverse(walk), rest: e.rest.traverse(walk), ..e }),
+        Expr::Repeat(e) => Expr::Repeat(ExprRepeat { expr: e.expr.traverse(walk), len: e.len.traverse(walk), ..e }),
+        Expr::Paren(e) => Expr::Paren(ExprParen { expr: e.expr.traverse(walk), ..e }),
+        Expr::Try(e) => Expr::Try(ExprTry { expr: e.expr.traverse(walk), ..e }),
+        Expr::Yield(e) => Expr::Yield(ExprYield { expr: e.expr.traverse(walk), ..e }),
+        Expr::Lit(e) => Expr::Lit(ExprLit { ..e }),
+        Expr::Async(e) => Expr::Async(ExprAsync { block: e.block.traverse(walk), ..e }),
+        Expr::TryBlock(e) => Expr::TryBlock(ExprTryBlock { block: e.block.traverse(walk), ..e }),
+        Expr::Unsafe(e) => Expr::Unsafe(ExprUnsafe { block: e.block.traverse(walk), ..e }),
+        Expr::Verbatim(_tokens) => unimplemented!(),
+        Expr::Await(e) => Expr::Await(ExprAwait { base: e.base.traverse(walk), ..e }),
+        _ => unimplemented!(),
+    }
 }
 
-pub fn traverse_trait_item_def<W: Traversal>(walk: &mut W, mut ti: TraitItem) -> TraitItem {
-    ti.kind = match ti.kind {
-        TraitItemKind::Const(ty, arg) => TraitItemKind::Const(ty, arg.traverse(walk)),
-        TraitItemKind::Method(sig, block) => TraitItemKind::Method(sig, block.traverse(walk)),
-        TraitItemKind::Type(bds, t) => TraitItemKind::Type(bds, t),
-        TraitItemKind::Macro(mac) => TraitItemKind::Macro(mac),
-    };
-    ti
+pub fn traverse_trait_item_def<W: Traversal>(walk: &mut W, ti: TraitItem) -> TraitItem {
+    match ti {
+        TraitItem::Const(ti) => TraitItem::Const(TraitItemConst {default: ti.default.traverse(walk), ..ti}),
+        TraitItem::Method(ti) => TraitItem::Method(TraitItemMethod {default: ti.default.traverse(walk), ..ti}),
+        TraitItem::Type(ti) => TraitItem::Type(TraitItemType {..ti}),
+        TraitItem::Macro(ti) => TraitItem::Macro(TraitItemMacro {..ti}),
+        _ => unimplemented!(),
+    }
 }
 
-pub fn traverse_impl_item_def<W: Traversal>(walk: &mut W, mut ii: ImplItem) -> ImplItem {
-    ii.kind = match ii.kind {
-        ImplItemKind::Const(ty, expr) => ImplItemKind::Const(ty, expr.traverse(walk)),
-        ImplItemKind::Method(sig, block) => ImplItemKind::Method(sig, block.traverse(walk)),
-        ImplItemKind::TyAlias(t) => ImplItemKind::TyAlias(t),
-        ImplItemKind::Macro(mac) => ImplItemKind::Macro(mac),
-    };
-    ii
+pub fn traverse_impl_item_def<W: Traversal>(walk: &mut W, ii: ImplItem) -> ImplItem {
+    match ii {
+        ImplItem::Const(ii) => ImplItem::Const(ImplItemConst {expr: ii.expr.traverse(walk), ..ii}),
+        ImplItem::Method(ii) => ImplItem::Method(ImplItemMethod {block: ii.block.traverse(walk), ..ii}),
+        ImplItem::Type(ii) => ImplItem::Type(ImplItemType {..ii}),
+        ImplItem::Macro(ii) => ImplItem::Macro(ImplItemMacro {..ii}),
+        _ => unimplemented!(),
+    }
 }
 
 pub fn traverse_block_def<W: Traversal>(walk: &mut W, mut b: Block) -> Block {
@@ -203,42 +217,40 @@ pub fn traverse_arm_def<W: Traversal>(walk: &mut W, mut a: Arm) -> Arm {
     a
 }
 
-pub fn traverse_field_def<W: Traversal>(walk: &mut W, mut f: Field) -> Field {
+pub fn traverse_field_def<W: Traversal>(walk: &mut W, mut f: FieldValue) -> FieldValue {
     f.expr = f.expr.traverse(walk);
     f
 }
 
-pub fn traverse_mod_def<W: Traversal>(walk: &mut W, mut m: Mod) -> Mod {
-    m.items = m.items.traverse(walk);
+pub fn traverse_mod_def<W: Traversal>(walk: &mut W, mut m: ItemMod) -> ItemMod {
+    m.content = m.content.traverse(walk);
     m
 }
 
-pub fn traverse_foreign_mod_def<W: Traversal>(walk: &mut W, mut m: ForeignMod) -> ForeignMod {
+pub fn traverse_foreign_mod_def<W: Traversal>(walk: &mut W, mut m: ItemForeignMod) -> ItemForeignMod {
     m.items = m.items.traverse(walk);
     m
 }
 
-pub fn traverse_item_def<W: Traversal>(walk: &mut W, mut i: Item) -> Item {
-    i.kind = match i.kind {
-        ItemKind::Static(ty, mu, p_expr) => ItemKind::Static(ty, mu, p_expr.traverse(walk)),
-        ItemKind::Const(ty, p_expr) => ItemKind::Const(ty, p_expr.traverse(walk)),
-        ItemKind::Fn(f, g, blk) => ItemKind::Fn(f, g, blk.traverse(walk)),
-        ItemKind::Mod(m) => ItemKind::Mod(m.traverse(walk)),
-        ItemKind::ForeignMod(fm) => ItemKind::ForeignMod(fm.traverse(walk)),
-        ItemKind::Trait(a, u, gen, bds, tis) => ItemKind::Trait(a, u, gen, bds, tis.traverse(walk)),
-        ItemKind::Impl(u, p, d, gen, tr, ty, iis) => {
-            ItemKind::Impl(u, p, d, gen, tr, ty, iis.traverse(walk))
-        }
-        ItemKind::Use(u) => ItemKind::Use(u),
-        ItemKind::ExternCrate(u) => ItemKind::ExternCrate(u),
-        ItemKind::GlobalAsm(u) => ItemKind::GlobalAsm(u),
-        ItemKind::TyAlias(l, r) => ItemKind::TyAlias(l, r),
-        ItemKind::Enum(l, r) => ItemKind::Enum(l, r),
-        ItemKind::Struct(l, r) => ItemKind::Struct(l, r),
-        ItemKind::Union(l, r) => ItemKind::Union(l, r),
-        ItemKind::TraitAlias(l, r) => ItemKind::TraitAlias(l, r),
-        ItemKind::Mac(m) => ItemKind::Mac(m),
-        ItemKind::MacroDef(m) => ItemKind::MacroDef(m),
-    };
-    i
+pub fn traverse_item_def<W: Traversal>(walk: &mut W, i: Item) -> Item {
+    match i {
+        Item::Static(item) => Item::Static(ItemStatic { expr: item.expr.traverse(walk), ..item}),
+        Item::Const(item) => Item::Const(ItemConst { expr: item.expr.traverse(walk), ..item}),
+        Item::Fn(item) => Item::Fn(ItemFn { block: item.block.traverse(walk), ..item}),
+        Item::Mod(item) => Item::Mod(ItemMod { content: item.content.traverse(walk), ..item}),
+        Item::ForeignMod(item) => Item::ForeignMod(ItemForeignMod { items: item.items.traverse(walk), ..item}),
+        Item::Trait(item) => Item::Trait(ItemTrait { items: item.items.traverse(walk), ..item}),
+        Item::Impl(item) => Item::Impl(ItemImpl { items: item.items.traverse(walk), ..item}),
+        Item::Use(item) => Item::Use(ItemUse { ..item}),
+        Item::ExternCrate(item) => Item::ExternCrate(ItemExternCrate { ..item}),
+        //Item::GlobalAsm(ItemGlobalAsm { u}) => Item::GlobalAsm(ItemGlobalAsm { u}),
+        Item::Type(item) => Item::Type(ItemType { ..item}),
+        Item::Enum(item) => Item::Enum(ItemEnum { ..item}),
+        Item::Struct(item) => Item::Struct(ItemStruct { ..item}),
+        Item::Union(item) => Item::Union(ItemUnion { ..item}),
+        Item::TraitAlias(item) => Item::TraitAlias(ItemTraitAlias { ..item}),
+        Item::Macro(item) => Item::Macro(ItemMacro { ..item}),
+        Item::Macro2(item) => Item::Macro2(ItemMacro2 { ..item}),
+        _ => unimplemented!()
+    }
 }
diff --git a/c2rust-transpile/src/translator/assembly.rs b/c2rust-transpile/src/translator/assembly.rs
index 8f9ee275b6..f5cd5f32ab 100644
--- a/c2rust-transpile/src/translator/assembly.rs
+++ b/c2rust-transpile/src/translator/assembly.rs
@@ -2,6 +2,334 @@
 //! This module provides basic support for converting inline assembly statements.
 
 use super::*;
+use proc_macro2::{TokenStream, TokenTree};
+use syn::__private::ToTokens;
+
+/// An argument direction specifier for a Rust asm! expression
+enum ArgDirSpec {
+    In,
+    Out,
+    InOut,
+    LateOut,
+    InLateOut,
+}
+
+impl ToString for ArgDirSpec {
+    fn to_string(&self) -> String {
+        use ArgDirSpec::*;
+        match self {
+            In => "in",
+            Out => "out",
+            InOut => "inout",
+            LateOut => "lateout",
+            InLateOut => "inlateout",
+        }.to_owned()
+    }
+}
+
+impl ArgDirSpec {
+    fn with_in(&self) -> Self {
+        use ArgDirSpec::*;
+        match self {
+            In => In,
+            Out => InOut,
+            InOut => InOut,
+            LateOut => InLateOut,
+            InLateOut => InLateOut,
+        }
+    }
+}
+
+fn parse_constraints(mut constraints: &str) ->
+    Result<(ArgDirSpec, bool, String), TranslationError> {
+    let parse_error = |constraints| {
+        Err(TranslationError::new(None, failure::err_msg(
+            "Inline assembly constraints could not be parsed: ".to_owned() + constraints,
+        ).context(TranslationErrorKind::Generic)))
+    };
+    use ArgDirSpec::*;
+    let mut is_input = match constraints.chars().next() {
+        Some('+') => {
+            constraints = &constraints[1..];
+            true
+        },
+        Some('=') => {
+            constraints = &constraints[1..];
+            false
+        },
+        _ => true,
+    };
+
+    let early_clobber = if constraints.starts_with('&') {
+        constraints = &constraints[1..];
+        true
+    } else {
+        false
+    };
+
+    let mut mem_only = if constraints.starts_with('*') {
+        constraints = &constraints[1..];
+        true
+    } else {
+        false
+    };
+
+    let mut split = constraints.splitn(2, ',');
+    constraints = match split.next() {
+        Some(c) => c,
+        // Parse error
+        _ => return parse_error(constraints),
+    };
+    // If a comma is present, this is an output of form =[&]foo,N
+    if split.next().is_some() {
+        if !is_input {
+            is_input = true;
+        } else {
+            // '+' followed by ',' is a parse error
+            return parse_error(constraints);
+        }
+    }
+
+    // Handle register names
+    let mut constraints = constraints.replace('{', "\"").replace('}', "\"");
+
+    match &*constraints {
+        "m" => {
+            mem_only = true;
+            constraints = "reg".into();
+        },
+        "r" => {
+            constraints = "reg".into();
+        }
+        _ => {},
+    };
+
+    let mode = if mem_only {
+        In
+    } else {
+        if is_input {
+            if early_clobber {InOut} else {InLateOut}
+        } else {
+            if early_clobber {Out} else {LateOut}
+        }
+    };
+
+    Ok((mode, mem_only, constraints))
+}
+
+/// Translate a template modifier from llvm/gcc asm template argument modifiers
+/// to those accepted by the Rust asm! macro. This is arch-dependent, so we need
+/// to know which architecture the asm targets.
+/// See https://doc.rust-lang.org/nightly/reference/inline-assembly.html#template-modifiers
+fn translate_modifier(modifier: char, arch: &str) -> Option<char> {
+    Some(match arch {
+        "x86" => match modifier {
+            'k' => 'e',
+            'q' => 'r',
+            'b' => 'l',
+            'h' => 'h',
+            'w' => 'x',
+            _ => return None,
+        },
+        "aarch64" => modifier,
+        "arm" => match modifier {
+            'p'|'q' => return None,
+            _ => modifier,
+        },
+        "riscv" => modifier,
+        _ => return None,
+    })
+}
+
+/// Rust-native asm! operands, which may be inputs, outputs, or both.
+struct BidirAsmOperand {
+    dir_spec: ArgDirSpec,
+    mem_only: bool,
+    constraints: String,
+    name: Option<String>,
+    // At least one of these is non-None
+    in_expr: Option<(usize, CExprId)>,
+    out_expr: Option<(usize, CExprId)>,
+}
+
+impl BidirAsmOperand {
+    /// Return whether an operand is positional (as opposed to named or using an explicit register)
+    fn is_positional(&self) -> bool {
+        !self.constraints.contains('"') && self.name.is_none()
+    }
+}
+
+/// Return the register and corresponding template modifiers if the constraint
+/// uses a reserved register. Assumes x86_64.
+fn reg_is_reserved(constraint: &str) -> Option<(&str, &str)> {
+    Some(match constraint {
+        "\"bl\"" | "\"bh\"" | "\"bx\"" | "\"ebx\"" | "\"rbx\"" => {
+            let reg = constraint.trim_matches('"');
+            let mods = if reg.len() == 2 {
+                &reg[1..] // l/h/x
+            } else {
+                &reg[..1] // e/r
+            };
+            (reg, mods)
+        },
+        _ => return None,
+    })
+}
+
+/// Emit mov instructions and modify inline assembly operands to copy in and/or
+/// out when an operand uses a reserved register. Instead of constraining the
+/// operand to the reserved register, constrain it to any register and then copy
+/// between the reserved register and the (suitably modified, e.g. `{0:x}`)
+/// operand.
+/// This also requires reordering the operands because we convert them to
+/// named operands, which must precede explicit register operands.
+///
+/// Modifies operands and returns a pair of prefix and suffix strings that
+/// should be appended to the assembly template.
+fn rewrite_reserved_reg_operands(att_syntax: bool, operands: &mut Vec<BidirAsmOperand>) -> (String, String) {
+    let (mut prolog, mut epilog) = (String::new(), String::new());
+
+    let mut rewrite_idxs = vec![];
+    let mut total_positional = 0;
+
+    // Determine which operands must be rewritten and how many
+    // positional operands there are. Positional operands must precede named
+    // operands, so this tells us where to reinsert operands we rewrite.
+    for (i, operand) in operands.iter().enumerate() {
+        if operand.is_positional() {
+            total_positional += 1;
+        } else if let Some((reg, mods)) = reg_is_reserved(&*operand.constraints) {
+            rewrite_idxs.push((i, reg.to_owned(), mods.to_owned()));
+        }
+    }
+
+    let mut n_moved = 0;
+    for (idx, reg, mods) in rewrite_idxs {
+        let operand = &mut operands[idx];
+        let name = format!("restmp{}", n_moved);
+        if let Some((_idx, in_expr)) = operand.in_expr {
+            let move_input = if att_syntax {
+                format!("mov %{}, {{{}:{}}}\n", reg, name, mods)
+            } else {
+                format!("mov {{{}:{}}}\n, {}", name, mods, reg)
+            };
+            prolog.push_str(&move_input);
+        }
+        if let Some((_idx, out_expr)) = operand.out_expr {
+            let move_output = if att_syntax {
+                format!("\nmov {{{}:{}}}, %{}", name, mods, reg)
+            } else {
+                format!("\nmov {}, {{{}:{}}}", reg, name, mods)
+            };
+            epilog.push_str(&move_output);
+        }
+        operand.constraints = "reg".into();
+        operand.name = Some(name);
+
+        // Move operand to after all positional arguments. This does not
+        // interfere with moving subsequent operands that use reserved registers
+        // because explicit register operands must all come after positional
+        // and named operands.
+        //let (positional, named, explicit) = split_operands(operands);
+        let nth_non_positional = total_positional + n_moved;
+        operands.swap(idx, nth_non_positional);
+        n_moved += 1;
+    }
+
+    (prolog, epilog)
+}
+
+fn asm_is_att_syntax(asm: &str) -> bool {
+    // For GCC, AT&T syntax is default... unless -masm=intel is passed. This
+    // means we can hope but not guarantee that x86 asm with no syntax directive
+    // uses AT&T syntax.
+    // To handle other cases, try to heuristically detect the variant we get
+    // (assuming it's actually x86 asm in the first place...).
+    // As the rust x86 default is intel syntax, we need to emit the "att_syntax"
+    // option if we get a hint that this asm uses AT&T syntax.
+
+    let intel_directive = asm.find(".intel_syntax");
+    let att_directive = asm.find(".att_syntax");
+    if let (Some(intel_pos), Some(att_pos)) = (intel_directive, att_directive) {
+        // Both directives are present; presumably this asm switches to one at
+        // its start and restores the default at the end. Whichever comes first
+        // should be what the asm uses.
+        att_pos < intel_pos
+    } else if intel_directive.is_some() {
+        false
+    } else if att_directive.is_some() {
+        true
+    } else if asm.contains("word ptr") {
+        false
+    } else {
+        asm.contains('$')
+    }
+}
+
+/// References of the form $0 need to be converted to {0}, and references
+/// that are mem-only need to be converted to [{0}].
+fn rewrite_asm<F: Fn(&str) -> bool>(asm: &str, is_mem_only: F) -> String {
+    let mut out = String::with_capacity(asm.len());
+
+    let mut first = true;
+    let mut last_empty = false;
+
+    // Iterate over $-prefixed chunks
+    for chunk in asm.split('$') {
+        // No modification needed for first chunk
+        if first {
+            first = false;
+            out.push_str(chunk);
+            continue
+        }
+
+        // Pass-through $$ as one $
+        if last_empty {
+            last_empty = false;
+            out.push_str("$");
+            out.push_str(chunk);
+            continue;
+        }
+
+        // Do not re-wrap ${...}, but do translate modifiers
+        if chunk.starts_with('{') {
+            // Translate operand modifiers ("template modifiers" per Rust)
+            if let Some(end_idx) = chunk.find('}') {
+                let ref_str = &chunk[..end_idx];
+                if let Some(colon_idx) = ref_str.find(':') {
+                    let (before_mods, modifiers) = ref_str.split_at(colon_idx + 1);
+                    out.push_str(before_mods);
+
+                    let modifiers = ref_str[colon_idx + 1..].chars();
+                    for modifier in modifiers {
+                        if let Some(new) = translate_modifier(modifier, "x86") {
+                            out.push(new);
+                        }
+                    }
+                    out.push_str(&chunk[end_idx..]);
+                }
+            } else {
+                out.push_str(chunk);
+            }
+            continue
+        }
+
+        if chunk == "" {
+            last_empty = true;
+            continue;
+        }
+
+        let ref_str = chunk.trim_matches(|c: char| !c.is_ascii_alphanumeric());
+        let mem_only = is_mem_only(ref_str);
+        // Push the reference wrapped in {}, or in [{}] if mem-only
+        out.push_str(if mem_only { "[{" } else {"{"});
+        out.push_str(ref_str);
+        out.push_str(if mem_only { "}]" } else {"}"});
+        // Push the rest of the chunk
+        out.push_str(&chunk[ref_str.len()..]);
+    }
+    out
+}
 
 impl<'c> Translation<'c> {
     /// Convert an inline-assembly statement into one or more Rust statements.
@@ -23,23 +351,19 @@ impl<'c> Translation<'c> {
     ) -> Result<Vec<Stmt>, TranslationError> {
         if !self.tcfg.translate_asm {
             return Err(TranslationError::generic(
-                "Inline assembly tranlationg not enabled.",
+                "Inline assembly translation not enabled.",
             ));
         }
 
         self.use_feature("asm");
 
-        fn push_expr(tokens: &mut Vec<TokenTree>, expr: P<Expr>) {
-            tokens.push(TokenTree::token(token::Interpolated(Rc::new(Nonterminal::NtExpr(expr))), DUMMY_SP));
+        fn push_expr(tokens: &mut Vec<TokenTree>, expr: Box<Expr>) {
+            tokens.extend(expr.to_token_stream());
         }
 
         let mut stmts: Vec<Stmt> = vec![];
         let mut post_stmts: Vec<Stmt> = vec![];
         let mut tokens: Vec<TokenTree> = vec![];
-        let mut first;
-
-        // Assembly template
-        push_expr(&mut tokens, mk().lit_expr(asm));
 
         let mut tied_operands = HashMap::new();
         for (input_idx, &AsmOperand {
@@ -56,40 +380,118 @@ impl<'c> Translation<'c> {
             }
         }
 
+        fn operand_is_mem_only(operand: &AsmOperand) -> bool {
+            if let Ok((_dir_spec, mem_only, _parsed)) = parse_constraints(&operand.constraints) {
+                mem_only
+            } else {
+                println!("could not parse asm constraints: {}", operand.constraints);
+                false
+            }
+        }
+
+        // Rewrite arg references in assembly template
+        let rewritten_asm = rewrite_asm(asm, |ref_str: &str| {
+            if let Ok(idx) = ref_str.parse::<usize>() {
+                inputs.iter()
+                    .chain(outputs.iter())
+                    .nth(idx)
+                    .map(operand_is_mem_only)
+                    .unwrap_or(false)
+            } else {
+                false
+            }
+        });
+
+        // Detect and pair inputs/outputs that constrain themselves to the same register
+        let mut inputs_by_register = HashMap::new();
+        for (i, input) in inputs.iter().enumerate() {
+            let (_dir_spec, mem_only, parsed) = parse_constraints(&input.constraints)?;
+            inputs_by_register.insert(parsed, (i, input.clone()));
+        }
+
+        // Convert gcc asm arguments (input and output lists) into a single list
+        // of operands with explicit arg dir specs (asm!-style)
+
+        // The unified arg list
+        let mut args = Vec::<BidirAsmOperand>::new();
+
+        // Add outputs as inout if a matching input is found, else as outputs
+        for (i, output) in outputs.into_iter().enumerate() {
+            match parse_constraints(&output.constraints) {
+                Ok((mut dir_spec, mem_only, parsed)) => {
+                    // Add to args list; if a matching in_expr is found, this is
+                    // an inout and we remove the output from the outputs list
+                    let mut in_expr = inputs_by_register.remove(&parsed);
+                    if in_expr.is_none() {
+                        // Also check for by-index references to this output
+                        in_expr = inputs_by_register.remove(&i.to_string());
+                    }
+                    // Extract expression
+                    let in_expr = in_expr.map(|(i, operand)| (i, operand.expression));
+
+                    // For inouts, change the dirspec to include 'in'
+                    if in_expr.is_some() {
+                        dir_spec = dir_spec.with_in();
+                    }
+                    args.push(BidirAsmOperand {
+                        dir_spec,
+                        mem_only,
+                        name: None,
+                        constraints: parsed,
+                        in_expr,
+                        out_expr: Some((i, output.expression))
+                    });
+                },
+                // Constraint could not be parsed, drop it
+                Err(e) => eprintln!("{}", e),
+            }
+        }
+        // Add unmatched inputs
+        for (_, (i, input)) in inputs_by_register {
+            let (dir_spec, mem_only, parsed) = match parse_constraints(&input.constraints) {
+                Ok(x) => x,
+                Err(e) => {eprintln!("{}", e); continue;}
+            };
+            args.push(BidirAsmOperand {
+                dir_spec,
+                mem_only,
+                name: None,
+                constraints: parsed,
+                in_expr: Some((i, input.expression)),
+                out_expr: None,
+            });
+        }
+
+        // Determine whether the assembly is in AT&T syntax
+        let att_syntax = asm_is_att_syntax(&*rewritten_asm);
+
+        // Add workaround for reserved registers (e.g. rbx on x86_64)
+        let (prolog, epilog) = rewrite_reserved_reg_operands(att_syntax, &mut args);
+        let rewritten_asm = prolog + &rewritten_asm + &epilog;
+
+        // Emit assembly template
+        push_expr(&mut tokens, mk().lit_expr(rewritten_asm));
+
         // Outputs and Inputs
         let mut operand_renames = HashMap::new();
-        for &(list, is_output) in &[(outputs, true), (inputs, false)] {
-            first = true;
-            tokens.push(TokenTree::token(token::Colon, DUMMY_SP)); // Always emitted, even if list is empty
-
-            for (operand_idx, &AsmOperand {
-                ref constraints,
-                expression,
-            }) in list.iter().enumerate()
-            {
-                if first {
-                    first = false
-                } else {
-                    tokens.push(TokenTree::token(token::Comma, DUMMY_SP))
-                }
+        for operand in args {
+            tokens.push(TokenTree::Punct(Punct::new(',', Alone)));
 
-                let mut result = self.convert_expr(ctx.used(), expression)?;
-                stmts.append(result.stmts_mut());
+            // First, convert output expr if present
+            let out_expr = if let Some((output_idx, out_expr)) = operand.out_expr {
+                let mut out_expr = self.convert_expr(ctx.used(), out_expr)?;
+                stmts.append(out_expr.stmts_mut());
+                let mut out_expr = out_expr.into_value();
 
-                let mut result = result.into_value();
-                if constraints.contains('*') {
+                if operand.mem_only {
                     // If the constraint string contains `*`, then
                     // c2rust-ast-exporter added it (there's no gcc equivalent);
                     // in this case, we need to do what clang does and pass in
                     // the operand by-address instead of by-value
-                    if is_output {
-                        result = mk().mutbl().addr_of_expr(result);
-                    } else {
-                        result = mk().addr_of_expr(result);
-                    }
+                    out_expr = mk().mutbl().addr_of_expr(out_expr);
                 }
 
-                if let Some(tied_operand) = tied_operands.get(&(operand_idx, is_output)) {
+                if let Some(tied_operand) = tied_operands.get(&(output_idx, true)) {
                     // If we have an input operand tied to an output operand,
                     // we need to replicate clang's behavior: the inline assembly
                     // uses the larger type internally, and the smaller value gets
@@ -97,96 +499,194 @@ impl<'c> Translation<'c> {
                     // back after (if needed). For portability, we moved the
                     // type conversions into the `c2rust-asm-casts` crate,
                     // so we call into that one from here.
-                    if is_output {
-                        // Convert `x` into `let freshN = &mut x; *x`
-                        let output_name = self.renamer.borrow_mut().fresh();
-                        let output_local = mk().local(
-                            mk().ident_pat(&output_name),
-                            None as Option<P<Ty>>,
-                            Some(mk().mutbl().addr_of_expr(result)),
-                        );
-                        stmts.push(mk().local_stmt(P(output_local)));
-
-                        // `let mut freshN;`
-                        let inner_name = self.renamer.borrow_mut().fresh();
-                        let inner_local = mk().local(
-                            mk().ident_pat(&inner_name),
-                            None as Option<P<Ty>>,
-                            None as Option<P<Expr>>,
-                        );
-                        stmts.push(mk().local_stmt(P(inner_local)));
-
-                        result = mk().ident_expr(&inner_name);
-                        operand_renames.insert(operand_idx, (output_name, inner_name));
-                    } else {
-                        self.use_crate(ExternCrate::C2RustAsmCasts);
-
-                        // Import the trait into scope
-                        self.with_cur_file_item_store(|item_store| {
-                            item_store.add_use(vec!["c2rust_asm_casts".into()], "AsmCastTrait");
-                        });
-
-                        let (output_name, inner_name) = operand_renames
-                            .get(&tied_operand)
-                            .unwrap();
-
-                        let input_name = self.renamer.borrow_mut().fresh();
-                        let input_local = mk().local(
-                            mk().ident_pat(&input_name),
-                            None as Option<P<Ty>>,
-                            Some(result),
-                        );
-                        stmts.push(mk().local_stmt(P(input_local)));
-
-                        // Replace `result` with
-                        // `c2rust_asm_casts::AsmCast::cast_in(output, input)`
-                        let path_expr = mk().path_expr(
-                            vec!["c2rust_asm_casts", "AsmCast", "cast_in"]
-                        );
-                        let output = mk().ident_expr(output_name);
-                        let input = mk().ident_expr(input_name);
-                        result = mk().call_expr(path_expr, vec![output.clone(), input.clone()]);
-
-                        // Append the cast-out call after the assembly macro:
-                        // `c2rust_asm_casts::AsmCast::cast_out(output, input, inner);`
-                        let path_expr = mk().path_expr(
-                            vec!["c2rust_asm_casts", "AsmCast", "cast_out"]);
-                        let inner = mk().ident_expr(inner_name);
-                        let cast_out = mk().call_expr(path_expr, vec![output, input, inner]);
-                        post_stmts.push(mk().semi_stmt(cast_out));
-                    }
+
+                    // Convert `x` into `let freshN = &mut x; *x`
+                    let output_name = self.renamer.borrow_mut().fresh();
+                    let output_local = mk().local(
+                        mk().ident_pat(&output_name),
+                        None as Option<Box<Type>>,
+                        Some(mk().mutbl().addr_of_expr(out_expr)),
+                    );
+                    stmts.push(mk().local_stmt(Box::new(output_local)));
+
+                    // `let mut freshN;`
+                    let inner_name = self.renamer.borrow_mut().fresh();
+                    let inner_local = mk().local(
+                        mk().ident_pat(&inner_name),
+                        None as Option<Box<Type>>,
+                        None as Option<Box<Expr>>,
+                    );
+                    stmts.push(mk().local_stmt(Box::new(inner_local)));
+
+                    out_expr = mk().ident_expr(&inner_name);
+                    operand_renames.insert(output_idx, (output_name, inner_name));
                 }
+                Some(out_expr)
+            } else {
+                None
+            };
 
-                push_expr(&mut tokens, mk().lit_expr(constraints));
-                push_expr(&mut tokens, mk().paren_expr(result));
+            // Then, handle input expr if present
+            let in_expr = if let Some((input_idx, in_expr)) = operand.in_expr {
+                let mut in_expr = self.convert_expr(ctx.used(), in_expr)?;
+                stmts.append(in_expr.stmts_mut());
+                let mut in_expr = in_expr.into_value();
+
+                if operand.mem_only {
+                    in_expr = mk().addr_of_expr(in_expr);
+                }
+                if let Some(tied_operand) = tied_operands.get(&(input_idx, false)) {
+                    self.use_crate(ExternCrate::C2RustAsmCasts);
+
+                    // Import the trait into scope
+                    self.with_cur_file_item_store(|item_store| {
+                        item_store.add_use(vec!["c2rust_asm_casts".into()], "AsmCastTrait");
+                    });
+
+                    let (output_name, inner_name) = operand_renames
+                        .get(&tied_operand)
+                        .unwrap();
+
+                    let input_name = self.renamer.borrow_mut().fresh();
+                    let input_local = mk().local(
+                        mk().ident_pat(&input_name),
+                        None as Option<Box<Type>>,
+                        Some(in_expr),
+                    );
+                    stmts.push(mk().local_stmt(Box::new(input_local)));
+
+                    // Replace `in_expr` with
+                    // `c2rust_asm_casts::AsmCast::cast_in(output, input)`
+                    let path_expr = mk().path_expr(
+                        vec!["c2rust_asm_casts", "AsmCast", "cast_in"]
+                    );
+                    let output = mk().ident_expr(output_name);
+                    let input = mk().ident_expr(input_name);
+                    in_expr = mk().call_expr(path_expr, vec![output.clone(), input.clone()]);
+
+                    // Append the cast-out call after the assembly macro:
+                    // `c2rust_asm_casts::AsmCast::cast_out(output, input, inner);`
+                    let path_expr = mk().path_expr(
+                        vec!["c2rust_asm_casts", "AsmCast", "cast_out"]);
+                    let inner = mk().ident_expr(inner_name);
+                    let cast_out = mk().call_expr(path_expr, vec![output, input, inner]);
+                    post_stmts.push(mk().semi_stmt(cast_out));
+                }
+                Some(in_expr)
+            } else {
+                None
+            };
+
+            // Emit "name =" if a name is given
+            if let Some(name) = operand.name {
+                push_expr(&mut tokens, mk().ident_expr(name));
+                tokens.push(TokenTree::Punct(Punct::new('=', Alone)));
+            }
+
+            // Emit dir_spec(constraint), quoting constraint if needed
+            push_expr(&mut tokens, mk().ident_expr(operand.dir_spec.to_string()));
+            let is_regname_or_int = operand.constraints.contains('"') ||
+                operand.constraints.starts_with(|c: char| c.is_ascii_digit());
+            let constraints_ident = if is_regname_or_int {
+                mk().lit_expr(operand.constraints.trim_matches('"'))
+            } else {
+                mk().ident_expr(operand.constraints)
+            };
+
+            // Emit input and/or output expressions, separated by "=>" if both
+            push_expr(&mut tokens, mk().paren_expr(constraints_ident));
+            if let Some(in_expr) = in_expr {
+                push_expr(&mut tokens, in_expr);
+                if out_expr.is_some() {
+                    tokens.push(TokenTree::Punct(Punct::new('=', Joint)));
+                    tokens.push(TokenTree::Punct(Punct::new('>', Alone)));
+                } else {
+                    // If inout but no out expr was given, mark clobbered ('_')
+                    if let ArgDirSpec::InOut | ArgDirSpec::InLateOut = operand.dir_spec {
+                        tokens.push(TokenTree::Punct(Punct::new('=', Joint)));
+                        tokens.push(TokenTree::Punct(Punct::new('>', Alone)));
+
+                        tokens.push(TokenTree::Punct(Punct::new('_', Alone)));
+                    }
+                }
+            }
+            if let Some(out_expr) = out_expr {
+                push_expr(&mut tokens, out_expr);
             }
         }
 
+        let mut preserves_flags = true;
+        let mut read_only = true;
+
         // Clobbers
-        first = true;
-        tokens.push(TokenTree::token(token::Colon, DUMMY_SP));
         for clobber in clobbers {
-            if first {
-                first = false
-            } else {
-                tokens.push(TokenTree::token(token::Comma, DUMMY_SP))
+            // Process and drop non-register clobbers
+            if clobber == "cc" {
+                preserves_flags = false;
+                continue
+            };
+            if clobber == "memory" {
+                read_only = false;
+                continue;
+            };
+
+            // We must drop clobbers of reserved registers, even though this
+            // really means we're misinforming the compiler of what's been
+            // overwritten. Warn verbosely.
+            let quoted = format!("\"{}\"", clobber);
+            if reg_is_reserved(&quoted).is_some() {
+                warn!("Attempting to clobber reserved register ({}), dropping clobber! \
+                This likely means the potential for miscompilation has been introduced. \
+                Please rewrite this assembly to save/restore the value of this register \
+                if at all possible.", clobber);
+                continue;
             }
-            push_expr(&mut tokens, mk().lit_expr(clobber));
+
+            tokens.push(TokenTree::Punct(Punct::new(',', Alone)));
+            let result = mk().call_expr(mk().ident_expr("out"), vec![mk().lit_expr(clobber)]);
+            push_expr(&mut tokens, result);
+            tokens.push(TokenTree::Punct(Punct::new(' ', Alone)));
+            push_expr(&mut tokens, mk().ident_expr("_"));
         }
 
         // Options
-        if is_volatile {
-            tokens.push(TokenTree::token(token::Colon, DUMMY_SP));
-            push_expr(&mut tokens, mk().lit_expr("volatile"));
+        {
+            let mut options = vec![];
+            if preserves_flags {
+                options.push(mk().ident_expr("preserves_flags"));
+            }
+            if !is_volatile {
+                // Pure cannot be applied if we have no outputs
+                if read_only && (outputs.len() + clobbers.len()) > 0 {
+                    options.push(mk().ident_expr("pure"));
+                    options.push(mk().ident_expr("readonly"));
+                }
+                // We never emit [pure, nomem] right now, but it would be nice
+            }
+
+            if att_syntax {
+                options.push(mk().ident_expr("att_syntax"));
+            }
+
+            if !options.is_empty() {
+                tokens.push(TokenTree::Punct(Punct::new(',', Alone)));
+                let result = mk().call_expr(mk().ident_expr("options"), options);
+                push_expr(&mut tokens, result);
+            }
         }
 
+        self.with_cur_file_item_store(|item_store| {
+            let std_or_core = if self.tcfg.emit_no_std { "core" } else { "std" }.to_string();
+            item_store.add_use(vec![std_or_core, "arch".into()], "asm");
+        });
+
         let mac = mk().mac(
             vec!["asm"],
             tokens.into_iter().collect::<TokenStream>(),
-            MacDelimiter::Parenthesis,
+            MacroDelimiter::Paren(Default::default()),
         );
         let mac = mk().mac_expr(mac);
-        let mac = mk().span(span).expr_stmt(mac);
+        let mac = mk().span(span).semi_stmt(mac);
         stmts.push(mac);
 
         // Push the post-macro statements
diff --git a/c2rust-transpile/src/translator/atomics.rs b/c2rust-transpile/src/translator/atomics.rs
index a49f01a13f..ccffd3387a 100644
--- a/c2rust-transpile/src/translator/atomics.rs
+++ b/c2rust-transpile/src/translator/atomics.rs
@@ -39,7 +39,7 @@ impl<'c> Translation<'c> {
         order_fail_id: Option<CExprId>,
         val2_id: Option<CExprId>,
         weak_id: Option<CExprId>,
-    ) -> Result<WithStmts<P<Expr>>, TranslationError> {
+    ) -> Result<WithStmts<Box<Expr>>, TranslationError> {
         let std_or_core = if self.tcfg.emit_no_std { "core" } else { "std" };
         let ptr = self.convert_expr(ctx.used(), ptr_id)?;
         let order = self.convert_memordering(order_id);
@@ -67,13 +67,13 @@ impl<'c> Translation<'c> {
                     self.use_feature("core_intrinsics");
 
                     let atomic_load =
-                        mk().path_expr(vec!["", std_or_core, "intrinsics", intrinsic_name]);
+                        mk().abs_path_expr(vec![std_or_core, "intrinsics", intrinsic_name]);
                     let call = mk().call_expr(atomic_load, vec![ptr]);
                     if name == "__atomic_load" {
                         let ret = val1.expect("__atomic_load should have a ret argument");
                         ret.and_then(|ret| {
                             let assignment = mk().assign_expr(
-                                mk().unary_expr(ast::UnOp::Deref, ret),
+                                mk().unary_expr(UnOp::Deref(Default::default()), ret),
                                 call,
                             );
                             self.convert_side_effects_expr(
@@ -112,9 +112,9 @@ impl<'c> Translation<'c> {
                         self.use_feature("core_intrinsics");
 
                         let atomic_store =
-                            mk().path_expr(vec!["", std_or_core, "intrinsics", intrinsic_name]);
+                            mk().abs_path_expr(vec![std_or_core, "intrinsics", intrinsic_name]);
                         let val = if name == "__atomic_store" {
-                            mk().unary_expr(ast::UnOp::Deref, val)
+                            mk().unary_expr(UnOp::Deref(Default::default()), val)
                         } else {
                             val
                         };
@@ -148,9 +148,9 @@ impl<'c> Translation<'c> {
                         self.use_feature("core_intrinsics");
 
                         let fn_path =
-                            mk().path_expr(vec!["", std_or_core, "intrinsics", intrinsic_name]);
+                            mk().abs_path_expr(vec![std_or_core, "intrinsics", intrinsic_name]);
                         let val = if name == "__atomic_exchange" {
-                            mk().unary_expr(ast::UnOp::Deref, val)
+                            mk().unary_expr(UnOp::Deref(Default::default()), val)
                         } else {
                             val
                         };
@@ -163,7 +163,7 @@ impl<'c> Translation<'c> {
                                 .expect("__atomic_exchange must have a ret pointer argument")
                                 .and_then(|ret| {
                                     let assignment = mk().assign_expr(
-                                        mk().unary_expr(ast::UnOp::Deref, ret),
+                                        mk().unary_expr(UnOp::Deref(Default::default()), ret),
                                         call,
                                     );
                                     self.convert_side_effects_expr(
@@ -262,27 +262,27 @@ impl<'c> Translation<'c> {
                             ))?;
 
                             self.use_feature("core_intrinsics");
-                            let expected = mk().unary_expr(ast::UnOp::Deref, expected);
+                            let expected = mk().unary_expr(UnOp::Deref(Default::default()), expected);
                             let desired = if name == "__atomic_compare_exchange_n" {
                                 desired
                             } else {
-                                mk().unary_expr(ast::UnOp::Deref, desired)
+                                mk().unary_expr(UnOp::Deref(Default::default()), desired)
                             };
 
                             let atomic_cxchg =
-                                mk().path_expr(vec!["", std_or_core, "intrinsics", intrinsic_name]);
+                                mk().abs_path_expr(vec![ std_or_core, "intrinsics", intrinsic_name]);
                             let call = mk().call_expr(atomic_cxchg, vec![ptr, expected.clone(), desired]);
                             let res_name = self.renamer.borrow_mut().fresh();
-                            let res_let = mk().local_stmt(P(mk().local(
+                            let res_let = mk().local_stmt(Box::new(mk().local(
                                 mk().ident_pat(&res_name),
-                                None as Option<P<Ty>>,
+                                None as Option<Box<Type>>,
                                 Some(call),
                             )));
                             let assignment = mk().semi_stmt(mk().assign_expr(
                                 expected,
-                                mk().field_expr(mk().ident_expr(&res_name), "0"),
+                                mk().anon_field_expr(mk().ident_expr(&res_name), 0),
                             ));
-                            let return_value = mk().field_expr(mk().ident_expr(&res_name), "1");
+                            let return_value = mk().anon_field_expr(mk().ident_expr(&res_name), 1);
                             self.convert_side_effects_expr(
                                 ctx,
                                 WithStmts::new(vec![res_let, assignment], return_value),
@@ -356,20 +356,20 @@ impl<'c> Translation<'c> {
         &self,
         ctx: ExprContext,
         intrinsic_name: &str,
-        dst: P<Expr>,
-        old_val: P<Expr>,
-        src_val: P<Expr>,
+        dst: Box<Expr>,
+        old_val: Box<Expr>,
+        src_val: Box<Expr>,
         returns_val: bool,
-    ) -> Result<WithStmts<P<Expr>>, TranslationError> {
+    ) -> Result<WithStmts<Box<Expr>>, TranslationError> {
         self.use_feature("core_intrinsics");
         let std_or_core = if self.tcfg.emit_no_std { "core" } else { "std" };
 
         // Emit `atomic_cxchg(a0, a1, a2).idx`
         let atomic_cxchg =
-            mk().path_expr(vec!["", std_or_core, "intrinsics", intrinsic_name]);
+            mk().abs_path_expr(vec![std_or_core, "intrinsics", intrinsic_name]);
         let call = mk().call_expr(atomic_cxchg, vec![dst, old_val, src_val]);
-        let field_idx = if returns_val { "0" } else { "1" };
-        let call_expr = mk().field_expr(call, field_idx);
+        let field_idx = if returns_val { 0 } else { 1 };
+        let call_expr = mk().anon_field_expr(call, field_idx);
         self.convert_side_effects_expr(
             ctx,
             WithStmts::new_val(call_expr),
@@ -381,15 +381,15 @@ impl<'c> Translation<'c> {
         &self,
         ctx: ExprContext,
         func_name: &str,
-        dst: P<Expr>,
-        src: P<Expr>,
+        dst: Box<Expr>,
+        src: Box<Expr>,
         fetch_first: bool,
-    ) -> Result<WithStmts<P<Expr>>, TranslationError> {
+    ) -> Result<WithStmts<Box<Expr>>, TranslationError> {
         self.use_feature("core_intrinsics");
         let std_or_core = if self.tcfg.emit_no_std { "core" } else { "std" };
 
         // Emit `atomic_func(a0, a1) (op a1)?`
-        let atomic_func = mk().path_expr(vec!["", std_or_core, "intrinsics", func_name]);
+        let atomic_func = mk().abs_path_expr(vec![std_or_core, "intrinsics", func_name]);
 
         if fetch_first {
             let call_expr = mk().call_expr(atomic_func, vec![dst, src]);
@@ -400,17 +400,17 @@ impl<'c> Translation<'c> {
             )
         } else {
             let (binary_op, is_nand) = if func_name.starts_with("atomic_xadd") {
-                (BinOpKind::Add, false)
+                (BinOp::Add(Default::default()), false)
             } else if func_name.starts_with("atomic_xsub") {
-                (BinOpKind::Sub, false)
+                (BinOp::Sub(Default::default()), false)
             } else if func_name.starts_with("atomic_or") {
-                (BinOpKind::BitOr, false)
+                (BinOp::BitOr(Default::default()), false)
             } else if func_name.starts_with("atomic_xor") {
-                (BinOpKind::BitXor, false)
+                (BinOp::BitXor(Default::default()), false)
             } else if func_name.starts_with("atomic_nand") {
-                (BinOpKind::BitAnd, true)
+                (BinOp::BitAnd(Default::default()), true)
             } else if func_name.starts_with("atomic_and") {
-                (BinOpKind::BitAnd, false)
+                (BinOp::BitAnd(Default::default()), false)
             } else {
                 panic!("Unexpected atomic intrinsic name: {}", func_name)
             };
@@ -419,16 +419,16 @@ impl<'c> Translation<'c> {
             // it into a local temporary so we don't duplicate any side-effects
             // To preserve ordering of side-effects, we also do this for arg0
             let arg0_name = self.renamer.borrow_mut().fresh();
-            let arg0_let = mk().local_stmt(P(mk().local(
+            let arg0_let = mk().local_stmt(Box::new(mk().local(
                 mk().ident_pat(&arg0_name),
-                None as Option<P<Ty>>,
+                None as Option<Box<Type>>,
                 Some(dst),
             )));
 
             let arg1_name = self.renamer.borrow_mut().fresh();
-            let arg1_let = mk().local_stmt(P(mk().local(
+            let arg1_let = mk().local_stmt(Box::new(mk().local(
                 mk().ident_pat(&arg1_name),
-                None as Option<P<Ty>>,
+                None as Option<Box<Type>>,
                 Some(src),
             )));
 
@@ -439,7 +439,7 @@ impl<'c> Translation<'c> {
             let val = mk().binary_expr(binary_op, call, mk().ident_expr(arg1_name));
             let val = if is_nand {
                 // For nand, return `!(atomic_nand(arg0, arg1) & arg1)`
-                mk().unary_expr(UnOp::Not, val)
+                mk().unary_expr(UnOp::Not(Default::default()), val)
             } else {
                 val
             };
diff --git a/c2rust-transpile/src/translator/builtins.rs b/c2rust-transpile/src/translator/builtins.rs
index eb92595dca..fb17f94074 100644
--- a/c2rust-transpile/src/translator/builtins.rs
+++ b/c2rust-transpile/src/translator/builtins.rs
@@ -10,7 +10,7 @@ impl<'c> Translation<'c> {
         ctx: ExprContext,
         fexp: CExprId,
         args: &[CExprId],
-    ) -> Result<WithStmts<P<Expr>>, TranslationError> {
+    ) -> Result<WithStmts<Box<Expr>>, TranslationError> {
         let expr = &self.ast_context[fexp];
         let src_loc = &expr.loc;
         let decl_id = match expr.kind {
@@ -33,40 +33,34 @@ impl<'c> Translation<'c> {
         let std_or_core = if self.tcfg.emit_no_std { "core" } else { "std" };
 
         match builtin_name {
-            "__builtin_huge_valf" => Ok(WithStmts::new_val(mk().path_expr(vec![
-                "",
+            "__builtin_huge_valf" => Ok(WithStmts::new_val(mk().abs_path_expr(vec![
                 std_or_core,
                 "f32",
                 "INFINITY",
             ]))),
             "__builtin_huge_val" | "__builtin_huge_vall" => {
-                Ok(WithStmts::new_val(mk().path_expr(vec![
-                    "",
+                Ok(WithStmts::new_val(mk().abs_path_expr(vec![
                     std_or_core,
                     "f64",
                     "INFINITY",
                 ])))
             }
-            "__builtin_inff" => Ok(WithStmts::new_val(mk().path_expr(vec![
-                "",
+            "__builtin_inff" => Ok(WithStmts::new_val(mk().abs_path_expr(vec![
                 std_or_core,
                 "f32",
                 "INFINITY",
             ]))),
-            "__builtin_inf" | "__builtin_infl" => Ok(WithStmts::new_val(mk().path_expr(vec![
-                "",
+            "__builtin_inf" | "__builtin_infl" => Ok(WithStmts::new_val(mk().abs_path_expr(vec![
                 std_or_core,
                 "f64",
                 "INFINITY",
             ]))),
-            "__builtin_nanf" => Ok(WithStmts::new_val(mk().path_expr(vec![
-                "",
+            "__builtin_nanf" => Ok(WithStmts::new_val(mk().abs_path_expr(vec![
                 std_or_core,
                 "f32",
                 "NAN",
             ]))),
-            "__builtin_nan" => Ok(WithStmts::new_val(mk().path_expr(vec![
-                "",
+            "__builtin_nan" => Ok(WithStmts::new_val(mk().abs_path_expr(vec![
                 std_or_core,
                 "f64",
                 "NAN",
@@ -91,7 +85,7 @@ impl<'c> Translation<'c> {
                 let val = self.convert_expr(ctx.used(), args[0])?;
 
                 Ok(val.map(|v| {
-                    let val = mk().method_call_expr(v, "is_sign_negative", vec![] as Vec<P<Expr>>);
+                    let val = mk().method_call_expr(v, "is_sign_negative", vec![] as Vec<Box<Expr>>);
 
                     mk().cast_expr(val, mk().path_ty(vec!["libc", "c_int"]))
                 }))
@@ -100,11 +94,11 @@ impl<'c> Translation<'c> {
                 let val = self.convert_expr(ctx.used(), args[0])?;
 
                 Ok(val.map(|x| {
-                    let add = BinOpKind::Add;
+                    let add = BinOp::Add(Default::default());
                     let zero = mk().lit_expr(mk().int_lit(0, ""));
                     let one = mk().lit_expr(mk().int_lit(1, ""));
-                    let cmp = BinOpKind::Eq;
-                    let zeros = mk().method_call_expr(x.clone(), "trailing_zeros", vec![] as Vec<P<Expr>>);
+                    let cmp = BinOp::Eq(Default::default());
+                    let zeros = mk().method_call_expr(x.clone(), "trailing_zeros", vec![] as Vec<Box<Expr>>);
                     let zeros_cast = mk().cast_expr(zeros, mk().path_ty(vec!["i32"]));
                     let zeros_plus1 = mk().binary_expr(add, zeros_cast, one);
                     let block = mk().block(vec![mk().expr_stmt(zero.clone())]);
@@ -116,24 +110,24 @@ impl<'c> Translation<'c> {
             "__builtin_clz" | "__builtin_clzl" | "__builtin_clzll" => {
                 let val = self.convert_expr(ctx.used(), args[0])?;
                 Ok(val.map(|x| {
-                    let zeros = mk().method_call_expr(x, "leading_zeros", vec![] as Vec<P<Expr>>);
+                    let zeros = mk().method_call_expr(x, "leading_zeros", vec![] as Vec<Box<Expr>>);
                     mk().cast_expr(zeros, mk().path_ty(vec!["i32"]))
                 }))
             }
             "__builtin_ctz" | "__builtin_ctzl" | "__builtin_ctzll" => {
                 let val = self.convert_expr(ctx.used(), args[0])?;
                 Ok(val.map(|x| {
-                    let zeros = mk().method_call_expr(x, "trailing_zeros", vec![] as Vec<P<Expr>>);
+                    let zeros = mk().method_call_expr(x, "trailing_zeros", vec![] as Vec<Box<Expr>>);
                     mk().cast_expr(zeros, mk().path_ty(vec!["i32"]))
                 }))
             }
             "__builtin_bswap16" | "__builtin_bswap32" | "__builtin_bswap64" => {
                 let val = self.convert_expr(ctx.used(), args[0])?;
-                Ok(val.map(|x| mk().method_call_expr(x, "swap_bytes", vec![] as Vec<P<Expr>>)))
+                Ok(val.map(|x| mk().method_call_expr(x, "swap_bytes", vec![] as Vec<Box<Expr>>)))
             }
             "__builtin_fabs" | "__builtin_fabsf" | "__builtin_fabsl" => {
                 let val = self.convert_expr(ctx.used(), args[0])?;
-                Ok(val.map(|x| mk().method_call_expr(x, "abs", vec![] as Vec<P<Expr>>)))
+                Ok(val.map(|x| mk().method_call_expr(x, "abs", vec![] as Vec<Box<Expr>>)))
             }
             "__builtin_isfinite" | "__builtin_isnan" => {
                 let val = self.convert_expr(ctx.used(), args[0])?;
@@ -144,7 +138,7 @@ impl<'c> Translation<'c> {
                     _ => panic!(),
                 };
                 Ok(val.map(|x| {
-                    let call = mk().method_call_expr(x, seg, vec![] as Vec<P<Expr>>);
+                    let call = mk().method_call_expr(x, seg, vec![] as Vec<Box<Expr>>);
                     mk().cast_expr(call, mk().path_ty(vec!["i32"]))
                 }))
             }
@@ -152,13 +146,13 @@ impl<'c> Translation<'c> {
                 // isinf_sign(x) -> fabs(x) == infinity ? (signbit(x) ? -1 : 1) : 0
                 let val = self.convert_expr(ctx.used(), args[0])?;
                 Ok(val.map(|x| {
-                    let inner_cond = mk().method_call_expr(x.clone(), "is_sign_positive", vec![] as Vec<P<Expr>>);
+                    let inner_cond = mk().method_call_expr(x.clone(), "is_sign_positive", vec![] as Vec<Box<Expr>>);
                     let one = mk().lit_expr(mk().int_lit(1, ""));
-                    let minus_one = mk().unary_expr(UnOp::Neg, mk().lit_expr(mk().int_lit(1, "")));
+                    let minus_one = mk().unary_expr(UnOp::Neg(Default::default()), mk().lit_expr(mk().int_lit(1, "")));
                     let one_block = mk().block(vec![mk().expr_stmt(one)]);
                     let inner_ifte = mk().ifte_expr(inner_cond, one_block, Some(minus_one));
                     let zero = mk().lit_expr(mk().int_lit(0, ""));
-                    let outer_cond = mk().method_call_expr(x, "is_infinite", vec![] as Vec<P<Expr>>);
+                    let outer_cond = mk().method_call_expr(x, "is_infinite", vec![] as Vec<Box<Expr>>);
                     let inner_ifte_block = mk().block(vec![mk().expr_stmt(inner_ifte)]);
                     mk().ifte_expr(outer_cond, inner_ifte_block, Some(zero))
                 }))
@@ -174,14 +168,14 @@ impl<'c> Translation<'c> {
             "__builtin_popcount" | "__builtin_popcountl" | "__builtin_popcountll" => {
                 let val = self.convert_expr(ctx.used(), args[0])?;
                 Ok(val.map(|x| {
-                    let zeros = mk().method_call_expr(x, "count_ones", vec![] as Vec<P<Expr>>);
+                    let zeros = mk().method_call_expr(x, "count_ones", vec![] as Vec<Box<Expr>>);
                     mk().cast_expr(zeros, mk().path_ty(vec!["i32"]))
                 }))
             }
             "__builtin_bzero" => {
                 let ptr_stmts = self.convert_expr(ctx.used(), args[0])?;
                 let n_stmts = self.convert_expr(ctx.used(), args[1])?;
-                let write_bytes = mk().path_expr(vec!["", "std", "ptr", "write_bytes"]);
+                let write_bytes = mk().abs_path_expr(vec!["std", "ptr", "write_bytes"]);
                 let zero = mk().lit_expr(mk().int_lit(0, "u8"));
                 ptr_stmts.and_then(|ptr| {
                     Ok(n_stmts.map(|n| mk().call_expr(write_bytes, vec![ptr, zero, n])))
@@ -253,11 +247,11 @@ impl<'c> Translation<'c> {
                 let type_arg = self.convert_expr(ctx.used(), args[1])?;
                 ptr_arg.and_then(|_| {
                     Ok(type_arg.map(|type_arg| {
-                        let type_and_2 = mk().binary_expr(BinOpKind::BitAnd, type_arg,
+                        let type_and_2 = mk().binary_expr(BinOp::BitAnd(Default::default()), type_arg,
                                                           mk().lit_expr(mk().int_lit(2, "")));
-                        let if_cond = mk().binary_expr(BinOpKind::Eq, type_and_2,
+                        let if_cond = mk().binary_expr(BinOp::Eq(Default::default()), type_and_2,
                                                        mk().lit_expr(mk().int_lit(0, "")));
-                        let minus_one = mk().unary_expr(UnOp::Neg, mk().lit_expr(mk().int_lit(1, "isize")));
+                        let minus_one = mk().unary_expr(UnOp::Neg(Default::default()), mk().lit_expr(mk().int_lit(1, "isize")));
                         let if_expr = mk().ifte_expr(if_cond,
                                        mk().block(vec![mk().expr_stmt(minus_one)]),
                                        Some(mk().lit_expr(mk().int_lit(0, "isize"))));
@@ -275,7 +269,7 @@ impl<'c> Translation<'c> {
                             let fn_ctx = self.function_context.borrow();
                             let src = fn_ctx.get_va_list_arg_name();
 
-                            let call_expr = mk().method_call_expr(mk().ident_expr(src), "clone", vec![] as Vec<P<Expr>>);
+                            let call_expr = mk().method_call_expr(mk().ident_expr(src), "clone", vec![] as Vec<Box<Expr>>);
                             let assign_expr = mk().assign_expr(dst.to_expr(), call_expr);
                             let stmt = mk().semi_stmt(assign_expr);
 
@@ -293,7 +287,7 @@ impl<'c> Translation<'c> {
                          let dst = self.convert_expr(ctx.expect_valistimpl().used(), args[0])?;
                          let src = self.convert_expr(ctx.expect_valistimpl().used(), args[1])?;
 
-                         let call_expr = mk().method_call_expr(src.to_expr(), "clone", vec![] as Vec<P<Expr>>);
+                         let call_expr = mk().method_call_expr(src.to_expr(), "clone", vec![] as Vec<Box<Expr>>);
                          let assign_expr = mk().assign_expr(dst.to_expr(), call_expr);
                          let stmt = mk().semi_stmt(assign_expr);
 
@@ -318,17 +312,17 @@ impl<'c> Translation<'c> {
                 let count = self.convert_expr(ctx.used(), args[0])?;
                 count.and_then(|count| {
                     let alloca_name = self.renamer.borrow_mut().fresh();
-                    let zero_elem = mk().lit_expr(mk().int_lit(0, LitIntType::Unsuffixed));
+                    let zero_elem = mk().lit_expr(mk().int_unsuffixed_lit(0));
                     Ok(WithStmts::new(
-                        vec![mk().local_stmt(P(mk().local(
+                        vec![mk().local_stmt(Box::new(mk().local(
                             mk().mutbl().ident_pat(&alloca_name),
-                            None as Option<P<Ty>>,
+                            None as Option<Box<Type>>,
                             Some(vec_expr(zero_elem, cast_int(count, "usize", false))),
                         )))],
                         mk().method_call_expr(
                             mk().ident_expr(&alloca_name),
                             "as_mut_ptr",
-                            vec![] as Vec<P<Expr>>,
+                            vec![] as Vec<Box<Expr>>,
                         ),
                     ))
                 })
@@ -548,8 +542,8 @@ impl<'c> Translation<'c> {
                 self.use_feature("core_intrinsics");
 
                 let atomic_func =
-                    mk().path_expr(vec!["", std_or_core, "intrinsics", "atomic_fence"]);
-                let call_expr = mk().call_expr(atomic_func, vec![] as Vec<P<Expr>>);
+                    mk().abs_path_expr(vec![std_or_core, "intrinsics", "atomic_fence"]);
+                let call_expr = mk().call_expr(atomic_func, vec![] as Vec<Box<Expr>>);
                 self.convert_side_effects_expr(
                     ctx,
                     WithStmts::new_val(call_expr),
@@ -566,7 +560,7 @@ impl<'c> Translation<'c> {
 
                 // Emit `atomic_xchg_acq(arg0, arg1)`
                 let atomic_func =
-                    mk().path_expr(vec!["", std_or_core, "intrinsics", "atomic_xchg_acq"]);
+                    mk().abs_path_expr(vec![std_or_core, "intrinsics", "atomic_xchg_acq"]);
                 let arg0 = self.convert_expr(ctx.used(), args[0])?;
                 let arg1 = self.convert_expr(ctx.used(), args[1])?;
                 arg0.and_then(|arg0| {
@@ -590,7 +584,7 @@ impl<'c> Translation<'c> {
 
                 // Emit `atomic_store_rel(arg0, 0)`
                 let atomic_func =
-                    mk().path_expr(vec!["", std_or_core, "intrinsics", "atomic_store_rel"]);
+                    mk().abs_path_expr(vec![std_or_core, "intrinsics", "atomic_store_rel"]);
                 let arg0 = self.convert_expr(ctx.used(), args[0])?;
                 arg0.and_then(|arg0| {
                     let zero = mk().lit_expr(mk().int_lit(0, ""));
@@ -612,7 +606,7 @@ impl<'c> Translation<'c> {
                     vec![mk().semi_stmt(mk().mac_expr(mk().mac(
                         vec!["unreachable"],
                         vec![],
-                        MacDelimiter::Parenthesis,
+                        MacroDelimiter::Paren(Default::default()),
                     )))],
                     self.panic_or_err("unreachable stub"),
                 ))
@@ -629,7 +623,7 @@ impl<'c> Translation<'c> {
         ctx: ExprContext,
         method_name: &str,
         args: &[CExprId],
-    ) -> Result<WithStmts<P<Expr>>, TranslationError> {
+    ) -> Result<WithStmts<Box<Expr>>, TranslationError> {
         let args = self.convert_exprs(ctx.used(), args)?;
         args.and_then(|args| {
             let mut args = args.into_iter();
@@ -639,17 +633,17 @@ impl<'c> Translation<'c> {
             let overflowing = mk().method_call_expr(a, method_name, vec![b]);
             let sum_name = self.renamer.borrow_mut().fresh();
             let over_name = self.renamer.borrow_mut().fresh();
-            let overflow_let = mk().local_stmt(P(mk().local(
+            let overflow_let = mk().local_stmt(Box::new(mk().local(
                 mk().tuple_pat(vec![
                     mk().ident_pat(&sum_name),
                     mk().ident_pat(over_name.clone()),
                 ]),
-                None as Option<P<Ty>>,
+                None as Option<Box<Type>>,
                 Some(overflowing),
             )));
 
             let out_assign = mk().assign_expr(
-                mk().unary_expr(ast::UnOp::Deref, c),
+                mk().unary_expr(UnOp::Deref(Default::default()), c),
                 mk().ident_expr(&sum_name),
             );
 
@@ -669,7 +663,7 @@ impl<'c> Translation<'c> {
         builtin_name: &str,
         ctx: ExprContext,
         args: &[CExprId],
-    ) -> Result<WithStmts<P<Expr>>, TranslationError> {
+    ) -> Result<WithStmts<Box<Expr>>, TranslationError> {
         let name = &builtin_name[10..];
         let mem = mk().path_expr(vec!["libc", name]);
         let args = self.convert_exprs(ctx.used(), args)?;
diff --git a/c2rust-transpile/src/translator/comments.rs b/c2rust-transpile/src/translator/comments.rs
index 18bb34c011..5210054bb6 100644
--- a/c2rust-transpile/src/translator/comments.rs
+++ b/c2rust-transpile/src/translator/comments.rs
@@ -1,11 +1,10 @@
 use std::collections::{HashMap, HashSet};
-use syntax::util::comments::CommentStyle;
-use syntax::source_map::{DUMMY_SP, Span};
 use crate::c_ast::{CDeclId, CDeclKind, CommentContext, SrcLoc, TypedAstContext};
 use crate::c_ast::iterators::{NodeVisitor, SomeId};
-use crate::rust_ast::pos_to_span;
 use crate::rust_ast::comment_store::CommentStore;
+use crate::rust_ast::{SpanExt, pos_to_span, DUMMY_SP};
 use super::Translation;
+use proc_macro2::Span;
 
 struct CommentLocator<'c> {
     ast_context: &'c TypedAstContext,
@@ -43,7 +42,7 @@ impl<'c> CommentLocator<'c> {
                     if let Some(pos) = self.comment_store.extend_existing_comments(
                         &[comment.kind.clone()],
                         existing_pos,
-                        CommentStyle::Trailing,
+                        //CommentStyle::Trailing,
                     ) {
                         debug!("Attaching comment {:?} to end of line at pos {:?}", comment.kind, pos);
                         // Add the span if we haven't already
@@ -89,7 +88,7 @@ impl<'c> NodeVisitor for CommentLocator<'c> {
                 let new_pos = self.comment_store.extend_existing_comments(
                     &comments,
                     Some(existing.lo()),
-                    CommentStyle::Isolated,
+                    //CommentStyle::Isolated,
                 );
                 debug!("Attaching more comments {:?} to id {:?} at pos {:?}", comments, id, new_pos);
             } else if let Some(pos) = self.comment_store.add_comments(&comments) {
diff --git a/c2rust-transpile/src/translator/literals.rs b/c2rust-transpile/src/translator/literals.rs
index 9dae997137..a9b97e07a0 100644
--- a/c2rust-transpile/src/translator/literals.rs
+++ b/c2rust-transpile/src/translator/literals.rs
@@ -7,11 +7,11 @@ use std::iter;
 
 impl<'c> Translation<'c> {
     /// Generate an integer literal corresponding to the given type, value, and base.
-    pub fn mk_int_lit(&self, ty: CQualTypeId, val: u64, base: IntBase) -> Result<P<Expr>, TranslationError> {
+    pub fn mk_int_lit(&self, ty: CQualTypeId, val: u64, base: IntBase) -> Result<Box<Expr>, TranslationError> {
         let lit = match base {
-            IntBase::Dec => mk().int_lit(val.into(), LitIntType::Unsuffixed),
-            IntBase::Hex => mk().float_unsuffixed_lit(format!("0x{:x}", val)),
-            IntBase::Oct => mk().float_unsuffixed_lit(format!("0o{:o}", val)),
+            IntBase::Dec => mk().int_unsuffixed_lit(val.into()),
+            IntBase::Hex => mk().float_unsuffixed_lit(&format!("0x{:x}", val)),
+            IntBase::Oct => mk().float_unsuffixed_lit(&format!("0o{:o}", val)),
         };
 
         let target_ty = self.convert_type(ty.ctype)?;
@@ -20,7 +20,7 @@ impl<'c> Translation<'c> {
 
     /// Given an integer value this attempts to either generate the corresponding enum
     /// variant directly, otherwise it transmutes a number to the enum type.
-    pub fn enum_for_i64(&self, enum_type_id: CTypeId, value: i64) -> P<Expr> {
+    pub fn enum_for_i64(&self, enum_type_id: CTypeId, value: i64) -> Box<Expr> {
         let def_id = match self.ast_context.resolve_type(enum_type_id).kind {
             CTypeKind::Enum(def_id) => def_id,
             _ => panic!("{:?} does not point to an `enum` type"),
@@ -56,10 +56,10 @@ impl<'c> Translation<'c> {
             underlying_type_id.expect("Attempt to construct value of forward declared enum");
         let value = match self.ast_context.resolve_type(underlying_type_id.ctype).kind {
             CTypeKind::UInt => {
-                mk().lit_expr(mk().int_lit((value as u32) as u128, LitIntType::Unsuffixed))
+                mk().lit_expr(mk().int_unsuffixed_lit((value as u32) as u128))
             }
             CTypeKind::ULong => {
-                mk().lit_expr(mk().int_lit((value as u64) as u128, LitIntType::Unsuffixed))
+                mk().lit_expr(mk().int_unsuffixed_lit((value as u64) as u128))
             }
             _ => signed_int_expr(value),
         };
@@ -72,10 +72,10 @@ impl<'c> Translation<'c> {
     /// Convert a C literal expression to a Rust expression
     pub fn convert_literal(
         &self,
-        ctx: ExprContext,
+        _ctx: ExprContext,
         ty: CQualTypeId,
         kind: &CLiteral,
-    ) -> Result<WithStmts<P<Expr>>, TranslationError> {
+    ) -> Result<WithStmts<Box<Expr>>, TranslationError> {
         match *kind {
             CLiteral::Integer(val, base) => Ok(WithStmts::new_val(self.mk_int_lit(ty, val, base)?)),
 
@@ -91,11 +91,11 @@ impl<'c> Translation<'c> {
                         // Fallback for characters outside of the valid Unicode range
                         if (val as i32) < 0 {
                             mk().unary_expr("-", mk().lit_expr(
-                                mk().int_lit((val as i32).abs() as u128, LitIntType::Signed(IntTy::I32))
+                                mk().int_lit((val as i32).abs() as u128, "i32")
                             ))
                         } else {
                             mk().lit_expr(
-                                mk().int_lit(val as u128, LitIntType::Signed(IntTy::I32))
+                                mk().int_lit(val as u128, "i32")
                             )
                         }
                     }
@@ -120,8 +120,8 @@ impl<'c> Translation<'c> {
 
                         mk().call_expr(fn_path, args)
                     }
-                    CTypeKind::Double => mk().lit_expr(mk().float_lit(str, FloatTy::F64)),
-                    CTypeKind::Float => mk().lit_expr(mk().float_lit(str, FloatTy::F32)),
+                    CTypeKind::Double => mk().lit_expr(mk().float_lit(&*str, "f64")),
+                    CTypeKind::Float => mk().lit_expr(mk().float_lit(&*str, "f32")),
                     ref k => panic!("Unsupported floating point literal type {:?}", k),
                 };
                 Ok(WithStmts::new_val(val))
@@ -145,7 +145,7 @@ impl<'c> Translation<'c> {
                 };
                 let u8_ty = mk().path_ty(vec!["u8"]);
                 let width_lit =
-                    mk().lit_expr(mk().int_lit(val.len() as u128, LitIntType::Unsuffixed));
+                    mk().lit_expr(mk().int_unsuffixed_lit(val.len() as u128));
                 let array_ty = mk().array_ty(u8_ty, width_lit);
                 let source_ty = mk().ref_ty(array_ty);
                 let mutbl = if ty.qualifiers.is_const {
@@ -155,10 +155,9 @@ impl<'c> Translation<'c> {
                 };
                 let target_ty = mk().set_mutbl(mutbl).ref_ty(self.convert_type(ty.ctype)?);
                 let byte_literal = mk().lit_expr(val);
-                if ctx.is_const || ctx.is_static { self.use_feature("const_transmute"); }
                 let pointer =
                     transmute_expr(source_ty, target_ty, byte_literal, self.tcfg.emit_no_std);
-                let array = mk().unary_expr(ast::UnOp::Deref, pointer);
+                let array = mk().unary_expr(UnOp::Deref(Default::default()), pointer);
                 Ok(WithStmts::new_unsafe_val(array))
             }
         }
@@ -172,7 +171,7 @@ impl<'c> Translation<'c> {
         ty: CQualTypeId,
         ids: &[CExprId],
         opt_union_field_id: Option<CFieldId>,
-    ) -> Result<WithStmts<P<Expr>>, TranslationError> {
+    ) -> Result<WithStmts<Box<Expr>>, TranslationError> {
         match self.ast_context.resolve_type(ty.ctype).kind {
             CTypeKind::ConstantArray(ty, n) => {
                 // Convert all of the provided initializer values
@@ -224,7 +223,7 @@ impl<'c> Translation<'c> {
                                 self.implicit_default_expr(ty, ctx.is_static)
                             ).take(n - ids.len())
                         )
-                        .collect::<Result<WithStmts<Vec<P<Expr>>>, TranslationError>>()?
+                        .collect::<Result<WithStmts<Vec<Box<Expr>>>, TranslationError>>()?
                         .map(|vals| {
                             mk().array_expr(vals)
                         }))
@@ -274,7 +273,7 @@ impl<'c> Translation<'c> {
         ids: &[CExprId],
         _ty: CQualTypeId,
         opt_union_field_id: Option<CFieldId>,
-    ) -> Result<WithStmts<P<Expr>>, TranslationError> {
+    ) -> Result<WithStmts<Box<Expr>>, TranslationError> {
         let union_field_id = opt_union_field_id.expect("union field ID");
 
         match self.ast_context.index(union_id).kind {
diff --git a/c2rust-transpile/src/translator/main_function.rs b/c2rust-transpile/src/translator/main_function.rs
index da9c534f25..12e697328d 100644
--- a/c2rust-transpile/src/translator/main_function.rs
+++ b/c2rust-transpile/src/translator/main_function.rs
@@ -4,10 +4,10 @@
 //! Rust.
 
 use super::*;
-use syntax::token::{self, TokenKind};
+use proc_macro2::{TokenStream, TokenTree};
 
 impl<'c> Translation<'c> {
-    pub fn convert_main(&self, main_id: CDeclId) -> Result<P<Item>, TranslationError> {
+    pub fn convert_main(&self, main_id: CDeclId) -> Result<Box<Item>, TranslationError> {
         if let CDeclKind::Function {
             ref parameters,
             typ,
@@ -25,30 +25,31 @@ impl<'c> Translation<'c> {
                 ))?,
             };
 
-            let decl = mk().fn_decl(vec![], FunctionRetTy::Default(DUMMY_SP));
-
             let main_fn_name = self
                 .renamer
                 .borrow()
                 .get(&main_id)
                 .expect("Could not find main function in renamer");
+
+            let decl = mk().fn_decl("main", vec![], None, ReturnType::Default);
+
             let main_fn = mk().path_expr(vec![main_fn_name]);
 
-            let exit_fn = mk().path_expr(vec!["", "std", "process", "exit"]);
-            let args_fn = mk().path_expr(vec!["", "std", "env", "args"]);
-            let vars_fn = mk().path_expr(vec!["", "std", "env", "vars"]);
+            let exit_fn = mk().abs_path_expr(vec!["std", "process", "exit"]);
+            let args_fn = mk().abs_path_expr(vec!["std", "env", "args"]);
+            let vars_fn = mk().abs_path_expr(vec!["std", "env", "vars"]);
 
-            let no_args: Vec<P<Expr>> = vec![];
+            let no_args: Vec<Box<Expr>> = vec![];
 
             let mut stmts: Vec<Stmt> = vec![];
-            let mut main_args: Vec<P<Expr>> = vec![];
+            let mut main_args: Vec<Box<Expr>> = vec![];
 
             let n = parameters.len();
 
             if n >= 2 {
                 // `argv` and `argc`
 
-                stmts.push(mk().local_stmt(P(mk().local(
+                stmts.push(mk().local_stmt(Box::new(mk().local(
                     mk().mutbl().ident_pat("args"),
                     Some(mk().path_ty(vec![mk().path_segment_with_args(
                         "Vec",
@@ -57,19 +58,19 @@ impl<'c> Translation<'c> {
                         ]),
                     )])),
                     Some(
-                        mk().call_expr(mk().path_expr(vec!["Vec", "new"]), vec![] as Vec<P<Expr>>),
+                        mk().call_expr(mk().path_expr(vec!["Vec", "new"]), vec![] as Vec<Box<Expr>>),
                     ),
                 ))));
                 stmts.push(mk().semi_stmt(mk().for_expr(
                     mk().ident_pat("arg"),
-                    mk().call_expr(args_fn, vec![] as Vec<P<Expr>>),
+                    mk().call_expr(args_fn, vec![] as Vec<Box<Expr>>),
                     mk().block(vec![mk().semi_stmt(mk().method_call_expr(
                         mk().path_expr(vec!["args"]),
                         "push",
                         vec![mk().method_call_expr(
                             mk().method_call_expr(
                                 mk().call_expr(
-                                    mk().path_expr(vec!["", "std", "ffi", "CString", "new"]),
+                                    mk().abs_path_expr(vec!["std", "ffi", "CString", "new"]),
                                     vec![mk().path_expr(vec!["arg"])],
                                 ),
                                 "expect",
@@ -78,7 +79,7 @@ impl<'c> Translation<'c> {
                                 )],
                             ),
                             "into_raw",
-                            vec![] as Vec<P<Expr>>,
+                            vec![] as Vec<Box<Expr>>,
                         )],
                     ))]),
                     None as Option<Ident>,
@@ -87,18 +88,18 @@ impl<'c> Translation<'c> {
                     mk().path_expr(vec!["args"]),
                     "push",
                     vec![mk().call_expr(
-                        mk().path_expr(vec!["", "std", "ptr", "null_mut"]),
-                        vec![] as Vec<P<Expr>>,
+                        mk().abs_path_expr(vec!["std", "ptr", "null_mut"]),
+                        vec![] as Vec<Box<Expr>>,
                     )],
                 )));
 
-                let argc_ty: P<Ty> = match self.ast_context.index(parameters[0]).kind {
+                let argc_ty: Box<Type> = match self.ast_context.index(parameters[0]).kind {
                     CDeclKind::Variable { ref typ, .. } => self.convert_type(typ.ctype),
                     _ => Err(TranslationError::generic(
                         "Cannot find type of 'argc' argument in main function",
                     )),
                 }?;
-                let argv_ty: P<Ty> = match self.ast_context.index(parameters[1]).kind {
+                let argv_ty: Box<Type> = match self.ast_context.index(parameters[1]).kind {
                     CDeclKind::Variable { ref typ, .. } => self.convert_type(typ.ctype),
                     _ => Err(TranslationError::generic(
                         "Cannot find type of 'argv' argument in main function",
@@ -107,7 +108,7 @@ impl<'c> Translation<'c> {
 
                 let args = mk().ident_expr("args");
                 let argc = mk().binary_expr(
-                    BinOpKind::Sub,
+                    BinOp::Sub(Default::default()),
                     mk().method_call_expr(args.clone(), "len", no_args.clone()),
                     mk().lit_expr(mk().int_lit(1, "")),
                 );
@@ -120,7 +121,7 @@ impl<'c> Translation<'c> {
             if n >= 3 {
                 // non-standard `envp`
 
-                stmts.push(mk().local_stmt(P(mk().local(
+                stmts.push(mk().local_stmt(Box::new(mk().local(
                     mk().mutbl().ident_pat("vars"),
                     Some(mk().path_ty(vec![mk().path_segment_with_args(
                         "Vec",
@@ -129,30 +130,29 @@ impl<'c> Translation<'c> {
                         ]),
                     )])),
                     Some(
-                        mk().call_expr(mk().path_expr(vec!["Vec", "new"]), vec![] as Vec<P<Expr>>),
+                        mk().call_expr(mk().path_expr(vec!["Vec", "new"]), vec![] as Vec<Box<Expr>>),
                     ),
                 ))));
                 let var_name_ident = mk().ident("var_name");
                 let var_value_ident = mk().ident("var_value");
                 stmts.push(mk().semi_stmt(mk().for_expr(
                     mk().tuple_pat(vec![mk().ident_pat("var_name"), mk().ident_pat("var_value")]),
-                    mk().call_expr(vars_fn, vec![] as Vec<P<Expr>>),
+                    mk().call_expr(vars_fn, vec![] as Vec<Box<Expr>>),
                     mk().block(vec![
-                        mk().local_stmt(P(mk().local(
+                        mk().local_stmt(Box::new(mk().local(
                             mk().ident_pat("var"),
                             Some(mk().path_ty(vec!["String"])),
                             Some(mk().mac_expr(mk().mac(
                                 vec!["format"],
                                 vec![
-                                    token::Interpolated(Rc::new(Nonterminal::NtExpr(mk().lit_expr("{}={}")))),
-                                    token::Comma,
-                                    TokenKind::Ident(var_name_ident.name, var_name_ident.is_raw_guess()),
-                                    token::Comma,
-                                    TokenKind::Ident(var_value_ident.name, var_value_ident.is_raw_guess())
+                                    TokenTree::Literal(proc_macro2::Literal::string("{}={}")),
+                                    TokenTree::Punct(Punct::new(',', proc_macro2::Spacing::Alone)),
+                                    TokenTree::Ident(var_name_ident),
+                                    TokenTree::Punct(Punct::new(',', proc_macro2::Spacing::Alone)),
+                                    TokenTree::Ident(var_value_ident),
                                 ].into_iter()
-                                    .map(|tk| TokenTree::token(tk, DUMMY_SP))
                                     .collect::<TokenStream>(),
-                                MacDelimiter::Parenthesis,
+                                MacroDelimiter::Paren(Default::default()),
                             )))
                         ))),
                         mk().semi_stmt(mk().method_call_expr(
@@ -162,7 +162,7 @@ impl<'c> Translation<'c> {
                                 mk().method_call_expr(
                                     mk().method_call_expr(
                                         mk().call_expr(
-                                            mk().path_expr(vec!["","std","ffi","CString","new"]),
+                                            mk().abs_path_expr(vec!["std", "ffi", "CString", "new"]),
                                             vec![mk().path_expr(vec!["var"])],
                                         ),
                                         "expect",
@@ -171,7 +171,7 @@ impl<'c> Translation<'c> {
                                         )],
                                     ),
                                     "into_raw",
-                                    vec![] as Vec<P<Expr>>,
+                                    vec![] as Vec<Box<Expr>>,
                                 )
                             ],
                         ))
@@ -182,12 +182,12 @@ impl<'c> Translation<'c> {
                     mk().path_expr(vec!["vars"]),
                     "push",
                     vec![mk().call_expr(
-                        mk().path_expr(vec!["", "std", "ptr", "null_mut"]),
-                        vec![] as Vec<P<Expr>>,
+                        mk().abs_path_expr(vec!["std", "ptr", "null_mut"]),
+                        vec![] as Vec<Box<Expr>>,
                     )],
                 )));
 
-                let envp_ty: P<Ty> = match self.ast_context.index(parameters[2]).kind {
+                let envp_ty: Box<Type> = match self.ast_context.index(parameters[2]).kind {
                     CDeclKind::Variable { ref typ, .. } => self.convert_type(typ.ctype),
                     _ => Err(TranslationError::generic(
                         "Cannot find type of 'envp' argument in main function",
@@ -209,9 +209,9 @@ impl<'c> Translation<'c> {
 
             if let CTypeKind::Void = ret {
                 let call_main = mk().call_expr(main_fn, main_args);
-                let unsafe_block = mk().unsafe_().block(vec![mk().expr_stmt(call_main)]);
+                let unsafe_block = mk().unsafe_block(vec![mk().expr_stmt(call_main)]);
 
-                stmts.push(mk().expr_stmt(mk().block_expr(unsafe_block)));
+                stmts.push(mk().expr_stmt(mk().unsafe_block_expr(unsafe_block)));
 
                 let exit_arg = mk().lit_expr(mk().int_lit(0, "i32"));
                 let call_exit = mk().call_expr(exit_fn, vec![exit_arg]);
@@ -224,15 +224,13 @@ impl<'c> Translation<'c> {
                 );
 
                 let call_exit = mk().call_expr(exit_fn, vec![call_main]);
-                let unsafe_block = mk().unsafe_().block(vec![mk().expr_stmt(call_exit)]);
+                let unsafe_block = mk().unsafe_block(vec![mk().expr_stmt(call_exit)]);
 
-                stmts.push(mk().expr_stmt(mk().block_expr(unsafe_block)));
+                stmts.push(mk().expr_stmt(mk().unsafe_block_expr(unsafe_block)));
             };
 
             let block = mk().block(stmts);
-            let main_attributes = mk().single_attr("main");
-            self.use_feature("main");
-            Ok(main_attributes.pub_().fn_item("main", decl, block))
+            Ok(mk().pub_().fn_item(decl, block))
         } else {
             Err(TranslationError::generic(
                 "Cannot translate non-function main entry point",
diff --git a/c2rust-transpile/src/translator/mod.rs b/c2rust-transpile/src/translator/mod.rs
index 26f0dbce15..d0e6d27f72 100644
--- a/c2rust-transpile/src/translator/mod.rs
+++ b/c2rust-transpile/src/translator/mod.rs
@@ -3,33 +3,25 @@ use std::collections::HashMap;
 use std::mem;
 use std::ops::Index;
 use std::path::{self, PathBuf};
-use std::rc::Rc;
 use std::char;
+use std::result::Result; // To override syn::Result from glob import
 
 use dtoa;
 
 use failure::{err_msg, Fail};
 use indexmap::{IndexMap, IndexSet};
+use proc_macro2::{Span, TokenStream, TokenTree, Punct, Spacing::*};
+use syn::*;
+use syn::{BinOp, UnOp}; // To override c_ast::{BinOp,UnOp} from glob import
+use syn::spanned::Spanned as _;
 
-use rustc_parse::parse_stream_from_source_str;
-use syntax::attr;
-use syntax::ast::*;
-use syntax::util::comments::CommentStyle;
-use syntax::token::{self, DelimToken, Nonterminal};
-use syntax::ptr::*;
-use syntax::sess::ParseSess;
-use syntax::source_map::{FilePathMapping, SourceMap};
-use syntax::tokenstream::{TokenStream, TokenTree};
-use syntax::{ast, with_globals};
-use syntax_pos::{FileName, Span, DUMMY_SP};
-use syntax_pos::edition::Edition;
-
-use crate::rust_ast::pos_to_span;
+use crate::rust_ast::{pos_to_span, SpanExt, DUMMY_SP};
 use crate::rust_ast::comment_store::CommentStore;
 use crate::rust_ast::item_store::ItemStore;
+use crate::rust_ast::set_span::SetSpan;
 use crate::rust_ast::traverse::Traversal;
-use c2rust_ast_builder::{mk, Builder, IntoSymbol};
-use c2rust_ast_printer::pprust::{self, Comments, PrintState};
+use c2rust_ast_builder::{mk, Builder, properties::*};
+use c2rust_ast_printer::pprust::{self, Comments};
 
 use crate::c_ast;
 use crate::c_ast::iterators::{DFExpr, SomeId};
@@ -261,7 +253,7 @@ pub struct Translation<'c> {
     // Translation state and utilities
     type_converter: RefCell<TypeConverter>,
     renamer: RefCell<Renamer<CDeclId>>,
-    zero_inits: RefCell<IndexMap<CDeclId, WithStmts<P<Expr>>>>,
+    zero_inits: RefCell<IndexMap<CDeclId, WithStmts<Box<Expr>>>>,
     function_context: RefCell<FunContext>,
     potential_flexible_array_members: RefCell<IndexSet<CDeclId>>,
     macro_expansions: RefCell<IndexMap<CDeclId, Option<MacroExpansion>>>,
@@ -287,33 +279,36 @@ pub struct Translation<'c> {
     cur_file: RefCell<Option<FileId>>,
 }
 
-fn simple_metaitem(name: &str) -> NestedMetaItem {
-    let meta_item = mk().meta_item(vec![name], MetaItemKind::Word);
+fn simple_metaitem(name: &str) -> NestedMeta {
+    let meta_item = mk().meta_path(name);
 
-    mk().nested_meta_item(NestedMetaItem::MetaItem(meta_item))
+    mk().nested_meta_item(NestedMeta::Meta(meta_item))
 }
 
-fn int_arg_metaitem(name: &str, arg: u128) -> NestedMetaItem {
-    let lit = mk().int_lit(arg, LitIntType::Unsuffixed);
-    let inner = mk().meta_item(
-        vec![name],
-        MetaItemKind::List(vec![
-            mk().nested_meta_item(NestedMetaItem::Literal(lit))
-        ]),
-    );
-    mk().nested_meta_item(NestedMetaItem::MetaItem(inner))
+fn int_arg_metaitem(name: &str, arg: u128) -> NestedMeta {
+    let lit = mk().int_unsuffixed_lit(arg);
+    use std::iter::FromIterator;
+    let inner =
+        Meta::List(MetaList {
+            path: mk().path(name),
+            paren_token: Default::default(),
+            nested: FromIterator::from_iter(vec![
+                mk().nested_meta_item(NestedMeta::Lit(lit))
+            ].into_iter()),
+    });
+    NestedMeta::Meta(inner)
 }
 
-fn cast_int(val: P<Expr>, name: &str, need_lit_suffix: bool) -> P<Expr> {
-    let opt_literal_val = match val.kind {
-        ExprKind::Lit(ref l) => match l.kind {
-            LitKind::Int(i, _) => Some(i),
+fn cast_int(val: Box<Expr>, name: &str, need_lit_suffix: bool) -> Box<Expr> {
+    let opt_literal_val = match &*val {
+        Expr::Lit(ref l) => match &l.lit {
+            Lit::Int(i) => Some(i.base10_digits().parse().unwrap()),
             _ => None,
         },
         _ => None,
     };
     match opt_literal_val {
-        Some(i) if !need_lit_suffix => mk().lit_expr(mk().int_lit(i, LitIntType::Unsuffixed)),
+        Some(i) if !need_lit_suffix => mk().lit_expr(mk().int_unsuffixed_lit(i)),
         Some(i) => mk().lit_expr(mk().int_lit(i, name)),
         None => mk().cast_expr(val, mk().path_ty(vec![name])),
     }
@@ -321,27 +316,27 @@ fn cast_int(val: P<Expr>, name: &str, need_lit_suffix: bool) -> P<Expr> {
 
 /// Pointer offset that casts its argument to isize
 fn pointer_offset(
-    ptr: P<Expr>,
-    offset: P<Expr>,
-    multiply_by: Option<P<Expr>>,
+    ptr: Box<Expr>,
+    offset: Box<Expr>,
+    multiply_by: Option<Box<Expr>>,
     neg: bool,
     mut deref: bool,
-) -> P<Expr> {
+) -> Box<Expr> {
     let mut offset = cast_int(offset, "isize", false);
 
     if let Some(mul) = multiply_by {
         let mul = cast_int(mul, "isize", false);
-        offset = mk().binary_expr(BinOpKind::Mul, offset, mul);
+        offset = mk().binary_expr(BinOp::Mul(Default::default()), offset, mul);
         deref = false;
     }
 
     if neg {
-        offset = mk().unary_expr(ast::UnOp::Neg, offset);
+        offset = mk().unary_expr(UnOp::Neg(Default::default()), offset);
     }
 
     let res = mk().method_call_expr(ptr, "offset", vec![offset]);
     if deref {
-        mk().unary_expr(ast::UnOp::Deref, res)
+        mk().unary_expr(UnOp::Deref(Default::default()), res)
     } else {
         res
     }
@@ -349,20 +344,18 @@ fn pointer_offset(
 
 /// Given an expression with type Option<fn(...)->...>, unwrap
 /// the Option and return the function.
-fn unwrap_function_pointer(ptr: P<Expr>) -> P<Expr> {
+fn unwrap_function_pointer(ptr: Box<Expr>) -> Box<Expr> {
     let err_msg = mk().lit_expr("non-null function pointer");
     mk().method_call_expr(ptr, "expect", vec![err_msg])
 }
 
-fn transmute_expr(source_ty: P<Ty>, target_ty: P<Ty>, expr: P<Expr>, no_std: bool) -> P<Expr> {
-    let type_args = match (&source_ty.kind, &target_ty.kind) {
-        (TyKind::Infer, TyKind::Infer) => Vec::new(),
-        (_, TyKind::Infer) => vec![source_ty],
+fn transmute_expr(source_ty: Box<Type>, target_ty: Box<Type>, expr: Box<Expr>, no_std: bool) -> Box<Expr> {
+    let type_args = match (&*source_ty, &*target_ty) {
+        (Type::Infer(_), Type::Infer(_)) => Vec::new(),
         _ => vec![source_ty, target_ty],
     };
     let std_or_core = if no_std { "core" } else { "std" };
     let mut path = vec![
-        mk().path_segment(""),
         mk().path_segment(std_or_core),
         mk().path_segment("mem"),
     ];
@@ -373,27 +366,30 @@ fn transmute_expr(source_ty: P<Ty>, target_ty: P<Ty>, expr: P<Expr>, no_std: boo
         path.push(mk().path_segment_with_args("transmute", mk().angle_bracketed_args(type_args)));
     }
 
-    mk().call_expr(mk().path_expr(path), vec![expr])
+    mk().call_expr(mk().abs_path_expr(path), vec![expr])
 }
 
-fn vec_expr(val: P<Expr>, count: P<Expr>) -> P<Expr> {
-    let from_elem = mk().path_expr(vec!["", "std", "vec", "from_elem"]);
+fn vec_expr(val: Box<Expr>, count: Box<Expr>) -> Box<Expr> {
+    let from_elem = mk().abs_path_expr(vec!["std", "vec", "from_elem"]);
     mk().call_expr(from_elem, vec![val, count])
 }
 
-pub fn stmts_block(mut stmts: Vec<Stmt>) -> P<Block> {
+pub fn stmts_block(mut stmts: Vec<Stmt>) -> Box<Block> {
     if stmts.len() == 1 {
-        if let StmtKind::Expr(ref e) = stmts[0].kind {
-            if let ExprKind::Block(ref b, None) = e.kind {
-                return b.clone();
+        if let Stmt::Expr(ref e) = stmts[0] {
+            if let Expr::Block(ExprBlock {block: ref b, label: None, ..}) = e {
+                return Box::new(b.clone());
             }
         }
     }
 
     if stmts.len() > 0 {
         let n = stmts.len() - 1;
-        let s = stmts.remove(n);
-        stmts.push(s.add_trailing_semicolon())
+        let mut s = stmts.remove(n);
+        if let Stmt::Expr(e) = s {
+            s = Stmt::Semi(e, Default::default());
+        }
+        stmts.push(s)
     }
 
     mk().block(stmts)
@@ -403,7 +399,11 @@ pub fn stmts_block(mut stmts: Vec<Stmt>) -> P<Block> {
 // values.
 fn mk_linkage(in_extern_block: bool, new_name: &str, old_name: &str) -> Builder {
     if new_name == old_name {
-        mk().single_attr("no_mangle") // Don't touch my name Rust!
+        if in_extern_block {
+            mk() // There is no mangling by default in extern blocks anymore
+        } else {
+            mk().single_attr("no_mangle") // Don't touch my name Rust!
+        }
     } else if in_extern_block {
         mk().str_attr("link_name", old_name) // Look for this name
     } else {
@@ -411,10 +411,10 @@ fn mk_linkage(in_extern_block: bool, new_name: &str, old_name: &str) -> Builder
     }
 }
 
-pub fn signed_int_expr(value: i64) -> P<Expr> {
+pub fn signed_int_expr(value: i64) -> Box<Expr> {
     if value < 0 {
         mk().unary_expr(
-            ast::UnOp::Neg,
+            UnOp::Neg(Default::default()),
             mk().lit_expr(mk().int_lit((-value) as u128, "")),
         )
     } else {
@@ -518,8 +518,7 @@ pub fn translate(
         expanding_macro: None,
     };
 
-    // `with_globals` sets up a thread-local variable required by the syntax crate.
-    with_globals(Edition::Edition2018, || {
+    {
         t.use_crate(ExternCrate::Libc);
 
         // Sort the top-level declarations by file and source location so that we
@@ -610,8 +609,8 @@ pub fn translate(
         // Helper function that returns true if there is either a matching typedef or its
         // corresponding struct/union/enum
         fn contains(prenamed_decls: &IndexMap<CDeclId, CDeclId>, decl_id: &CDeclId) -> bool {
-            (prenamed_decls.contains_key(decl_id)
-                || prenamed_decls.values().find(|id| *id == decl_id).is_some())
+            prenamed_decls.contains_key(decl_id)
+                || prenamed_decls.values().find(|id| *id == decl_id).is_some()
         }
 
         // Populate renamer with top-level names
@@ -794,7 +793,7 @@ pub fn translate(
         let pragmas = t.get_pragmas();
         let crates = t.extern_crates.borrow().clone();
 
-        let mut mod_items: Vec<P<Item>> = Vec::new();
+        let mut mod_items: Vec<Box<Item>> = Vec::new();
 
         // Keep track of new uses we need while building header submodules
         let mut new_uses = ItemStore::new();
@@ -810,14 +809,14 @@ pub fn translate(
                     &t.mod_names,
                 );
                 let comments = t.comment_context.get_remaining_comments(*file_id);
-                submodule.span = match t
+                submodule.set_span(match t
                     .comment_store
                     .borrow_mut()
                     .add_comments(&comments)
                 {
-                    Some(pos) => submodule.span.with_hi(pos),
-                    None => submodule.span,
-                };
+                    Some(pos) => submodule.span().with_hi(pos),
+                    None => submodule.span(),
+                });
                 mod_items.push(submodule);
             }
         }
@@ -830,21 +829,23 @@ pub fn translate(
         // that's bad design
         let mut traverser = t.comment_store.replace(CommentStore::new()).into_comment_traverser();
 
+        /*
         // Add a comment mapping span to each node that should have a
         // comment printed before it. The pretty printer picks up these
         // spans and uses them to decide when to emit comments.
         mod_items = mod_items
             .into_iter()
-            .map(|p_i| p_i.map(|i| traverser.traverse_item(i)))
+            .map(|i| traverser.traverse_item(*i)).map(Box::new)
             .collect();
         let foreign_items: Vec<ForeignItem> = foreign_items
             .into_iter()
             .map(|fi| traverser.traverse_foreign_item(fi))
             .collect();
-        let items: Vec<P<Item>> = items
+        let items: Vec<Box<Item>> = items
             .into_iter()
-            .map(|p_i| p_i.map(|i| traverser.traverse_item(i)))
+            .map(|i| traverser.traverse_item(*i)).map(Box::new)
             .collect();
+        */
 
         let mut reordered_comment_store = traverser.into_comment_store();
         let remaining_comments = t.comment_context.get_remaining_comments(t.main_file);
@@ -855,45 +856,94 @@ pub fn translate(
         // print trailing comments after exprs/stmts/etc. on the same line. The
         // SourceMap will think that all Spans are invalid, but will return line
         // 0 for all of them.
-        let sm = SourceMap::new(FilePathMapping::empty());
-        sm.new_source_file(FileName::Custom("<dummy>".to_string()), " ".to_string());
 
-        let comments = Comments::new(&sm, reordered_comment_store.into_comments());
+        let comments = Comments::new(reordered_comment_store.into_comments());
 
         // pass all converted items to the Rust pretty printer
         let translation = pprust::to_string_with_comments(comments, |s| {
-            print_header(s, &t, t.tcfg.is_binary(main_file.as_path()));
+            let (attrs, mut all_items) = arrange_header(&t, t.tcfg.is_binary(main_file.as_path()));
 
-            for mod_item in mod_items {
-                s.print_item(&*mod_item);
-            }
+            all_items.extend(mod_items);
 
             // This could have been merged in with items below; however, it's more idiomatic to have
             // imports near the top of the file than randomly scattered about. Also, there is probably
             // no reason to have comments associated with imports so it doesn't need to go through
             // the above comment store process
-            for use_item in uses.into_items() {
-                s.print_item(&use_item);
-            }
+            all_items.extend(uses.into_items());
 
             // Print new uses from submodules
             let (_, _, new_uses) = new_uses.drain();
-            for use_item in new_uses.into_items() {
-                s.print_item(&use_item);
-            }
+            all_items.extend(new_uses.into_items());
+
 
             if !foreign_items.is_empty() {
-                s.print_item(&mk().extern_("C").foreign_items(foreign_items))
+                all_items.push(mk().extern_("C").foreign_items(foreign_items));
             }
 
             // Add the items accumulated
-            for x in items {
-                s.print_item(&*x);
-            }
+            all_items.extend(items);
 
-            s.print_remaining_comments();
+            //s.print_remaining_comments();
+            s.file(&syn::File {shebang: None, attrs, items: all_items.into_iter().map(|x| *x).collect()});
         });
         (translation, pragmas, crates)
+    }
+}
+
+fn item_ident(i: &Item) -> Option<&Ident> {
+    Some(match i {
+        Item::Const(ic) => &ic.ident,
+        Item::Enum(ie) => &ie.ident,
+        Item::ExternCrate(iec) => &iec.ident,
+        Item::Fn(ifn) => &ifn.sig.ident,
+        Item::ForeignMod(_ifm) => return None,
+        Item::Impl(_ii) => return None,
+        Item::Macro(im) => return im.ident.as_ref(),
+        Item::Macro2(im2) => &im2.ident,
+        Item::Mod(im) => &im.ident,
+        Item::Static(is) => &is.ident,
+        Item::Struct(is) => &is.ident,
+        Item::Trait(it) => &it.ident,
+        Item::TraitAlias(ita) => &ita.ident,
+        Item::Type(it) => &it.ident,
+        Item::Union(iu) => &iu.ident,
+        Item::Use(ItemUse {tree: _, ..}) => unimplemented!(),
+        Item::Verbatim(_tokenstream) => {warn!("cannot determine name of tokenstream item"); return None},
+        _ => {warn!("cannot determine name of unknown item kind"); return None},
+    })
+}
+
+fn item_vis(i: &Item) -> Option<Visibility> {
+    Some(match i {
+        Item::Const(ic) => &ic.vis,
+        Item::Enum(ie) => &ie.vis,
+        Item::ExternCrate(iec) => &iec.vis,
+        Item::Fn(ifn) => &ifn.vis,
+        Item::ForeignMod(_ifm) => return None,
+        Item::Impl(_ii) => return None,
+        Item::Macro(_im) => return None,
+        Item::Macro2(im2) => &im2.vis,
+        Item::Mod(im) => &im.vis,
+        Item::Static(is) => &is.vis,
+        Item::Struct(is) => &is.vis,
+        Item::Trait(it) => &it.vis,
+        Item::TraitAlias(ita) => &ita.vis,
+        Item::Type(it) => &it.vis,
+        Item::Union(iu) => &iu.vis,
+        Item::Use(ItemUse {vis, ..}) => vis,
+        Item::Verbatim(_tokenstream) => {warn!("cannot determine visibility of tokenstream item"); return None},
+        _ => {warn!("cannot determine visibility of unknown item kind"); return None},
+    }.clone())
+}
+
+fn foreign_item_ident_vis(fi: &ForeignItem) -> Option<(&Ident, Visibility)> {
+    Some(match fi {
+        ForeignItem::Fn(ifn) => (&ifn.sig.ident, ifn.vis.clone()),
+        ForeignItem::Static(is) => (&is.ident, is.vis.clone()),
+        ForeignItem::Type(it) => (&it.ident, it.vis.clone()),
+        ForeignItem::Macro(_im) => return None,
+        ForeignItem::Verbatim(_tokenstream) => {warn!("cannot determine name and visibility of tokenstream foreign item"); return None},
+        _ => {warn!("cannot determine name and visibility of unknown foreign item kind"); return None},
     })
 }
 
@@ -903,26 +953,33 @@ fn make_submodule(
     file_id: FileId,
     use_item_store: &mut ItemStore,
     mod_names: &RefCell<IndexMap<String, PathBuf>>,
-) -> P<Item> {
+) -> Box<Item> {
     let (mut items, foreign_items, uses) = item_store.drain();
     let file_path = ast_context.get_file_path(file_id);
     let include_line_number = ast_context.get_file_include_line_number(file_id).unwrap_or(0);
     let mod_name = clean_path(mod_names, file_path);
 
     for item in items.iter() {
-        let ident_name = item.ident.name.as_str();
+        let ident_name = match item_ident(item) {
+            Some(i) => i.to_string(),
+            None => continue,
+        };
         let use_path = vec!["self".into(), mod_name.clone()];
 
-        let vis = match item.vis.node {
-            VisibilityKind::Public => mk().pub_(),
-            _ => mk(),
+        let vis = match item_vis(item) {
+            Some(Visibility::Public(_)) => mk().pub_(),
+            Some(_) => mk(),
+            None => continue,
         };
 
         use_item_store.add_use_with_attr(use_path, &ident_name, vis);
     }
 
     for foreign_item in foreign_items.iter() {
-        let ident_name = foreign_item.ident.name.as_str();
+        let ident_name = match foreign_item_ident_vis(foreign_item) {
+            Some((ident, _vis)) => ident.to_string(),
+            None => continue,
+        };
         let use_path = vec!["self".into(), mod_name.clone()];
 
         use_item_store.add_use(use_path, &ident_name);
@@ -945,34 +1002,37 @@ fn make_submodule(
             vec!["c2rust", "header_src"],
             format!("{}:{}", file_path_str, include_line_number),
         )
-        .mod_item(mod_name, mk().mod_(items))
+        .mod_item(mod_name, Some(mk().mod_(items)))
 }
 
 /// Pretty-print the leading pragmas and extern crate declarations
-fn print_header(s: &mut pprust::State, t: &Translation, is_binary: bool) {
+fn arrange_header(t: &Translation, is_binary: bool) -> (Vec<syn::Attribute>, Vec<Box<Item>>) {
+    let mut out_attrs = vec![];
+    let mut out_items = vec![];
     if t.tcfg.emit_modules && !is_binary {
         for c in t.extern_crates.borrow().iter() {
-            s.print_item(&mk().use_simple_item(
-                vec![String::new(), ExternCrateDetails::from(*c).ident],
+            out_items.push(mk().use_simple_item(
+                mk().abs_path(vec![ExternCrateDetails::from(*c).ident]),
                 None as Option<Ident>,
-            ));
+            ))
         }
     } else {
         let pragmas = t.get_pragmas();
         for (key, mut values) in pragmas {
             values.sort();
+            // generate #[key(values)]
             let value_attr_vec = values
                 .into_iter()
-                .map(|value| mk().nested_meta_item(mk().meta_item(vec![value], MetaItemKind::Word)))
+                .map(|value| mk().nested_meta_item(mk().meta_path(value)))
                 .collect::<Vec<_>>();
-            let item = mk().meta_item(vec![key], MetaItemKind::List(value_attr_vec));
-            for attr in mk().meta_item_attr(AttrStyle::Inner, item).as_inner_attrs() {
-                s.print_attribute(&attr);
+            let item = mk().meta_list(vec![key], value_attr_vec);
+            for attr in mk().meta_item_attr(AttrStyle::Inner(Default::default()), item).as_inner_attrs() {
+                out_attrs.push(attr);
             }
         }
 
         if t.tcfg.emit_no_std {
-            s.print_attribute(&mk().single_attr("no_std").as_inner_attrs()[0]);
+            out_attrs.push(mk().single_attr("no_std").as_inner_attrs()[0].clone());
         }
 
         if is_binary {
@@ -980,35 +1040,72 @@ fn print_header(s: &mut pprust::State, t: &Translation, is_binary: bool) {
             for extern_crate in t.extern_crates.borrow().iter() {
                 let extern_crate = ExternCrateDetails::from(*extern_crate);
                 if extern_crate.macro_use {
-                    s.print_item(
-                        &mk()
+                    out_items.push(
+                        mk()
                             .single_attr("macro_use")
                             .extern_crate_item(extern_crate.ident.clone(), None),
                     );
                 }
             }
 
-            s.print_item(&mk().use_glob_item(vec!["", &t.tcfg.crate_name()]));
+            out_items.push(mk().use_glob_item(mk().abs_path(vec![&t.tcfg.crate_name()])));
         }
     }
+    (out_attrs, out_items)
 }
 
 /// Convert a boolean expression to a c_int
-fn bool_to_int(val: P<Expr>) -> P<Expr> {
+fn bool_to_int(val: Box<Expr>) -> Box<Expr> {
     mk().cast_expr(val, mk().path_ty(vec!["libc", "c_int"]))
 }
 
 /// Add a src_loc = "line:col" attribute to an item/foreign_item
-fn add_src_loc_attr(attrs: &mut Vec<ast::Attribute>, src_loc: &Option<SrcLoc>) {
+fn add_src_loc_attr(attrs: &mut Vec<syn::Attribute>, src_loc: &Option<SrcLoc>) {
     if let Some(src_loc) = src_loc.as_ref() {
         let loc_str = format!("{}:{}", src_loc.line, src_loc.column);
-        attrs.push(attr::mk_attr_outer(mk().meta_item(
-            vec!["c2rust", "src_loc"],
-            loc_str.into_symbol(),
-        )));
+        let meta = mk().meta_namevalue(vec!["c2rust", "src_loc"], loc_str);
+        let prepared = mk().prepare_meta(meta);
+        let attr = mk().attribute(AttrStyle::Outer, prepared.path, prepared.tokens);
+        attrs.push(attr);
     }
 }
 
+/// Get a mutable reference to the attributes of a ForeignItem
+fn foreign_item_attrs(item: &mut ForeignItem) -> Option<&mut Vec<syn::Attribute>> {
+    Some(match item {
+        ForeignItem::Fn(ForeignItemFn {ref mut attrs, ..}) => attrs,
+        ForeignItem::Static(ForeignItemStatic {ref mut attrs, ..}) => attrs,
+        ForeignItem::Type(ForeignItemType {ref mut attrs, ..}) => attrs,
+        ForeignItem::Macro(ForeignItemMacro {ref mut attrs, ..}) => attrs,
+        ForeignItem::Verbatim(TokenStream {..}) => return None,
+        _ => return None,
+    })
+}
+
+/// Get a mutable reference to the attributes of an Item
+fn item_attrs(item: &mut Item) -> Option<&mut Vec<syn::Attribute>> {
+    Some(match item {
+        Item::Const(ItemConst {ref mut attrs, ..}) => attrs,
+        Item::Enum(ItemEnum {ref mut attrs, ..}) => attrs,
+        Item::ExternCrate(ItemExternCrate {ref mut attrs, ..}) => attrs,
+        Item::Fn(ItemFn {ref mut attrs, ..}) => attrs,
+        Item::ForeignMod(ItemForeignMod {ref mut attrs, ..}) => attrs,
+        Item::Impl(ItemImpl {ref mut attrs, ..}) => attrs,
+        Item::Macro(ItemMacro {ref mut attrs, ..}) => attrs,
+        Item::Macro2(ItemMacro2 {ref mut attrs, ..}) => attrs,
+        Item::Mod(ItemMod {ref mut attrs, ..}) => attrs,
+        Item::Static(ItemStatic {ref mut attrs, ..}) => attrs,
+        Item::Struct(ItemStruct {ref mut attrs, ..}) => attrs,
+        Item::Trait(ItemTrait {ref mut attrs, ..}) => attrs,
+        Item::TraitAlias(ItemTraitAlias {ref mut attrs, ..}) => attrs,
+        Item::Type(ItemType {ref mut attrs, ..}) => attrs,
+        Item::Union(ItemUnion {ref mut attrs, ..}) => attrs,
+        Item::Use(ItemUse {ref mut attrs, ..}) => attrs,
+        Item::Verbatim(TokenStream {..}) => return None,
+        _ => return None,
+    })
+}
+
 /// This represents all of the ways a C expression can be used in a C program. Making this
 /// distinction is important for:
 ///
@@ -1040,8 +1137,8 @@ pub enum ExprUse {
 #[derive(Debug)]
 pub enum ConvertedDecl {
     ForeignItem(ForeignItem),
-    Item(P<Item>),
-    Items(Vec<P<Item>>),
+    Item(Box<Item>),
+    Items(Vec<Box<Item>>),
     NoItem,
 }
 
@@ -1112,7 +1209,7 @@ impl<'c> Translation<'c> {
     {
         let mut item_stores = self.items.borrow_mut();
         let item_store = item_stores
-            .entry(self.cur_file())
+            .entry(Self::cur_file(&self))
             .or_insert_with(ItemStore::new);
         f(item_store)
     }
@@ -1150,21 +1247,20 @@ impl<'c> Translation<'c> {
 
     // This node should _never_ show up in the final generated code. This is an easy way to notice
     // if it does.
-    pub fn panic_or_err(&self, msg: &str) -> P<Expr> {
+    pub fn panic_or_err(&self, msg: &str) -> Box<Expr> {
         self.panic_or_err_helper(msg, self.tcfg.panic_on_translator_failure)
     }
 
-    pub fn panic(&self, msg: &str) -> P<Expr> {
+    pub fn panic(&self, msg: &str) -> Box<Expr> {
         self.panic_or_err_helper(msg, true)
     }
 
-    fn panic_or_err_helper(&self, msg: &str, panic: bool) -> P<Expr> {
+    fn panic_or_err_helper(&self, msg: &str, panic: bool) -> Box<Expr> {
         let macro_name = if panic { "panic" } else { "compile_error" };
-        let macro_msg = vec![TokenTree::token(token::Interpolated(Rc::new(Nonterminal::NtExpr(
-            mk().lit_expr(msg)))), DUMMY_SP)]
+        let macro_msg = vec![TokenTree::Literal(proc_macro2::Literal::string(msg))]
         .into_iter()
             .collect::<TokenStream>();
-        mk().mac_expr(mk().mac(vec![macro_name], macro_msg, MacDelimiter::Parenthesis))
+        mk().mac_expr(mk().mac(vec![macro_name], macro_msg, MacroDelimiter::Paren(Default::default())))
     }
 
     fn static_initializer_is_unsafe(&self, expr_id: Option<CExprId>, qty: CQualTypeId) -> bool {
@@ -1333,7 +1429,7 @@ impl<'c> Translation<'c> {
         &self,
         name: &str,
         typ: CQualTypeId,
-        init: &mut P<Expr>,
+        init: &mut Box<Expr>,
     ) -> Result<(), TranslationError> {
         let mut default_init = self.implicit_default_expr(typ.ctype, true)?.to_expr();
 
@@ -1348,7 +1444,7 @@ impl<'c> Translation<'c> {
         Ok(())
     }
 
-    fn generate_global_static_init(&mut self) -> (P<Item>, P<Item>) {
+    fn generate_global_static_init(&mut self) -> (Box<Item>, Box<Item>) {
         // If we don't want to consume self.sectioned_static_initializers for some reason, we could clone the vec
         let sectioned_static_initializers = self.sectioned_static_initializers.replace(Vec::new());
 
@@ -1356,34 +1452,41 @@ impl<'c> Translation<'c> {
             .renamer
             .borrow_mut()
             .pick_name("run_static_initializers");
-        let fn_ty = FunctionRetTy::Default(DUMMY_SP);
-        let fn_decl = mk().fn_decl(vec![], fn_ty);
+        let fn_ty = ReturnType::Default;
+        let fn_decl = mk().fn_decl(fn_name.clone(), vec![], None, fn_ty.clone());
+        let fn_bare_decl = Box::new((vec![], None, fn_ty));
         let fn_block = mk().block(sectioned_static_initializers);
         let fn_item = mk()
             .unsafe_()
             .extern_("C")
-            .fn_item(&fn_name, fn_decl.clone(), fn_block);
+            .fn_item(fn_decl.clone(), fn_block);
 
         let static_attributes = mk()
             .single_attr("used")
-            .call_attr(
+            .meta_item_attr(AttrStyle::Outer, mk().meta_list(
                 "cfg_attr",
-                vec!["target_os = \"linux\"", "link_section = \".init_array\""],
-            )
-            .call_attr(
+                vec![
+                    mk().nested_meta_item(mk().meta_namevalue("target_os", "linux")),
+                    mk().nested_meta_item(mk().meta_namevalue("link_section", ".init_array")),
+                ],
+            ))
+            .meta_item_attr(AttrStyle::Outer, mk().meta_list(
                 "cfg_attr",
-                vec!["target_os = \"windows\"", "link_section = \".CRT$XIB\""],
-            )
-            .call_attr(
+                vec![
+                    mk().nested_meta_item(mk().meta_namevalue("target_os", "windows")),
+                    mk().nested_meta_item(mk().meta_namevalue("link_section", ".CRT$XIB")),
+                ],
+            ))
+            .meta_item_attr(AttrStyle::Outer, mk().meta_list(
                 "cfg_attr",
                 vec![
-                    "target_os = \"macos\"",
-                    "link_section = \"__DATA,__mod_init_func\"",
+                    mk().nested_meta_item(mk().meta_namevalue("target_os", "macos")),
+                    mk().nested_meta_item(mk().meta_namevalue("link_section", "__DATA,__mod_init_func")),
                 ],
-            );
-        let static_array_size = mk().lit_expr(mk().int_lit(1, LitIntType::Unsuffixed));
+            ));
+        let static_array_size = mk().lit_expr(mk().int_unsuffixed_lit(1));
         let static_ty = mk().array_ty(
-            mk().unsafe_().extern_("C").barefn_ty(fn_decl),
+            mk().unsafe_().extern_("C").barefn_ty(fn_bare_decl),
             static_array_size,
         );
         let static_val = mk().array_expr(vec![mk().path_expr(vec![fn_name])]);
@@ -1508,7 +1611,7 @@ impl<'c> Translation<'c> {
                     assert!(self.ast_context.has_inner_struct_decl(decl_id));
                     let inner_name = self.resolve_decl_inner_name(decl_id);
                     let inner_ty = mk().path_ty(vec![inner_name.clone()]);
-                    let inner_repr_attr = mk().meta_item(vec!["repr"], MetaItemKind::List(reprs));
+                    let inner_repr_attr = mk().meta_list("repr", reprs);
                     let inner_struct = mk().span(s)
                         .pub_()
                         .call_attr("derive", derives)
@@ -1522,7 +1625,7 @@ impl<'c> Translation<'c> {
                         int_arg_metaitem("align", alignment as u128),
                         // TODO: copy others from `reprs` above
                     ];
-                    let repr_attr = mk().meta_item(vec!["repr"], MetaItemKind::List(outer_reprs));
+                    let repr_attr = mk().meta_list("repr", outer_reprs);
                     let outer_field = mk().pub_().enum_field(mk().ident_ty(inner_name));
                     let outer_struct = mk().span(s)
                         .pub_()
@@ -1539,7 +1642,7 @@ impl<'c> Translation<'c> {
                     let outer_size = self.compute_size_of_ty(outer_ty)?.to_expr();
                     let inner_size = self.compute_size_of_ty(inner_ty)?.to_expr();
                     let padding_value =
-                        mk().binary_expr(BinOpKind::Sub, outer_size, inner_size);
+                        mk().binary_expr(BinOp::Sub(Default::default()), outer_size, inner_size);
                     let padding_const = mk().span(s)
                         .call_attr("allow", vec!["dead_code", "non_upper_case_globals"])
                         .const_item(padding_name, padding_ty, padding_value);
@@ -1548,7 +1651,7 @@ impl<'c> Translation<'c> {
                     Ok(ConvertedDecl::Items(structs))
                 } else {
                     assert!(!self.ast_context.has_inner_struct_decl(decl_id));
-                    let repr_attr = mk().meta_item(vec!["repr"], MetaItemKind::List(reprs));
+                    let repr_attr = mk().meta_list("repr", reprs);
                     Ok(ConvertedDecl::Item(
                         mk().span(s)
                             .pub_()
@@ -1653,7 +1756,7 @@ impl<'c> Translation<'c> {
                 let val = match value {
                     ConstIntExpr::I(value) => signed_int_expr(value),
                     ConstIntExpr::U(value) => {
-                        mk().lit_expr(mk().int_lit(value as u128, LitIntType::Unsuffixed))
+                        mk().lit_expr(mk().int_unsuffixed_lit(value as u128))
                     }
                 };
 
@@ -1738,7 +1841,7 @@ impl<'c> Translation<'c> {
                     .resolve_decl_name(decl_id)
                     .unwrap();
 
-                if self.import_simd_typedef(new_name) {
+                if self.import_simd_typedef(new_name)? {
                     return Ok(ConvertedDecl::NoItem);
                 }
 
@@ -1860,7 +1963,7 @@ impl<'c> Translation<'c> {
                         .extend_existing_comments(
                             &[comment],
                             comment_pos,
-                            CommentStyle::Isolated,
+                            //CommentStyle::Isolated,
                         )
                         .map(pos_to_span)
                         .unwrap_or(s);
@@ -1974,10 +2077,10 @@ impl<'c> Translation<'c> {
         &self,
         ctx: ExprContext,
         replacements: &[CExprId],
-    ) -> Result<(P<Expr>, CTypeId), TranslationError> {
+    ) -> Result<(Box<Expr>, CTypeId), TranslationError> {
         let (val, ty) = replacements
             .iter()
-            .try_fold::<Option<(WithStmts<P<Expr>>, CTypeId)>, _, _>(
+            .try_fold::<Option<(WithStmts<Box<Expr>>, CTypeId)>, _, _>(
                 None,
                 |canonical, id| {
                     let ty = self.ast_context[*id].kind.get_type()
@@ -2036,7 +2139,7 @@ impl<'c> Translation<'c> {
         self.function_context.borrow_mut().enter_new(name);
 
         self.with_scope(|| {
-            let mut args: Vec<Param> = vec![];
+            let mut args: Vec<FnArg> = vec![];
 
             // handle regular (non-variadic) arguments
             for &(decl_id, ref var, typ) in arguments {
@@ -2092,12 +2195,12 @@ impl<'c> Translation<'c> {
             // If a return type is void, we should instead omit the unit type return,
             // -> (), to be more idiomatic
             let ret = if is_void_ret {
-                FunctionRetTy::Default(DUMMY_SP)
+                ReturnType::Default
             } else {
-                FunctionRetTy::Ty(ret)
+                ReturnType::Type(Default::default(), ret)
             };
 
-            let decl = mk().fn_decl(args, ret);
+            let decl = mk().fn_decl(new_name, args, is_variadic.then(|| mk().variadic_arg(vec![])), ret);
 
             if let Some(body) = body {
                 // Translating an actual function
@@ -2129,7 +2232,7 @@ impl<'c> Translation<'c> {
                 body_stmts.append(&mut self.convert_function_body(ctx, name, body_ids, ret)?);
                 let mut block = stmts_block(body_stmts);
                 if let Some(span) = self.get_span(SomeId::Stmt(body)) {
-                    block.span = span;
+                    block.set_span(span);
                 }
 
                 // Only add linkage attributes if the function is `extern`
@@ -2150,9 +2253,9 @@ impl<'c> Translation<'c> {
 
                 for attr in attrs {
                     mk_ = match attr {
-                        c_ast::Attribute::AlwaysInline => mk_.single_attr("inline(always)"),
+                        c_ast::Attribute::AlwaysInline => mk_.call_attr("inline", vec!["always"]),
                         c_ast::Attribute::Cold => mk_.single_attr("cold"),
-                        c_ast::Attribute::NoInline => mk_.single_attr("inline(never)"),
+                        c_ast::Attribute::NoInline => mk_.call_attr("inline", vec!["never"]),
                         _ => continue,
                     };
                 }
@@ -2177,14 +2280,14 @@ impl<'c> Translation<'c> {
                     if is_global && is_extern && !attrs.contains(&c_ast::Attribute::GnuInline) {
                         self.use_feature("linkage");
                         // ensures that public inlined rust function can be used in other modules
-                        mk_ = mk_.single_attr("linkage = \"external\"");
+                        mk_ = mk_.str_attr("linkage", "external");
                     }
                     // NOTE: it does not seem necessary to have an else branch here that
                     // specifies internal linkage in all other cases due to name mangling by rustc.
                 }
 
                 Ok(ConvertedDecl::Item(
-                    mk_.span(span).unsafe_().fn_item(new_name, decl, block),
+                    mk_.span(span).unsafe_().fn_item(decl, block),
                 ))
             } else {
                 // Translating an extern function declaration
@@ -2205,7 +2308,7 @@ impl<'c> Translation<'c> {
                     };
                 }
 
-                let function_decl = mk_.fn_foreign_item(new_name, decl);
+                let function_decl = mk_.fn_foreign_item(decl);
 
                 Ok(ConvertedDecl::ForeignItem(function_decl))
             }
@@ -2270,9 +2373,9 @@ impl<'c> Translation<'c> {
             let local = mk().local(
                 mk().mutbl().ident_pat(current_block_ident),
                 Some(current_block_ty),
-                None as Option<P<Expr>>,
+                None as Option<Box<Expr>>,
             );
-            stmts.push(mk().local_stmt(P(local)))
+            stmts.push(mk().local_stmt(Box::new(local)))
         }
 
         stmts.extend(cfg::structures::structured_cfg(
@@ -2305,14 +2408,14 @@ impl<'c> Translation<'c> {
         ctx: ExprContext,
         target: bool,
         cond_id: CExprId,
-    ) -> Result<WithStmts<P<Expr>>, TranslationError> {
+    ) -> Result<WithStmts<Box<Expr>>, TranslationError> {
         let ty_id = self.ast_context[cond_id]
             .kind
             .get_type()
             .ok_or_else(|| format_err!("bad condition type"))?;
 
         let null_pointer_case =
-            |negated: bool, ptr: CExprId| -> Result<WithStmts<P<Expr>>, TranslationError> {
+            |negated: bool, ptr: CExprId| -> Result<WithStmts<Box<Expr>>, TranslationError> {
                 let val = self.convert_expr(ctx.used().decay_ref(), ptr)?;
                 let ptr_type = self.ast_context[ptr]
                     .kind
@@ -2321,14 +2424,14 @@ impl<'c> Translation<'c> {
                 Ok(val.map(|e| {
                     if self.ast_context.is_function_pointer(ptr_type) {
                         if negated {
-                            mk().method_call_expr(e, "is_some", vec![] as Vec<P<Expr>>)
+                            mk().method_call_expr(e, "is_some", vec![] as Vec<Box<Expr>>)
                         } else {
-                            mk().method_call_expr(e, "is_none", vec![] as Vec<P<Expr>>)
+                            mk().method_call_expr(e, "is_none", vec![] as Vec<Box<Expr>>)
                         }
                     } else {
-                        let is_null = mk().method_call_expr(e, "is_null", vec![] as Vec<P<Expr>>);
+                        let is_null = mk().method_call_expr(e, "is_null", vec![] as Vec<Box<Expr>>);
                         if negated {
-                            mk().unary_expr(ast::UnOp::Not, is_null)
+                            mk().unary_expr(UnOp::Not(Default::default()), is_null)
                         } else {
                             is_null
                         }
@@ -2479,15 +2582,15 @@ impl<'c> Translation<'c> {
                     let pat_mut = mk().set_mutbl("mut").ident_pat(rust_name.clone());
                     let ty = {
                         let std_or_core = if self.tcfg.emit_no_std { "core" } else { "std" };
-                        let path = vec!["", std_or_core, "ffi", "VaListImpl"];
-                        mk().path_ty(path)
+                        let path = vec![std_or_core, "ffi", "VaListImpl"];
+                        mk().path_ty(mk().abs_path(path))
                     };
-                    let local_mut = mk().local::<_, _, P<Expr>>(pat_mut, Some(ty), None);
+                    let local_mut = mk().local::<_, _, Box<Expr>>(pat_mut, Some(ty), None);
 
                     return Ok(cfg::DeclStmtInfo::new(
-                        vec![],                              // decl
-                        vec![],                              // assign
-                        vec![mk().local_stmt(P(local_mut))], // decl_and_assign
+                        vec![],                                     // decl
+                        vec![],                                     // assign
+                        vec![mk().local_stmt(Box::new(local_mut))], // decl_and_assign
                     ));
                 }
 
@@ -2519,12 +2622,12 @@ impl<'c> Translation<'c> {
                     let mut assign_stmts = stmts.clone();
                     assign_stmts.push(mk().semi_stmt(assign.clone()));
 
-                    let mut decl_and_assign = vec![mk().local_stmt(P(local_mut.clone()))];
+                    let mut decl_and_assign = vec![mk().local_stmt(Box::new(local_mut.clone()))];
                     decl_and_assign.append(&mut stmts);
                     decl_and_assign.push(mk().expr_stmt(assign));
 
                     Ok(cfg::DeclStmtInfo::new(
-                        vec![mk().local_stmt(P(local_mut))],
+                        vec![mk().local_stmt(Box::new(local_mut))],
                         assign_stmts,
                         decl_and_assign,
                     ))
@@ -2546,10 +2649,10 @@ impl<'c> Translation<'c> {
                     assign_stmts.push(mk().semi_stmt(assign));
 
                     let mut decl_and_assign = stmts;
-                    decl_and_assign.push(mk().local_stmt(P(local)));
+                    decl_and_assign.push(mk().local_stmt(Box::new(local)));
 
                     Ok(cfg::DeclStmtInfo::new(
-                        vec![mk().local_stmt(P(local_mut))],
+                        vec![mk().local_stmt(Box::new(local_mut))],
                         assign_stmts,
                         decl_and_assign,
                     ))
@@ -2693,9 +2796,9 @@ impl<'c> Translation<'c> {
         typ: CQualTypeId,
     ) -> Result<
         (
-            P<Ty>,
+            Box<Type>,
             Mutability,
-            Result<WithStmts<P<Expr>>, TranslationError>,
+            Result<WithStmts<Box<Expr>>, TranslationError>,
         ),
         TranslationError,
     > {
@@ -2727,7 +2830,7 @@ impl<'c> Translation<'c> {
         Ok((ty, mutbl, init))
     }
 
-    fn convert_type(&self, type_id: CTypeId) -> Result<P<Ty>, TranslationError> {
+    fn convert_type(&self, type_id: CTypeId) -> Result<Box<Type>, TranslationError> {
         if let Some(cur_file) = *self.cur_file.borrow() {
             self.import_type(type_id, cur_file);
         }
@@ -2738,7 +2841,7 @@ impl<'c> Translation<'c> {
 
     /// Construct an expression for a NULL at any type, including forward declarations,
     /// function pointers, and normal pointers.
-    fn null_ptr(&self, type_id: CTypeId, is_static: bool) -> Result<P<Expr>, TranslationError> {
+    fn null_ptr(&self, type_id: CTypeId, is_static: bool) -> Result<Box<Expr>, TranslationError> {
         if self.ast_context.is_function_pointer(type_id) {
             return Ok(mk().path_expr(vec!["None"]));
         }
@@ -2748,11 +2851,10 @@ impl<'c> Translation<'c> {
             _ => return Err(TranslationError::generic("null_ptr requires a pointer")),
         };
         let ty = self.convert_type(type_id)?;
-        let mut zero = mk().lit_expr(mk().int_lit(0, LitIntType::Unsuffixed));
+        let mut zero = mk().lit_expr(mk().int_unsuffixed_lit(0));
         if is_static && !pointee.qualifiers.is_const {
             let mut qtype = pointee;
             qtype.qualifiers.is_const = true;
-            self.use_feature("const_raw_ptr_to_usize_cast");
             let ty_ = self
                 .type_converter
                 .borrow_mut()
@@ -2765,12 +2867,12 @@ impl<'c> Translation<'c> {
     /// Write to a `lhs` that is volatile
     pub fn volatile_write(
         &self,
-        lhs: &P<Expr>,
+        lhs: &Box<Expr>,
         lhs_type: CQualTypeId,
-        rhs: P<Expr>,
-    ) -> Result<P<Expr>, TranslationError> {
-        let addr_lhs = match lhs.kind {
-            ExprKind::Unary(ast::UnOp::Deref, ref e) => {
+        rhs: Box<Expr>,
+    ) -> Result<Box<Expr>, TranslationError> {
+        let addr_lhs = match **lhs {
+            Expr::Unary(ExprUnary {op: UnOp::Deref(_), expr: ref e, ..}) => {
                 if lhs_type.qualifiers.is_const {
                     let lhs_type = self.convert_type(lhs_type.ctype)?;
                     let ty = mk().mutbl().ptr_ty(lhs_type);
@@ -2792,7 +2894,7 @@ impl<'c> Translation<'c> {
         let std_or_core = if self.tcfg.emit_no_std { "core" } else { "std" };
 
         Ok(mk().call_expr(
-            mk().path_expr(vec!["", std_or_core, "ptr", "write_volatile"]),
+            mk().abs_path_expr(vec![std_or_core, "ptr", "write_volatile"]),
             vec![addr_lhs, rhs],
         ))
     }
@@ -2800,11 +2902,11 @@ impl<'c> Translation<'c> {
     /// Read from a `lhs` that is volatile
     pub fn volatile_read(
         &self,
-        lhs: &P<Expr>,
+        lhs: &Box<Expr>,
         lhs_type: CQualTypeId,
-    ) -> Result<P<Expr>, TranslationError> {
-        let addr_lhs = match lhs.kind {
-            ExprKind::Unary(ast::UnOp::Deref, ref e) => {
+    ) -> Result<Box<Expr>, TranslationError> {
+        let addr_lhs = match **lhs {
+            Expr::Unary(ExprUnary {op: UnOp::Deref(_), expr: ref e, ..}) => {
                 if !lhs_type.qualifiers.is_const {
                     let lhs_type = self.convert_type(lhs_type.ctype)?;
                     let ty = mk().ptr_ty(lhs_type);
@@ -2829,7 +2931,7 @@ impl<'c> Translation<'c> {
         // in order to avoid omitted bit-casts to const from causing the
         // wrong type to be inferred via the result of the pointer.
         let mut path_parts: Vec<PathSegment> = vec![];
-        for elt in vec!["", std_or_core, "ptr"] {
+        for elt in vec![std_or_core, "ptr"] {
             path_parts.push(mk().path_segment(elt))
         }
         let elt_ty = self.convert_type(lhs_type.ctype)?;
@@ -2837,13 +2939,13 @@ impl<'c> Translation<'c> {
         let elt = mk().path_segment_with_args("read_volatile", ty_params);
         path_parts.push(elt);
 
-        let read_volatile_expr = mk().path_expr(path_parts);
+        let read_volatile_expr = mk().abs_path_expr(path_parts);
         Ok(mk().call_expr(read_volatile_expr, vec![addr_lhs]))
     }
 
     // Compute the offset multiplier for variable length array indexing
     // Rust type: usize
-    pub fn compute_size_of_expr(&self, type_id: CTypeId) -> Option<P<Expr>> {
+    pub fn compute_size_of_expr(&self, type_id: CTypeId) -> Option<Box<Expr>> {
         match self.ast_context.resolve_type(type_id).kind {
             CTypeKind::VariableArray(elts, Some(counts)) => {
                 let opt_esize = self.compute_size_of_expr(elts);
@@ -2856,7 +2958,7 @@ impl<'c> Translation<'c> {
 
                 let val = match opt_esize {
                     None => csize,
-                    Some(esize) => mk().binary_expr(BinOpKind::Mul, csize, esize),
+                    Some(esize) => mk().binary_expr(BinOp::Mul(Default::default()), csize, esize),
                 };
                 Some(val)
             }
@@ -2902,12 +3004,12 @@ impl<'c> Translation<'c> {
 
                             let local = mk().local(
                                 mk().ident_pat(name),
-                                None as Option<P<Ty>>,
+                                None as Option<Box<Type>>,
                                 Some(mk().cast_expr(expr, mk().path_ty(vec!["usize"]))),
                             );
 
                             let res: Result<WithStmts<()>, TranslationError> = Ok(
-                                WithStmts::new(vec![mk().local_stmt(P(local))], ())
+                                WithStmts::new(vec![mk().local_stmt(Box::new(local))], ())
                             );
                             res
                         })?;
@@ -2927,7 +3029,7 @@ impl<'c> Translation<'c> {
         &self,
         ctx: ExprContext,
         type_id: CTypeId,
-    ) -> Result<WithStmts<P<Expr>>, TranslationError> {
+    ) -> Result<WithStmts<Box<Expr>>, TranslationError> {
         if let CTypeKind::VariableArray(elts, len) = self.ast_context.resolve_type(type_id).kind {
             let len = len.expect("Sizeof a VLA type with count expression omitted");
 
@@ -2936,7 +3038,7 @@ impl<'c> Translation<'c> {
                 let len = self.convert_expr(ctx.used().not_static(), len)?;
                 Ok(len.map(|len| {
                     let rhs = cast_int(len, "usize", true);
-                    mk().binary_expr(BinOpKind::Mul, lhs, rhs)
+                    mk().binary_expr(BinOp::Mul(Default::default()), lhs, rhs)
                 }))
             });
         }
@@ -2946,18 +3048,17 @@ impl<'c> Translation<'c> {
 
     fn compute_size_of_ty(
         &self,
-        ty: P<Ty>,
-    ) -> Result<WithStmts<P<Expr>>, TranslationError> {
+        ty: Box<Type>,
+    ) -> Result<WithStmts<Box<Expr>>, TranslationError> {
         let std_or_core = if self.tcfg.emit_no_std { "core" } else { "std" };
         let name = "size_of";
         let params = mk().angle_bracketed_args(vec![ty]);
         let path = vec![
-            mk().path_segment(""),
             mk().path_segment(std_or_core),
             mk().path_segment("mem"),
             mk().path_segment_with_args(name, params),
         ];
-        let call = mk().call_expr(mk().path_expr(path), vec![] as Vec<P<Expr>>);
+        let call = mk().call_expr(mk().abs_path_expr(path), vec![] as Vec<Box<Expr>>);
 
         Ok(WithStmts::new_val(call))
     }
@@ -2966,12 +3067,12 @@ impl<'c> Translation<'c> {
         &self,
         mut type_id: CTypeId,
         preferred: bool,
-    ) -> Result<WithStmts<P<Expr>>, TranslationError> {
+    ) -> Result<WithStmts<Box<Expr>>, TranslationError> {
         type_id = self.variable_array_base_type(type_id);
 
         let ty = self.convert_type(type_id)?;
         let tys = vec![ty];
-        let mut path = vec![mk().path_segment("")];
+        let mut path = vec![];
         if self.tcfg.emit_no_std {
             path.push(mk().path_segment("core"));
         } else {
@@ -2985,12 +3086,12 @@ impl<'c> Translation<'c> {
             path.push(mk().path_segment("mem"));
             path.push(mk().path_segment_with_args("align_of", mk().angle_bracketed_args(tys)));
         }
-        let call = mk().call_expr(mk().path_expr(path), vec![] as Vec<P<Expr>>);
+        let call = mk().call_expr(mk().abs_path_expr(path), vec![] as Vec<Box<Expr>>);
         Ok(WithStmts::new_val(call))
     }
 
     fn convert_exprs(&self, ctx: ExprContext, exprs: &[CExprId])
-                     -> Result<WithStmts<Vec<P<Expr>>>, TranslationError>
+                     -> Result<WithStmts<Vec<Box<Expr>>>, TranslationError>
     {
         exprs
             .iter()
@@ -3011,7 +3112,7 @@ impl<'c> Translation<'c> {
         &self,
         mut ctx: ExprContext,
         expr_id: CExprId,
-    ) -> Result<WithStmts<P<Expr>>, TranslationError> {
+    ) -> Result<WithStmts<Box<Expr>>, TranslationError> {
         let Located {
             loc: src_loc,
             kind: expr_kind,
@@ -3057,7 +3158,7 @@ impl<'c> Translation<'c> {
                             let inner_size = self.compute_size_of_type(ctx, inner)?;
 
                             if let Some(sz) = self.compute_size_of_expr(arg_ty.ctype) {
-                                inner_size.map(|x| mk().binary_expr(BinOpKind::Mul, sz, x))
+                                inner_size.map(|x| mk().binary_expr(BinOp::Mul(Default::default()), sz, x))
                             } else {
                                 // Otherwise, use the pointer and make a deref of a pointer offset expression
                                 inner_size
@@ -3131,7 +3232,7 @@ impl<'c> Translation<'c> {
                 // Most references to the va_list should refer to the VaList
                 // type, not VaListImpl
                 if !ctx.expecting_valistimpl && self.ast_context.is_va_list(qual_ty.ctype) {
-                    val = mk().method_call_expr(val, "as_va_list", Vec::<P<Expr>>::new());
+                    val = mk().method_call_expr(val, "as_va_list", Vec::<Box<Expr>>::new());
                 }
 
                 // If we are referring to a function and need its address, we
@@ -3146,9 +3247,6 @@ impl<'c> Translation<'c> {
                         if let Some(actual_ty) = actual_ty {
                             // If we're casting a concrete function to
                             // a K&R function pointer type, use transmute
-                            if ctx.is_static || ctx.is_const {
-                                self.use_feature("const_transmute");
-                            }
                             if let Some(cur_file) = *self.cur_file.borrow() {
                                 self.import_type(qual_ty.ctype, cur_file);
                             }
@@ -3163,7 +3261,7 @@ impl<'c> Translation<'c> {
                 if let CTypeKind::VariableArray(..) =
                     self.ast_context.resolve_type(qual_ty.ctype).kind
                 {
-                    val = mk().method_call_expr(val, "as_mut_ptr", vec![] as Vec<P<Expr>>);
+                    val = mk().method_call_expr(val, "as_mut_ptr", vec![] as Vec<Box<Expr>>);
                 }
 
                 let mut res = WithStmts::new_val(val);
@@ -3189,7 +3287,7 @@ impl<'c> Translation<'c> {
                             .expect("Did not find decl_id for offsetof struct")
                     };
                     let name = self.resolve_decl_inner_name(decl_id);
-                    let ty_ident = Nonterminal::NtIdent(mk().ident(name), false);
+                    let ty_ident = mk().ident(name);
 
                     // Field name
                     let field_name = self
@@ -3197,7 +3295,7 @@ impl<'c> Translation<'c> {
                         .borrow()
                         .resolve_field_name(None, *field_id)
                         .expect("Did not find name for offsetof struct field");
-                    let field_ident = Nonterminal::NtIdent(mk().ident(field_name), false);
+                    let field_ident = mk().ident(field_name);
 
                     // Index Expr
                     let expr = self.convert_expr(ctx, *expr_id)?
@@ -3206,19 +3304,18 @@ impl<'c> Translation<'c> {
                             format_err!("Expected Variable offsetof to be a side-effect free")
                         })?;
                     let expr = mk().cast_expr(expr, mk().ident_ty("usize"));
-                    let index_expr = Nonterminal::NtExpr(expr);
+                    use syn::__private::ToTokens;
+                    let index_expr = expr.to_token_stream();
 
                     // offset_of!(Struct, field[expr as usize]) as ty
                     let macro_body = vec![
-                        TokenTree::token(token::Interpolated(Rc::new(ty_ident)), DUMMY_SP),
-                        TokenTree::token(token::Comma, DUMMY_SP),
-                        TokenTree::token(token::Interpolated(Rc::new(field_ident)), DUMMY_SP),
-                        TokenTree::token(token::OpenDelim(DelimToken::Bracket), DUMMY_SP),
-                        TokenTree::token(token::Interpolated(Rc::new(index_expr)), DUMMY_SP),
-                        TokenTree::token(token::CloseDelim(DelimToken::Bracket), DUMMY_SP),
+                        TokenTree::Ident(ty_ident),
+                        TokenTree::Punct(Punct::new(',', Alone)),
+                        TokenTree::Ident(field_ident),
+                        TokenTree::Group(proc_macro2::Group::new(proc_macro2::Delimiter::Bracket, index_expr)),
                     ];
                     let path = mk().path("offset_of");
-                    let mac = mk().mac_expr(mk().mac(path, macro_body, MacDelimiter::Parenthesis));
+                    let mac = mk().mac_expr(mk().mac(path, macro_body, MacroDelimiter::Paren(Default::default())));
 
                     // Cast type
                     let cast_ty = self.convert_type(ty.ctype)?;
@@ -3284,8 +3381,8 @@ impl<'c> Translation<'c> {
 
                 if ctx.is_unused() {
                     let is_unsafe = lhs.is_unsafe() || rhs.is_unsafe();
-                    let then: P<Block> = mk().block(lhs.into_stmts());
-                    let els: P<Expr> = mk().block_expr(mk().block(rhs.into_stmts()));
+                    let then: Box<Block> = mk().block(lhs.into_stmts());
+                    let els: Box<Expr> = mk().block_expr(mk().block(rhs.into_stmts()));
 
                     let mut res = cond.and_then(|c| -> Result<_, TranslationError> {
                         Ok(WithStmts::new(
@@ -3296,8 +3393,8 @@ impl<'c> Translation<'c> {
                     res.merge_unsafe(is_unsafe);
                     Ok(res)
                 } else {
-                    let then: P<Block> = lhs.to_block();
-                    let els: P<Expr> = rhs.to_expr();
+                    let then: Box<Block> = lhs.to_block();
+                    let els: Box<Expr> = rhs.to_expr();
 
                     Ok(cond.map(|c| {
                         let ifte_expr = mk().ifte_expr(c, then, Some(els));
@@ -3322,7 +3419,7 @@ impl<'c> Translation<'c> {
                             vec![mk().semi_stmt(mk().ifte_expr(
                                 val,
                                 mk().block(rhs.into_stmts()),
-                                None as Option<P<Expr>>,
+                                None as Option<Box<Expr>>,
                             ))],
                             self.panic_or_err(
                                 "Binary conditional expression is not supposed to be used",
@@ -3495,28 +3592,22 @@ impl<'c> Translation<'c> {
                     // Function pointer call
                     _ => {
                         let callee = self.convert_expr(ctx.used(), func)?;
-                        let make_fn_ty = |ret_ty: P<Ty>| {
-                            let ret_ty = match ret_ty.kind {
-                                TyKind::Tup(ref v) if v.is_empty() => FunctionRetTy::Default(DUMMY_SP),
-                                _ => FunctionRetTy::Ty(ret_ty),
+                        let make_fn_ty = |ret_ty: Box<Type>| {
+                            let ret_ty = match *ret_ty {
+                                Type::Tuple(TypeTuple {elems: ref v, ..}) if v.is_empty() => ReturnType::Default,
+                                _ => ReturnType::Type(Default::default(), ret_ty),
                             };
-                            mk().barefn_ty(
-                                mk().fn_decl(
-                                    vec![
-                                        mk().arg(
-                                            mk().infer_ty(),
-                                            mk().wild_pat(),
-                                        );
-                                        args.len()
-                                    ],
-                                    ret_ty,
-                                )
-                            )
+                            let bare_ty : (Vec<BareFnArg>, Option<Variadic>, ReturnType) = (
+                                vec![mk().bare_arg(mk().infer_ty(), None::<Box<Ident>>); args.len()],
+                                None,
+                                ret_ty
+                            );
+                            let bare_ty = Box::new(bare_ty);
+                            mk().barefn_ty(bare_ty)
                         };
                         match fn_ty {
                             Some(CTypeKind::Function(ret_ty, _, _, _, false)) => {
                                 // K&R function pointer without arguments
-                                if ctx.is_const { self.use_feature("const_transmute"); }
                                 let ret_ty = self.convert_type(ret_ty.ctype)?;
                                 let target_ty = make_fn_ty(ret_ty);
                                 callee.map(|fn_ptr| {
@@ -3526,7 +3617,6 @@ impl<'c> Translation<'c> {
                             }
                             None => {
                                 // We have to infer the return type from our expression type
-                                if ctx.is_const { self.use_feature("const_transmute"); }
                                 let ret_ty = self.convert_type(call_expr_ty.ctype)?;
                                 let target_ty = make_fn_ty(ret_ty);
                                 callee.map(|fn_ptr| {
@@ -3577,7 +3667,7 @@ impl<'c> Translation<'c> {
                                 self.convert_expr(ctx, subexpr_id)?
                             } else {
                                 let val = self.convert_expr(ctx, expr)?;
-                                val.map(|v| mk().unary_expr(ast::UnOp::Deref, v))
+                                val.map(|v| mk().unary_expr(UnOp::Deref(Default::default()), v))
                             }
                         }
                     };
@@ -3586,7 +3676,7 @@ impl<'c> Translation<'c> {
                     if self.ast_context.has_inner_struct_decl(record_id) {
                         // The structure is split into an outer and an inner,
                         // so we need to go through the outer structure to the inner one
-                        val = val.map(|v| mk().field_expr(v, "0"));
+                        val = val.map(|v| mk().anon_field_expr(v, 0));
                     };
 
                     let field_name = self
@@ -3612,7 +3702,7 @@ impl<'c> Translation<'c> {
                         // to and will have to be handled elsewhere, IE `bf.set_a(1)`
                         if !ctx.is_bitfield_write {
                             // Cases A and B above
-                            val = val.map(|v| mk().method_call_expr(v, field_name, vec![] as Vec<P<Expr>>));
+                            val = val.map(|v| mk().method_call_expr(v, field_name, vec![] as Vec<Box<Expr>>));
                         }
                     } else {
                         val = val.map(|v| mk().field_expr(v, field_name));
@@ -3671,26 +3761,26 @@ impl<'c> Translation<'c> {
         }
     }
 
-    pub fn convert_constant(&self, constant: ConstIntExpr) -> Result<P<Expr>, TranslationError> {
+    pub fn convert_constant(&self, constant: ConstIntExpr) -> Result<Box<Expr>, TranslationError> {
         let expr = match constant {
             ConstIntExpr::U(n) => {
-                mk().lit_expr(mk().int_lit(n as u128, LitIntType::Unsuffixed))
+                mk().lit_expr(mk().int_unsuffixed_lit(n as u128))
             }
 
             ConstIntExpr::I(n) if n >= 0 => {
-                mk().lit_expr(mk().int_lit(n as u128, LitIntType::Unsuffixed))
+                mk().lit_expr(mk().int_unsuffixed_lit(n as u128))
             }
 
             ConstIntExpr::I(n) => mk().unary_expr(
-                syntax::ast::UnOp::Neg,
-                mk().lit_expr(mk().int_lit((-n) as u128, LitIntType::Unsuffixed)),
+                UnOp::Neg(Default::default()),
+                mk().lit_expr(mk().int_unsuffixed_lit((-n) as u128)),
             ),
         };
         Ok(expr)
     }
 
     fn convert_macro_expansion(&self, ctx: ExprContext, expr_id: CExprId)
-                               -> Result<Option<WithStmts<P<Expr>>>, TranslationError> {
+                               -> Result<Option<WithStmts<Box<Expr>>>, TranslationError> {
         if let Some(macs) = self.ast_context.macro_invocations.get(&expr_id) {
             // Find the first macro after the macro we're currently
             // expanding, if any.
@@ -3750,19 +3840,13 @@ impl<'c> Translation<'c> {
     }
 
     fn convert_macro_invocation(&self, _ctx: ExprContext, text: &str)
-                                -> Option<WithStmts<P<Expr>>> {
+                                -> Option<WithStmts<Box<Expr>>> {
         let mut split = text.splitn(2, '(');
         let ident = split.next()?;
         let args = split.next()?.trim_end_matches(')');
 
-        let parse_sess = ParseSess::new(FilePathMapping::empty());
-        let ts = parse_stream_from_source_str(
-            FileName::Anon(0),
-            args.to_string(),
-            &parse_sess,
-            None,
-        );
-        Some(WithStmts::new_val(mk().mac_expr(mk().mac(ident, ts, MacDelimiter::Parenthesis))))
+        let ts: TokenStream = syn::parse_str(&args.to_string()).ok()?;
+        Some(WithStmts::new_val(mk().mac_expr(mk().mac(ident, ts, MacroDelimiter::Paren(Default::default())))))
     }
 
     /// If `ctx` is unused, convert `expr` to a semi statement, otherwise return
@@ -3770,9 +3854,9 @@ impl<'c> Translation<'c> {
     fn convert_side_effects_expr(
         &self,
         ctx: ExprContext,
-        expr: WithStmts<P<Expr>>,
+        expr: WithStmts<Box<Expr>>,
         panic_msg: &str,
-    ) -> Result<WithStmts<P<Expr>>, TranslationError> {
+    ) -> Result<WithStmts<Box<Expr>>, TranslationError> {
         if ctx.is_unused() {
             // Recall that if `used` is false, the `stmts` field of the output must contain
             // all side-effects (and a function call can always have side-effects)
@@ -3791,19 +3875,17 @@ impl<'c> Translation<'c> {
         &self,
         ctx: ExprContext,
         compound_stmt_id: CStmtId,
-    ) -> Result<WithStmts<P<Expr>>, TranslationError> {
-        fn as_semi_break_stmt(stmt: &ast::Stmt, lbl: &cfg::Label) -> Option<Option<P<ast::Expr>>> {
-            if let ast::Stmt {
-                kind: ast::StmtKind::Semi(ref expr),
-                ..
-            } = *stmt
+    ) -> Result<WithStmts<Box<Expr>>, TranslationError> {
+        fn as_semi_break_stmt(stmt: &Stmt, lbl: &cfg::Label) -> Option<Option<Box<Expr>>> {
+            if let Stmt::Semi(ref expr, _) = *stmt
             {
-                if let ast::Expr {
-                    kind: ast::ExprKind::Break(Some(ref blbl), ref ret_val),
+                if let Expr::Break(ExprBreak {
+                    label: Some(ref blbl),
+                    expr: ref ret_val,
                     ..
-                } = **expr
+                }) = *expr
                 {
-                    if blbl.ident == mk().label(lbl.pretty_print()).ident {
+                    if blbl.ident == mk().label(lbl.pretty_print()).name.ident {
                         return Some(ret_val.clone());
                     }
                 }
@@ -3847,7 +3929,7 @@ impl<'c> Translation<'c> {
                             // https://github.com/rust-lang/rust/issues/54482
                             let val = mk().paren_expr(block);
                             let stmts = if ctx.is_unused() {
-                                vec![mk().expr_stmt(val.clone())]
+                                vec![mk().semi_stmt(val.clone())]
                             } else {
                                 Vec::new()
                             };
@@ -3862,7 +3944,7 @@ impl<'c> Translation<'c> {
                 }
 
                 let block_body = mk().block(stmts.clone());
-                let val: P<Expr> = mk().labelled_block_expr(block_body, lbl.pretty_print());
+                let val: Box<Expr> = mk().labelled_block_expr(block_body, lbl.pretty_print());
 
                 Ok(WithStmts::new(stmts, val))
             }
@@ -3883,11 +3965,11 @@ impl<'c> Translation<'c> {
         ctx: ExprContext,
         source_ty: CQualTypeId,
         ty: CQualTypeId,
-        val: WithStmts<P<Expr>>,
+        val: WithStmts<Box<Expr>>,
         expr: Option<CExprId>,
         kind: Option<CastKind>,
         opt_field_id: Option<CFieldId>,
-    ) -> Result<WithStmts<P<Expr>>, TranslationError> {
+    ) -> Result<WithStmts<Box<Expr>>, TranslationError> {
         let source_ty_kind = &self.ast_context.resolve_type(source_ty.ctype).kind;
         let target_ty_kind = &self.ast_context.resolve_type(ty.ctype).kind;
 
@@ -3958,9 +4040,6 @@ impl<'c> Translation<'c> {
                     if self.ast_context.is_function_pointer(ty.ctype)
                         || self.ast_context.is_function_pointer(source_ty.ctype)
                     {
-                        if ctx.is_static || ctx.is_const {
-                            self.use_feature("const_transmute");
-                        }
                         let source_ty = self.convert_type(source_ty.ctype)?;
                         let target_ty = self.convert_type(ty.ctype)?;
                         Ok(WithStmts::new_unsafe_val(transmute_expr(
@@ -3978,9 +4057,6 @@ impl<'c> Translation<'c> {
             }
 
             CastKind::IntegralToPointer if self.ast_context.is_function_pointer(ty.ctype) => {
-                if ctx.is_static || ctx.is_const {
-                    self.use_feature("const_transmute");
-                }
                 let target_ty = self.convert_type(ty.ctype)?;
                 val.and_then(|x| {
                     let intptr_t = mk().path_ty(vec!["libc", "intptr_t"]);
@@ -4019,9 +4095,6 @@ impl<'c> Translation<'c> {
                     // unless the cast is to a function pointer then use `transmute`.
                     val.and_then(|x| {
                         if self.ast_context.is_function_pointer(source_ty_ctype_id) {
-                            if ctx.is_static || ctx.is_const {
-                                self.use_feature("const_transmute");
-                            }
                             Ok(WithStmts::new_unsafe_val(transmute_expr(source_ty, target_ty, x, self.tcfg.emit_no_std)))
                         } else {
                             Ok(WithStmts::new_val(mk().cast_expr(x, target_ty)))
@@ -4080,7 +4153,7 @@ impl<'c> Translation<'c> {
                             };
 
                             let call = val
-                                .map(|x| mk().method_call_expr(x, method, vec![] as Vec<P<Expr>>));
+                                .map(|x| mk().method_call_expr(x, method, vec![] as Vec<Box<Expr>>));
 
                             // Static arrays can now use as_ptr. Can also cast that const ptr to a
                             // mutable pointer as we do here:
@@ -4161,9 +4234,9 @@ impl<'c> Translation<'c> {
     /// Cast a f128 to some other int or float type
     fn f128_cast_to(
         &self,
-        val: WithStmts<P<Expr>>,
+        val: WithStmts<Box<Expr>>,
         target_ty_ctype: &CTypeKind,
-    ) -> Result<WithStmts<P<Expr>>, TranslationError> {
+    ) -> Result<WithStmts<Box<Expr>>, TranslationError> {
         self.use_crate(ExternCrate::NumTraits);
 
         self.with_cur_file_item_store(|item_store| {
@@ -4194,12 +4267,12 @@ impl<'c> Translation<'c> {
         };
 
         Ok(val.map(|val| {
-            let to_call = mk().method_call_expr(val, to_method_name, Vec::<P<Expr>>::new());
+            let to_call = mk().method_call_expr(val, to_method_name, Vec::<Box<Expr>>::new());
 
             mk().method_call_expr(
                 to_call,
                 "unwrap",
-                Vec::<P<Expr>>::new(),
+                Vec::<Box<Expr>>::new(),
             )
         }))
     }
@@ -4215,10 +4288,10 @@ impl<'c> Translation<'c> {
         enum_type: CTypeId,
         enum_decl: CEnumId, // ID of the enum declaration corresponding to the target type
         expr: CExprId,      // ID of initial C argument to cast
-        val: WithStmts<P<Expr>>, // translated Rust argument to cast
-        _source_ty: P<Ty>,  // source type of cast
-        target_ty: P<Ty>,   // target type of cast
-    ) -> WithStmts<P<Expr>> {
+        val: WithStmts<Box<Expr>>, // translated Rust argument to cast
+        _source_ty: Box<Type>,  // source type of cast
+        target_ty: Box<Type>,   // target type of cast
+    ) -> WithStmts<Box<Expr>> {
         // Extract the IDs of the `EnumConstant` decls underlying the enum.
         let variants = match self.ast_context.index(enum_decl).kind {
             CDeclKind::Enum { ref variants, .. } => variants,
@@ -4230,8 +4303,9 @@ impl<'c> Translation<'c> {
             // we are casting to. Here, we can just remove the extraneous cast instead of generating
             // a new one.
             CExprKind::DeclRef(_, decl_id, _) if variants.contains(&decl_id) => {
-                return val.map(|x| match x.kind {
-                    ast::ExprKind::Cast(ref e, _) => e.clone(),
+                return val.map(|x| match *x {
+                    Expr::Paren(ExprParen {expr: box Expr::Cast(ExprCast {ref expr, ..}), ..}) |
+                    Expr::Cast(ExprCast {ref expr, ..}) => expr.clone(),
                     _ => panic!(format!(
                         "DeclRef {:?} of enum {:?} is not cast",
                         expr, enum_decl
@@ -4263,14 +4337,14 @@ impl<'c> Translation<'c> {
         &self,
         ty_id: CTypeId,
         is_static: bool,
-    ) -> Result<WithStmts<P<Expr>>, TranslationError> {
+    ) -> Result<WithStmts<Box<Expr>>, TranslationError> {
         let resolved_ty_id = self.ast_context.resolve_type_id(ty_id);
         let resolved_ty = &self.ast_context.index(resolved_ty_id).kind;
 
         if resolved_ty.is_bool() {
             Ok(WithStmts::new_val(mk().lit_expr(mk().bool_lit(false))))
         } else if resolved_ty.is_integral_type() {
-            Ok(WithStmts::new_val(mk().lit_expr(mk().int_lit(0, LitIntType::Unsuffixed))))
+            Ok(WithStmts::new_val(mk().lit_expr(mk().int_unsuffixed_lit(0))))
         } else if resolved_ty.is_floating_type() {
             match self.ast_context[ty_id].kind {
                 CTypeKind::LongDouble => Ok(WithStmts::new_val(mk().path_expr(vec!["f128", "f128", "ZERO"]))),
@@ -4280,12 +4354,12 @@ impl<'c> Translation<'c> {
             self.null_ptr(resolved_ty_id, is_static)
                 .map(WithStmts::new_val)
         } else if let &CTypeKind::ConstantArray(elt, sz) = resolved_ty {
-            let sz = mk().lit_expr(mk().int_lit(sz as u128, LitIntType::Unsuffixed));
+            let sz = mk().lit_expr(mk().int_unsuffixed_lit(sz as u128));
             Ok(self.implicit_default_expr(elt, is_static)?
                 .map(|elt| mk().repeat_expr(elt, sz)))
         } else if let &CTypeKind::IncompleteArray(_) = resolved_ty {
             // Incomplete arrays are translated to zero length arrays
-            Ok(WithStmts::new_val(mk().array_expr(vec![] as Vec<P<Expr>>)))
+            Ok(WithStmts::new_val(mk().array_expr(vec![] as Vec<Box<Expr>>)))
         } else if let Some(decl_id) = resolved_ty.as_underlying_decl() {
             self.zero_initializer(decl_id, ty_id, is_static)
         } else if let &CTypeKind::VariableArray(elt, _) = resolved_ty {
@@ -4310,7 +4384,7 @@ impl<'c> Translation<'c> {
         decl_id: CDeclId,
         type_id: CTypeId,
         is_static: bool,
-    ) -> Result<WithStmts<P<Expr>>, TranslationError> {
+    ) -> Result<WithStmts<Box<Expr>>, TranslationError> {
         if let Some(file_id) = self.cur_file.borrow().as_ref() {
             self.import_type(type_id, *file_id);
         }
@@ -4432,48 +4506,54 @@ impl<'c> Translation<'c> {
     }
 
     /// Convert a boolean expression to a boolean for use in && or || or if
-    fn match_bool(&self, target: bool, ty_id: CTypeId, val: P<Expr>) -> P<Expr> {
+    fn match_bool(&self, target: bool, ty_id: CTypeId, val: Box<Expr>) -> Box<Expr> {
         let ty = &self.ast_context.resolve_type(ty_id).kind;
 
         if self.ast_context.is_function_pointer(ty_id) {
             if target {
-                mk().method_call_expr(val, "is_some", vec![] as Vec<P<Expr>>)
+                mk().method_call_expr(val, "is_some", vec![] as Vec<Box<Expr>>)
             } else {
-                mk().method_call_expr(val, "is_none", vec![] as Vec<P<Expr>>)
+                mk().method_call_expr(val, "is_none", vec![] as Vec<Box<Expr>>)
             }
         } else if ty.is_pointer() {
-            let mut res = mk().method_call_expr(val, "is_null", vec![] as Vec<P<Expr>>);
+            let mut res = mk().method_call_expr(val, "is_null", vec![] as Vec<Box<Expr>>);
             if target {
-                res = mk().unary_expr(ast::UnOp::Not, res)
+                res = mk().unary_expr(UnOp::Not(Default::default()), res)
             }
             res
         } else if ty.is_bool() {
             if target {
                 val
             } else {
-                mk().unary_expr(ast::UnOp::Not, val)
+                mk().unary_expr(UnOp::Not(Default::default()), val)
             }
         } else {
             // One simplification we can make at the cost of inspecting `val` more closely: if `val`
             // is already in the form `(x <op> y) as <ty>` where `<op>` is a Rust operator
             // that returns a boolean, we can simple output `x <op> y` or `!(x <op> y)`.
-            if let ExprKind::Cast(ref arg, _) = val.kind {
-                if let ExprKind::Binary(op, _, _) = arg.kind {
-                    match op.node {
-                        BinOpKind::Or
-                        | BinOpKind::And
-                        | BinOpKind::Eq
-                        | BinOpKind::Ne
-                        | BinOpKind::Lt
-                        | BinOpKind::Le
-                        | BinOpKind::Gt
-                        | BinOpKind::Ge => {
+            fn unparen(expr: &Box<Expr>) -> &Box<Expr> {
+                match **expr {
+                    Expr::Paren(ExprParen { ref expr, .. }) => expr,
+                    _ => expr,
+                }
+            }
+            if let Expr::Cast(ExprCast { expr: ref arg, ..}) = **unparen(&val) {
+                if let Expr::Binary(ExprBinary {op, ..}) = **unparen(arg) {
+                    match op {
+                        BinOp::Or(_)
+                        | BinOp::And(_)
+                        | BinOp::Eq(_)
+                        | BinOp::Ne(_)
+                        | BinOp::Lt(_)
+                        | BinOp::Le(_)
+                        | BinOp::Gt(_)
+                        | BinOp::Ge(_) => {
                             if target {
                                 // If target == true, just return the argument
-                                return arg.clone();
+                                return unparen(arg).clone();
                             } else {
                                 // If target == false, return !arg
-                                return mk().unary_expr(ast::UnOp::Not, arg.clone());
+                                return mk().unary_expr(UnOp::Not(Default::default()), unparen(arg).clone());
                             }
                         }
                         _ => {}
@@ -4491,13 +4571,13 @@ impl<'c> Translation<'c> {
             let zero = if ty.is_floating_type() {
                 mk().lit_expr(mk().float_unsuffixed_lit("0."))
             } else {
-                mk().lit_expr(mk().int_lit(0, LitIntType::Unsuffixed))
+                mk().lit_expr(mk().int_unsuffixed_lit(0))
             };
 
             if target {
-                mk().binary_expr(BinOpKind::Ne, val, zero)
+                mk().binary_expr(BinOp::Ne(Default::default()), val, zero)
             } else {
-                mk().binary_expr(BinOpKind::Eq, val, zero)
+                mk().binary_expr(BinOp::Eq(Default::default()), val, zero)
             }
         }
     }
@@ -4514,11 +4594,12 @@ impl<'c> Translation<'c> {
 
     /// If we're trying to organize item definitions into submodules, add them to a module
     /// scoped "namespace" if we have a path available, otherwise add it to the global "namespace"
-    fn insert_item(&self, mut item: P<Item>, decl: &CDecl) {
+    fn insert_item(&self, mut item: Box<Item>, decl: &CDecl) {
         let decl_file_id = self.ast_context.file_id(decl);
 
         if self.tcfg.reorganize_definitions {
-            add_src_loc_attr(&mut item.attrs, &decl.loc.as_ref().map(|x| x.begin()));
+            let attrs = item_attrs(&mut item).expect("no attrs field on unexpected item variant");
+            add_src_loc_attr(attrs, &decl.loc.as_ref().map(|x| x.begin()));
             let mut item_stores = self.items.borrow_mut();
             let items = item_stores
                 .entry(decl_file_id.unwrap())
@@ -4536,7 +4617,8 @@ impl<'c> Translation<'c> {
         let decl_file_id = self.ast_context.file_id(decl);
 
         if self.tcfg.reorganize_definitions {
-            add_src_loc_attr(&mut item.attrs, &decl.loc.as_ref().map(|x| x.begin()));
+            let attrs = foreign_item_attrs(&mut item).expect("no attrs field on unexpected foreign item variant");
+            add_src_loc_attr(attrs, &decl.loc.as_ref().map(|x| x.begin()));
             let mut items = self.items.borrow_mut();
             let mod_block_items = items
                 .entry(decl_file_id.unwrap())
diff --git a/c2rust-transpile/src/translator/named_references.rs b/c2rust-transpile/src/translator/named_references.rs
index b3f7088e09..990aed44cf 100644
--- a/c2rust-transpile/src/translator/named_references.rs
+++ b/c2rust-transpile/src/translator/named_references.rs
@@ -12,7 +12,7 @@ impl<'c> Translation<'c> {
         &self,
         ctx: ExprContext,
         reference: CExprId,
-    ) -> Result<WithStmts<P<Expr>>, TranslationError> {
+    ) -> Result<WithStmts<Box<Expr>>, TranslationError> {
         self.name_reference(ctx, reference, false)
             .map(|ws| ws.map(|(lvalue, _)| lvalue))
     }
@@ -24,7 +24,7 @@ impl<'c> Translation<'c> {
         &self,
         ctx: ExprContext,
         reference: CExprId,
-    ) -> Result<WithStmts<(P<Expr>, P<Expr>)>, TranslationError> {
+    ) -> Result<WithStmts<(Box<Expr>, Box<Expr>)>, TranslationError> {
         let msg: &str = "When called with `uses_read = true`, `name_reference` should always \
                          return an rvalue (something from which to read the memory location)";
 
@@ -45,7 +45,7 @@ impl<'c> Translation<'c> {
         ctx: ExprContext,
         reference: CExprId,
         uses_read: bool,
-    ) -> Result<WithStmts<(P<Expr>, Option<P<Expr>>)>, TranslationError> {
+    ) -> Result<WithStmts<(Box<Expr>, Option<Box<Expr>>)>, TranslationError> {
         let reference_ty = self
             .ast_context
             .index(reference)
@@ -56,28 +56,28 @@ impl<'c> Translation<'c> {
         reference.and_then(|reference| {
             /// Check if something is a valid Rust lvalue. Inspired by `librustc::ty::expr_is_lval`.
             fn is_lvalue(e: &Expr) -> bool {
-                match e.kind {
-                    ExprKind::Path(..)
-                        | ExprKind::Unary(ast::UnOp::Deref, _)
-                        | ExprKind::Field(..)
-                        | ExprKind::Index(..) => true,
+                match e {
+                    Expr::Path(..)
+                        | Expr::Unary(ExprUnary {op: syn::UnOp::Deref(_), ..})
+                        | Expr::Field(..)
+                        | Expr::Index(..) => true,
                     _ => false,
                 }
             }
 
             // Check if something is a side-effect free Rust lvalue.
             fn is_simple_lvalue(e: &Expr) -> bool {
-                match e.kind {
-                    ExprKind::Path(..) => true,
-                    ExprKind::Unary(ast::UnOp::Deref, ref e)
-                        | ExprKind::Field(ref e, _)
-                        | ExprKind::Index(ref e, _) => is_simple_lvalue(e),
+                match e {
+                    Expr::Path(..) => true,
+                    Expr::Unary(ExprUnary {op: syn::UnOp::Deref(_), ref expr, ..})
+                        | Expr::Field(ExprField {base: ref expr, ..})
+                        | Expr::Index(ExprIndex {ref expr, ..}) => is_simple_lvalue(expr),
                     _ => false,
                 }
             }
 
             // Given the LHS access to a variable, produce the RHS one
-            let read = |write: P<Expr>| -> Result<P<Expr>, TranslationError> {
+            let read = |write: Box<Expr>| -> Result<Box<Expr>, TranslationError> {
                 if reference_ty.qualifiers.is_volatile {
                     self.volatile_read(&write, reference_ty)
                 } else {
@@ -95,13 +95,13 @@ impl<'c> Translation<'c> {
                 let ptr_name = self.renamer.borrow_mut().fresh();
 
                 // let ref mut p = lhs;
-                let compute_ref = mk().local_stmt(P(mk().local(
+                let compute_ref = mk().local_stmt(Box::new(mk().local(
                     mk().mutbl().ident_ref_pat(&ptr_name),
-                    None as Option<P<Ty>>,
+                    None as Option<Box<Type>>,
                     Some(reference),
                 )));
 
-                let write = mk().unary_expr(ast::UnOp::Deref, mk().ident_expr(&ptr_name));
+                let write = mk().unary_expr(UnOp::Deref(Default::default()), mk().ident_expr(&ptr_name));
 
                 Ok(WithStmts::new(
                     vec![compute_ref],
diff --git a/c2rust-transpile/src/translator/operators.rs b/c2rust-transpile/src/translator/operators.rs
index 4c840c3502..97daa6d17b 100644
--- a/c2rust-transpile/src/translator/operators.rs
+++ b/c2rust-transpile/src/translator/operators.rs
@@ -2,37 +2,37 @@
 
 use super::*;
 
-fn neg_expr(arg: P<Expr>) -> P<Expr> {
-    mk().unary_expr(ast::UnOp::Neg, arg)
+fn neg_expr(arg: Box<Expr>) -> Box<Expr> {
+    mk().unary_expr(UnOp::Neg(Default::default()), arg)
 }
 
-fn wrapping_neg_expr(arg: P<Expr>) -> P<Expr> {
-    mk().method_call_expr(arg, "wrapping_neg", vec![] as Vec<P<Expr>>)
+fn wrapping_neg_expr(arg: Box<Expr>) -> Box<Expr> {
+    mk().method_call_expr(arg, "wrapping_neg", vec![] as Vec<Box<Expr>>)
 }
 
-impl From<c_ast::BinOp> for BinOpKind {
+impl From<c_ast::BinOp> for BinOp {
     fn from(op: c_ast::BinOp) -> Self {
         match op {
-            c_ast::BinOp::Multiply => BinOpKind::Mul,
-            c_ast::BinOp::Divide => BinOpKind::Div,
-            c_ast::BinOp::Modulus => BinOpKind::Rem,
-            c_ast::BinOp::Add => BinOpKind::Add,
-            c_ast::BinOp::Subtract => BinOpKind::Sub,
-            c_ast::BinOp::ShiftLeft => BinOpKind::Shl,
-            c_ast::BinOp::ShiftRight => BinOpKind::Shr,
-            c_ast::BinOp::Less => BinOpKind::Lt,
-            c_ast::BinOp::Greater => BinOpKind::Gt,
-            c_ast::BinOp::LessEqual => BinOpKind::Le,
-            c_ast::BinOp::GreaterEqual => BinOpKind::Ge,
-            c_ast::BinOp::EqualEqual => BinOpKind::Eq,
-            c_ast::BinOp::NotEqual => BinOpKind::Ne,
-            c_ast::BinOp::BitAnd => BinOpKind::BitAnd,
-            c_ast::BinOp::BitXor => BinOpKind::BitXor,
-            c_ast::BinOp::BitOr => BinOpKind::BitOr,
-            c_ast::BinOp::And => BinOpKind::And,
-            c_ast::BinOp::Or => BinOpKind::Or,
-
-            _ => panic!("C BinOp {:?} is not a valid Rust BinOpKind"),
+            c_ast::BinOp::Multiply => BinOp::Mul(Default::default()),
+            c_ast::BinOp::Divide => BinOp::Div(Default::default()),
+            c_ast::BinOp::Modulus => BinOp::Rem(Default::default()),
+            c_ast::BinOp::Add => BinOp::Add(Default::default()),
+            c_ast::BinOp::Subtract => BinOp::Sub(Default::default()),
+            c_ast::BinOp::ShiftLeft => BinOp::Shl(Default::default()),
+            c_ast::BinOp::ShiftRight => BinOp::Shr(Default::default()),
+            c_ast::BinOp::Less => BinOp::Lt(Default::default()),
+            c_ast::BinOp::Greater => BinOp::Gt(Default::default()),
+            c_ast::BinOp::LessEqual => BinOp::Le(Default::default()),
+            c_ast::BinOp::GreaterEqual => BinOp::Ge(Default::default()),
+            c_ast::BinOp::EqualEqual => BinOp::Eq(Default::default()),
+            c_ast::BinOp::NotEqual => BinOp::Ne(Default::default()),
+            c_ast::BinOp::BitAnd => BinOp::BitAnd(Default::default()),
+            c_ast::BinOp::BitXor => BinOp::BitXor(Default::default()),
+            c_ast::BinOp::BitOr => BinOp::BitOr(Default::default()),
+            c_ast::BinOp::And => BinOp::And(Default::default()),
+            c_ast::BinOp::Or => BinOp::Or(Default::default()),
+
+            _ => panic!("C BinOp {:?} is not a valid Rust BinOp", op),
         }
     }
 }
@@ -48,7 +48,7 @@ impl<'c> Translation<'c> {
         rhs: CExprId,
         opt_lhs_type_id: Option<CQualTypeId>,
         opt_res_type_id: Option<CQualTypeId>,
-    ) -> Result<WithStmts<P<Expr>>, TranslationError> {
+    ) -> Result<WithStmts<Box<Expr>>, TranslationError> {
         // If we're not making an assignment, a binop will require parens
         // applied to ternary conditionals
         if !op.is_assignment() {
@@ -68,7 +68,7 @@ impl<'c> Translation<'c> {
                 let lhs = self.convert_condition(ctx, true, lhs)?;
                 let rhs = self.convert_condition(ctx, true, rhs)?;
                 lhs
-                    .map(|x| bool_to_int(mk().binary_expr(BinOpKind::from(op), x, rhs.to_expr())))
+                    .map(|x| bool_to_int(mk().binary_expr(BinOp::from(op), x, rhs.to_expr())))
                     .and_then(|out| {
                         if ctx.is_unused() {
                             Ok(WithStmts::new(
@@ -173,16 +173,16 @@ impl<'c> Translation<'c> {
     fn convert_assignment_operator_aux(
         &self,
         ctx: ExprContext,
-        bin_op_kind: BinOpKind,
+        bin_op_kind: BinOp,
         bin_op: c_ast::BinOp,
-        read: P<Expr>,
-        write: P<Expr>,
-        rhs: P<Expr>,
+        read: Box<Expr>,
+        write: Box<Expr>,
+        rhs: Box<Expr>,
         compute_lhs_ty: Option<CQualTypeId>,
         compute_res_ty: Option<CQualTypeId>,
         lhs_ty: CQualTypeId,
         rhs_ty: CQualTypeId,
-    ) -> Result<WithStmts<P<Expr>>, TranslationError> {
+    ) -> Result<WithStmts<Box<Expr>>, TranslationError> {
         let compute_lhs_ty = compute_lhs_ty.unwrap();
         let compute_res_ty = compute_res_ty.unwrap();
 
@@ -223,7 +223,6 @@ impl<'c> Translation<'c> {
                 .is_enum();
             let result_type = self.convert_type(lhs_ty.ctype)?;
             let val = if is_enum_result {
-                if ctx.is_const { self.use_feature("const_transmute"); }
                 WithStmts::new_unsafe_val(transmute_expr(lhs_type, result_type, val, self.tcfg.emit_no_std))
             } else {
                 // We can't as-cast from a non primitive like f128 back to the result_type
@@ -249,7 +248,7 @@ impl<'c> Translation<'c> {
         rhs: CExprId,
         compute_type: Option<CQualTypeId>,
         result_type: Option<CQualTypeId>,
-    ) -> Result<WithStmts<P<Expr>>, TranslationError> {
+    ) -> Result<WithStmts<Box<Expr>>, TranslationError> {
         let rhs_type_id = self
             .ast_context
             .index(rhs)
@@ -277,10 +276,10 @@ impl<'c> Translation<'c> {
         qtype: CQualTypeId,
         lhs: CExprId,
         rhs_type_id: CQualTypeId,
-        rhs_translation: WithStmts<P<Expr>>,
+        rhs_translation: WithStmts<Box<Expr>>,
         compute_type: Option<CQualTypeId>,
         result_type: Option<CQualTypeId>,
-    ) -> Result<WithStmts<P<Expr>>, TranslationError> {
+    ) -> Result<WithStmts<Box<Expr>>, TranslationError> {
         let ty = self.convert_type(qtype.ctype)?;
 
         let result_type_id = result_type.unwrap_or(qtype);
@@ -410,7 +409,6 @@ impl<'c> Translation<'c> {
                             let result_type = self.convert_type(qtype.ctype)?;
                             let val = if is_enum_result {
                                 is_unsafe = true;
-                                if ctx.is_const { self.use_feature("const_transmute"); }
                                 transmute_expr(lhs_type, result_type, val, self.tcfg.emit_no_std)
                             } else {
                                 mk().cast_expr(val, result_type)
@@ -444,7 +442,7 @@ impl<'c> Translation<'c> {
 
                     c_ast::BinOp::AssignAdd => self.convert_assignment_operator_aux(
                         ctx,
-                        BinOpKind::Add,
+                        BinOp::AddEq(Default::default()),
                         c_ast::BinOp::Add,
                         read.clone(),
                         write,
@@ -456,7 +454,7 @@ impl<'c> Translation<'c> {
                     )?,
                     c_ast::BinOp::AssignSubtract => self.convert_assignment_operator_aux(
                         ctx,
-                        BinOpKind::Sub,
+                        BinOp::SubEq(Default::default()),
                         c_ast::BinOp::Subtract,
                         read.clone(),
                         write,
@@ -468,7 +466,7 @@ impl<'c> Translation<'c> {
                     )?,
                     c_ast::BinOp::AssignMultiply => self.convert_assignment_operator_aux(
                         ctx,
-                        BinOpKind::Mul,
+                        BinOp::MulEq(Default::default()),
                         c_ast::BinOp::Multiply,
                         read.clone(),
                         write,
@@ -480,7 +478,7 @@ impl<'c> Translation<'c> {
                     )?,
                     c_ast::BinOp::AssignDivide => self.convert_assignment_operator_aux(
                         ctx,
-                        BinOpKind::Div,
+                        BinOp::DivEq(Default::default()),
                         c_ast::BinOp::Divide,
                         read.clone(),
                         write,
@@ -492,7 +490,7 @@ impl<'c> Translation<'c> {
                     )?,
                     c_ast::BinOp::AssignModulus => self.convert_assignment_operator_aux(
                         ctx,
-                        BinOpKind::Rem,
+                        BinOp::RemEq(Default::default()),
                         c_ast::BinOp::Modulus,
                         read.clone(),
                         write,
@@ -504,7 +502,7 @@ impl<'c> Translation<'c> {
                     )?,
                     c_ast::BinOp::AssignBitXor => self.convert_assignment_operator_aux(
                         ctx,
-                        BinOpKind::BitXor,
+                        BinOp::BitXorEq(Default::default()),
                         c_ast::BinOp::BitXor,
                         read.clone(),
                         write,
@@ -516,7 +514,7 @@ impl<'c> Translation<'c> {
                     )?,
                     c_ast::BinOp::AssignShiftLeft => self.convert_assignment_operator_aux(
                         ctx,
-                        BinOpKind::Shl,
+                        BinOp::ShlEq(Default::default()),
                         c_ast::BinOp::ShiftLeft,
                         read.clone(),
                         write,
@@ -528,7 +526,7 @@ impl<'c> Translation<'c> {
                     )?,
                     c_ast::BinOp::AssignShiftRight => self.convert_assignment_operator_aux(
                         ctx,
-                        BinOpKind::Shr,
+                        BinOp::ShrEq(Default::default()),
                         c_ast::BinOp::ShiftRight,
                         read.clone(),
                         write,
@@ -540,7 +538,7 @@ impl<'c> Translation<'c> {
                     )?,
                     c_ast::BinOp::AssignBitOr => self.convert_assignment_operator_aux(
                         ctx,
-                        BinOpKind::BitOr,
+                        BinOp::BitOrEq(Default::default()),
                         c_ast::BinOp::BitOr,
                         read.clone(),
                         write,
@@ -552,7 +550,7 @@ impl<'c> Translation<'c> {
                     )?,
                     c_ast::BinOp::AssignBitAnd => self.convert_assignment_operator_aux(
                         ctx,
-                        BinOpKind::BitAnd,
+                        BinOp::BitAndEq(Default::default()),
                         c_ast::BinOp::BitAnd,
                         read.clone(),
                         write,
@@ -568,7 +566,7 @@ impl<'c> Translation<'c> {
 
                 assign_stmt.and_then(|assign_stmt| {
                     Ok(WithStmts::new(
-                        vec![mk().expr_stmt(assign_stmt)],
+                        vec![mk().semi_stmt(assign_stmt)],
                         read,
                     ))
                 })
@@ -582,14 +580,14 @@ impl<'c> Translation<'c> {
         &self,
         ctx: ExprContext,
         op: c_ast::BinOp,
-        ty: P<Ty>,
+        ty: Box<Type>,
         ctype: CTypeId,
         lhs_type: CQualTypeId,
         rhs_type: CQualTypeId,
-        lhs: P<Expr>,
-        rhs: P<Expr>,
+        lhs: Box<Expr>,
+        rhs: Box<Expr>,
         lhs_rhs_ids: Option<(CExprId, CExprId)>,
-    ) -> Result<P<Expr>, TranslationError> {
+    ) -> Result<Box<Expr>, TranslationError> {
         let is_unsigned_integral_type = self
             .ast_context
             .index(ctype)
@@ -608,7 +606,7 @@ impl<'c> Translation<'c> {
                 }
                 Ok(mk().method_call_expr(lhs, mk().path_segment("wrapping_mul"), vec![rhs]))
             }
-            c_ast::BinOp::Multiply => Ok(mk().binary_expr(BinOpKind::Mul, lhs, rhs)),
+            c_ast::BinOp::Multiply => Ok(mk().binary_expr(BinOp::Mul(Default::default()), lhs, rhs)),
 
             c_ast::BinOp::Divide if is_unsigned_integral_type => {
                 if ctx.is_const {
@@ -618,7 +616,7 @@ impl<'c> Translation<'c> {
                 }
                 Ok(mk().method_call_expr(lhs, mk().path_segment("wrapping_div"), vec![rhs]))
             }
-            c_ast::BinOp::Divide => Ok(mk().binary_expr(BinOpKind::Div, lhs, rhs)),
+            c_ast::BinOp::Divide => Ok(mk().binary_expr(BinOp::Div(Default::default()), lhs, rhs)),
 
             c_ast::BinOp::Modulus if is_unsigned_integral_type => {
                 if ctx.is_const {
@@ -628,12 +626,12 @@ impl<'c> Translation<'c> {
                 }
                 Ok(mk().method_call_expr(lhs, mk().path_segment("wrapping_rem"), vec![rhs]))
             }
-            c_ast::BinOp::Modulus => Ok(mk().binary_expr(BinOpKind::Rem, lhs, rhs)),
+            c_ast::BinOp::Modulus => Ok(mk().binary_expr(BinOp::Rem(Default::default()), lhs, rhs)),
 
-            c_ast::BinOp::BitXor => Ok(mk().binary_expr(BinOpKind::BitXor, lhs, rhs)),
+            c_ast::BinOp::BitXor => Ok(mk().binary_expr(BinOp::BitXor(Default::default()), lhs, rhs)),
 
-            c_ast::BinOp::ShiftRight => Ok(mk().binary_expr(BinOpKind::Shr, lhs, rhs)),
-            c_ast::BinOp::ShiftLeft => Ok(mk().binary_expr(BinOpKind::Shl, lhs, rhs)),
+            c_ast::BinOp::ShiftRight => Ok(mk().binary_expr(BinOp::Shr(Default::default()), lhs, rhs)),
+            c_ast::BinOp::ShiftLeft => Ok(mk().binary_expr(BinOp::Shl(Default::default()), lhs, rhs)),
 
             c_ast::BinOp::EqualEqual => {
                 // Using is_none method for null comparison means we don't have to
@@ -645,14 +643,14 @@ impl<'c> Translation<'c> {
                         && self.ast_context.is_null_expr(lhs_expr_id);
 
                     if fn_eq_null {
-                        mk().method_call_expr(lhs, "is_none", vec![] as Vec<P<Expr>>)
+                        mk().method_call_expr(lhs, "is_none", vec![] as Vec<Box<Expr>>)
                     } else if null_eq_fn {
-                        mk().method_call_expr(rhs, "is_none", vec![] as Vec<P<Expr>>)
+                        mk().method_call_expr(rhs, "is_none", vec![] as Vec<Box<Expr>>)
                     } else {
-                        mk().binary_expr(BinOpKind::Eq, lhs, rhs)
+                        mk().binary_expr(BinOp::Eq(Default::default()), lhs, rhs)
                     }
                 } else {
-                    mk().binary_expr(BinOpKind::Eq, lhs, rhs)
+                    mk().binary_expr(BinOp::Eq(Default::default()), lhs, rhs)
                 };
 
                 Ok(bool_to_int(expr))
@@ -667,25 +665,25 @@ impl<'c> Translation<'c> {
                         && self.ast_context.is_null_expr(lhs_expr_id);
 
                     if fn_eq_null {
-                        mk().method_call_expr(lhs, "is_some", vec![] as Vec<P<Expr>>)
+                        mk().method_call_expr(lhs, "is_some", vec![] as Vec<Box<Expr>>)
                     } else if null_eq_fn {
-                        mk().method_call_expr(rhs, "is_some", vec![] as Vec<P<Expr>>)
+                        mk().method_call_expr(rhs, "is_some", vec![] as Vec<Box<Expr>>)
                     } else {
-                        mk().binary_expr(BinOpKind::Ne, lhs, rhs)
+                        mk().binary_expr(BinOp::Ne(Default::default()), lhs, rhs)
                     }
                 } else {
-                    mk().binary_expr(BinOpKind::Ne, lhs, rhs)
+                    mk().binary_expr(BinOp::Ne(Default::default()), lhs, rhs)
                 };
 
                 Ok(bool_to_int(expr))
             }
-            c_ast::BinOp::Less => Ok(bool_to_int(mk().binary_expr(BinOpKind::Lt, lhs, rhs))),
-            c_ast::BinOp::Greater => Ok(bool_to_int(mk().binary_expr(BinOpKind::Gt, lhs, rhs))),
-            c_ast::BinOp::GreaterEqual => Ok(bool_to_int(mk().binary_expr(BinOpKind::Ge, lhs, rhs))),
-            c_ast::BinOp::LessEqual => Ok(bool_to_int(mk().binary_expr(BinOpKind::Le, lhs, rhs))),
+            c_ast::BinOp::Less => Ok(bool_to_int(mk().binary_expr(BinOp::Lt(Default::default()), lhs, rhs))),
+            c_ast::BinOp::Greater => Ok(bool_to_int(mk().binary_expr(BinOp::Gt(Default::default()), lhs, rhs))),
+            c_ast::BinOp::GreaterEqual => Ok(bool_to_int(mk().binary_expr(BinOp::Ge(Default::default()), lhs, rhs))),
+            c_ast::BinOp::LessEqual => Ok(bool_to_int(mk().binary_expr(BinOp::Le(Default::default()), lhs, rhs))),
 
-            c_ast::BinOp::BitAnd => Ok(mk().binary_expr(BinOpKind::BitAnd, lhs, rhs)),
-            c_ast::BinOp::BitOr => Ok(mk().binary_expr(BinOpKind::BitOr, lhs, rhs)),
+            c_ast::BinOp::BitAnd => Ok(mk().binary_expr(BinOp::BitAnd(Default::default()), lhs, rhs)),
+            c_ast::BinOp::BitOr => Ok(mk().binary_expr(BinOp::BitOr(Default::default()), lhs, rhs)),
 
             op => unimplemented!("Translation of binary operator {:?}", op),
         }
@@ -696,9 +694,9 @@ impl<'c> Translation<'c> {
         ctx: ExprContext,
         lhs_type_id: CQualTypeId,
         rhs_type_id: CQualTypeId,
-        lhs: P<Expr>,
-        rhs: P<Expr>,
-    ) -> Result<P<Expr>, TranslationError> {
+        lhs: Box<Expr>,
+        rhs: Box<Expr>,
+    ) -> Result<Box<Expr>, TranslationError> {
         let lhs_type = &self.ast_context.resolve_type(lhs_type_id.ctype).kind;
         let rhs_type = &self.ast_context.resolve_type(rhs_type_id.ctype).kind;
 
@@ -716,19 +714,19 @@ impl<'c> Translation<'c> {
             }
             Ok(mk().method_call_expr(lhs, mk().path_segment("wrapping_add"), vec![rhs]))
         } else {
-            Ok(mk().binary_expr(BinOpKind::Add, lhs, rhs))
+            Ok(mk().binary_expr(BinOp::Add(Default::default()), lhs, rhs))
         }
     }
 
     fn convert_subtraction(
         &self,
         ctx: ExprContext,
-        ty: P<Ty>,
+        ty: Box<Type>,
         lhs_type_id: CQualTypeId,
         rhs_type_id: CQualTypeId,
-        lhs: P<Expr>,
-        rhs: P<Expr>,
-    ) -> Result<P<Expr>, TranslationError> {
+        lhs: Box<Expr>,
+        rhs: Box<Expr>,
+    ) -> Result<Box<Expr>, TranslationError> {
         let lhs_type = &self.ast_context.resolve_type(lhs_type_id.ctype).kind;
         let rhs_type = &self.ast_context.resolve_type(rhs_type_id.ctype).kind;
 
@@ -738,16 +736,11 @@ impl<'c> Translation<'c> {
                     "Cannot use wrapping offset from in a const expression",
                 ));
             }
-            // The wrapping_offset_from method is locked behind a feature gate
-            // and replaces the now deprecated offset_to (opposite argument order)
-            // wrapping_offset_from panics when the pointee is a ZST
-            self.use_feature("ptr_wrapping_offset_from");
-
-            let mut offset = mk().method_call_expr(lhs, "wrapping_offset_from", vec![rhs]);
+            let mut offset = mk().method_call_expr(lhs, "offset_from", vec![rhs]);
 
             if let Some(sz) = self.compute_size_of_expr(pointee.ctype) {
                 let div = cast_int(sz, "isize", false);
-                offset = mk().binary_expr(BinOpKind::Div, offset, div);
+                offset = mk().binary_expr(BinOp::Div(Default::default()), offset, div);
             }
 
             Ok(mk().cast_expr(offset, ty))
@@ -762,7 +755,7 @@ impl<'c> Translation<'c> {
             }
             Ok(mk().method_call_expr(lhs, mk().path_segment("wrapping_sub"), vec![rhs]))
         } else {
-            Ok(mk().binary_expr(BinOpKind::Sub, lhs, rhs))
+            Ok(mk().binary_expr(BinOp::Sub(Default::default()), lhs, rhs))
         }
     }
 
@@ -772,7 +765,7 @@ impl<'c> Translation<'c> {
         ty: CQualTypeId,
         up: bool,
         arg: CExprId,
-    ) -> Result<WithStmts<P<Expr>>, TranslationError> {
+    ) -> Result<WithStmts<Box<Expr>>, TranslationError> {
         let op = if up {
             c_ast::BinOp::AssignAdd
         } else {
@@ -790,7 +783,7 @@ impl<'c> Translation<'c> {
 
                 mk().call_expr(fn_path, args)
             }
-            _ => mk().lit_expr(mk().int_lit(1, LitIntType::Unsuffixed)),
+            _ => mk().lit_expr(mk().int_unsuffixed_lit(1)),
         };
         let arg_type = self.ast_context[arg]
             .kind
@@ -814,7 +807,7 @@ impl<'c> Translation<'c> {
         ty: CQualTypeId,
         up: bool,
         arg: CExprId,
-    ) -> Result<WithStmts<P<Expr>>, TranslationError> {
+    ) -> Result<WithStmts<Box<Expr>>, TranslationError> {
         // If we aren't going to be using the result, may as well do a simple pre-increment
         if ctx.is_unused() {
             return self.convert_pre_increment(ctx, ty, up, arg);
@@ -830,9 +823,9 @@ impl<'c> Translation<'c> {
         self.name_reference_write_read(ctx, arg)?
             .and_then(|(write, read)| {
                 let val_name = self.renamer.borrow_mut().fresh();
-                let save_old_val = mk().local_stmt(P(mk().local(
+                let save_old_val = mk().local_stmt(Box::new(mk().local(
                     mk().ident_pat(&val_name),
-                    None as Option<P<Ty>>,
+                    None as Option<Box<Type>>,
                     Some(read.clone()),
                 )));
 
@@ -848,7 +841,7 @@ impl<'c> Translation<'c> {
 
                         mk().call_expr(fn_path, args)
                     }
-                    _ => mk().lit_expr(mk().int_lit(1, LitIntType::Unsuffixed)),
+                    _ => mk().lit_expr(mk().int_unsuffixed_lit(1)),
                 };
 
                 // *p + 1
@@ -861,7 +854,7 @@ impl<'c> Translation<'c> {
                         let n = if up {
                             one
                         } else {
-                            mk().unary_expr(ast::UnOp::Neg, one)
+                            mk().unary_expr(UnOp::Neg(Default::default()), one)
                         };
                         mk().method_call_expr(read.clone(), "offset", vec![n])
                     } else {
@@ -879,7 +872,7 @@ impl<'c> Translation<'c> {
                             let m = if up { "wrapping_add" } else { "wrapping_sub" };
                             mk().method_call_expr(read.clone(), m, vec![one])
                         } else {
-                            let k = if up { BinOpKind::Add } else { BinOpKind::Sub };
+                            let k = if up { BinOp::Add(Default::default()) } else { BinOp::Sub(Default::default()) };
                             mk().binary_expr(k, read.clone(), one)
                         }
                     };
@@ -905,7 +898,7 @@ impl<'c> Translation<'c> {
         cqual_type: CQualTypeId,
         arg: CExprId,
         lrvalue: LRValue,
-    ) -> Result<WithStmts<P<Expr>>, TranslationError> {
+    ) -> Result<WithStmts<Box<Expr>>, TranslationError> {
         let CQualTypeId { ctype, .. } = cqual_type;
         let ty = self.convert_type(ctype)?;
         let resolved_ctype = self.ast_context.resolve_type(ctype);
@@ -947,14 +940,14 @@ impl<'c> Translation<'c> {
                     };
 
                     arg.result_map(|a| {
-                        let mut addr_of_arg: P<Expr>;
+                        let mut addr_of_arg: Box<Expr>;
 
                         if ctx.is_static {
                             // static variable initializers aren't able to use &mut,
                             // so we work around that by using & and an extra cast
                             // through & to *const to *mut
                             addr_of_arg = mk().addr_of_expr(a);
-                            if mutbl == Mutability::Mutable {
+                            if let Mutability::Mutable = mutbl {
                                 let mut qtype = pointee_ty;
                                 qtype.qualifiers.is_const = true;
                                 let ty_ = self
@@ -988,7 +981,7 @@ impl<'c> Translation<'c> {
                     }
                     _ => {
                         self.convert_expr(ctx.used(), arg)?
-                            .result_map(|val: P<Expr>| {
+                            .result_map(|val: Box<Expr>| {
                                 if let CTypeKind::Function(..) =
                                     self.ast_context.resolve_type(ctype).kind
                                 {
@@ -996,7 +989,7 @@ impl<'c> Translation<'c> {
                                 } else if let Some(_vla) = self.compute_size_of_expr(ctype) {
                                     Ok(val)
                                 } else {
-                                    let mut val = mk().unary_expr(ast::UnOp::Deref, val);
+                                    let mut val = mk().unary_expr(UnOp::Deref(Default::default()), val);
 
                                     // If the type on the other side of the pointer we are dereferencing is volatile and
                                     // this whole expression is not an LValue, we should make this a volatile read
@@ -1027,7 +1020,7 @@ impl<'c> Translation<'c> {
             }
             c_ast::UnOp::Complement => Ok(self
                 .convert_expr(ctx.used(), arg)?
-                .map(|a| mk().unary_expr(ast::UnOp::Not, a))),
+                .map(|a| mk().unary_expr(UnOp::Not(Default::default()), a))),
 
             c_ast::UnOp::Not => {
                 let val = self.convert_condition(ctx, false, arg)?;
diff --git a/c2rust-transpile/src/translator/simd.rs b/c2rust-transpile/src/translator/simd.rs
index dc1cf553ea..6548dc0cef 100644
--- a/c2rust-transpile/src/translator/simd.rs
+++ b/c2rust-transpile/src/translator/simd.rs
@@ -71,19 +71,24 @@ impl<'c> Translation<'c> {
     /// Given the name of a typedef check if its one of the SIMD types.
     /// This function returns `true` when the name of the type is one that
     /// it knows how to implement and no further translation should be done.
-    pub fn import_simd_typedef(&self, name: &str) -> bool {
-        match name {
+    pub fn import_simd_typedef(&self, name: &str) -> Result<bool, TranslationError> {
+        Ok(match name {
             // Public API SIMD typedefs:
             "__m128i" | "__m128" | "__m128d" | "__m64" | "__m256" | "__m256d" | "__m256i" => {
-                // __m64 is still behind a feature gate
+                // __m64 and MMX support were removed from upstream Rust.
+                // See https://github.com/immunant/c2rust/issues/369
                 if name == "__m64" {
-                    self.use_feature("stdsimd");
+                    Err(format_err!(
+                        "__m64 and MMX are no longer supported, due to removed upstream support. See https://github.com/immunant/c2rust/issues/369"
+                    ))?;
                 }
 
                 self.with_cur_file_item_store(|item_store| {
-                    let x86_attr = mk().call_attr("cfg", vec!["target_arch = \"x86\""]).pub_();
+                    let x86_attr = mk()
+                        .meta_item_attr(AttrStyle::Outer, mk().meta_list("cfg", vec![NestedMeta::Meta (mk().meta_namevalue("target_arch", "x86"))]))
+                        .pub_();
                     let x86_64_attr = mk()
-                        .call_attr("cfg", vec!["target_arch = \"x86_64\""])
+                        .meta_item_attr(AttrStyle::Outer, mk().meta_list("cfg", vec![NestedMeta::Meta(mk().meta_namevalue("target_arch", "x86_64"))]))
                         .pub_();
                     let std_or_core = if self.tcfg.emit_no_std { "core" } else { "std" }.to_string();
 
@@ -138,7 +143,7 @@ impl<'c> Translation<'c> {
             | "__mm_loadh_pi_v2f32"
             | "__mm_loadl_pi_v2f32" => true,
             _ => false,
-        }
+        })
     }
 
     /// Determine if a particular function name is an SIMD primitive. If so an appropriate
@@ -162,7 +167,9 @@ impl<'c> Translation<'c> {
 
                 // REVIEW: Also a linear lookup
                 if !SIMD_X86_64_ONLY.contains(&name) {
-                    let x86_attr = mk().call_attr("cfg", vec!["target_arch = \"x86\""]).pub_();
+                    let x86_attr = mk()
+                        .meta_item_attr(AttrStyle::Outer, mk().meta_list("cfg", vec![NestedMeta::Meta (mk().meta_namevalue("target_arch", "x86"))]))
+                        .pub_();
 
                     item_store.add_use_with_attr(
                         vec![std_or_core.clone(), "arch".into(), "x86".into()],
@@ -172,7 +179,7 @@ impl<'c> Translation<'c> {
                 }
 
                 let x86_64_attr = mk()
-                    .call_attr("cfg", vec!["target_arch = \"x86_64\""])
+                    .meta_item_attr(AttrStyle::Outer, mk().meta_list("cfg", vec![NestedMeta::Meta (mk().meta_namevalue("target_arch", "x86_64"))]))
                     .pub_();
 
                 item_store.add_use_with_attr(
@@ -216,7 +223,7 @@ impl<'c> Translation<'c> {
         ctx: ExprContext,
         fn_name: &str,
         args: &[CExprId],
-    ) -> Result<WithStmts<P<Expr>>, TranslationError> {
+    ) -> Result<WithStmts<Box<Expr>>, TranslationError> {
         self.import_simd_function(fn_name)?;
 
         let mut processed_args = vec![];
@@ -232,7 +239,7 @@ impl<'c> Translation<'c> {
                 Ok(WithStmts::new_val(call))
             } else {
                 Ok(WithStmts::new(
-                    vec![mk().expr_stmt(call)],
+                    vec![mk().semi_stmt(call)],
                     self.panic_or_err("No value for unused shuffle vector return"),
                 ))
             }
@@ -246,7 +253,7 @@ impl<'c> Translation<'c> {
         ctype: CTypeId,
         len: usize,
         is_static: bool,
-    ) -> Result<WithStmts<P<Expr>>, TranslationError> {
+    ) -> Result<WithStmts<Box<Expr>>, TranslationError> {
         // NOTE: This is only for x86/_64, and so support for other architectures
         // might need some sort of disambiguation to be exported
         let (fn_name, bytes) = match (&self.ast_context[ctype].kind, len) {
@@ -270,8 +277,6 @@ impl<'c> Translation<'c> {
         };
 
         if is_static {
-            self.use_feature("const_transmute");
-
             let zero_expr = mk().lit_expr(mk().int_lit(0, "u8"));
             let n_bytes_expr = mk().lit_expr(mk().int_lit(bytes, ""));
             let expr = mk().repeat_expr(zero_expr, n_bytes_expr);
@@ -286,7 +291,7 @@ impl<'c> Translation<'c> {
             self.import_simd_function(fn_name)
                 .expect("None of these fns should be unsupported in rust");
 
-            Ok(WithStmts::new_val(mk().call_expr(mk().ident_expr(fn_name), Vec::new() as Vec<P<Expr>>)))
+            Ok(WithStmts::new_val(mk().call_expr(mk().ident_expr(fn_name), Vec::new() as Vec<Box<Expr>>)))
         }
     }
 
@@ -297,7 +302,7 @@ impl<'c> Translation<'c> {
         ids: &[CExprId],
         ctype: CTypeId,
         len: usize,
-    ) -> Result<WithStmts<P<Expr>>, TranslationError> {
+    ) -> Result<WithStmts<Box<Expr>>, TranslationError> {
         let param_translation = self.convert_exprs(ctx, ids)?;
         param_translation.and_then(|mut params| {
             // When used in a static, we cannot call the standard functions since they
@@ -311,8 +316,6 @@ impl<'c> Translation<'c> {
                     self.tcfg.emit_no_std,
                 );
 
-                self.use_feature("const_transmute");
-
                 transmute
             } else {
                 let fn_call_name = match (&self.ast_context[ctype].kind, len) {
@@ -365,7 +368,7 @@ impl<'c> Translation<'c> {
         &self,
         ctx: ExprContext,
         child_expr_ids: &[CExprId],
-    ) -> Result<WithStmts<P<Expr>>, TranslationError> {
+    ) -> Result<WithStmts<Box<Expr>>, TranslationError> {
         // There are three shuffle vector functions which are actually functions, not superbuiltins/macros,
         // which do not need to be handled here: _mm_shuffle_pi8, _mm_shuffle_epi8, _mm256_shuffle_epi8
 
diff --git a/c2rust-transpile/src/translator/structs.rs b/c2rust-transpile/src/translator/structs.rs
index e0ea93f5d1..40e5686879 100644
--- a/c2rust-transpile/src/translator/structs.rs
+++ b/c2rust-transpile/src/translator/structs.rs
@@ -11,13 +11,11 @@ use crate::translator::{ExprContext, Translation, PADDING_SUFFIX};
 use crate::with_stmts::WithStmts;
 use c2rust_ast_builder::mk;
 use c2rust_ast_printer::pprust;
-use syntax::ast::{
-    self, AttrStyle, BinOpKind, Expr, ExprKind, Lit, LitIntType, LitKind, MetaItemKind,
-    NestedMetaItem, StmtKind, StrStyle, StructField, Ty, TyKind,
+use syn::{
+    self, AttrStyle, BinOp as RBinOp, Expr, Meta,
+    NestedMeta, Stmt, Field, Type,
+    ExprBlock, ExprAssign, ExprAssignOp, ExprBinary, ExprUnary, ExprMethodCall, ExprCast,
 };
-use syntax::ptr::P;
-use syntax::source_map::symbol::Symbol;
-use syntax_pos::DUMMY_SP;
 
 use itertools::EitherOrBoth::{Both, Right};
 use itertools::Itertools;
@@ -28,7 +26,7 @@ enum FieldType {
         start_bit: u64,
         field_name: String,
         bytes: u64,
-        attrs: Vec<(String, P<Ty>, String)>,
+        attrs: Vec<(String, Box<Type>, String)>,
     },
     Padding {
         bytes: u64,
@@ -39,37 +37,34 @@ enum FieldType {
     Regular {
         name: String,
         ctype: CTypeId,
-        field: StructField,
+        field: Field,
         use_inner_type: bool,
     },
 }
 
-fn contains_block(expr_kind: &ExprKind) -> bool {
+fn contains_block(expr_kind: &Expr) -> bool {
     match expr_kind {
-        ExprKind::Block(..) => true,
-        ExprKind::Assign(lhs, rhs) => contains_block(&lhs.kind) || contains_block(&rhs.kind),
-        ExprKind::AssignOp(_, lhs, rhs) => contains_block(&lhs.kind) || contains_block(&rhs.kind),
-        ExprKind::Binary(_, lhs, rhs) => contains_block(&lhs.kind) || contains_block(&rhs.kind),
-        ExprKind::Unary(_, e) => contains_block(&e.kind),
-        ExprKind::MethodCall(_, exprs) => exprs.iter().map(|e| contains_block(&e.kind)).any(|b| b),
-        ExprKind::Cast(e, _) => contains_block(&e.kind),
+        Expr::Block(..) => true,
+        Expr::Assign(ExprAssign {left, right, ..}) => contains_block(&left) || contains_block(&right),
+        Expr::AssignOp(ExprAssignOp {left, right, ..}) => contains_block(&left) || contains_block(&right),
+        Expr::Binary(ExprBinary {left, right, ..}) => contains_block(&left) || contains_block(&right),
+        Expr::Unary(ExprUnary {expr, ..}) => contains_block(&expr),
+        Expr::MethodCall(ExprMethodCall {args, ..}) => args.iter().map(|e| contains_block(&e)).any(|b| b),
+        Expr::Cast(ExprCast {expr, ..}) => contains_block(&expr),
         _ => false,
     }
 }
 
-fn assigment_metaitem(lhs: &str, rhs: &str) -> NestedMetaItem {
-    let kind = LitKind::Str(Symbol::intern(rhs), StrStyle::Cooked);
-    let token = kind.to_lit_token();
-    let meta_item = mk().meta_item(
-        vec![lhs],
-        MetaItemKind::NameValue(Lit {
-            token,
-            kind,
-            span: DUMMY_SP,
-        }),
-    );
-
-    mk().nested_meta_item(NestedMetaItem::MetaItem(meta_item))
+fn assignment_metaitem(lhs: &str, rhs: &str) -> NestedMeta {
+    use c2rust_ast_builder::Make;
+    let token = rhs.make(&mk());
+    let meta_item = Meta::NameValue(syn::MetaNameValue {
+        path: mk().path(lhs),
+        eq_token: Default::default(),
+        lit: token,
+    });
+
+    NestedMeta::Meta(meta_item)
 }
 
 impl<'a> Translation<'a> {
@@ -277,7 +272,7 @@ impl<'a> Translation<'a> {
         struct_id: CRecordId,
         field_ids: &[CDeclId],
         platform_byte_size: u64,
-    ) -> Result<Vec<StructField>, TranslationError> {
+    ) -> Result<Vec<Field>, TranslationError> {
         let mut field_entries = Vec::with_capacity(field_ids.len());
         // We need to clobber bitfields in consecutive bytes together (leaving
         // regular fields alone) and add in padding as necessary
@@ -303,21 +298,21 @@ impl<'a> Translation<'a> {
                 } => {
                     let ty = mk().array_ty(
                         mk().ident_ty("u8"),
-                        mk().lit_expr(mk().int_lit(bytes.into(), LitIntType::Unsuffixed)),
+                        mk().lit_expr(mk().int_unsuffixed_lit(bytes.into())),
                     );
                     let mut field = mk();
                     let field_attrs = attrs.iter().map(|attr| {
-                        let ty_str = match &attr.1.kind {
-                            TyKind::Path(_, path) => pprust::path_to_string(path),
+                        let ty_str = match &*attr.1 {
+                            Type::Path(syn::TypePath {path, ..}) => pprust::path_to_string(path),
                             _ => unreachable!("Found type other than path"),
                         };
                         let field_attr_items = vec![
-                            assigment_metaitem("name", &attr.0),
-                            assigment_metaitem("ty", &ty_str),
-                            assigment_metaitem("bits", &attr.2),
+                            assignment_metaitem("name", &attr.0),
+                            assignment_metaitem("ty", &ty_str),
+                            assignment_metaitem("bits", &attr.2),
                         ];
 
-                        mk().meta_item("bitfield", MetaItemKind::List(field_attr_items))
+                        mk().meta_list("bitfield", field_attr_items)
                     });
 
                     for field_attr in field_attrs {
@@ -330,15 +325,15 @@ impl<'a> Translation<'a> {
                     let field_name = next_padding_field();
                     let ty = mk().array_ty(
                         mk().ident_ty("u8"),
-                        mk().lit_expr(mk().int_lit(bytes.into(), LitIntType::Unsuffixed)),
+                        mk().lit_expr(mk().int_unsuffixed_lit(bytes.into())),
                     );
 
                     // Mark it with `#[bitfield(padding)]`
-                    let field_padding_inner = mk().meta_item("padding", MetaItemKind::Word);
+                    let field_padding_inner = NestedMeta::Meta(mk().meta_path("padding"));
                     let field_padding_inner =
-                        vec![mk().nested_meta_item(NestedMetaItem::MetaItem(field_padding_inner))];
+                        vec![mk().nested_meta_item(field_padding_inner)];
                     let field_padding_outer =
-                        mk().meta_item("bitfield", MetaItemKind::List(field_padding_inner));
+                        mk().meta_list("bitfield", field_padding_inner);
                     let field = mk()
                         .meta_item_attr(AttrStyle::Outer, field_padding_outer)
                         .pub_()
@@ -381,7 +376,7 @@ impl<'a> Translation<'a> {
         ctx: ExprContext,
         struct_id: CRecordId,
         field_expr_ids: &[CExprId],
-    ) -> Result<WithStmts<P<Expr>>, TranslationError> {
+    ) -> Result<WithStmts<Box<Expr>>, TranslationError> {
         let name = self.resolve_decl_inner_name(struct_id);
 
         let (field_decl_ids, platform_byte_size) = match self.ast_context.index(struct_id).kind {
@@ -421,8 +416,8 @@ impl<'a> Translation<'a> {
                     field_name, bytes, ..
                 } => {
                     let array_expr = mk().repeat_expr(
-                        mk().lit_expr(mk().int_lit(0, LitIntType::Unsuffixed)),
-                        mk().lit_expr(mk().int_lit(bytes.into(), LitIntType::Unsuffixed)),
+                        mk().lit_expr(mk().int_unsuffixed_lit(0)),
+                        mk().lit_expr(mk().int_unsuffixed_lit(bytes.into())),
                     );
                     let field = mk().field(field_name, array_expr);
 
@@ -431,8 +426,8 @@ impl<'a> Translation<'a> {
                 FieldType::Padding { bytes } => {
                     let field_name = next_padding_field();
                     let array_expr = mk().repeat_expr(
-                        mk().lit_expr(mk().int_lit(0, LitIntType::Unsuffixed)),
-                        mk().lit_expr(mk().int_lit(bytes.into(), LitIntType::Unsuffixed)),
+                        mk().lit_expr(mk().int_unsuffixed_lit(0)),
+                        mk().lit_expr(mk().int_unsuffixed_lit(bytes.into())),
                     );
                     let field = mk().field(field_name, array_expr);
 
@@ -441,7 +436,7 @@ impl<'a> Translation<'a> {
                 FieldType::ComputedPadding { ident } => {
                     let field_name = next_padding_field();
                     let array_expr = mk().repeat_expr(
-                        mk().lit_expr(mk().int_lit(0, LitIntType::Unsuffixed)),
+                        mk().lit_expr(mk().int_unsuffixed_lit(0)),
                         mk().ident_expr(ident),
                     );
                     let field = mk().field(field_name, array_expr);
@@ -500,7 +495,7 @@ impl<'a> Translation<'a> {
                         // Small hack: we need a value of the inner type,
                         // but `implicit_default_expr` produced a value
                         // of the outer type, so unwrap it manually
-                        init = init.map(|fi| mk().field_expr(fi, "0"));
+                        init = init.map(|fi| mk().anon_field_expr(fi, 0));
                     }
                     let field = init.map(|init| mk().field(field_name, init));
                     fields.push(field);
@@ -516,7 +511,7 @@ impl<'a> Translation<'a> {
 
                     if use_inner_type {
                         // See comment above
-                        expr = expr.map(|fi| mk().field_expr(fi, "0"));
+                        expr = expr.map(|fi| mk().anon_field_expr(fi, 0));
                     }
 
                     if bitfield_width.is_some() {
@@ -533,11 +528,11 @@ impl<'a> Translation<'a> {
 
         fields
             .into_iter()
-            .collect::<WithStmts<Vec<ast::Field>>>()
+            .collect::<WithStmts<Vec<syn::FieldValue>>>()
             .and_then(|fields| {
                 let struct_expr = mk().struct_expr(name.as_str(), fields);
                 let local_variable =
-                    P(mk().local(local_pat, None as Option<P<Ty>>, Some(struct_expr)));
+                    Box::new(mk().local(local_pat, None as Option<Box<Type>>, Some(struct_expr)));
 
                 let mut is_unsafe = false;
                 let mut stmts = vec![mk().local_stmt(local_variable)];
@@ -552,7 +547,7 @@ impl<'a> Translation<'a> {
                         .expect("Expected no statements in bitfield initializer");
                     let expr = mk().method_call_expr(struct_ident, field_name_setter, vec![val]);
 
-                    stmts.push(mk().expr_stmt(expr));
+                    stmts.push(mk().semi_stmt(expr));
                 }
 
                 let struct_ident = mk().ident_expr("init");
@@ -578,7 +573,7 @@ impl<'a> Translation<'a> {
         field_ids: &[CDeclId],
         platform_byte_size: u64,
         is_static: bool,
-    ) -> Result<WithStmts<P<Expr>>, TranslationError> {
+    ) -> Result<WithStmts<Box<Expr>>, TranslationError> {
         let reorganized_fields = self.get_field_types(struct_id, field_ids, platform_byte_size)?;
         let mut fields = Vec::with_capacity(reorganized_fields.len());
 
@@ -598,8 +593,8 @@ impl<'a> Translation<'a> {
                     field_name, bytes, ..
                 } => {
                     let array_expr = mk().repeat_expr(
-                        mk().lit_expr(mk().int_lit(0, LitIntType::Unsuffixed)),
-                        mk().lit_expr(mk().int_lit(bytes.into(), LitIntType::Unsuffixed)),
+                        mk().lit_expr(mk().int_unsuffixed_lit(0)),
+                        mk().lit_expr(mk().int_unsuffixed_lit(bytes.into())),
                     );
                     let field = mk().field(field_name, array_expr);
 
@@ -608,8 +603,8 @@ impl<'a> Translation<'a> {
                 FieldType::Padding { bytes } => {
                     let field_name = next_padding_field();
                     let array_expr = mk().repeat_expr(
-                        mk().lit_expr(mk().int_lit(0, LitIntType::Unsuffixed)),
-                        mk().lit_expr(mk().int_lit(bytes.into(), LitIntType::Unsuffixed)),
+                        mk().lit_expr(mk().int_unsuffixed_lit(0)),
+                        mk().lit_expr(mk().int_unsuffixed_lit(bytes.into())),
                     );
                     let field = mk().field(field_name, array_expr);
 
@@ -618,7 +613,7 @@ impl<'a> Translation<'a> {
                 FieldType::ComputedPadding { ident } => {
                     let field_name = next_padding_field();
                     let array_expr = mk().repeat_expr(
-                        mk().lit_expr(mk().int_lit(0, LitIntType::Unsuffixed)),
+                        mk().lit_expr(mk().int_unsuffixed_lit(0)),
                         mk().ident_expr(ident),
                     );
                     let field = mk().field(field_name, array_expr);
@@ -639,7 +634,7 @@ impl<'a> Translation<'a> {
                     }
                     if use_inner_type {
                         // See comment above
-                        field_init = field_init.map(|fi| mk().field_expr(fi, "0"));
+                        field_init = field_init.map(|fi| mk().anon_field_expr(fi, 0));
                     }
                     fields.push(field_init.map(|init| mk().field(name, init)))
                 }
@@ -648,7 +643,7 @@ impl<'a> Translation<'a> {
 
         Ok(fields
             .into_iter()
-            .collect::<WithStmts<Vec<ast::Field>>>()
+            .collect::<WithStmts<Vec<syn::FieldValue>>>()
             .map(|fields| mk().struct_expr(name.as_str(), fields)))
     }
 
@@ -667,9 +662,9 @@ impl<'a> Translation<'a> {
         ctx: ExprContext,
         op: BinOp,
         lhs: CExprId,
-        rhs_expr: P<Expr>,
+        rhs_expr: Box<Expr>,
         field_id: CDeclId,
-    ) -> Result<WithStmts<P<Expr>>, TranslationError> {
+    ) -> Result<WithStmts<Box<Expr>>, TranslationError> {
         let ctx = ctx.set_bitfield_write(true);
         let named_reference = self.name_reference_write_read(ctx, lhs)?;
         named_reference.and_then(|named_reference| {
@@ -681,22 +676,22 @@ impl<'a> Translation<'a> {
                 .ok_or("Could not find bitfield name")?;
             let setter_name = format!("set_{}", field_name);
             let lhs_expr_read =
-                mk().method_call_expr(lhs_expr.clone(), field_name, Vec::<P<Expr>>::new());
+                mk().method_call_expr(lhs_expr.clone(), field_name, Vec::<Box<Expr>>::new());
             // Allow the value of this assignment to be used as the RHS of other assignments
             let val = lhs_expr_read.clone();
             let param_expr = match op {
-                BinOp::AssignAdd => mk().binary_expr(BinOpKind::Add, lhs_expr_read, rhs_expr),
-                BinOp::AssignSubtract => mk().binary_expr(BinOpKind::Sub, lhs_expr_read, rhs_expr),
-                BinOp::AssignMultiply => mk().binary_expr(BinOpKind::Mul, lhs_expr_read, rhs_expr),
-                BinOp::AssignDivide => mk().binary_expr(BinOpKind::Div, lhs_expr_read, rhs_expr),
-                BinOp::AssignModulus => mk().binary_expr(BinOpKind::Rem, lhs_expr_read, rhs_expr),
-                BinOp::AssignBitXor => mk().binary_expr(BinOpKind::BitXor, lhs_expr_read, rhs_expr),
-                BinOp::AssignShiftLeft => mk().binary_expr(BinOpKind::Shl, lhs_expr_read, rhs_expr),
+                BinOp::AssignAdd => mk().binary_expr(RBinOp::Add(Default::default()), lhs_expr_read, rhs_expr),
+                BinOp::AssignSubtract => mk().binary_expr(RBinOp::Sub(Default::default()), lhs_expr_read, rhs_expr),
+                BinOp::AssignMultiply => mk().binary_expr(RBinOp::Mul(Default::default()), lhs_expr_read, rhs_expr),
+                BinOp::AssignDivide => mk().binary_expr(RBinOp::Div(Default::default()), lhs_expr_read, rhs_expr),
+                BinOp::AssignModulus => mk().binary_expr(RBinOp::Rem(Default::default()), lhs_expr_read, rhs_expr),
+                BinOp::AssignBitXor => mk().binary_expr(RBinOp::BitXor(Default::default()), lhs_expr_read, rhs_expr),
+                BinOp::AssignShiftLeft => mk().binary_expr(RBinOp::Shl(Default::default()), lhs_expr_read, rhs_expr),
                 BinOp::AssignShiftRight => {
-                    mk().binary_expr(BinOpKind::Shr, lhs_expr_read, rhs_expr)
+                    mk().binary_expr(RBinOp::Shr(Default::default()), lhs_expr_read, rhs_expr)
                 }
-                BinOp::AssignBitOr => mk().binary_expr(BinOpKind::BitOr, lhs_expr_read, rhs_expr),
-                BinOp::AssignBitAnd => mk().binary_expr(BinOpKind::BitAnd, lhs_expr_read, rhs_expr),
+                BinOp::AssignBitOr => mk().binary_expr(RBinOp::BitOr(Default::default()), lhs_expr_read, rhs_expr),
+                BinOp::AssignBitAnd => mk().binary_expr(RBinOp::BitAnd(Default::default()), lhs_expr_read, rhs_expr),
                 BinOp::Assign => rhs_expr,
                 _ => panic!("Cannot convert non-assignment operator"),
             };
@@ -706,8 +701,8 @@ impl<'a> Translation<'a> {
             // If there's just one statement we should be able to be able to fit it into one line without issue
             // If there's a block we can flatten it into the current scope, and if the expr contains a block it's
             // likely complex enough to warrant putting it into a temporary variable to avoid borrowing issues
-            match param_expr.kind {
-                ExprKind::Block(ref block, _) => {
+            match *param_expr {
+                Expr::Block(ExprBlock{ block, ..}) => {
                     let last = block.stmts.len() - 1;
 
                     for (i, stmt) in block.stmts.iter().enumerate() {
@@ -718,30 +713,30 @@ impl<'a> Translation<'a> {
                         stmts.push(stmt.clone());
                     }
 
-                    let last_expr = match block.stmts[last].kind {
-                        StmtKind::Expr(ref expr) => expr.clone(),
-                        _ => return Err(TranslationError::generic("Expected Expr StmtKind")),
+                    let last_expr = match block.stmts[last] {
+                        Stmt::Expr(ref expr) => expr.clone(),
+                        _ => return Err(TranslationError::generic("Expected Expr Stmt")),
                     };
-                    let method_call = mk().method_call_expr(lhs_expr, setter_name, vec![last_expr]);
+                    let method_call = mk().method_call_expr(lhs_expr, setter_name, vec![Box::new(last_expr)]);
 
-                    stmts.push(mk().expr_stmt(method_call));
+                    stmts.push(mk().semi_stmt(method_call));
                 }
-                _ if contains_block(&param_expr.kind) => {
+                _ if contains_block(&param_expr) => {
                     let name = self.renamer.borrow_mut().pick_name("rhs");
                     let name_ident = mk().mutbl().ident_pat(name.clone());
                     let temporary_stmt =
-                        mk().local(name_ident, None as Option<P<Ty>>, Some(param_expr.clone()));
+                        mk().local(name_ident, None as Option<Box<Type>>, Some(param_expr.clone()));
                     let assignment_expr =
                         mk().method_call_expr(lhs_expr, setter_name, vec![mk().ident_expr(name)]);
 
-                    stmts.push(mk().local_stmt(P(temporary_stmt)));
-                    stmts.push(mk().expr_stmt(assignment_expr));
+                    stmts.push(mk().local_stmt(Box::new(temporary_stmt)));
+                    stmts.push(mk().semi_stmt(assignment_expr));
                 }
                 _ => {
                     let assignment_expr =
                         mk().method_call_expr(lhs_expr, setter_name, vec![param_expr.clone()]);
 
-                    stmts.push(mk().expr_stmt(assignment_expr));
+                    stmts.push(mk().semi_stmt(assignment_expr));
                 }
             };
 
diff --git a/c2rust-transpile/src/translator/variadic.rs b/c2rust-transpile/src/translator/variadic.rs
index 3cffd8f0a5..45e38f1751 100644
--- a/c2rust-transpile/src/translator/variadic.rs
+++ b/c2rust-transpile/src/translator/variadic.rs
@@ -109,14 +109,14 @@ impl<'c> Translation<'c> {
         ctx: ExprContext,
         ty: CQualTypeId,
         val_id: CExprId,
-    ) -> Result<WithStmts<P<Expr>>, TranslationError> {
+    ) -> Result<WithStmts<Box<Expr>>, TranslationError> {
         if self.tcfg.translate_valist {
             let val = self.convert_expr(ctx.expect_valistimpl().used(), val_id)?;
 
             // The current implementation of the C-variadics feature doesn't allow us to
             // return `Option<fn(...) -> _>` from `VaList::arg`, so we detect function pointers
             // and construct the corresponding unsafe type `* mut fn(...) -> _`.
-            let fn_ptr_ty : Option<P<Ty>> = {
+            let fn_ptr_ty : Option<Box<Type>> = {
                 let resolved_ctype = self.ast_context.resolve_type(ty.ctype);
                 if let CTypeKind::Pointer(p) = resolved_ctype.kind {
                     // ty is a pointer type
@@ -153,7 +153,7 @@ impl<'c> Translation<'c> {
             val.and_then(|val| {
                 let path = mk()
                     .path_segment_with_args(mk().ident("arg"), mk().angle_bracketed_args(vec![arg_ty]));
-                let mut val = mk().method_call_expr(val, path, vec![] as Vec<P<Expr>>);
+                let mut val = mk().method_call_expr(val, path, vec![] as Vec<Box<Expr>>);
                 if let Some(ty) = real_arg_ty {
                     val = mk().cast_expr(val, ty);
                 }
@@ -166,7 +166,6 @@ impl<'c> Translation<'c> {
                 } else {
                     let val = if have_fn_ptr {
                         // transmute result of call to `arg` when expecting a function pointer
-                        if ctx.is_const { self.use_feature("const_transmute"); }
                         transmute_expr(mk().infer_ty(), mk().infer_ty(), val, self.tcfg.emit_no_std)
                     } else {
                         val
diff --git a/c2rust-transpile/src/with_stmts.rs b/c2rust-transpile/src/with_stmts.rs
index e7aee33c99..e31f3a3870 100644
--- a/c2rust-transpile/src/with_stmts.rs
+++ b/c2rust-transpile/src/with_stmts.rs
@@ -1,7 +1,6 @@
 use c2rust_ast_builder::mk;
 use std::iter::FromIterator;
-use syntax::ast::{Block, Expr, Stmt};
-use syntax::ptr::P;
+use syn::{Block, Expr, Stmt};
 
 #[derive(Clone, Debug)]
 pub struct WithStmts<T> {
@@ -109,9 +108,9 @@ impl<T> WithStmts<T> {
     }
 }
 
-impl WithStmts<P<Expr>> {
+impl WithStmts<Box<Expr>> {
     /// Package a series of statements and an expression into one block expression
-    pub fn to_expr(self) -> P<Expr> {
+    pub fn to_expr(self) -> Box<Expr> {
         if self.stmts.is_empty() {
             self.val
         } else {
@@ -120,18 +119,18 @@ impl WithStmts<P<Expr>> {
     }
 
     /// Package a series of statements and an expression into one block
-    pub fn to_block(mut self) -> P<Block> {
+    pub fn to_block(mut self) -> Box<Block> {
         self.stmts.push(mk().expr_stmt(self.val));
         mk().block(self.stmts)
     }
 
-    pub fn to_unsafe_pure_expr(self) -> Option<P<Expr>> {
+    pub fn to_unsafe_pure_expr(self) -> Option<Box<Expr>> {
         let is_unsafe = self.is_unsafe;
         self.to_pure_expr()
             .map(|expr| {
                 if is_unsafe {
-                    mk().block_expr(
-                        mk().unsafe_().block(
+                    mk().unsafe_block_expr(
+                        mk().unsafe_block(
                             vec![mk().expr_stmt(expr)]
                         )
                     )
@@ -141,7 +140,7 @@ impl WithStmts<P<Expr>> {
             })
     }
 
-    pub fn to_pure_expr(self) -> Option<P<Expr>> {
+    pub fn to_pure_expr(self) -> Option<Box<Expr>> {
         if self.stmts.is_empty() {
             Some(self.val)
         } else {
diff --git a/c2rust/Cargo.toml b/c2rust/Cargo.toml
index 41626c9e9c..7f54577ebf 100644
--- a/c2rust/Cargo.toml
+++ b/c2rust/Cargo.toml
@@ -22,7 +22,6 @@ env_logger = "0.7"
 regex = "1.3"
 shlex = "0.1"
 c2rust-transpile = { version = "0.15.1", path = "../c2rust-transpile" }
-c2rust-refactor = { version = "0.15.0", path = "../c2rust-refactor" }
 
 [build-dependencies]
 rustc_version = "0.2"
@@ -31,4 +30,3 @@ chrono = "0.4"
 [features]
 # Force static linking of LLVM
 llvm-static = ["c2rust-transpile/llvm-static"]
-profile = ["c2rust-refactor/profile"]
diff --git a/c2rust/build.rs b/c2rust/build.rs
index b415eae87c..95357c53a9 100644
--- a/c2rust/build.rs
+++ b/c2rust/build.rs
@@ -6,8 +6,6 @@ use chrono::{Duration, NaiveDate};
 use rustc_version::Channel;
 
 fn main() {
-    check_nightly_version();
-
     let sysroot = Command::new(env::var("RUSTC").unwrap())
         .arg("--print=sysroot")
         .output()
@@ -28,33 +26,3 @@ fn main() {
         .expect("Unexpected non-Unicode character in rustlib path");
     println!("cargo:rustc-env=RUSTLIB={}", path_string);
 }
-
-// This can be simplified into Cargo.toml if
-// https://github.com/rust-lang/rfcs/pull/2495 ever lands.
-fn check_nightly_version() {
-    let expected_nightly_date = include_str!("rust-toolchain")
-        .trim()
-        .splitn(2, '-')
-        .nth(1)
-        .and_then(|s| s.parse::<NaiveDate>().ok())
-        .expect("Could not parse expected toolchain version");
-    let expected_commit_date = (expected_nightly_date - Duration::days(1)).to_string();
-    let version = rustc_version::version_meta()
-        .expect("Could not find rustc version");
-    if version.channel != Channel::Nightly {
-        panic!(
-            "C2Rust requires rustc nightly-{}, but version {} was found",
-            expected_nightly_date,
-            version.semver,
-        );
-    }
-    if version.commit_date.clone().unwrap() != expected_commit_date {
-        let nightly_date = (version.commit_date.unwrap().parse::<NaiveDate>().unwrap()
-                           + Duration::days(1)).to_string();
-        panic!(
-            "C2Rust requires rustc nightly-{}, but version nightly-{} was found",
-            expected_nightly_date,
-            nightly_date,
-        );
-    }
-}
diff --git a/c2rust/src/bin/c2rust-refactor.rs b/c2rust/src/bin/c2rust-refactor.rs
deleted file mode 100644
index 13701cea81..0000000000
--- a/c2rust/src/bin/c2rust-refactor.rs
+++ /dev/null
@@ -1,203 +0,0 @@
-extern crate env_logger;
-#[macro_use]
-extern crate log;
-#[macro_use]
-extern crate clap;
-extern crate c2rust_refactor;
-extern crate shlex;
-
-use clap::{App, ArgMatches};
-use std::fs::File;
-use std::io::Read;
-use std::process;
-use std::str::FromStr;
-
-use c2rust_refactor::{file_io, CargoTarget, Command, Cursor, Mark, Options, RustcArgSource};
-
-fn main() {
-    let yaml = load_yaml!("../refactor.yaml");
-    let args = App::from_yaml(yaml).get_matches();
-
-    let opts = match parse_opts(&args) {
-        Some(x) => x,
-        None => return,
-    };
-
-    let ret = match c2rust_refactor::lib_main(opts) {
-        Ok(()) => 0,
-        Err(_) => 1,
-    };
-    process::exit(ret);
-}
-
-fn parse_opts(args: &ArgMatches) -> Option<Options> {
-    // Parse rewrite mode
-    let rewrite_modes = match args.values_of("rewrite-mode") {
-        Some(values) => values
-            .map(|s| match s {
-                "inplace" => file_io::OutputMode::InPlace,
-                "alongside" => file_io::OutputMode::Alongside,
-                "print" => file_io::OutputMode::Print,
-                "diff" => file_io::OutputMode::PrintDiff,
-                "json" => file_io::OutputMode::Json,
-                "marks" => file_io::OutputMode::Marks,
-                _ => unreachable!(),
-            })
-            .collect(),
-        None => vec![file_io::OutputMode::Print],
-    };
-
-    // Parse cursors
-    let cursor_strs = args.values_of_lossy("cursor").unwrap_or(vec![]);
-    let mut cursors = Vec::with_capacity(cursor_strs.len());
-    for s in &cursor_strs {
-        let mut parts = s.split(':');
-
-        let file = match parts.next() {
-            Some(x) => x.to_owned(),
-            None => {
-                info!("Bad cursor string: {:?}", s);
-                return None;
-            }
-        };
-
-        let line = match parts.next().map(|s| u32::from_str(s).map_err(|_| s)) {
-            Some(Ok(x)) => x,
-            Some(Err(s)) => {
-                info!("Bad cursor line number: {:?}", s);
-                return None;
-            }
-            None => {
-                info!("Bad cursor string: {:?}", s);
-                return None;
-            }
-        };
-
-        let col = match parts.next().map(|s| u32::from_str(s).map_err(|_| s)) {
-            Some(Ok(x)) => x,
-            Some(Err(s)) => {
-                info!("Bad cursor column number: {:?}", s);
-                return None;
-            }
-            None => {
-                info!("Bad cursor string: {:?}", s);
-                return None;
-            }
-        };
-
-        let label = match parts.next() {
-            Some(s) if s.len() > 0 => Some(s.to_owned()),
-            _ => None,
-        };
-
-        let kind = parts.next().map(|s| s.to_owned());
-
-        if parts.next().is_some() {
-            info!("Bad cursor string: {:?}", s);
-            return None;
-        }
-
-        cursors.push(Cursor::new(file, line, col, label, kind));
-    }
-
-    // Parse marks
-    let mark_strs = args.values_of_lossy("mark").unwrap_or(vec![]);
-    let mut marks = Vec::with_capacity(mark_strs.len());
-    for s in &mark_strs {
-        let mut parts = s.split(':');
-
-        let id = match parts.next().map(|s| usize::from_str(s).map_err(|_| s)) {
-            Some(Ok(x)) => x,
-            Some(Err(s)) => {
-                info!("Bad mark node ID: {:?}", s);
-                return None;
-            }
-            None => {
-                info!("Bad mark string: {:?}", s);
-                return None;
-            }
-        };
-
-        let label = parts.next().map(|s| s.to_owned());
-
-        if parts.next().is_some() {
-            info!("Bad mark string: {:?}", s);
-            return None;
-        }
-
-        marks.push(Mark::new(id, label));
-    }
-
-    // Get plugin options
-    let plugins = args.values_of_lossy("plugin-name").unwrap_or(vec![]);
-    let plugin_dirs = args.values_of_lossy("plugin-dir").unwrap_or(vec![]);
-
-    // Handle --cargo and rustc-args
-    let rustc_args = match args.values_of_lossy("rustc-args") {
-        Some(args) => RustcArgSource::CmdLine(args),
-        None => {
-            assert!(args.is_present("cargo"));
-            let target = if let Some(bin) = args.value_of("bin") {
-                CargoTarget::Bin(bin.to_string())
-            } else if args.is_present("bins") {
-                CargoTarget::AllBins
-            } else if args.is_present("lib") {
-                CargoTarget::Lib
-            } else {
-                CargoTarget::All
-            };
-            RustcArgSource::Cargo(target)
-        }
-    };
-
-    // Parse command names + args
-    let transforms_file = match args.value_of("transforms-file") {
-        Some(file_name) => {
-            let mut file = File::open(file_name).unwrap_or_else(|e| {
-                panic!("Could not open transforms file {:?}: {}", file_name, e);
-            });
-            let mut buf = String::new();
-            file.read_to_string(&mut buf).unwrap_or_else(|e| {
-                panic!("Could not read transforms file {:?}: {}", file_name, e);
-            });
-            buf
-        }
-        None => String::new(),
-    };
-    let transforms: Box<dyn Iterator<Item = String>> = match args.value_of("transforms-file") {
-        Some(_) => Box::new(shlex::Shlex::new(&transforms_file)),
-        None => Box::new(args.values_of("transforms").unwrap().map(String::from)),
-    };
-    let mut commands = Vec::new();
-    let mut cur_command = None;
-    for arg in transforms {
-        if arg == ";" {
-            if let Some(cmd) = cur_command.take() {
-                commands.push(cmd);
-            } else {
-                info!("Expected command before ';'");
-                return None;
-            }
-        } else if cur_command.is_none() {
-            cur_command = Some(Command {
-                name: arg,
-                args: Vec::new(),
-            });
-        } else {
-            cur_command.as_mut().unwrap().args.push(arg);
-        }
-    }
-    if let Some(cmd) = cur_command.take() {
-        commands.push(cmd);
-    }
-
-    Some(Options {
-        rewrite_modes,
-        commands,
-        rustc_args,
-        cursors,
-        marks,
-        plugins,
-        plugin_dirs,
-    })
-}
diff --git a/c2rust/src/main.rs b/c2rust/src/main.rs
index 53067127ac..c6f4d8a575 100644
--- a/c2rust/src/main.rs
+++ b/c2rust/src/main.rs
@@ -6,7 +6,7 @@ use std::ffi::OsStr;
 use std::process::{exit, Command};
 
 fn main() {
-    let subcommand_yamls = [load_yaml!("transpile.yaml"), load_yaml!("refactor.yaml")];
+    let subcommand_yamls = [load_yaml!("transpile.yaml")];
     let matches = App::new("C2Rust")
         .version(crate_version!())
         .author(crate_authors!(", "))
diff --git a/docs/source_walkthrough.md b/docs/source_walkthrough.md
index f0b0fbd227..6bbb8eefaa 100644
--- a/docs/source_walkthrough.md
+++ b/docs/source_walkthrough.md
@@ -16,9 +16,7 @@ This crate contains logic for dispatching command-line arguments to the correct
 
 ### c2rust-ast-builder
 
-The c2rust-ast-builder crate provides an AST building abstraction on top of rustc's libsyntax. This is used for code generation both in translation and refactoring.
-
-The builder implemented in this package provides a more stable interface to AST generation that we'd get depending directly on libsyntax. Libsyntax itself is consided unstable and subject to change dramatically at each nightly release. Libsyntax provides is own AST building functionality, but it doesn't have many of the conveniences that we use in our own implementation.
+The c2rust-ast-builder crate provides an AST building abstraction on top of the syn crate. This is used for code generation both in translation and refactoring.
 
 ### c2rust-ast-exporter
 
@@ -59,17 +57,13 @@ The `Make` trait allows for convenient, implicit coercions when using the `Build
 pub trait Make<T> { fn make(self, mk: &Builder) -> T; }
 ```
 
-### P type
-
-The `P` type comes from the `libsyntax` crate and provides functionality similar to `Box` for immutable, shared values. Many components of the Rust AST will store `P<T>` instead of `T` when there are potential savings to be had from shared references.
-
 ### Spans and Node IDs
 
 The Rust AST types are designed to be able to be cross-referenced to source-file locations and various type-information metadata maps. These references are tracked through span and node IDs scattered throughout the AST type definitions. In the case of generating new syntax we don't have any corresponding metadata maps to align with. Instead we fill all of these ID fields with various dummy values: `DUMMY_SP` and `DUMMY_NODE_ID`.
 
 ### Naming convention
 
-Builder methods are named using the pattern `kind_type`. For example to make a `P<Ty>` that is a pointer to another `Ty` use the `ptr_ty` method because internally you're making a `TyKind::Ptr`.
+Builder methods are named using the pattern `kind_type`. For example to make a `Box<Ty>` that is a pointer to another `Ty` use the `ptr_ty` method because internally you're making a `TyKind::Ptr`.
 
 ## Crate Walkthrough: c2rust-transpile
 
diff --git a/prettyplease/.gitattributes b/prettyplease/.gitattributes
new file mode 100644
index 0000000000..cbe6fb1edc
--- /dev/null
+++ b/prettyplease/.gitattributes
@@ -0,0 +1 @@
+examples/*.rs linguist-generated
diff --git a/prettyplease/.github/workflows/ci.yml b/prettyplease/.github/workflows/ci.yml
new file mode 100644
index 0000000000..301d544425
--- /dev/null
+++ b/prettyplease/.github/workflows/ci.yml
@@ -0,0 +1,54 @@
+name: CI
+
+on:
+  push:
+  pull_request:
+  schedule: [cron: "40 1 * * *"]
+
+env:
+  RUSTFLAGS: '-Dwarnings'
+
+jobs:
+  test:
+    name: Rust ${{matrix.rust}}
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        rust: [nightly, beta, stable, 1.56.0]
+    steps:
+      - uses: actions/checkout@v2
+      - uses: dtolnay/rust-toolchain@master
+        with:
+          toolchain: ${{matrix.rust}}
+      - run: cargo check
+      - run: cargo test
+
+  examples:
+    name: Examples
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: dtolnay/rust-toolchain@nightly
+        with:
+          components: rustc-dev, rustfmt
+      - run: cargo run --manifest-path examples/update/Cargo.toml
+      - run: git diff --exit-code
+
+  clippy:
+    name: Clippy
+    runs-on: ubuntu-latest
+    if: github.event_name != 'pull_request'
+    steps:
+      - uses: actions/checkout@v2
+      - uses: dtolnay/rust-toolchain@clippy
+      - run: cargo clippy -- -Dclippy::all -Dclippy::pedantic
+
+  outdated:
+    name: Outdated
+    runs-on: ubuntu-latest
+    if: github.event_name != 'pull_request'
+    steps:
+      - uses: actions/checkout@v2
+      - uses: dtolnay/install@cargo-outdated
+      - run: cargo outdated --exit-code 1
diff --git a/prettyplease/.gitignore b/prettyplease/.gitignore
new file mode 100644
index 0000000000..96ef6c0b94
--- /dev/null
+++ b/prettyplease/.gitignore
@@ -0,0 +1,2 @@
+/target
+Cargo.lock
diff --git a/prettyplease/Cargo.toml b/prettyplease/Cargo.toml
new file mode 100644
index 0000000000..f28763a500
--- /dev/null
+++ b/prettyplease/Cargo.toml
@@ -0,0 +1,22 @@
+[package]
+name = "prettyplease"
+version = "0.1.1"
+authors = ["David Tolnay <dtolnay@gmail.com>"]
+edition = "2021"
+rust-version = "1.56"
+license = "MIT OR Apache-2.0"
+description = "A minimal `syn` syntax tree pretty-printer"
+repository = "https://github.com/dtolnay/prettyplease"
+documentation = "https://docs.rs/prettyplease"
+readme = "README.md"
+autoexamples = false
+
+[dependencies]
+proc-macro2 = { version = "1.0", default-features = false }
+syn = { version = "1.0.85", default-features = false, features = ["full"] }
+
+[dev-dependencies]
+syn = { version = "1.0.85", default-features = false, features = ["parsing"] }
+
+#[workspace]
+#members = ["examples/update"]
diff --git a/prettyplease/LICENSE-APACHE b/prettyplease/LICENSE-APACHE
new file mode 100644
index 0000000000..16fe87b06e
--- /dev/null
+++ b/prettyplease/LICENSE-APACHE
@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/prettyplease/LICENSE-MIT b/prettyplease/LICENSE-MIT
new file mode 100644
index 0000000000..31aa79387f
--- /dev/null
+++ b/prettyplease/LICENSE-MIT
@@ -0,0 +1,23 @@
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/prettyplease/README.md b/prettyplease/README.md
new file mode 100644
index 0000000000..93bfea4c7f
--- /dev/null
+++ b/prettyplease/README.md
@@ -0,0 +1,312 @@
+prettyplease::unparse
+=====================
+
+[<img alt="github" src="https://img.shields.io/badge/github-dtolnay/prettyplease-8da0cb?style=for-the-badge&labelColor=555555&logo=github" height="20">](https://github.com/dtolnay/prettyplease)
+[<img alt="crates.io" src="https://img.shields.io/crates/v/prettyplease.svg?style=for-the-badge&color=fc8d62&logo=rust" height="20">](https://crates.io/crates/prettyplease)
+[<img alt="docs.rs" src="https://img.shields.io/badge/docs.rs-prettyplease-66c2a5?style=for-the-badge&labelColor=555555&logoColor=white&logo=data:image/svg+xml;base64,PHN2ZyByb2xlPSJpbWciIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyIgdmlld0JveD0iMCAwIDUxMiA1MTIiPjxwYXRoIGZpbGw9IiNmNWY1ZjUiIGQ9Ik00ODguNiAyNTAuMkwzOTIgMjE0VjEwNS41YzAtMTUtOS4zLTI4LjQtMjMuNC0zMy43bC0xMDAtMzcuNWMtOC4xLTMuMS0xNy4xLTMuMS0yNS4zIDBsLTEwMCAzNy41Yy0xNC4xIDUuMy0yMy40IDE4LjctMjMuNCAzMy43VjIxNGwtOTYuNiAzNi4yQzkuMyAyNTUuNSAwIDI2OC45IDAgMjgzLjlWMzk0YzAgMTMuNiA3LjcgMjYuMSAxOS45IDMyLjJsMTAwIDUwYzEwLjEgNS4xIDIyLjEgNS4xIDMyLjIgMGwxMDMuOS01MiAxMDMuOSA1MmMxMC4xIDUuMSAyMi4xIDUuMSAzMi4yIDBsMTAwLTUwYzEyLjItNi4xIDE5LjktMTguNiAxOS45LTMyLjJWMjgzLjljMC0xNS05LjMtMjguNC0yMy40LTMzLjd6TTM1OCAyMTQuOGwtODUgMzEuOXYtNjguMmw4NS0zN3Y3My4zek0xNTQgMTA0LjFsMTAyLTM4LjIgMTAyIDM4LjJ2LjZsLTEwMiA0MS40LTEwMi00MS40di0uNnptODQgMjkxLjFsLTg1IDQyLjV2LTc5LjFsODUtMzguOHY3NS40em0wLTExMmwtMTAyIDQxLjQtMTAyLTQxLjR2LS42bDEwMi0zOC4yIDEwMiAzOC4ydi42em0yNDAgMTEybC04NSA0Mi41di03OS4xbDg1LTM4Ljh2NzUuNHptMC0xMTJsLTEwMiA0MS40LTEwMi00MS40di0uNmwxMDItMzguMiAxMDIgMzguMnYuNnoiPjwvcGF0aD48L3N2Zz4K" height="20">](https://docs.rs/prettyplease)
+[<img alt="build status" src="https://img.shields.io/github/workflow/status/dtolnay/prettyplease/CI/master?style=for-the-badge" height="20">](https://github.com/dtolnay/prettyplease/actions?query=branch%3Amaster)
+
+A minimal `syn` syntax tree pretty-printer.
+
+<br>
+
+## Overview
+
+This is a pretty-printer to turn a `syn` syntax tree into a `String` of
+well-formatted source code. In contrast to rustfmt, this library is intended to
+be suitable for arbitrary generated code.
+
+Rustfmt prioritizes high-quality output that is impeccable enough that you'd be
+comfortable spending your career staring at its output &mdash; but that means
+some heavyweight algorithms, and it has a tendency to bail out on code that is
+hard to format (for example [rustfmt#3697], and there are dozens more issues
+like it). That's not necessarily a big deal for human-generated code because
+when code gets highly nested, the human will naturally be inclined to refactor
+into more easily formattable code. But for generated code, having the formatter
+just give up leaves it totally unreadable.
+
+[rustfmt#3697]: https://github.com/rust-lang/rustfmt/issues/3697
+
+This library is designed using the simplest possible algorithm and data
+structures that can deliver about 95% of the quality of rustfmt-formatted
+output. In my experience testing real-world code, approximately 97-98% of output
+lines come out identical between rustfmt's formatting and this crate's. The rest
+have slightly different linebreak decisions, but still clearly follow the
+dominant modern Rust style.
+
+The tradeoffs made by this crate are a good fit for generated code that you will
+*not* spend your career staring at. For example, the output of `bindgen`, or the
+output of `cargo-expand`. In those cases it's more important that the whole
+thing be formattable without the formatter giving up, than that it be flawless.
+
+<br>
+
+## Feature matrix
+
+Here are a few superficial comparisons of this crate against the AST
+pretty-printer built into rustc, and rustfmt. The sections below go into more
+detail comparing the output of each of these libraries.
+
+| | prettyplease | rustc | rustfmt |
+| --- | --- | --- | --- |
+| non-pathological behavior on big or generated code | ✔️ | ❌ | ❌ |
+| idiomatic modern formatting ("locally indistinguishable from rustfmt") | ✔️ | ❌ | ✔️ |
+| throughput | 60 MB/s | 39 MB/s | 2.8 MB/s |
+| number of dependencies | 3 | 72 | 66 |
+| compile time including dependencies | 2.4 sec | 23.1 sec | 29.8 sec |
+| buildable using a stable Rust compiler | ✔️ | ❌ | ❌ |
+| published to crates.io | ✔️ | ❌ | ❌ |
+| extensively configurable output | ❌ | ❌ | ✔️ |
+| intended to accommodate hand-maintained source code | ❌ | ❌ | ✔️ |
+
+<br>
+
+## Comparison to rustfmt
+
+- [input.rs](https://github.com/dtolnay/prettyplease/blob/0.1.0/examples/input.rs)
+- [output.prettyplease.rs](https://github.com/dtolnay/prettyplease/blob/0.1.0/examples/output.prettyplease.rs)
+- [output.rustfmt.rs](https://github.com/dtolnay/prettyplease/blob/0.1.0/examples/output.rustfmt.rs)
+
+If you weren't told which output file is which, it would be practically
+impossible to tell &mdash; **except** for line 435 in the rustfmt output, which
+is more than 1000 characters long because rustfmt just gave up formatting that
+part of the file:
+
+```rust
+            match segments[5] {
+                0 => write!(f, "::{}", ipv4),
+                0xffff => write!(f, "::ffff:{}", ipv4),
+                _ => unreachable!(),
+            }
+        } else { # [derive (Copy , Clone , Default)] struct Span { start : usize , len : usize , } let zeroes = { let mut longest = Span :: default () ; let mut current = Span :: default () ; for (i , & segment) in segments . iter () . enumerate () { if segment == 0 { if current . len == 0 { current . start = i ; } current . len += 1 ; if current . len > longest . len { longest = current ; } } else { current = Span :: default () ; } } longest } ; # [doc = " Write a colon-separated part of the address"] # [inline] fn fmt_subslice (f : & mut fmt :: Formatter < '_ > , chunk : & [u16]) -> fmt :: Result { if let Some ((first , tail)) = chunk . split_first () { write ! (f , "{:x}" , first) ? ; for segment in tail { f . write_char (':') ? ; write ! (f , "{:x}" , segment) ? ; } } Ok (()) } if zeroes . len > 1 { fmt_subslice (f , & segments [.. zeroes . start]) ? ; f . write_str ("::") ? ; fmt_subslice (f , & segments [zeroes . start + zeroes . len ..]) } else { fmt_subslice (f , & segments) } }
+    } else {
+        const IPV6_BUF_LEN: usize = (4 * 8) + 7;
+        let mut buf = [0u8; IPV6_BUF_LEN];
+        let mut buf_slice = &mut buf[..];
+```
+
+This is a pretty typical manifestation of rustfmt bailing out in generated code
+&mdash; a chunk of the input ends up on one line. The other manifestation is
+that you're working on some code, running rustfmt on save like a conscientious
+developer, but after a while notice it isn't doing anything. You introduce an
+intentional formatting issue, like a stray indent or semicolon, and run rustfmt
+to check your suspicion. Nope, it doesn't get cleaned up &mdash; rustfmt is just
+not formatting the part of the file you are working on.
+
+The prettyplease library is designed to have no pathological cases that force a
+bail out; the entire input you give it will get formatted in some "good enough"
+form.
+
+Separately, rustfmt can be problematic to integrate into projects. It's written
+using rustc's internal syntax tree, so it can't be built by a stable compiler.
+Its releases are not regularly published to crates.io, so in Cargo builds you'd
+need to depend on it as a git dependency, which precludes publishing your crate
+to crates.io also. You can shell out to a `rustfmt` binary, but that'll be
+whatever rustfmt version is installed on each developer's system (if any), which
+can lead to spurious diffs in checked-in generated code formatted by different
+versions. In contrast prettyplease is designed to be easy to pull in as a
+library, and compiles fast.
+
+<br>
+
+## Comparison to rustc_ast_pretty
+
+- [input.rs](https://github.com/dtolnay/prettyplease/blob/0.1.0/examples/input.rs)
+- [output.prettyplease.rs](https://github.com/dtolnay/prettyplease/blob/0.1.0/examples/output.prettyplease.rs)
+- [output.rustc.rs](https://github.com/dtolnay/prettyplease/blob/0.1.0/examples/output.rustc.rs)
+
+This is the pretty-printer that gets used when rustc prints source code, such as
+`rustc -Zunpretty=expanded`. It's used also by the standard library's
+`stringify!` when stringifying an interpolated macro_rules AST fragment, like an
+$:expr, and transitively by `dbg!` and many macros in the ecosystem.
+
+Rustc's formatting is mostly okay, but does not hew closely to the dominant
+contemporary style of Rust formatting. Some things wouldn't ever be written on
+one line, like this `match` expression, and certainly not with a comma in front
+of the closing brace:
+
+```rust
+fn eq(&self, other: &IpAddr) -> bool {
+    match other { IpAddr::V4(v4) => self == v4, IpAddr::V6(_) => false, }
+}
+```
+
+Some places use non-multiple-of-4 indentation, which is definitely not the norm:
+
+```rust
+pub const fn to_ipv6_mapped(&self) -> Ipv6Addr {
+    let [a, b, c, d] = self.octets();
+    Ipv6Addr{inner:
+                 c::in6_addr{s6_addr:
+                                 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF,
+                                  0xFF, a, b, c, d],},}
+}
+```
+
+And although there isn't an egregious example of it in the link because the
+input code is pretty tame, in general rustc_ast_pretty has pathological behavior
+on generated code. It has a tendency to use excessive horizontal indentation and
+rapidly run out of width:
+
+```rust
+::std::io::_print(::core::fmt::Arguments::new_v1(&[""],
+                                                 &match (&msg,) {
+                                                      _args =>
+                                                      [::core::fmt::ArgumentV1::new(_args.0,
+                                                                                    ::core::fmt::Display::fmt)],
+                                                  }));
+```
+
+The snippets above are clearly different from modern rustfmt style. In contrast,
+prettyplease is designed to have output that is practically indistinguishable
+from rustfmt-formatted code.
+
+<br>
+
+## Example
+
+```rust
+// [dependencies]
+// prettyplease = "0.1"
+// syn = { version = "1", default-features = false, features = ["full", "parsing"] }
+
+const INPUT: &str = stringify! {
+    use crate::{
+          lazy::{Lazy, SyncLazy, SyncOnceCell}, panic,
+        sync::{ atomic::{AtomicUsize, Ordering::SeqCst},
+            mpsc::channel, Mutex, },
+      thread,
+    };
+    impl<T, U> Into<U> for T where U: From<T> {
+        fn into(self) -> U { U::from(self) }
+    }
+};
+
+fn main() {
+    let syntax_tree = syn::parse_file(INPUT).unwrap();
+    let formatted = prettyplease::unparse(&syntax_tree);
+    print!("{}", formatted);
+}
+```
+
+<br>
+
+## Algorithm notes
+
+The approach and terminology used in the implementation are derived from [*Derek
+C. Oppen, "Pretty Printing" (1979)*][paper], on which rustc_ast_pretty is also
+based, and from rustc_ast_pretty's implementation written by Graydon Hoare in
+2011 (and modernized over the years by dozens of volunteer maintainers).
+
+[paper]: http://i.stanford.edu/pub/cstr/reports/cs/tr/79/770/CS-TR-79-770.pdf
+
+The paper describes two language-agnostic interacting procedures `Scan()` and
+`Print()`. Language-specific code decomposes an input data structure into a
+stream of `string` and `break` tokens, and `begin` and `end` tokens for
+grouping. Each `begin`&ndash;`end` range may be identified as either "consistent
+breaking" or "inconsistent breaking". If a group is consistently breaking, then
+if the whole contents do not fit on the line, *every* `break` token in the group
+will receive a linebreak. This is appropriate, for example, for Rust struct
+literals, or arguments of a function call. If a group is inconsistently
+breaking, then the `string` tokens in the group are greedily placed on the line
+until out of space, and linebroken only at those `break` tokens for which the
+next string would not fit. For example, this is appropriate for the contents of
+a braced `use` statement in Rust.
+
+Scan's job is to efficiently accumulate sizing information about groups and
+breaks. For every `begin` token we compute the distance to the matched `end`
+token, and for every `break` we compute the distance to the next `break`. The
+algorithm uses a ringbuffer to hold tokens whose size is not yet ascertained.
+The maximum size of the ringbuffer is bounded by the target line length and does
+not grow indefinitely, regardless of deep nesting in the input stream. That's
+because once a group is sufficiently big, the precise size can no longer make a
+difference to linebreak decisions and we can effectively treat it as "infinity".
+
+Print's job is to use the sizing information to efficiently assign a "broken" or
+"not broken" status to every `begin` token. At that point the output is easily
+constructed by concatenating `string` tokens and breaking at `break` tokens
+contained within a broken group.
+
+Leveraging these primitives (i.e. cleverly placing the all-or-nothing consistent
+breaks and greedy inconsistent breaks) to yield rustfmt-compatible formatting
+for all of Rust's syntax tree nodes is a fun challenge.
+
+Here is a visualization of some Rust tokens fed into the pretty printing
+algorithm. Consistently breaking `begin`&mdash;`end` pairs are represented by
+`«`&#8288;`»`, inconsistently breaking by `‹`&#8288;`›`, `break` by `·`, and the
+rest of the non-whitespace are `string`.
+
+```text
+use crate::«{·
+‹    lazy::«{·‹Lazy,· SyncLazy,· SyncOnceCell›·}»,·
+    panic,·
+    sync::«{·
+‹        atomic::«{·‹AtomicUsize,· Ordering::SeqCst›·}»,·
+        mpsc::channel,· Mutex›,·
+    }»,·
+    thread›,·
+}»;·
+«‹«impl<«·T‹›,· U‹›·»>» Into<«·U·»>· for T›·
+where·
+    U:‹ From<«·T·»>›,·
+{·
+«    fn into(·«·self·») -> U {·
+‹        U::from(«·self·»)›·
+»    }·
+»}·
+```
+
+The algorithm described in the paper is not quite sufficient for producing
+well-formatted Rust code that is locally indistinguishable from rustfmt's style.
+The reason is that in the paper, the complete non-whitespace contents are
+assumed to be independent of linebreak decisions, with Scan and Print being only
+in control of the whitespace (spaces and line breaks). In Rust as idiomatically
+formattted by rustfmt, that is not the case. Trailing commas are one example;
+the punctuation is only known *after* the broken vs non-broken status of the
+surrounding group is known:
+
+```rust
+let _ = Struct { x: 0, y: true };
+
+let _ = Struct {
+    x: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx,
+    y: yyyyyyyyyyyyyyyyyyyyyyyyyyyyyy,   //<- trailing comma if the expression wrapped
+};
+```
+
+The formatting of `match` expressions is another case; we want small arms on the
+same line as the pattern, and big arms wrapped in a brace. The presence of the
+brace punctuation, comma, and semicolon are all dependent on whether the arm
+fits on the line:
+
+```rust
+match total_nanos.checked_add(entry.nanos as u64) {
+    Some(n) => tmp = n,   //<- small arm, inline with comma
+    None => {
+        total_secs = total_secs
+            .checked_add(total_nanos / NANOS_PER_SEC as u64)
+            .expect("overflow in iter::sum over durations");
+    }   //<- big arm, needs brace added, and also semicolon^
+}
+```
+
+The printing algorithm implementation in this crate accommodates all of these
+situations with conditional punctuation tokens whose selection can be deferred
+and populated after it's known that the group is or is not broken.
+
+<br>
+
+#### License
+
+<sup>
+Licensed under either of <a href="LICENSE-APACHE">Apache License, Version
+2.0</a> or <a href="LICENSE-MIT">MIT license</a> at your option.
+</sup>
+
+<br>
+
+<sub>
+Unless you explicitly state otherwise, any contribution intentionally submitted
+for inclusion in this crate by you, as defined in the Apache-2.0 license, shall
+be dual licensed as above, without any additional terms or conditions.
+</sub>
diff --git a/prettyplease/examples/.tokeignore b/prettyplease/examples/.tokeignore
new file mode 100644
index 0000000000..6f5f3d11d3
--- /dev/null
+++ b/prettyplease/examples/.tokeignore
@@ -0,0 +1 @@
+*.rs
diff --git a/prettyplease/examples/input.rs b/prettyplease/examples/input.rs
new file mode 100644
index 0000000000..ca3d9803a8
--- /dev/null
+++ b/prettyplease/examples/input.rs
@@ -0,0 +1 @@
+use crate :: cmp :: Ordering ; use crate :: fmt :: { self , Write as FmtWrite } ; use crate :: hash ; use crate :: io :: Write as IoWrite ; use crate :: mem :: transmute ; use crate :: sys :: net :: netc as c ; use crate :: sys_common :: { AsInner , FromInner , IntoInner } ; # [derive (Copy , Clone , Eq , PartialEq , Hash , PartialOrd , Ord)] pub enum IpAddr { V4 (Ipv4Addr) , V6 (Ipv6Addr) , } # [derive (Copy)] pub struct Ipv4Addr { inner : c :: in_addr , } # [derive (Copy)] pub struct Ipv6Addr { inner : c :: in6_addr , } # [derive (Copy , PartialEq , Eq , Clone , Hash , Debug)] # [non_exhaustive] pub enum Ipv6MulticastScope { InterfaceLocal , LinkLocal , RealmLocal , AdminLocal , SiteLocal , OrganizationLocal , Global , } impl IpAddr { pub const fn is_unspecified (& self) -> bool { match self { IpAddr :: V4 (ip) => ip . is_unspecified () , IpAddr :: V6 (ip) => ip . is_unspecified () , } } pub const fn is_loopback (& self) -> bool { match self { IpAddr :: V4 (ip) => ip . is_loopback () , IpAddr :: V6 (ip) => ip . is_loopback () , } } pub const fn is_global (& self) -> bool { match self { IpAddr :: V4 (ip) => ip . is_global () , IpAddr :: V6 (ip) => ip . is_global () , } } pub const fn is_multicast (& self) -> bool { match self { IpAddr :: V4 (ip) => ip . is_multicast () , IpAddr :: V6 (ip) => ip . is_multicast () , } } pub const fn is_documentation (& self) -> bool { match self { IpAddr :: V4 (ip) => ip . is_documentation () , IpAddr :: V6 (ip) => ip . is_documentation () , } } pub const fn is_benchmarking (& self) -> bool { match self { IpAddr :: V4 (ip) => ip . is_benchmarking () , IpAddr :: V6 (ip) => ip . is_benchmarking () , } } pub const fn is_ipv4 (& self) -> bool { matches ! (self , IpAddr :: V4 (_)) } pub const fn is_ipv6 (& self) -> bool { matches ! (self , IpAddr :: V6 (_)) } pub const fn to_canonical (& self) -> IpAddr { match self { & v4 @ IpAddr :: V4 (_) => v4 , IpAddr :: V6 (v6) => v6 . to_canonical () , } } } impl Ipv4Addr { pub const fn new (a : u8 , b : u8 , c : u8 , d : u8) -> Ipv4Addr { Ipv4Addr { inner : c :: in_addr { s_addr : u32 :: from_ne_bytes ([a , b , c , d]) } } } pub const LOCALHOST : Self = Ipv4Addr :: new (127 , 0 , 0 , 1) ; # [doc (alias = "INADDR_ANY")] pub const UNSPECIFIED : Self = Ipv4Addr :: new (0 , 0 , 0 , 0) ; pub const BROADCAST : Self = Ipv4Addr :: new (255 , 255 , 255 , 255) ; pub const fn octets (& self) -> [u8 ; 4] { self . inner . s_addr . to_ne_bytes () } pub const fn is_unspecified (& self) -> bool { self . inner . s_addr == 0 } pub const fn is_loopback (& self) -> bool { self . octets () [0] == 127 } pub const fn is_private (& self) -> bool { match self . octets () { [10 , ..] => true , [172 , b , ..] if b >= 16 && b <= 31 => true , [192 , 168 , ..] => true , _ => false , } } pub const fn is_link_local (& self) -> bool { matches ! (self . octets () , [169 , 254 , ..]) } pub const fn is_global (& self) -> bool { if u32 :: from_be_bytes (self . octets ()) == 0xc0000009 || u32 :: from_be_bytes (self . octets ()) == 0xc000000a { return true ; } ! self . is_private () && ! self . is_loopback () && ! self . is_link_local () && ! self . is_broadcast () && ! self . is_documentation () && ! self . is_shared () && ! (self . octets () [0] == 192 && self . octets () [1] == 0 && self . octets () [2] == 0) && ! self . is_reserved () && ! self . is_benchmarking () && self . octets () [0] != 0 } pub const fn is_shared (& self) -> bool { self . octets () [0] == 100 && (self . octets () [1] & 0b1100_0000 == 0b0100_0000) } pub const fn is_benchmarking (& self) -> bool { self . octets () [0] == 198 && (self . octets () [1] & 0xfe) == 18 } pub const fn is_reserved (& self) -> bool { self . octets () [0] & 240 == 240 && ! self . is_broadcast () } pub const fn is_multicast (& self) -> bool { self . octets () [0] >= 224 && self . octets () [0] <= 239 } pub const fn is_broadcast (& self) -> bool { u32 :: from_be_bytes (self . octets ()) == u32 :: from_be_bytes (Self :: BROADCAST . octets ()) } pub const fn is_documentation (& self) -> bool { matches ! (self . octets () , [192 , 0 , 2 , _] | [198 , 51 , 100 , _] | [203 , 0 , 113 , _]) } pub const fn to_ipv6_compatible (& self) -> Ipv6Addr { let [a , b , c , d] = self . octets () ; Ipv6Addr { inner : c :: in6_addr { s6_addr : [0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , a , b , c , d] } , } } pub const fn to_ipv6_mapped (& self) -> Ipv6Addr { let [a , b , c , d] = self . octets () ; Ipv6Addr { inner : c :: in6_addr { s6_addr : [0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0xFF , 0xFF , a , b , c , d] } , } } } impl fmt :: Display for IpAddr { fn fmt (& self , fmt : & mut fmt :: Formatter < '_ >) -> fmt :: Result { match self { IpAddr :: V4 (ip) => ip . fmt (fmt) , IpAddr :: V6 (ip) => ip . fmt (fmt) , } } } impl fmt :: Debug for IpAddr { fn fmt (& self , fmt : & mut fmt :: Formatter < '_ >) -> fmt :: Result { fmt :: Display :: fmt (self , fmt) } } impl From < Ipv4Addr > for IpAddr { fn from (ipv4 : Ipv4Addr) -> IpAddr { IpAddr :: V4 (ipv4) } } impl From < Ipv6Addr > for IpAddr { fn from (ipv6 : Ipv6Addr) -> IpAddr { IpAddr :: V6 (ipv6) } } impl fmt :: Display for Ipv4Addr { fn fmt (& self , fmt : & mut fmt :: Formatter < '_ >) -> fmt :: Result { let octets = self . octets () ; if fmt . precision () . is_none () && fmt . width () . is_none () { write ! (fmt , "{}.{}.{}.{}" , octets [0] , octets [1] , octets [2] , octets [3]) } else { const IPV4_BUF_LEN : usize = 15 ; let mut buf = [0u8 ; IPV4_BUF_LEN] ; let mut buf_slice = & mut buf [..] ; write ! (buf_slice , "{}.{}.{}.{}" , octets [0] , octets [1] , octets [2] , octets [3]) . unwrap () ; let len = IPV4_BUF_LEN - buf_slice . len () ; let buf = unsafe { crate :: str :: from_utf8_unchecked (& buf [.. len]) } ; fmt . pad (buf) } } } impl fmt :: Debug for Ipv4Addr { fn fmt (& self , fmt : & mut fmt :: Formatter < '_ >) -> fmt :: Result { fmt :: Display :: fmt (self , fmt) } } impl Clone for Ipv4Addr { fn clone (& self) -> Ipv4Addr { * self } } impl PartialEq for Ipv4Addr { fn eq (& self , other : & Ipv4Addr) -> bool { self . inner . s_addr == other . inner . s_addr } } impl PartialEq < Ipv4Addr > for IpAddr { fn eq (& self , other : & Ipv4Addr) -> bool { match self { IpAddr :: V4 (v4) => v4 == other , IpAddr :: V6 (_) => false , } } } impl PartialEq < IpAddr > for Ipv4Addr { fn eq (& self , other : & IpAddr) -> bool { match other { IpAddr :: V4 (v4) => self == v4 , IpAddr :: V6 (_) => false , } } } impl Eq for Ipv4Addr { } impl hash :: Hash for Ipv4Addr { fn hash < H : hash :: Hasher > (& self , s : & mut H) { { self . inner . s_addr } . hash (s) } } impl PartialOrd for Ipv4Addr { fn partial_cmp (& self , other : & Ipv4Addr) -> Option < Ordering > { Some (self . cmp (other)) } } impl PartialOrd < Ipv4Addr > for IpAddr { fn partial_cmp (& self , other : & Ipv4Addr) -> Option < Ordering > { match self { IpAddr :: V4 (v4) => v4 . partial_cmp (other) , IpAddr :: V6 (_) => Some (Ordering :: Greater) , } } } impl PartialOrd < IpAddr > for Ipv4Addr { fn partial_cmp (& self , other : & IpAddr) -> Option < Ordering > { match other { IpAddr :: V4 (v4) => self . partial_cmp (v4) , IpAddr :: V6 (_) => Some (Ordering :: Less) , } } } impl Ord for Ipv4Addr { fn cmp (& self , other : & Ipv4Addr) -> Ordering { u32 :: from_be (self . inner . s_addr) . cmp (& u32 :: from_be (other . inner . s_addr)) } } impl IntoInner < c :: in_addr > for Ipv4Addr { fn into_inner (self) -> c :: in_addr { self . inner } } impl From < Ipv4Addr > for u32 { fn from (ip : Ipv4Addr) -> u32 { let ip = ip . octets () ; u32 :: from_be_bytes (ip) } } impl From < u32 > for Ipv4Addr { fn from (ip : u32) -> Ipv4Addr { Ipv4Addr :: from (ip . to_be_bytes ()) } } impl From < [u8 ; 4] > for Ipv4Addr { fn from (octets : [u8 ; 4]) -> Ipv4Addr { Ipv4Addr :: new (octets [0] , octets [1] , octets [2] , octets [3]) } } impl From < [u8 ; 4] > for IpAddr { fn from (octets : [u8 ; 4]) -> IpAddr { IpAddr :: V4 (Ipv4Addr :: from (octets)) } } impl Ipv6Addr { pub const fn new (a : u16 , b : u16 , c : u16 , d : u16 , e : u16 , f : u16 , g : u16 , h : u16) -> Ipv6Addr { let addr16 = [a . to_be () , b . to_be () , c . to_be () , d . to_be () , e . to_be () , f . to_be () , g . to_be () , h . to_be () ,] ; Ipv6Addr { inner : c :: in6_addr { s6_addr : unsafe { transmute :: < _ , [u8 ; 16] > (addr16) } , } , } } pub const LOCALHOST : Self = Ipv6Addr :: new (0 , 0 , 0 , 0 , 0 , 0 , 0 , 1) ; pub const UNSPECIFIED : Self = Ipv6Addr :: new (0 , 0 , 0 , 0 , 0 , 0 , 0 , 0) ; pub const fn segments (& self) -> [u16 ; 8] { let [a , b , c , d , e , f , g , h] = unsafe { transmute :: < _ , [u16 ; 8] > (self . inner . s6_addr) } ; [u16 :: from_be (a) , u16 :: from_be (b) , u16 :: from_be (c) , u16 :: from_be (d) , u16 :: from_be (e) , u16 :: from_be (f) , u16 :: from_be (g) , u16 :: from_be (h) ,] } pub const fn is_unspecified (& self) -> bool { u128 :: from_be_bytes (self . octets ()) == u128 :: from_be_bytes (Ipv6Addr :: UNSPECIFIED . octets ()) } pub const fn is_loopback (& self) -> bool { u128 :: from_be_bytes (self . octets ()) == u128 :: from_be_bytes (Ipv6Addr :: LOCALHOST . octets ()) } pub const fn is_global (& self) -> bool { match self . multicast_scope () { Some (Ipv6MulticastScope :: Global) => true , None => self . is_unicast_global () , _ => false , } } pub const fn is_unique_local (& self) -> bool { (self . segments () [0] & 0xfe00) == 0xfc00 } pub const fn is_unicast (& self) -> bool { ! self . is_multicast () } pub const fn is_unicast_link_local (& self) -> bool { (self . segments () [0] & 0xffc0) == 0xfe80 } pub const fn is_documentation (& self) -> bool { (self . segments () [0] == 0x2001) && (self . segments () [1] == 0xdb8) } pub const fn is_benchmarking (& self) -> bool { (self . segments () [0] == 0x2001) && (self . segments () [1] == 0x2) && (self . segments () [2] == 0) } pub const fn is_unicast_global (& self) -> bool { self . is_unicast () && ! self . is_loopback () && ! self . is_unicast_link_local () && ! self . is_unique_local () && ! self . is_unspecified () && ! self . is_documentation () } pub const fn multicast_scope (& self) -> Option < Ipv6MulticastScope > { if self . is_multicast () { match self . segments () [0] & 0x000f { 1 => Some (Ipv6MulticastScope :: InterfaceLocal) , 2 => Some (Ipv6MulticastScope :: LinkLocal) , 3 => Some (Ipv6MulticastScope :: RealmLocal) , 4 => Some (Ipv6MulticastScope :: AdminLocal) , 5 => Some (Ipv6MulticastScope :: SiteLocal) , 8 => Some (Ipv6MulticastScope :: OrganizationLocal) , 14 => Some (Ipv6MulticastScope :: Global) , _ => None , } } else { None } } pub const fn is_multicast (& self) -> bool { (self . segments () [0] & 0xff00) == 0xff00 } pub const fn to_ipv4_mapped (& self) -> Option < Ipv4Addr > { match self . octets () { [0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0xff , 0xff , a , b , c , d] => { Some (Ipv4Addr :: new (a , b , c , d)) } _ => None , } } pub const fn to_ipv4 (& self) -> Option < Ipv4Addr > { if let [0 , 0 , 0 , 0 , 0 , 0 | 0xffff , ab , cd] = self . segments () { let [a , b] = ab . to_be_bytes () ; let [c , d] = cd . to_be_bytes () ; Some (Ipv4Addr :: new (a , b , c , d)) } else { None } } pub const fn to_canonical (& self) -> IpAddr { if let Some (mapped) = self . to_ipv4_mapped () { return IpAddr :: V4 (mapped) ; } IpAddr :: V6 (* self) } pub const fn octets (& self) -> [u8 ; 16] { self . inner . s6_addr } } impl fmt :: Display for Ipv6Addr { fn fmt (& self , f : & mut fmt :: Formatter < '_ >) -> fmt :: Result { if f . precision () . is_none () && f . width () . is_none () { let segments = self . segments () ; if self . is_unspecified () { f . write_str ("::") } else if self . is_loopback () { f . write_str ("::1") } else if let Some (ipv4) = self . to_ipv4 () { match segments [5] { 0 => write ! (f , "::{}" , ipv4) , 0xffff => write ! (f , "::ffff:{}" , ipv4) , _ => unreachable ! () , } } else { # [derive (Copy , Clone , Default)] struct Span { start : usize , len : usize , } let zeroes = { let mut longest = Span :: default () ; let mut current = Span :: default () ; for (i , & segment) in segments . iter () . enumerate () { if segment == 0 { if current . len == 0 { current . start = i ; } current . len += 1 ; if current . len > longest . len { longest = current ; } } else { current = Span :: default () ; } } longest } ; # [doc = " Write a colon-separated part of the address"] # [inline] fn fmt_subslice (f : & mut fmt :: Formatter < '_ > , chunk : & [u16]) -> fmt :: Result { if let Some ((first , tail)) = chunk . split_first () { write ! (f , "{:x}" , first) ? ; for segment in tail { f . write_char (':') ? ; write ! (f , "{:x}" , segment) ? ; } } Ok (()) } if zeroes . len > 1 { fmt_subslice (f , & segments [.. zeroes . start]) ? ; f . write_str ("::") ? ; fmt_subslice (f , & segments [zeroes . start + zeroes . len ..]) } else { fmt_subslice (f , & segments) } } } else { const IPV6_BUF_LEN : usize = (4 * 8) + 7 ; let mut buf = [0u8 ; IPV6_BUF_LEN] ; let mut buf_slice = & mut buf [..] ; write ! (buf_slice , "{}" , self) . unwrap () ; let len = IPV6_BUF_LEN - buf_slice . len () ; let buf = unsafe { crate :: str :: from_utf8_unchecked (& buf [.. len]) } ; f . pad (buf) } } } impl fmt :: Debug for Ipv6Addr { fn fmt (& self , fmt : & mut fmt :: Formatter < '_ >) -> fmt :: Result { fmt :: Display :: fmt (self , fmt) } } impl Clone for Ipv6Addr { fn clone (& self) -> Ipv6Addr { * self } } impl PartialEq for Ipv6Addr { fn eq (& self , other : & Ipv6Addr) -> bool { self . inner . s6_addr == other . inner . s6_addr } } impl PartialEq < IpAddr > for Ipv6Addr { fn eq (& self , other : & IpAddr) -> bool { match other { IpAddr :: V4 (_) => false , IpAddr :: V6 (v6) => self == v6 , } } } impl PartialEq < Ipv6Addr > for IpAddr { fn eq (& self , other : & Ipv6Addr) -> bool { match self { IpAddr :: V4 (_) => false , IpAddr :: V6 (v6) => v6 == other , } } } impl Eq for Ipv6Addr { } impl hash :: Hash for Ipv6Addr { fn hash < H : hash :: Hasher > (& self , s : & mut H) { self . inner . s6_addr . hash (s) } } impl PartialOrd for Ipv6Addr { fn partial_cmp (& self , other : & Ipv6Addr) -> Option < Ordering > { Some (self . cmp (other)) } } impl PartialOrd < Ipv6Addr > for IpAddr { fn partial_cmp (& self , other : & Ipv6Addr) -> Option < Ordering > { match self { IpAddr :: V4 (_) => Some (Ordering :: Less) , IpAddr :: V6 (v6) => v6 . partial_cmp (other) , } } } impl PartialOrd < IpAddr > for Ipv6Addr { fn partial_cmp (& self , other : & IpAddr) -> Option < Ordering > { match other { IpAddr :: V4 (_) => Some (Ordering :: Greater) , IpAddr :: V6 (v6) => self . partial_cmp (v6) , } } } impl Ord for Ipv6Addr { fn cmp (& self , other : & Ipv6Addr) -> Ordering { self . segments () . cmp (& other . segments ()) } } impl AsInner < c :: in6_addr > for Ipv6Addr { fn as_inner (& self) -> & c :: in6_addr { & self . inner } } impl FromInner < c :: in6_addr > for Ipv6Addr { fn from_inner (addr : c :: in6_addr) -> Ipv6Addr { Ipv6Addr { inner : addr } } } impl From < Ipv6Addr > for u128 { fn from (ip : Ipv6Addr) -> u128 { let ip = ip . octets () ; u128 :: from_be_bytes (ip) } } impl From < u128 > for Ipv6Addr { fn from (ip : u128) -> Ipv6Addr { Ipv6Addr :: from (ip . to_be_bytes ()) } } impl From < [u8 ; 16] > for Ipv6Addr { fn from (octets : [u8 ; 16]) -> Ipv6Addr { let inner = c :: in6_addr { s6_addr : octets } ; Ipv6Addr :: from_inner (inner) } } impl From < [u16 ; 8] > for Ipv6Addr { fn from (segments : [u16 ; 8]) -> Ipv6Addr { let [a , b , c , d , e , f , g , h] = segments ; Ipv6Addr :: new (a , b , c , d , e , f , g , h) } } impl From < [u8 ; 16] > for IpAddr { fn from (octets : [u8 ; 16]) -> IpAddr { IpAddr :: V6 (Ipv6Addr :: from (octets)) } } impl From < [u16 ; 8] > for IpAddr { fn from (segments : [u16 ; 8]) -> IpAddr { IpAddr :: V6 (Ipv6Addr :: from (segments)) } }
diff --git a/prettyplease/examples/output.prettyplease.rs b/prettyplease/examples/output.prettyplease.rs
new file mode 100644
index 0000000000..45b65d00f1
--- /dev/null
+++ b/prettyplease/examples/output.prettyplease.rs
@@ -0,0 +1,593 @@
+use crate::cmp::Ordering;
+use crate::fmt::{self, Write as FmtWrite};
+use crate::hash;
+use crate::io::Write as IoWrite;
+use crate::mem::transmute;
+use crate::sys::net::netc as c;
+use crate::sys_common::{AsInner, FromInner, IntoInner};
+#[derive(Copy, Clone, Eq, PartialEq, Hash, PartialOrd, Ord)]
+pub enum IpAddr {
+    V4(Ipv4Addr),
+    V6(Ipv6Addr),
+}
+#[derive(Copy)]
+pub struct Ipv4Addr {
+    inner: c::in_addr,
+}
+#[derive(Copy)]
+pub struct Ipv6Addr {
+    inner: c::in6_addr,
+}
+#[derive(Copy, PartialEq, Eq, Clone, Hash, Debug)]
+#[non_exhaustive]
+pub enum Ipv6MulticastScope {
+    InterfaceLocal,
+    LinkLocal,
+    RealmLocal,
+    AdminLocal,
+    SiteLocal,
+    OrganizationLocal,
+    Global,
+}
+impl IpAddr {
+    pub const fn is_unspecified(&self) -> bool {
+        match self {
+            IpAddr::V4(ip) => ip.is_unspecified(),
+            IpAddr::V6(ip) => ip.is_unspecified(),
+        }
+    }
+    pub const fn is_loopback(&self) -> bool {
+        match self {
+            IpAddr::V4(ip) => ip.is_loopback(),
+            IpAddr::V6(ip) => ip.is_loopback(),
+        }
+    }
+    pub const fn is_global(&self) -> bool {
+        match self {
+            IpAddr::V4(ip) => ip.is_global(),
+            IpAddr::V6(ip) => ip.is_global(),
+        }
+    }
+    pub const fn is_multicast(&self) -> bool {
+        match self {
+            IpAddr::V4(ip) => ip.is_multicast(),
+            IpAddr::V6(ip) => ip.is_multicast(),
+        }
+    }
+    pub const fn is_documentation(&self) -> bool {
+        match self {
+            IpAddr::V4(ip) => ip.is_documentation(),
+            IpAddr::V6(ip) => ip.is_documentation(),
+        }
+    }
+    pub const fn is_benchmarking(&self) -> bool {
+        match self {
+            IpAddr::V4(ip) => ip.is_benchmarking(),
+            IpAddr::V6(ip) => ip.is_benchmarking(),
+        }
+    }
+    pub const fn is_ipv4(&self) -> bool {
+        matches!(self, IpAddr::V4(_))
+    }
+    pub const fn is_ipv6(&self) -> bool {
+        matches!(self, IpAddr::V6(_))
+    }
+    pub const fn to_canonical(&self) -> IpAddr {
+        match self {
+            &v4 @ IpAddr::V4(_) => v4,
+            IpAddr::V6(v6) => v6.to_canonical(),
+        }
+    }
+}
+impl Ipv4Addr {
+    pub const fn new(a: u8, b: u8, c: u8, d: u8) -> Ipv4Addr {
+        Ipv4Addr {
+            inner: c::in_addr {
+                s_addr: u32::from_ne_bytes([a, b, c, d]),
+            },
+        }
+    }
+    pub const LOCALHOST: Self = Ipv4Addr::new(127, 0, 0, 1);
+    #[doc(alias = "INADDR_ANY")]
+    pub const UNSPECIFIED: Self = Ipv4Addr::new(0, 0, 0, 0);
+    pub const BROADCAST: Self = Ipv4Addr::new(255, 255, 255, 255);
+    pub const fn octets(&self) -> [u8; 4] {
+        self.inner.s_addr.to_ne_bytes()
+    }
+    pub const fn is_unspecified(&self) -> bool {
+        self.inner.s_addr == 0
+    }
+    pub const fn is_loopback(&self) -> bool {
+        self.octets()[0] == 127
+    }
+    pub const fn is_private(&self) -> bool {
+        match self.octets() {
+            [10, ..] => true,
+            [172, b, ..] if b >= 16 && b <= 31 => true,
+            [192, 168, ..] => true,
+            _ => false,
+        }
+    }
+    pub const fn is_link_local(&self) -> bool {
+        matches!(self.octets(), [169, 254, ..])
+    }
+    pub const fn is_global(&self) -> bool {
+        if u32::from_be_bytes(self.octets()) == 0xc0000009
+            || u32::from_be_bytes(self.octets()) == 0xc000000a
+        {
+            return true;
+        }
+        !self.is_private() && !self.is_loopback() && !self.is_link_local()
+            && !self.is_broadcast() && !self.is_documentation() && !self.is_shared()
+            && !(self.octets()[0] == 192 && self.octets()[1] == 0
+                && self.octets()[2] == 0) && !self.is_reserved()
+            && !self.is_benchmarking() && self.octets()[0] != 0
+    }
+    pub const fn is_shared(&self) -> bool {
+        self.octets()[0] == 100 && (self.octets()[1] & 0b1100_0000 == 0b0100_0000)
+    }
+    pub const fn is_benchmarking(&self) -> bool {
+        self.octets()[0] == 198 && (self.octets()[1] & 0xfe) == 18
+    }
+    pub const fn is_reserved(&self) -> bool {
+        self.octets()[0] & 240 == 240 && !self.is_broadcast()
+    }
+    pub const fn is_multicast(&self) -> bool {
+        self.octets()[0] >= 224 && self.octets()[0] <= 239
+    }
+    pub const fn is_broadcast(&self) -> bool {
+        u32::from_be_bytes(self.octets()) == u32::from_be_bytes(Self::BROADCAST.octets())
+    }
+    pub const fn is_documentation(&self) -> bool {
+        matches!(self.octets(), [192, 0, 2, _] | [198, 51, 100, _] | [203, 0, 113, _])
+    }
+    pub const fn to_ipv6_compatible(&self) -> Ipv6Addr {
+        let [a, b, c, d] = self.octets();
+        Ipv6Addr {
+            inner: c::in6_addr {
+                s6_addr: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, a, b, c, d],
+            },
+        }
+    }
+    pub const fn to_ipv6_mapped(&self) -> Ipv6Addr {
+        let [a, b, c, d] = self.octets();
+        Ipv6Addr {
+            inner: c::in6_addr {
+                s6_addr: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF, a, b, c, d],
+            },
+        }
+    }
+}
+impl fmt::Display for IpAddr {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            IpAddr::V4(ip) => ip.fmt(fmt),
+            IpAddr::V6(ip) => ip.fmt(fmt),
+        }
+    }
+}
+impl fmt::Debug for IpAddr {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Display::fmt(self, fmt)
+    }
+}
+impl From<Ipv4Addr> for IpAddr {
+    fn from(ipv4: Ipv4Addr) -> IpAddr {
+        IpAddr::V4(ipv4)
+    }
+}
+impl From<Ipv6Addr> for IpAddr {
+    fn from(ipv6: Ipv6Addr) -> IpAddr {
+        IpAddr::V6(ipv6)
+    }
+}
+impl fmt::Display for Ipv4Addr {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let octets = self.octets();
+        if fmt.precision().is_none() && fmt.width().is_none() {
+            write!(fmt, "{}.{}.{}.{}", octets[0], octets[1], octets[2], octets[3])
+        } else {
+            const IPV4_BUF_LEN: usize = 15;
+            let mut buf = [0u8; IPV4_BUF_LEN];
+            let mut buf_slice = &mut buf[..];
+            write!(buf_slice, "{}.{}.{}.{}", octets[0], octets[1], octets[2], octets[3])
+                .unwrap();
+            let len = IPV4_BUF_LEN - buf_slice.len();
+            let buf = unsafe { crate::str::from_utf8_unchecked(&buf[..len]) };
+            fmt.pad(buf)
+        }
+    }
+}
+impl fmt::Debug for Ipv4Addr {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Display::fmt(self, fmt)
+    }
+}
+impl Clone for Ipv4Addr {
+    fn clone(&self) -> Ipv4Addr {
+        *self
+    }
+}
+impl PartialEq for Ipv4Addr {
+    fn eq(&self, other: &Ipv4Addr) -> bool {
+        self.inner.s_addr == other.inner.s_addr
+    }
+}
+impl PartialEq<Ipv4Addr> for IpAddr {
+    fn eq(&self, other: &Ipv4Addr) -> bool {
+        match self {
+            IpAddr::V4(v4) => v4 == other,
+            IpAddr::V6(_) => false,
+        }
+    }
+}
+impl PartialEq<IpAddr> for Ipv4Addr {
+    fn eq(&self, other: &IpAddr) -> bool {
+        match other {
+            IpAddr::V4(v4) => self == v4,
+            IpAddr::V6(_) => false,
+        }
+    }
+}
+impl Eq for Ipv4Addr {}
+impl hash::Hash for Ipv4Addr {
+    fn hash<H: hash::Hasher>(&self, s: &mut H) {
+        { self.inner.s_addr }.hash(s)
+    }
+}
+impl PartialOrd for Ipv4Addr {
+    fn partial_cmp(&self, other: &Ipv4Addr) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+impl PartialOrd<Ipv4Addr> for IpAddr {
+    fn partial_cmp(&self, other: &Ipv4Addr) -> Option<Ordering> {
+        match self {
+            IpAddr::V4(v4) => v4.partial_cmp(other),
+            IpAddr::V6(_) => Some(Ordering::Greater),
+        }
+    }
+}
+impl PartialOrd<IpAddr> for Ipv4Addr {
+    fn partial_cmp(&self, other: &IpAddr) -> Option<Ordering> {
+        match other {
+            IpAddr::V4(v4) => self.partial_cmp(v4),
+            IpAddr::V6(_) => Some(Ordering::Less),
+        }
+    }
+}
+impl Ord for Ipv4Addr {
+    fn cmp(&self, other: &Ipv4Addr) -> Ordering {
+        u32::from_be(self.inner.s_addr).cmp(&u32::from_be(other.inner.s_addr))
+    }
+}
+impl IntoInner<c::in_addr> for Ipv4Addr {
+    fn into_inner(self) -> c::in_addr {
+        self.inner
+    }
+}
+impl From<Ipv4Addr> for u32 {
+    fn from(ip: Ipv4Addr) -> u32 {
+        let ip = ip.octets();
+        u32::from_be_bytes(ip)
+    }
+}
+impl From<u32> for Ipv4Addr {
+    fn from(ip: u32) -> Ipv4Addr {
+        Ipv4Addr::from(ip.to_be_bytes())
+    }
+}
+impl From<[u8; 4]> for Ipv4Addr {
+    fn from(octets: [u8; 4]) -> Ipv4Addr {
+        Ipv4Addr::new(octets[0], octets[1], octets[2], octets[3])
+    }
+}
+impl From<[u8; 4]> for IpAddr {
+    fn from(octets: [u8; 4]) -> IpAddr {
+        IpAddr::V4(Ipv4Addr::from(octets))
+    }
+}
+impl Ipv6Addr {
+    pub const fn new(
+        a: u16,
+        b: u16,
+        c: u16,
+        d: u16,
+        e: u16,
+        f: u16,
+        g: u16,
+        h: u16,
+    ) -> Ipv6Addr {
+        let addr16 = [
+            a.to_be(),
+            b.to_be(),
+            c.to_be(),
+            d.to_be(),
+            e.to_be(),
+            f.to_be(),
+            g.to_be(),
+            h.to_be(),
+        ];
+        Ipv6Addr {
+            inner: c::in6_addr {
+                s6_addr: unsafe { transmute::<_, [u8; 16]>(addr16) },
+            },
+        }
+    }
+    pub const LOCALHOST: Self = Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1);
+    pub const UNSPECIFIED: Self = Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 0);
+    pub const fn segments(&self) -> [u16; 8] {
+        let [a, b, c, d, e, f, g, h] = unsafe {
+            transmute::<_, [u16; 8]>(self.inner.s6_addr)
+        };
+        [
+            u16::from_be(a),
+            u16::from_be(b),
+            u16::from_be(c),
+            u16::from_be(d),
+            u16::from_be(e),
+            u16::from_be(f),
+            u16::from_be(g),
+            u16::from_be(h),
+        ]
+    }
+    pub const fn is_unspecified(&self) -> bool {
+        u128::from_be_bytes(self.octets())
+            == u128::from_be_bytes(Ipv6Addr::UNSPECIFIED.octets())
+    }
+    pub const fn is_loopback(&self) -> bool {
+        u128::from_be_bytes(self.octets())
+            == u128::from_be_bytes(Ipv6Addr::LOCALHOST.octets())
+    }
+    pub const fn is_global(&self) -> bool {
+        match self.multicast_scope() {
+            Some(Ipv6MulticastScope::Global) => true,
+            None => self.is_unicast_global(),
+            _ => false,
+        }
+    }
+    pub const fn is_unique_local(&self) -> bool {
+        (self.segments()[0] & 0xfe00) == 0xfc00
+    }
+    pub const fn is_unicast(&self) -> bool {
+        !self.is_multicast()
+    }
+    pub const fn is_unicast_link_local(&self) -> bool {
+        (self.segments()[0] & 0xffc0) == 0xfe80
+    }
+    pub const fn is_documentation(&self) -> bool {
+        (self.segments()[0] == 0x2001) && (self.segments()[1] == 0xdb8)
+    }
+    pub const fn is_benchmarking(&self) -> bool {
+        (self.segments()[0] == 0x2001) && (self.segments()[1] == 0x2)
+            && (self.segments()[2] == 0)
+    }
+    pub const fn is_unicast_global(&self) -> bool {
+        self.is_unicast() && !self.is_loopback() && !self.is_unicast_link_local()
+            && !self.is_unique_local() && !self.is_unspecified()
+            && !self.is_documentation()
+    }
+    pub const fn multicast_scope(&self) -> Option<Ipv6MulticastScope> {
+        if self.is_multicast() {
+            match self.segments()[0] & 0x000f {
+                1 => Some(Ipv6MulticastScope::InterfaceLocal),
+                2 => Some(Ipv6MulticastScope::LinkLocal),
+                3 => Some(Ipv6MulticastScope::RealmLocal),
+                4 => Some(Ipv6MulticastScope::AdminLocal),
+                5 => Some(Ipv6MulticastScope::SiteLocal),
+                8 => Some(Ipv6MulticastScope::OrganizationLocal),
+                14 => Some(Ipv6MulticastScope::Global),
+                _ => None,
+            }
+        } else {
+            None
+        }
+    }
+    pub const fn is_multicast(&self) -> bool {
+        (self.segments()[0] & 0xff00) == 0xff00
+    }
+    pub const fn to_ipv4_mapped(&self) -> Option<Ipv4Addr> {
+        match self.octets() {
+            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff, a, b, c, d] => {
+                Some(Ipv4Addr::new(a, b, c, d))
+            }
+            _ => None,
+        }
+    }
+    pub const fn to_ipv4(&self) -> Option<Ipv4Addr> {
+        if let [0, 0, 0, 0, 0, 0 | 0xffff, ab, cd] = self.segments() {
+            let [a, b] = ab.to_be_bytes();
+            let [c, d] = cd.to_be_bytes();
+            Some(Ipv4Addr::new(a, b, c, d))
+        } else {
+            None
+        }
+    }
+    pub const fn to_canonical(&self) -> IpAddr {
+        if let Some(mapped) = self.to_ipv4_mapped() {
+            return IpAddr::V4(mapped);
+        }
+        IpAddr::V6(*self)
+    }
+    pub const fn octets(&self) -> [u8; 16] {
+        self.inner.s6_addr
+    }
+}
+impl fmt::Display for Ipv6Addr {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if f.precision().is_none() && f.width().is_none() {
+            let segments = self.segments();
+            if self.is_unspecified() {
+                f.write_str("::")
+            } else if self.is_loopback() {
+                f.write_str("::1")
+            } else if let Some(ipv4) = self.to_ipv4() {
+                match segments[5] {
+                    0 => write!(f, "::{}", ipv4),
+                    0xffff => write!(f, "::ffff:{}", ipv4),
+                    _ => unreachable!(),
+                }
+            } else {
+                #[derive(Copy, Clone, Default)]
+                struct Span {
+                    start: usize,
+                    len: usize,
+                }
+                let zeroes = {
+                    let mut longest = Span::default();
+                    let mut current = Span::default();
+                    for (i, &segment) in segments.iter().enumerate() {
+                        if segment == 0 {
+                            if current.len == 0 {
+                                current.start = i;
+                            }
+                            current.len += 1;
+                            if current.len > longest.len {
+                                longest = current;
+                            }
+                        } else {
+                            current = Span::default();
+                        }
+                    }
+                    longest
+                };
+                /// Write a colon-separated part of the address
+                #[inline]
+                fn fmt_subslice(
+                    f: &mut fmt::Formatter<'_>,
+                    chunk: &[u16],
+                ) -> fmt::Result {
+                    if let Some((first, tail)) = chunk.split_first() {
+                        write!(f, "{:x}", first)?;
+                        for segment in tail {
+                            f.write_char(':')?;
+                            write!(f, "{:x}", segment)?;
+                        }
+                    }
+                    Ok(())
+                }
+                if zeroes.len > 1 {
+                    fmt_subslice(f, &segments[..zeroes.start])?;
+                    f.write_str("::")?;
+                    fmt_subslice(f, &segments[zeroes.start + zeroes.len..])
+                } else {
+                    fmt_subslice(f, &segments)
+                }
+            }
+        } else {
+            const IPV6_BUF_LEN: usize = (4 * 8) + 7;
+            let mut buf = [0u8; IPV6_BUF_LEN];
+            let mut buf_slice = &mut buf[..];
+            write!(buf_slice, "{}", self).unwrap();
+            let len = IPV6_BUF_LEN - buf_slice.len();
+            let buf = unsafe { crate::str::from_utf8_unchecked(&buf[..len]) };
+            f.pad(buf)
+        }
+    }
+}
+impl fmt::Debug for Ipv6Addr {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Display::fmt(self, fmt)
+    }
+}
+impl Clone for Ipv6Addr {
+    fn clone(&self) -> Ipv6Addr {
+        *self
+    }
+}
+impl PartialEq for Ipv6Addr {
+    fn eq(&self, other: &Ipv6Addr) -> bool {
+        self.inner.s6_addr == other.inner.s6_addr
+    }
+}
+impl PartialEq<IpAddr> for Ipv6Addr {
+    fn eq(&self, other: &IpAddr) -> bool {
+        match other {
+            IpAddr::V4(_) => false,
+            IpAddr::V6(v6) => self == v6,
+        }
+    }
+}
+impl PartialEq<Ipv6Addr> for IpAddr {
+    fn eq(&self, other: &Ipv6Addr) -> bool {
+        match self {
+            IpAddr::V4(_) => false,
+            IpAddr::V6(v6) => v6 == other,
+        }
+    }
+}
+impl Eq for Ipv6Addr {}
+impl hash::Hash for Ipv6Addr {
+    fn hash<H: hash::Hasher>(&self, s: &mut H) {
+        self.inner.s6_addr.hash(s)
+    }
+}
+impl PartialOrd for Ipv6Addr {
+    fn partial_cmp(&self, other: &Ipv6Addr) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+impl PartialOrd<Ipv6Addr> for IpAddr {
+    fn partial_cmp(&self, other: &Ipv6Addr) -> Option<Ordering> {
+        match self {
+            IpAddr::V4(_) => Some(Ordering::Less),
+            IpAddr::V6(v6) => v6.partial_cmp(other),
+        }
+    }
+}
+impl PartialOrd<IpAddr> for Ipv6Addr {
+    fn partial_cmp(&self, other: &IpAddr) -> Option<Ordering> {
+        match other {
+            IpAddr::V4(_) => Some(Ordering::Greater),
+            IpAddr::V6(v6) => self.partial_cmp(v6),
+        }
+    }
+}
+impl Ord for Ipv6Addr {
+    fn cmp(&self, other: &Ipv6Addr) -> Ordering {
+        self.segments().cmp(&other.segments())
+    }
+}
+impl AsInner<c::in6_addr> for Ipv6Addr {
+    fn as_inner(&self) -> &c::in6_addr {
+        &self.inner
+    }
+}
+impl FromInner<c::in6_addr> for Ipv6Addr {
+    fn from_inner(addr: c::in6_addr) -> Ipv6Addr {
+        Ipv6Addr { inner: addr }
+    }
+}
+impl From<Ipv6Addr> for u128 {
+    fn from(ip: Ipv6Addr) -> u128 {
+        let ip = ip.octets();
+        u128::from_be_bytes(ip)
+    }
+}
+impl From<u128> for Ipv6Addr {
+    fn from(ip: u128) -> Ipv6Addr {
+        Ipv6Addr::from(ip.to_be_bytes())
+    }
+}
+impl From<[u8; 16]> for Ipv6Addr {
+    fn from(octets: [u8; 16]) -> Ipv6Addr {
+        let inner = c::in6_addr { s6_addr: octets };
+        Ipv6Addr::from_inner(inner)
+    }
+}
+impl From<[u16; 8]> for Ipv6Addr {
+    fn from(segments: [u16; 8]) -> Ipv6Addr {
+        let [a, b, c, d, e, f, g, h] = segments;
+        Ipv6Addr::new(a, b, c, d, e, f, g, h)
+    }
+}
+impl From<[u8; 16]> for IpAddr {
+    fn from(octets: [u8; 16]) -> IpAddr {
+        IpAddr::V6(Ipv6Addr::from(octets))
+    }
+}
+impl From<[u16; 8]> for IpAddr {
+    fn from(segments: [u16; 8]) -> IpAddr {
+        IpAddr::V6(Ipv6Addr::from(segments))
+    }
+}
diff --git a/prettyplease/examples/output.rustc.rs b/prettyplease/examples/output.rustc.rs
new file mode 100644
index 0000000000..8fa19b4d7c
--- /dev/null
+++ b/prettyplease/examples/output.rustc.rs
@@ -0,0 +1,504 @@
+use crate::cmp::Ordering;
+use crate::fmt::{self, Write as FmtWrite};
+use crate::hash;
+use crate::io::Write as IoWrite;
+use crate::mem::transmute;
+use crate::sys::net::netc as c;
+use crate::sys_common::{AsInner, FromInner, IntoInner};
+#[derive(Copy, Clone, Eq, PartialEq, Hash, PartialOrd, Ord)]
+pub enum IpAddr { V4(Ipv4Addr), V6(Ipv6Addr), }
+#[derive(Copy)]
+pub struct Ipv4Addr {
+    inner: c::in_addr,
+}
+#[derive(Copy)]
+pub struct Ipv6Addr {
+    inner: c::in6_addr,
+}
+#[derive(Copy, PartialEq, Eq, Clone, Hash, Debug)]
+#[non_exhaustive]
+pub enum Ipv6MulticastScope {
+    InterfaceLocal,
+    LinkLocal,
+    RealmLocal,
+    AdminLocal,
+    SiteLocal,
+    OrganizationLocal,
+    Global,
+}
+impl IpAddr {
+    pub const fn is_unspecified(&self) -> bool {
+        match self {
+            IpAddr::V4(ip) => ip.is_unspecified(),
+            IpAddr::V6(ip) => ip.is_unspecified(),
+        }
+    }
+    pub const fn is_loopback(&self) -> bool {
+        match self {
+            IpAddr::V4(ip) => ip.is_loopback(),
+            IpAddr::V6(ip) => ip.is_loopback(),
+        }
+    }
+    pub const fn is_global(&self) -> bool {
+        match self {
+            IpAddr::V4(ip) => ip.is_global(),
+            IpAddr::V6(ip) => ip.is_global(),
+        }
+    }
+    pub const fn is_multicast(&self) -> bool {
+        match self {
+            IpAddr::V4(ip) => ip.is_multicast(),
+            IpAddr::V6(ip) => ip.is_multicast(),
+        }
+    }
+    pub const fn is_documentation(&self) -> bool {
+        match self {
+            IpAddr::V4(ip) => ip.is_documentation(),
+            IpAddr::V6(ip) => ip.is_documentation(),
+        }
+    }
+    pub const fn is_benchmarking(&self) -> bool {
+        match self {
+            IpAddr::V4(ip) => ip.is_benchmarking(),
+            IpAddr::V6(ip) => ip.is_benchmarking(),
+        }
+    }
+    pub const fn is_ipv4(&self) -> bool { matches!(self, IpAddr :: V4(_)) }
+    pub const fn is_ipv6(&self) -> bool { matches!(self, IpAddr :: V6(_)) }
+    pub const fn to_canonical(&self) -> IpAddr {
+        match self {
+            &v4 @ IpAddr::V4(_) => v4,
+            IpAddr::V6(v6) => v6.to_canonical(),
+        }
+    }
+}
+impl Ipv4Addr {
+    pub const fn new(a: u8, b: u8, c: u8, d: u8) -> Ipv4Addr {
+        Ipv4Addr{inner:
+                     c::in_addr{s_addr: u32::from_ne_bytes([a, b, c, d]),},}
+    }
+    pub const LOCALHOST: Self = Ipv4Addr::new(127, 0, 0, 1);
+    #[doc(alias = "INADDR_ANY")]
+    pub const UNSPECIFIED: Self = Ipv4Addr::new(0, 0, 0, 0);
+    pub const BROADCAST: Self = Ipv4Addr::new(255, 255, 255, 255);
+    pub const fn octets(&self) -> [u8; 4] { self.inner.s_addr.to_ne_bytes() }
+    pub const fn is_unspecified(&self) -> bool { self.inner.s_addr == 0 }
+    pub const fn is_loopback(&self) -> bool { self.octets()[0] == 127 }
+    pub const fn is_private(&self) -> bool {
+        match self.octets() {
+            [10, ..] => true,
+            [172, b, ..] if b >= 16 && b <= 31 => true,
+            [192, 168, ..] => true,
+            _ => false,
+        }
+    }
+    pub const fn is_link_local(&self) -> bool {
+        matches!(self.octets(), [169, 254, ..])
+    }
+    pub const fn is_global(&self) -> bool {
+        if u32::from_be_bytes(self.octets()) == 0xc0000009 ||
+               u32::from_be_bytes(self.octets()) == 0xc000000a {
+            return true;
+        }
+        !self.is_private() && !self.is_loopback() && !self.is_link_local() &&
+            !self.is_broadcast() && !self.is_documentation() &&
+            !self.is_shared() &&
+            !(self.octets()[0] == 192 && self.octets()[1] == 0 &&
+                  self.octets()[2] == 0) && !self.is_reserved() &&
+            !self.is_benchmarking() && self.octets()[0] != 0
+    }
+    pub const fn is_shared(&self) -> bool {
+        self.octets()[0] == 100 &&
+            (self.octets()[1] & 0b1100_0000 == 0b0100_0000)
+    }
+    pub const fn is_benchmarking(&self) -> bool {
+        self.octets()[0] == 198 && (self.octets()[1] & 0xfe) == 18
+    }
+    pub const fn is_reserved(&self) -> bool {
+        self.octets()[0] & 240 == 240 && !self.is_broadcast()
+    }
+    pub const fn is_multicast(&self) -> bool {
+        self.octets()[0] >= 224 && self.octets()[0] <= 239
+    }
+    pub const fn is_broadcast(&self) -> bool {
+        u32::from_be_bytes(self.octets()) ==
+            u32::from_be_bytes(Self::BROADCAST.octets())
+    }
+    pub const fn is_documentation(&self) -> bool {
+        matches!(self.octets(), [192, 0, 2, _] | [198, 51, 100, _] |
+                 [203, 0, 113, _])
+    }
+    pub const fn to_ipv6_compatible(&self) -> Ipv6Addr {
+        let [a, b, c, d] = self.octets();
+        Ipv6Addr{inner:
+                     c::in6_addr{s6_addr:
+                                     [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, a,
+                                      b, c, d],},}
+    }
+    pub const fn to_ipv6_mapped(&self) -> Ipv6Addr {
+        let [a, b, c, d] = self.octets();
+        Ipv6Addr{inner:
+                     c::in6_addr{s6_addr:
+                                     [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF,
+                                      0xFF, a, b, c, d],},}
+    }
+}
+impl fmt::Display for IpAddr {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            IpAddr::V4(ip) => ip.fmt(fmt),
+            IpAddr::V6(ip) => ip.fmt(fmt),
+        }
+    }
+}
+impl fmt::Debug for IpAddr {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Display::fmt(self, fmt)
+    }
+}
+impl From<Ipv4Addr> for IpAddr {
+    fn from(ipv4: Ipv4Addr) -> IpAddr { IpAddr::V4(ipv4) }
+}
+impl From<Ipv6Addr> for IpAddr {
+    fn from(ipv6: Ipv6Addr) -> IpAddr { IpAddr::V6(ipv6) }
+}
+impl fmt::Display for Ipv4Addr {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let octets = self.octets();
+        if fmt.precision().is_none() && fmt.width().is_none() {
+            write!(fmt, "{}.{}.{}.{}", octets [0], octets [1], octets [2],
+                   octets [3])
+        } else {
+            const IPV4_BUF_LEN: usize = 15;
+            let mut buf = [0u8; IPV4_BUF_LEN];
+            let mut buf_slice = &mut buf[..];
+            write!(buf_slice, "{}.{}.{}.{}", octets [0], octets [1], octets
+                   [2], octets [3]).unwrap();
+            let len = IPV4_BUF_LEN - buf_slice.len();
+            let buf = unsafe { crate::str::from_utf8_unchecked(&buf[..len]) };
+            fmt.pad(buf)
+        }
+    }
+}
+impl fmt::Debug for Ipv4Addr {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Display::fmt(self, fmt)
+    }
+}
+impl Clone for Ipv4Addr {
+    fn clone(&self) -> Ipv4Addr { *self }
+}
+impl PartialEq for Ipv4Addr {
+    fn eq(&self, other: &Ipv4Addr) -> bool {
+        self.inner.s_addr == other.inner.s_addr
+    }
+}
+impl PartialEq<Ipv4Addr> for IpAddr {
+    fn eq(&self, other: &Ipv4Addr) -> bool {
+        match self { IpAddr::V4(v4) => v4 == other, IpAddr::V6(_) => false, }
+    }
+}
+impl PartialEq<IpAddr> for Ipv4Addr {
+    fn eq(&self, other: &IpAddr) -> bool {
+        match other { IpAddr::V4(v4) => self == v4, IpAddr::V6(_) => false, }
+    }
+}
+impl Eq for Ipv4Addr {}
+impl hash::Hash for Ipv4Addr {
+    fn hash<H: hash::Hasher>(&self, s: &mut H) {
+        { self.inner.s_addr }.hash(s)
+    }
+}
+impl PartialOrd for Ipv4Addr {
+    fn partial_cmp(&self, other: &Ipv4Addr) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+impl PartialOrd<Ipv4Addr> for IpAddr {
+    fn partial_cmp(&self, other: &Ipv4Addr) -> Option<Ordering> {
+        match self {
+            IpAddr::V4(v4) => v4.partial_cmp(other),
+            IpAddr::V6(_) => Some(Ordering::Greater),
+        }
+    }
+}
+impl PartialOrd<IpAddr> for Ipv4Addr {
+    fn partial_cmp(&self, other: &IpAddr) -> Option<Ordering> {
+        match other {
+            IpAddr::V4(v4) => self.partial_cmp(v4),
+            IpAddr::V6(_) => Some(Ordering::Less),
+        }
+    }
+}
+impl Ord for Ipv4Addr {
+    fn cmp(&self, other: &Ipv4Addr) -> Ordering {
+        u32::from_be(self.inner.s_addr).cmp(&u32::from_be(other.inner.s_addr))
+    }
+}
+impl IntoInner<c::in_addr> for Ipv4Addr {
+    fn into_inner(self) -> c::in_addr { self.inner }
+}
+impl From<Ipv4Addr> for u32 {
+    fn from(ip: Ipv4Addr) -> u32 {
+        let ip = ip.octets();
+        u32::from_be_bytes(ip)
+    }
+}
+impl From<u32> for Ipv4Addr {
+    fn from(ip: u32) -> Ipv4Addr { Ipv4Addr::from(ip.to_be_bytes()) }
+}
+impl From<[u8; 4]> for Ipv4Addr {
+    fn from(octets: [u8; 4]) -> Ipv4Addr {
+        Ipv4Addr::new(octets[0], octets[1], octets[2], octets[3])
+    }
+}
+impl From<[u8; 4]> for IpAddr {
+    fn from(octets: [u8; 4]) -> IpAddr { IpAddr::V4(Ipv4Addr::from(octets)) }
+}
+impl Ipv6Addr {
+    pub const fn new(a: u16, b: u16, c: u16, d: u16, e: u16, f: u16, g: u16,
+                     h: u16) -> Ipv6Addr {
+        let addr16 =
+            [a.to_be(), b.to_be(), c.to_be(), d.to_be(), e.to_be(), f.to_be(),
+             g.to_be(), h.to_be()];
+        Ipv6Addr{inner:
+                     c::in6_addr{s6_addr:
+                                     unsafe {
+                                         transmute::<_, [u8; 16]>(addr16)
+                                     },},}
+    }
+    pub const LOCALHOST: Self = Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1);
+    pub const UNSPECIFIED: Self = Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 0);
+    pub const fn segments(&self) -> [u16; 8] {
+        let [a, b, c, d, e, f, g, h] =
+            unsafe { transmute::<_, [u16; 8]>(self.inner.s6_addr) };
+        [u16::from_be(a), u16::from_be(b), u16::from_be(c), u16::from_be(d),
+         u16::from_be(e), u16::from_be(f), u16::from_be(g), u16::from_be(h)]
+    }
+    pub const fn is_unspecified(&self) -> bool {
+        u128::from_be_bytes(self.octets()) ==
+            u128::from_be_bytes(Ipv6Addr::UNSPECIFIED.octets())
+    }
+    pub const fn is_loopback(&self) -> bool {
+        u128::from_be_bytes(self.octets()) ==
+            u128::from_be_bytes(Ipv6Addr::LOCALHOST.octets())
+    }
+    pub const fn is_global(&self) -> bool {
+        match self.multicast_scope() {
+            Some(Ipv6MulticastScope::Global) => true,
+            None => self.is_unicast_global(),
+            _ => false,
+        }
+    }
+    pub const fn is_unique_local(&self) -> bool {
+        (self.segments()[0] & 0xfe00) == 0xfc00
+    }
+    pub const fn is_unicast(&self) -> bool { !self.is_multicast() }
+    pub const fn is_unicast_link_local(&self) -> bool {
+        (self.segments()[0] & 0xffc0) == 0xfe80
+    }
+    pub const fn is_documentation(&self) -> bool {
+        (self.segments()[0] == 0x2001) && (self.segments()[1] == 0xdb8)
+    }
+    pub const fn is_benchmarking(&self) -> bool {
+        (self.segments()[0] == 0x2001) && (self.segments()[1] == 0x2) &&
+            (self.segments()[2] == 0)
+    }
+    pub const fn is_unicast_global(&self) -> bool {
+        self.is_unicast() && !self.is_loopback() &&
+            !self.is_unicast_link_local() && !self.is_unique_local() &&
+            !self.is_unspecified() && !self.is_documentation()
+    }
+    pub const fn multicast_scope(&self) -> Option<Ipv6MulticastScope> {
+        if self.is_multicast() {
+            match self.segments()[0] & 0x000f {
+                1 => Some(Ipv6MulticastScope::InterfaceLocal),
+                2 => Some(Ipv6MulticastScope::LinkLocal),
+                3 => Some(Ipv6MulticastScope::RealmLocal),
+                4 => Some(Ipv6MulticastScope::AdminLocal),
+                5 => Some(Ipv6MulticastScope::SiteLocal),
+                8 => Some(Ipv6MulticastScope::OrganizationLocal),
+                14 => Some(Ipv6MulticastScope::Global),
+                _ => None,
+            }
+        } else { None }
+    }
+    pub const fn is_multicast(&self) -> bool {
+        (self.segments()[0] & 0xff00) == 0xff00
+    }
+    pub const fn to_ipv4_mapped(&self) -> Option<Ipv4Addr> {
+        match self.octets() {
+            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff, a, b, c, d] => {
+                Some(Ipv4Addr::new(a, b, c, d))
+            }
+            _ => None,
+        }
+    }
+    pub const fn to_ipv4(&self) -> Option<Ipv4Addr> {
+        if let [0, 0, 0, 0, 0, 0 | 0xffff, ab, cd] = self.segments() {
+            let [a, b] = ab.to_be_bytes();
+            let [c, d] = cd.to_be_bytes();
+            Some(Ipv4Addr::new(a, b, c, d))
+        } else { None }
+    }
+    pub const fn to_canonical(&self) -> IpAddr {
+        if let Some(mapped) = self.to_ipv4_mapped() {
+            return IpAddr::V4(mapped);
+        }
+        IpAddr::V6(*self)
+    }
+    pub const fn octets(&self) -> [u8; 16] { self.inner.s6_addr }
+}
+impl fmt::Display for Ipv6Addr {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if f.precision().is_none() && f.width().is_none() {
+            let segments = self.segments();
+            if self.is_unspecified() {
+                f.write_str("::")
+            } else if self.is_loopback() {
+                f.write_str("::1")
+            } else if let Some(ipv4) = self.to_ipv4() {
+                match segments[5] {
+                    0 => write!(f, "::{}", ipv4),
+                    0xffff => write!(f, "::ffff:{}", ipv4),
+                    _ => unreachable!(),
+                }
+            } else {
+                #[derive(Copy, Clone, Default)]
+                struct Span {
+                    start: usize,
+                    len: usize,
+                }
+                let zeroes =
+                    {
+                        let mut longest = Span::default();
+                        let mut current = Span::default();
+                        for (i, &segment) in segments.iter().enumerate() {
+                            if segment == 0 {
+                                if current.len == 0 { current.start = i; }
+                                current.len += 1;
+                                if current.len > longest.len {
+                                    longest = current;
+                                }
+                            } else { current = Span::default(); }
+                        }
+                        longest
+                    };
+                #[doc = " Write a colon-separated part of the address"]
+                #[inline]
+                fn fmt_subslice(f: &mut fmt::Formatter<'_>, chunk: &[u16])
+                 -> fmt::Result {
+                    if let Some((first, tail)) = chunk.split_first() {
+                        write!(f, "{:x}", first)?;
+                        for segment in tail {
+                            f.write_char(':')?;
+                            write!(f, "{:x}", segment)?;
+                        }
+                    }
+                    Ok(())
+                }
+                if zeroes.len > 1 {
+                    fmt_subslice(f, &segments[..zeroes.start])?;
+                    f.write_str("::")?;
+                    fmt_subslice(f, &segments[zeroes.start + zeroes.len..])
+                } else { fmt_subslice(f, &segments) }
+            }
+        } else {
+            const IPV6_BUF_LEN: usize = (4 * 8) + 7;
+            let mut buf = [0u8; IPV6_BUF_LEN];
+            let mut buf_slice = &mut buf[..];
+            write!(buf_slice, "{}", self).unwrap();
+            let len = IPV6_BUF_LEN - buf_slice.len();
+            let buf = unsafe { crate::str::from_utf8_unchecked(&buf[..len]) };
+            f.pad(buf)
+        }
+    }
+}
+impl fmt::Debug for Ipv6Addr {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Display::fmt(self, fmt)
+    }
+}
+impl Clone for Ipv6Addr {
+    fn clone(&self) -> Ipv6Addr { *self }
+}
+impl PartialEq for Ipv6Addr {
+    fn eq(&self, other: &Ipv6Addr) -> bool {
+        self.inner.s6_addr == other.inner.s6_addr
+    }
+}
+impl PartialEq<IpAddr> for Ipv6Addr {
+    fn eq(&self, other: &IpAddr) -> bool {
+        match other { IpAddr::V4(_) => false, IpAddr::V6(v6) => self == v6, }
+    }
+}
+impl PartialEq<Ipv6Addr> for IpAddr {
+    fn eq(&self, other: &Ipv6Addr) -> bool {
+        match self { IpAddr::V4(_) => false, IpAddr::V6(v6) => v6 == other, }
+    }
+}
+impl Eq for Ipv6Addr {}
+impl hash::Hash for Ipv6Addr {
+    fn hash<H: hash::Hasher>(&self, s: &mut H) { self.inner.s6_addr.hash(s) }
+}
+impl PartialOrd for Ipv6Addr {
+    fn partial_cmp(&self, other: &Ipv6Addr) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+impl PartialOrd<Ipv6Addr> for IpAddr {
+    fn partial_cmp(&self, other: &Ipv6Addr) -> Option<Ordering> {
+        match self {
+            IpAddr::V4(_) => Some(Ordering::Less),
+            IpAddr::V6(v6) => v6.partial_cmp(other),
+        }
+    }
+}
+impl PartialOrd<IpAddr> for Ipv6Addr {
+    fn partial_cmp(&self, other: &IpAddr) -> Option<Ordering> {
+        match other {
+            IpAddr::V4(_) => Some(Ordering::Greater),
+            IpAddr::V6(v6) => self.partial_cmp(v6),
+        }
+    }
+}
+impl Ord for Ipv6Addr {
+    fn cmp(&self, other: &Ipv6Addr) -> Ordering {
+        self.segments().cmp(&other.segments())
+    }
+}
+impl AsInner<c::in6_addr> for Ipv6Addr {
+    fn as_inner(&self) -> &c::in6_addr { &self.inner }
+}
+impl FromInner<c::in6_addr> for Ipv6Addr {
+    fn from_inner(addr: c::in6_addr) -> Ipv6Addr { Ipv6Addr{inner: addr,} }
+}
+impl From<Ipv6Addr> for u128 {
+    fn from(ip: Ipv6Addr) -> u128 {
+        let ip = ip.octets();
+        u128::from_be_bytes(ip)
+    }
+}
+impl From<u128> for Ipv6Addr {
+    fn from(ip: u128) -> Ipv6Addr { Ipv6Addr::from(ip.to_be_bytes()) }
+}
+impl From<[u8; 16]> for Ipv6Addr {
+    fn from(octets: [u8; 16]) -> Ipv6Addr {
+        let inner = c::in6_addr{s6_addr: octets,};
+        Ipv6Addr::from_inner(inner)
+    }
+}
+impl From<[u16; 8]> for Ipv6Addr {
+    fn from(segments: [u16; 8]) -> Ipv6Addr {
+        let [a, b, c, d, e, f, g, h] = segments;
+        Ipv6Addr::new(a, b, c, d, e, f, g, h)
+    }
+}
+impl From<[u8; 16]> for IpAddr {
+    fn from(octets: [u8; 16]) -> IpAddr { IpAddr::V6(Ipv6Addr::from(octets)) }
+}
+impl From<[u16; 8]> for IpAddr {
+    fn from(segments: [u16; 8]) -> IpAddr {
+        IpAddr::V6(Ipv6Addr::from(segments))
+    }
+}
diff --git a/prettyplease/examples/output.rustfmt.rs b/prettyplease/examples/output.rustfmt.rs
new file mode 100644
index 0000000000..3c7181d8ef
--- /dev/null
+++ b/prettyplease/examples/output.rustfmt.rs
@@ -0,0 +1,552 @@
+use crate::cmp::Ordering;
+use crate::fmt::{self, Write as FmtWrite};
+use crate::hash;
+use crate::io::Write as IoWrite;
+use crate::mem::transmute;
+use crate::sys::net::netc as c;
+use crate::sys_common::{AsInner, FromInner, IntoInner};
+#[derive(Copy, Clone, Eq, PartialEq, Hash, PartialOrd, Ord)]
+pub enum IpAddr {
+    V4(Ipv4Addr),
+    V6(Ipv6Addr),
+}
+#[derive(Copy)]
+pub struct Ipv4Addr {
+    inner: c::in_addr,
+}
+#[derive(Copy)]
+pub struct Ipv6Addr {
+    inner: c::in6_addr,
+}
+#[derive(Copy, PartialEq, Eq, Clone, Hash, Debug)]
+#[non_exhaustive]
+pub enum Ipv6MulticastScope {
+    InterfaceLocal,
+    LinkLocal,
+    RealmLocal,
+    AdminLocal,
+    SiteLocal,
+    OrganizationLocal,
+    Global,
+}
+impl IpAddr {
+    pub const fn is_unspecified(&self) -> bool {
+        match self {
+            IpAddr::V4(ip) => ip.is_unspecified(),
+            IpAddr::V6(ip) => ip.is_unspecified(),
+        }
+    }
+    pub const fn is_loopback(&self) -> bool {
+        match self {
+            IpAddr::V4(ip) => ip.is_loopback(),
+            IpAddr::V6(ip) => ip.is_loopback(),
+        }
+    }
+    pub const fn is_global(&self) -> bool {
+        match self {
+            IpAddr::V4(ip) => ip.is_global(),
+            IpAddr::V6(ip) => ip.is_global(),
+        }
+    }
+    pub const fn is_multicast(&self) -> bool {
+        match self {
+            IpAddr::V4(ip) => ip.is_multicast(),
+            IpAddr::V6(ip) => ip.is_multicast(),
+        }
+    }
+    pub const fn is_documentation(&self) -> bool {
+        match self {
+            IpAddr::V4(ip) => ip.is_documentation(),
+            IpAddr::V6(ip) => ip.is_documentation(),
+        }
+    }
+    pub const fn is_benchmarking(&self) -> bool {
+        match self {
+            IpAddr::V4(ip) => ip.is_benchmarking(),
+            IpAddr::V6(ip) => ip.is_benchmarking(),
+        }
+    }
+    pub const fn is_ipv4(&self) -> bool {
+        matches!(self, IpAddr::V4(_))
+    }
+    pub const fn is_ipv6(&self) -> bool {
+        matches!(self, IpAddr::V6(_))
+    }
+    pub const fn to_canonical(&self) -> IpAddr {
+        match self {
+            &v4 @ IpAddr::V4(_) => v4,
+            IpAddr::V6(v6) => v6.to_canonical(),
+        }
+    }
+}
+impl Ipv4Addr {
+    pub const fn new(a: u8, b: u8, c: u8, d: u8) -> Ipv4Addr {
+        Ipv4Addr {
+            inner: c::in_addr {
+                s_addr: u32::from_ne_bytes([a, b, c, d]),
+            },
+        }
+    }
+    pub const LOCALHOST: Self = Ipv4Addr::new(127, 0, 0, 1);
+    #[doc(alias = "INADDR_ANY")]
+    pub const UNSPECIFIED: Self = Ipv4Addr::new(0, 0, 0, 0);
+    pub const BROADCAST: Self = Ipv4Addr::new(255, 255, 255, 255);
+    pub const fn octets(&self) -> [u8; 4] {
+        self.inner.s_addr.to_ne_bytes()
+    }
+    pub const fn is_unspecified(&self) -> bool {
+        self.inner.s_addr == 0
+    }
+    pub const fn is_loopback(&self) -> bool {
+        self.octets()[0] == 127
+    }
+    pub const fn is_private(&self) -> bool {
+        match self.octets() {
+            [10, ..] => true,
+            [172, b, ..] if b >= 16 && b <= 31 => true,
+            [192, 168, ..] => true,
+            _ => false,
+        }
+    }
+    pub const fn is_link_local(&self) -> bool {
+        matches!(self.octets(), [169, 254, ..])
+    }
+    pub const fn is_global(&self) -> bool {
+        if u32::from_be_bytes(self.octets()) == 0xc0000009
+            || u32::from_be_bytes(self.octets()) == 0xc000000a
+        {
+            return true;
+        }
+        !self.is_private()
+            && !self.is_loopback()
+            && !self.is_link_local()
+            && !self.is_broadcast()
+            && !self.is_documentation()
+            && !self.is_shared()
+            && !(self.octets()[0] == 192 && self.octets()[1] == 0 && self.octets()[2] == 0)
+            && !self.is_reserved()
+            && !self.is_benchmarking()
+            && self.octets()[0] != 0
+    }
+    pub const fn is_shared(&self) -> bool {
+        self.octets()[0] == 100 && (self.octets()[1] & 0b1100_0000 == 0b0100_0000)
+    }
+    pub const fn is_benchmarking(&self) -> bool {
+        self.octets()[0] == 198 && (self.octets()[1] & 0xfe) == 18
+    }
+    pub const fn is_reserved(&self) -> bool {
+        self.octets()[0] & 240 == 240 && !self.is_broadcast()
+    }
+    pub const fn is_multicast(&self) -> bool {
+        self.octets()[0] >= 224 && self.octets()[0] <= 239
+    }
+    pub const fn is_broadcast(&self) -> bool {
+        u32::from_be_bytes(self.octets()) == u32::from_be_bytes(Self::BROADCAST.octets())
+    }
+    pub const fn is_documentation(&self) -> bool {
+        matches!(
+            self.octets(),
+            [192, 0, 2, _] | [198, 51, 100, _] | [203, 0, 113, _]
+        )
+    }
+    pub const fn to_ipv6_compatible(&self) -> Ipv6Addr {
+        let [a, b, c, d] = self.octets();
+        Ipv6Addr {
+            inner: c::in6_addr {
+                s6_addr: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, a, b, c, d],
+            },
+        }
+    }
+    pub const fn to_ipv6_mapped(&self) -> Ipv6Addr {
+        let [a, b, c, d] = self.octets();
+        Ipv6Addr {
+            inner: c::in6_addr {
+                s6_addr: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF, a, b, c, d],
+            },
+        }
+    }
+}
+impl fmt::Display for IpAddr {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            IpAddr::V4(ip) => ip.fmt(fmt),
+            IpAddr::V6(ip) => ip.fmt(fmt),
+        }
+    }
+}
+impl fmt::Debug for IpAddr {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Display::fmt(self, fmt)
+    }
+}
+impl From<Ipv4Addr> for IpAddr {
+    fn from(ipv4: Ipv4Addr) -> IpAddr {
+        IpAddr::V4(ipv4)
+    }
+}
+impl From<Ipv6Addr> for IpAddr {
+    fn from(ipv6: Ipv6Addr) -> IpAddr {
+        IpAddr::V6(ipv6)
+    }
+}
+impl fmt::Display for Ipv4Addr {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let octets = self.octets();
+        if fmt.precision().is_none() && fmt.width().is_none() {
+            write!(
+                fmt,
+                "{}.{}.{}.{}",
+                octets[0], octets[1], octets[2], octets[3]
+            )
+        } else {
+            const IPV4_BUF_LEN: usize = 15;
+            let mut buf = [0u8; IPV4_BUF_LEN];
+            let mut buf_slice = &mut buf[..];
+            write!(
+                buf_slice,
+                "{}.{}.{}.{}",
+                octets[0], octets[1], octets[2], octets[3]
+            )
+            .unwrap();
+            let len = IPV4_BUF_LEN - buf_slice.len();
+            let buf = unsafe { crate::str::from_utf8_unchecked(&buf[..len]) };
+            fmt.pad(buf)
+        }
+    }
+}
+impl fmt::Debug for Ipv4Addr {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Display::fmt(self, fmt)
+    }
+}
+impl Clone for Ipv4Addr {
+    fn clone(&self) -> Ipv4Addr {
+        *self
+    }
+}
+impl PartialEq for Ipv4Addr {
+    fn eq(&self, other: &Ipv4Addr) -> bool {
+        self.inner.s_addr == other.inner.s_addr
+    }
+}
+impl PartialEq<Ipv4Addr> for IpAddr {
+    fn eq(&self, other: &Ipv4Addr) -> bool {
+        match self {
+            IpAddr::V4(v4) => v4 == other,
+            IpAddr::V6(_) => false,
+        }
+    }
+}
+impl PartialEq<IpAddr> for Ipv4Addr {
+    fn eq(&self, other: &IpAddr) -> bool {
+        match other {
+            IpAddr::V4(v4) => self == v4,
+            IpAddr::V6(_) => false,
+        }
+    }
+}
+impl Eq for Ipv4Addr {}
+impl hash::Hash for Ipv4Addr {
+    fn hash<H: hash::Hasher>(&self, s: &mut H) {
+        { self.inner.s_addr }.hash(s)
+    }
+}
+impl PartialOrd for Ipv4Addr {
+    fn partial_cmp(&self, other: &Ipv4Addr) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+impl PartialOrd<Ipv4Addr> for IpAddr {
+    fn partial_cmp(&self, other: &Ipv4Addr) -> Option<Ordering> {
+        match self {
+            IpAddr::V4(v4) => v4.partial_cmp(other),
+            IpAddr::V6(_) => Some(Ordering::Greater),
+        }
+    }
+}
+impl PartialOrd<IpAddr> for Ipv4Addr {
+    fn partial_cmp(&self, other: &IpAddr) -> Option<Ordering> {
+        match other {
+            IpAddr::V4(v4) => self.partial_cmp(v4),
+            IpAddr::V6(_) => Some(Ordering::Less),
+        }
+    }
+}
+impl Ord for Ipv4Addr {
+    fn cmp(&self, other: &Ipv4Addr) -> Ordering {
+        u32::from_be(self.inner.s_addr).cmp(&u32::from_be(other.inner.s_addr))
+    }
+}
+impl IntoInner<c::in_addr> for Ipv4Addr {
+    fn into_inner(self) -> c::in_addr {
+        self.inner
+    }
+}
+impl From<Ipv4Addr> for u32 {
+    fn from(ip: Ipv4Addr) -> u32 {
+        let ip = ip.octets();
+        u32::from_be_bytes(ip)
+    }
+}
+impl From<u32> for Ipv4Addr {
+    fn from(ip: u32) -> Ipv4Addr {
+        Ipv4Addr::from(ip.to_be_bytes())
+    }
+}
+impl From<[u8; 4]> for Ipv4Addr {
+    fn from(octets: [u8; 4]) -> Ipv4Addr {
+        Ipv4Addr::new(octets[0], octets[1], octets[2], octets[3])
+    }
+}
+impl From<[u8; 4]> for IpAddr {
+    fn from(octets: [u8; 4]) -> IpAddr {
+        IpAddr::V4(Ipv4Addr::from(octets))
+    }
+}
+impl Ipv6Addr {
+    pub const fn new(a: u16, b: u16, c: u16, d: u16, e: u16, f: u16, g: u16, h: u16) -> Ipv6Addr {
+        let addr16 = [
+            a.to_be(),
+            b.to_be(),
+            c.to_be(),
+            d.to_be(),
+            e.to_be(),
+            f.to_be(),
+            g.to_be(),
+            h.to_be(),
+        ];
+        Ipv6Addr {
+            inner: c::in6_addr {
+                s6_addr: unsafe { transmute::<_, [u8; 16]>(addr16) },
+            },
+        }
+    }
+    pub const LOCALHOST: Self = Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1);
+    pub const UNSPECIFIED: Self = Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 0);
+    pub const fn segments(&self) -> [u16; 8] {
+        let [a, b, c, d, e, f, g, h] = unsafe { transmute::<_, [u16; 8]>(self.inner.s6_addr) };
+        [
+            u16::from_be(a),
+            u16::from_be(b),
+            u16::from_be(c),
+            u16::from_be(d),
+            u16::from_be(e),
+            u16::from_be(f),
+            u16::from_be(g),
+            u16::from_be(h),
+        ]
+    }
+    pub const fn is_unspecified(&self) -> bool {
+        u128::from_be_bytes(self.octets()) == u128::from_be_bytes(Ipv6Addr::UNSPECIFIED.octets())
+    }
+    pub const fn is_loopback(&self) -> bool {
+        u128::from_be_bytes(self.octets()) == u128::from_be_bytes(Ipv6Addr::LOCALHOST.octets())
+    }
+    pub const fn is_global(&self) -> bool {
+        match self.multicast_scope() {
+            Some(Ipv6MulticastScope::Global) => true,
+            None => self.is_unicast_global(),
+            _ => false,
+        }
+    }
+    pub const fn is_unique_local(&self) -> bool {
+        (self.segments()[0] & 0xfe00) == 0xfc00
+    }
+    pub const fn is_unicast(&self) -> bool {
+        !self.is_multicast()
+    }
+    pub const fn is_unicast_link_local(&self) -> bool {
+        (self.segments()[0] & 0xffc0) == 0xfe80
+    }
+    pub const fn is_documentation(&self) -> bool {
+        (self.segments()[0] == 0x2001) && (self.segments()[1] == 0xdb8)
+    }
+    pub const fn is_benchmarking(&self) -> bool {
+        (self.segments()[0] == 0x2001) && (self.segments()[1] == 0x2) && (self.segments()[2] == 0)
+    }
+    pub const fn is_unicast_global(&self) -> bool {
+        self.is_unicast()
+            && !self.is_loopback()
+            && !self.is_unicast_link_local()
+            && !self.is_unique_local()
+            && !self.is_unspecified()
+            && !self.is_documentation()
+    }
+    pub const fn multicast_scope(&self) -> Option<Ipv6MulticastScope> {
+        if self.is_multicast() {
+            match self.segments()[0] & 0x000f {
+                1 => Some(Ipv6MulticastScope::InterfaceLocal),
+                2 => Some(Ipv6MulticastScope::LinkLocal),
+                3 => Some(Ipv6MulticastScope::RealmLocal),
+                4 => Some(Ipv6MulticastScope::AdminLocal),
+                5 => Some(Ipv6MulticastScope::SiteLocal),
+                8 => Some(Ipv6MulticastScope::OrganizationLocal),
+                14 => Some(Ipv6MulticastScope::Global),
+                _ => None,
+            }
+        } else {
+            None
+        }
+    }
+    pub const fn is_multicast(&self) -> bool {
+        (self.segments()[0] & 0xff00) == 0xff00
+    }
+    pub const fn to_ipv4_mapped(&self) -> Option<Ipv4Addr> {
+        match self.octets() {
+            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff, a, b, c, d] => {
+                Some(Ipv4Addr::new(a, b, c, d))
+            }
+            _ => None,
+        }
+    }
+    pub const fn to_ipv4(&self) -> Option<Ipv4Addr> {
+        if let [0, 0, 0, 0, 0, 0 | 0xffff, ab, cd] = self.segments() {
+            let [a, b] = ab.to_be_bytes();
+            let [c, d] = cd.to_be_bytes();
+            Some(Ipv4Addr::new(a, b, c, d))
+        } else {
+            None
+        }
+    }
+    pub const fn to_canonical(&self) -> IpAddr {
+        if let Some(mapped) = self.to_ipv4_mapped() {
+            return IpAddr::V4(mapped);
+        }
+        IpAddr::V6(*self)
+    }
+    pub const fn octets(&self) -> [u8; 16] {
+        self.inner.s6_addr
+    }
+}
+impl fmt::Display for Ipv6Addr {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if f.precision().is_none() && f.width().is_none() {
+            let segments = self.segments();
+            if self.is_unspecified() {
+                f.write_str("::")
+            } else if self.is_loopback() {
+                f.write_str("::1")
+            } else if let Some(ipv4) = self.to_ipv4() {
+                match segments[5] {
+                    0 => write!(f, "::{}", ipv4),
+                    0xffff => write!(f, "::ffff:{}", ipv4),
+                    _ => unreachable!(),
+                }
+            } else { # [derive (Copy , Clone , Default)] struct Span { start : usize , len : usize , } let zeroes = { let mut longest = Span :: default () ; let mut current = Span :: default () ; for (i , & segment) in segments . iter () . enumerate () { if segment == 0 { if current . len == 0 { current . start = i ; } current . len += 1 ; if current . len > longest . len { longest = current ; } } else { current = Span :: default () ; } } longest } ; # [doc = " Write a colon-separated part of the address"] # [inline] fn fmt_subslice (f : & mut fmt :: Formatter < '_ > , chunk : & [u16]) -> fmt :: Result { if let Some ((first , tail)) = chunk . split_first () { write ! (f , "{:x}" , first) ? ; for segment in tail { f . write_char (':') ? ; write ! (f , "{:x}" , segment) ? ; } } Ok (()) } if zeroes . len > 1 { fmt_subslice (f , & segments [.. zeroes . start]) ? ; f . write_str ("::") ? ; fmt_subslice (f , & segments [zeroes . start + zeroes . len ..]) } else { fmt_subslice (f , & segments) } }
+        } else {
+            const IPV6_BUF_LEN: usize = (4 * 8) + 7;
+            let mut buf = [0u8; IPV6_BUF_LEN];
+            let mut buf_slice = &mut buf[..];
+            write!(buf_slice, "{}", self).unwrap();
+            let len = IPV6_BUF_LEN - buf_slice.len();
+            let buf = unsafe { crate::str::from_utf8_unchecked(&buf[..len]) };
+            f.pad(buf)
+        }
+    }
+}
+impl fmt::Debug for Ipv6Addr {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Display::fmt(self, fmt)
+    }
+}
+impl Clone for Ipv6Addr {
+    fn clone(&self) -> Ipv6Addr {
+        *self
+    }
+}
+impl PartialEq for Ipv6Addr {
+    fn eq(&self, other: &Ipv6Addr) -> bool {
+        self.inner.s6_addr == other.inner.s6_addr
+    }
+}
+impl PartialEq<IpAddr> for Ipv6Addr {
+    fn eq(&self, other: &IpAddr) -> bool {
+        match other {
+            IpAddr::V4(_) => false,
+            IpAddr::V6(v6) => self == v6,
+        }
+    }
+}
+impl PartialEq<Ipv6Addr> for IpAddr {
+    fn eq(&self, other: &Ipv6Addr) -> bool {
+        match self {
+            IpAddr::V4(_) => false,
+            IpAddr::V6(v6) => v6 == other,
+        }
+    }
+}
+impl Eq for Ipv6Addr {}
+impl hash::Hash for Ipv6Addr {
+    fn hash<H: hash::Hasher>(&self, s: &mut H) {
+        self.inner.s6_addr.hash(s)
+    }
+}
+impl PartialOrd for Ipv6Addr {
+    fn partial_cmp(&self, other: &Ipv6Addr) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+impl PartialOrd<Ipv6Addr> for IpAddr {
+    fn partial_cmp(&self, other: &Ipv6Addr) -> Option<Ordering> {
+        match self {
+            IpAddr::V4(_) => Some(Ordering::Less),
+            IpAddr::V6(v6) => v6.partial_cmp(other),
+        }
+    }
+}
+impl PartialOrd<IpAddr> for Ipv6Addr {
+    fn partial_cmp(&self, other: &IpAddr) -> Option<Ordering> {
+        match other {
+            IpAddr::V4(_) => Some(Ordering::Greater),
+            IpAddr::V6(v6) => self.partial_cmp(v6),
+        }
+    }
+}
+impl Ord for Ipv6Addr {
+    fn cmp(&self, other: &Ipv6Addr) -> Ordering {
+        self.segments().cmp(&other.segments())
+    }
+}
+impl AsInner<c::in6_addr> for Ipv6Addr {
+    fn as_inner(&self) -> &c::in6_addr {
+        &self.inner
+    }
+}
+impl FromInner<c::in6_addr> for Ipv6Addr {
+    fn from_inner(addr: c::in6_addr) -> Ipv6Addr {
+        Ipv6Addr { inner: addr }
+    }
+}
+impl From<Ipv6Addr> for u128 {
+    fn from(ip: Ipv6Addr) -> u128 {
+        let ip = ip.octets();
+        u128::from_be_bytes(ip)
+    }
+}
+impl From<u128> for Ipv6Addr {
+    fn from(ip: u128) -> Ipv6Addr {
+        Ipv6Addr::from(ip.to_be_bytes())
+    }
+}
+impl From<[u8; 16]> for Ipv6Addr {
+    fn from(octets: [u8; 16]) -> Ipv6Addr {
+        let inner = c::in6_addr { s6_addr: octets };
+        Ipv6Addr::from_inner(inner)
+    }
+}
+impl From<[u16; 8]> for Ipv6Addr {
+    fn from(segments: [u16; 8]) -> Ipv6Addr {
+        let [a, b, c, d, e, f, g, h] = segments;
+        Ipv6Addr::new(a, b, c, d, e, f, g, h)
+    }
+}
+impl From<[u8; 16]> for IpAddr {
+    fn from(octets: [u8; 16]) -> IpAddr {
+        IpAddr::V6(Ipv6Addr::from(octets))
+    }
+}
+impl From<[u16; 8]> for IpAddr {
+    fn from(segments: [u16; 8]) -> IpAddr {
+        IpAddr::V6(Ipv6Addr::from(segments))
+    }
+}
diff --git a/prettyplease/examples/update/Cargo.toml b/prettyplease/examples/update/Cargo.toml
new file mode 100644
index 0000000000..17b8c57ed8
--- /dev/null
+++ b/prettyplease/examples/update/Cargo.toml
@@ -0,0 +1,16 @@
+[package]
+name = "prettyplease-update-examples"
+version = "0.0.0"
+authors = ["David Tolnay <dtolnay@gmail.com>"]
+edition = "2021"
+publish = false
+
+[[bin]]
+name = "prettyplease-update-examples"
+path = "update-examples.rs"
+
+[dependencies]
+anyhow = "1.0"
+prettyplease = { path = "../../" }
+quote = { version = "1.0", default-features = false }
+syn = { version = "1.0", default-features = false, features = ["parsing", "printing"] }
diff --git a/prettyplease/examples/update/update-examples.rs b/prettyplease/examples/update/update-examples.rs
new file mode 100644
index 0000000000..18a29dfdfa
--- /dev/null
+++ b/prettyplease/examples/update/update-examples.rs
@@ -0,0 +1,65 @@
+#![feature(rustc_private)]
+
+extern crate rustc_ast_pretty;
+extern crate rustc_parse;
+extern crate rustc_session;
+extern crate rustc_span;
+
+use anyhow::Result;
+use quote::quote;
+use rustc_session::parse::ParseSess;
+use rustc_span::edition::Edition::Edition2021;
+use rustc_span::source_map::FilePathMapping;
+use std::fs::{self, File};
+use std::path::Path;
+use std::process::{Command, Stdio};
+
+fn main() -> Result<()> {
+    let manifest_dir = Path::new(env!("CARGO_MANIFEST_DIR"));
+
+    // Read and parse input.rs
+    let input_path = manifest_dir.join("..").join("input.rs");
+    let input_contents = fs::read_to_string(&input_path)?;
+    let syntax_tree = syn::parse_file(&input_contents)?;
+
+    // Write input.rs
+    let tokens = quote!(#syntax_tree);
+    let mut string = tokens.to_string();
+    string.push('\n');
+    fs::write(&input_path, string)?;
+
+    // Write output.prettyplease.rs
+    let output_path = manifest_dir.join("..").join("output.prettyplease.rs");
+    let string = prettyplease::unparse(&syntax_tree);
+    fs::write(&output_path, string)?;
+
+    // Write output.rustc.rs
+    let output_path = manifest_dir.join("..").join("output.rustc.rs");
+    let mut string = rustc_span::create_session_globals_then(Edition2021, || {
+        let sess = ParseSess::new(FilePathMapping::new(Vec::new()));
+        let krate = rustc_parse::parse_crate_from_file(&input_path, &sess).unwrap();
+        rustc_ast_pretty::pprust::crate_to_string_for_macros(&krate)
+    });
+    string.push('\n');
+    fs::write(&output_path, string)?;
+
+    // Write output.rustfmt.rs
+    let output_path = manifest_dir.join("..").join("output.rustfmt.rs");
+    let output_file = File::create(output_path)?;
+    Command::new("rustfmt")
+        .arg("--edition=2021")
+        .arg("--config=reorder_imports=false")
+        .arg("--config=normalize_doc_attributes=true")
+        .arg("--emit=stdout")
+        .arg("--quiet")
+        .arg("--unstable-features")
+        .arg("--skip-children")
+        .arg(&input_path)
+        .stdin(Stdio::null())
+        .stdout(output_file)
+        .stderr(Stdio::inherit())
+        .spawn()?
+        .wait()?;
+
+    Ok(())
+}
diff --git a/prettyplease/src/algorithm.rs b/prettyplease/src/algorithm.rs
new file mode 100644
index 0000000000..73c1b7bc41
--- /dev/null
+++ b/prettyplease/src/algorithm.rs
@@ -0,0 +1,376 @@
+// Adapted from https://github.com/rust-lang/rust/blob/1.57.0/compiler/rustc_ast_pretty/src/pp.rs.
+// See "Algorithm notes" in the crate-level rustdoc.
+
+use crate::ring::RingBuffer;
+use crate::{MARGIN, MIN_SPACE};
+use std::borrow::Cow;
+use std::cmp;
+use std::collections::VecDeque;
+use std::iter;
+
+#[derive(Clone, Copy, PartialEq)]
+pub enum Breaks {
+    Consistent,
+    Inconsistent,
+}
+
+#[derive(Clone, Copy, Default)]
+pub struct BreakToken {
+    pub offset: isize,
+    pub blank_space: usize,
+    pub pre_break: Option<char>,
+    pub post_break: Option<char>,
+    pub no_break: Option<char>,
+    pub if_nonempty: bool,
+    pub never_break: bool,
+}
+
+#[derive(Clone, Copy)]
+pub struct BeginToken {
+    pub offset: isize,
+    pub breaks: Breaks,
+}
+
+#[derive(Clone)]
+pub enum Token {
+    String(Cow<'static, str>),
+    Break(BreakToken),
+    Begin(BeginToken),
+    End,
+}
+
+#[derive(Copy, Clone)]
+enum PrintFrame {
+    Fits(Breaks),
+    Broken(usize, Breaks),
+}
+
+pub const SIZE_INFINITY: isize = 0xffff;
+
+pub struct Printer {
+    out: String,
+    // Number of spaces left on line
+    space: isize,
+    // Ring-buffer of tokens and calculated sizes
+    buf: RingBuffer<BufEntry>,
+    // Total size of tokens already printed
+    left_total: isize,
+    // Total size of tokens enqueued, including printed and not yet printed
+    right_total: isize,
+    // Holds the ring-buffer index of the Begin that started the current block,
+    // possibly with the most recent Break after that Begin (if there is any) on
+    // top of it. Values are pushed and popped on the back of the queue using it
+    // like stack, and elsewhere old values are popped from the front of the
+    // queue as they become irrelevant due to the primary ring-buffer advancing.
+    scan_stack: VecDeque<usize>,
+    // Stack of blocks-in-progress being flushed by print
+    print_stack: Vec<PrintFrame>,
+    // Level of indentation of current line
+    indent: usize,
+    // Buffered indentation to avoid writing trailing whitespace
+    pending_indentation: usize,
+}
+
+#[derive(Clone)]
+struct BufEntry {
+    token: Token,
+    size: isize,
+}
+
+impl Printer {
+    pub fn new() -> Self {
+        Printer {
+            out: String::new(),
+            space: MARGIN,
+            buf: RingBuffer::new(),
+            left_total: 0,
+            right_total: 0,
+            scan_stack: VecDeque::new(),
+            print_stack: Vec::new(),
+            indent: 0,
+            pending_indentation: 0,
+        }
+    }
+
+    pub fn eof(mut self) -> String {
+        if !self.scan_stack.is_empty() {
+            self.check_stack(0);
+            self.advance_left();
+        }
+        self.out
+    }
+
+    pub fn scan_begin(&mut self, token: BeginToken) {
+        if self.scan_stack.is_empty() {
+            self.left_total = 1;
+            self.right_total = 1;
+            self.buf.clear();
+        }
+        let right = self.buf.push(BufEntry {
+            token: Token::Begin(token),
+            size: -self.right_total,
+        });
+        self.scan_stack.push_back(right);
+    }
+
+    pub fn scan_end(&mut self) {
+        if self.scan_stack.is_empty() {
+            self.print_end();
+        } else {
+            if !self.buf.is_empty() {
+                if let Token::Break(break_token) = self.buf.last().token {
+                    if self.buf.len() >= 2 {
+                        if let Token::Begin(_) = self.buf.second_last().token {
+                            self.buf.pop_last();
+                            self.buf.pop_last();
+                            self.scan_stack.pop_back();
+                            self.scan_stack.pop_back();
+                            self.right_total -= break_token.blank_space as isize;
+                            return;
+                        }
+                    }
+                    if break_token.if_nonempty {
+                        self.buf.pop_last();
+                        self.scan_stack.pop_back();
+                        self.right_total -= break_token.blank_space as isize;
+                    }
+                }
+            }
+            let right = self.buf.push(BufEntry {
+                token: Token::End,
+                size: -1,
+            });
+            self.scan_stack.push_back(right);
+        }
+    }
+
+    pub fn scan_break(&mut self, token: BreakToken) {
+        if self.scan_stack.is_empty() {
+            self.left_total = 1;
+            self.right_total = 1;
+            self.buf.clear();
+        } else {
+            self.check_stack(0);
+        }
+        let right = self.buf.push(BufEntry {
+            token: Token::Break(token),
+            size: -self.right_total,
+        });
+        self.scan_stack.push_back(right);
+        self.right_total += token.blank_space as isize;
+    }
+
+    pub fn scan_string(&mut self, string: Cow<'static, str>) {
+        if self.scan_stack.is_empty() {
+            self.print_string(string);
+        } else {
+            let len = string.len() as isize;
+            self.buf.push(BufEntry {
+                token: Token::String(string),
+                size: len,
+            });
+            self.right_total += len;
+            self.check_stream();
+        }
+    }
+
+    pub fn offset(&mut self, offset: isize) {
+        match &mut self.buf.last_mut().token {
+            Token::Break(token) => token.offset += offset,
+            Token::Begin(_) => {}
+            Token::String(_) | Token::End => unreachable!(),
+        }
+    }
+
+    pub fn end_with_max_width(&mut self, max: isize) {
+        let mut depth = 1;
+        for &index in self.scan_stack.iter().rev() {
+            let entry = &self.buf[index];
+            match entry.token {
+                Token::Begin(_) => {
+                    depth -= 1;
+                    if depth == 0 {
+                        if entry.size < 0 {
+                            let actual_width = entry.size + self.right_total;
+                            if actual_width > max {
+                                self.buf.push(BufEntry {
+                                    token: Token::String(Cow::Borrowed("")),
+                                    size: SIZE_INFINITY,
+                                });
+                                self.right_total += SIZE_INFINITY;
+                            }
+                        }
+                        break;
+                    }
+                }
+                Token::End => depth += 1,
+                Token::Break(_) => {}
+                Token::String(_) => unreachable!(),
+            }
+        }
+        self.scan_end();
+    }
+
+    fn check_stream(&mut self) {
+        while self.right_total - self.left_total > self.space {
+            if *self.scan_stack.front().unwrap() == self.buf.index_of_first() {
+                self.scan_stack.pop_front().unwrap();
+                self.buf.first_mut().size = SIZE_INFINITY;
+            }
+
+            self.advance_left();
+
+            if self.buf.is_empty() {
+                break;
+            }
+        }
+    }
+
+    fn advance_left(&mut self) {
+        while self.buf.first().size >= 0 {
+            let left = self.buf.pop_first();
+
+            match left.token {
+                Token::String(string) => {
+                    self.left_total += left.size;
+                    self.print_string(string);
+                }
+                Token::Break(token) => {
+                    self.left_total += token.blank_space as isize;
+                    self.print_break(token, left.size);
+                }
+                Token::Begin(token) => self.print_begin(token, left.size),
+                Token::End => self.print_end(),
+            }
+
+            if self.buf.is_empty() {
+                break;
+            }
+        }
+    }
+
+    fn check_stack(&mut self, mut depth: usize) {
+        while let Some(&index) = self.scan_stack.back() {
+            let mut entry = &mut self.buf[index];
+            match entry.token {
+                Token::Begin(_) => {
+                    if depth == 0 {
+                        break;
+                    }
+                    self.scan_stack.pop_back().unwrap();
+                    entry.size += self.right_total;
+                    depth -= 1;
+                }
+                Token::End => {
+                    self.scan_stack.pop_back().unwrap();
+                    entry.size = 1;
+                    depth += 1;
+                }
+                Token::Break(_) => {
+                    self.scan_stack.pop_back().unwrap();
+                    entry.size += self.right_total;
+                    if depth == 0 {
+                        break;
+                    }
+                }
+                Token::String(_) => unreachable!(),
+            }
+        }
+    }
+
+    fn get_top(&self) -> PrintFrame {
+        const OUTER: PrintFrame = PrintFrame::Broken(0, Breaks::Inconsistent);
+        self.print_stack.last().map_or(OUTER, PrintFrame::clone)
+    }
+
+    fn print_begin(&mut self, token: BeginToken, size: isize) {
+        if cfg!(prettyplease_debug) {
+            self.out.push(match token.breaks {
+                Breaks::Consistent => '«',
+                Breaks::Inconsistent => '‹',
+            });
+            if cfg!(prettyplease_debug_indent) {
+                self.out
+                    .extend(token.offset.to_string().chars().map(|ch| match ch {
+                        '0'..='9' => ['₀', '₁', '₂', '₃', '₄', '₅', '₆', '₇', '₈', '₉']
+                            [(ch as u8 - b'0') as usize]
+                            as char,
+                        '-' => '₋',
+                        _ => unreachable!(),
+                    }));
+            }
+        }
+        if size > self.space {
+            self.print_stack
+                .push(PrintFrame::Broken(self.indent, token.breaks));
+            self.indent = usize::try_from(self.indent as isize + token.offset).unwrap();
+        } else {
+            self.print_stack.push(PrintFrame::Fits(token.breaks));
+        }
+    }
+
+    fn print_end(&mut self) {
+        let breaks = match self.print_stack.pop().unwrap() {
+            PrintFrame::Broken(indent, breaks) => {
+                self.indent = indent;
+                breaks
+            }
+            PrintFrame::Fits(breaks) => breaks,
+        };
+        if cfg!(prettyplease_debug) {
+            self.out.push(match breaks {
+                Breaks::Consistent => '»',
+                Breaks::Inconsistent => '›',
+            });
+        }
+    }
+
+    fn print_break(&mut self, token: BreakToken, size: isize) {
+        let fits = token.never_break
+            || match self.get_top() {
+                PrintFrame::Fits(..) => true,
+                PrintFrame::Broken(.., Breaks::Consistent) => false,
+                PrintFrame::Broken(.., Breaks::Inconsistent) => size <= self.space,
+            };
+        if fits {
+            self.pending_indentation += token.blank_space;
+            self.space -= token.blank_space as isize;
+            if let Some(no_break) = token.no_break {
+                self.out.push(no_break);
+                self.space -= no_break.len_utf8() as isize;
+            }
+            if cfg!(prettyplease_debug) {
+                self.out.push('·');
+            }
+        } else {
+            if let Some(pre_break) = token.pre_break {
+                self.out.push(pre_break);
+            }
+            if cfg!(prettyplease_debug) {
+                self.out.push('·');
+            }
+            self.out.push('\n');
+            let indent = self.indent as isize + token.offset;
+            self.pending_indentation = usize::try_from(indent).unwrap();
+            self.space = cmp::max(MARGIN - indent, MIN_SPACE);
+            if let Some(post_break) = token.post_break {
+                self.print_indent();
+                self.out.push(post_break);
+                self.space -= post_break.len_utf8() as isize;
+            }
+        }
+    }
+
+    fn print_string(&mut self, string: Cow<'static, str>) {
+        self.print_indent();
+        self.out.push_str(&string);
+        self.space -= string.len() as isize;
+    }
+
+    fn print_indent(&mut self) {
+        self.out.reserve(self.pending_indentation);
+        self.out
+            .extend(iter::repeat(' ').take(self.pending_indentation));
+        self.pending_indentation = 0;
+    }
+}
diff --git a/prettyplease/src/attr.rs b/prettyplease/src/attr.rs
new file mode 100644
index 0000000000..9130dd323c
--- /dev/null
+++ b/prettyplease/src/attr.rs
@@ -0,0 +1,179 @@
+use crate::algorithm::Printer;
+use crate::INDENT;
+use proc_macro2::{Delimiter, TokenStream, TokenTree};
+use syn::{AttrStyle, Attribute, Lit, PathArguments};
+
+impl Printer {
+    pub fn outer_attrs(&mut self, attrs: &[Attribute]) {
+        for attr in attrs {
+            if let AttrStyle::Outer = attr.style {
+                self.attr(attr);
+            }
+        }
+    }
+
+    pub fn inner_attrs(&mut self, attrs: &[Attribute]) {
+        for attr in attrs {
+            if let AttrStyle::Inner(_) = attr.style {
+                self.attr(attr);
+            }
+        }
+    }
+
+    pub fn attr(&mut self, attr: &Attribute) {
+        if let Some(doc) = value_of_attribute("doc", attr) {
+            if doc.contains('\n') {
+                self.word(match attr.style {
+                    AttrStyle::Outer => "/**",
+                    AttrStyle::Inner(_) => "/*!",
+                });
+                self.word(doc);
+                self.word("*/");
+            } else {
+                self.word(match attr.style {
+                    AttrStyle::Outer => "///",
+                    AttrStyle::Inner(_) => "//!",
+                });
+                self.word(doc);
+            }
+            self.hardbreak();
+        } else if let Some(comment) = value_of_attribute("comment", attr) {
+            if comment.contains('\n') {
+                self.word("/*");
+                self.word(comment);
+                self.word("*/");
+            } else {
+                self.word("//");
+                self.word(comment);
+            }
+            self.hardbreak();
+        } else {
+            self.word(match attr.style {
+                AttrStyle::Outer => "#",
+                AttrStyle::Inner(_) => "#!",
+            });
+            self.word("[");
+            self.path(&attr.path);
+            self.attr_tokens(attr.tokens.clone());
+            self.word("]");
+            self.space();
+        }
+    }
+
+    fn attr_tokens(&mut self, tokens: TokenStream) {
+        let mut stack = Vec::new();
+        stack.push((tokens.into_iter(), Delimiter::None));
+        let mut space = Self::nbsp as fn(&mut Self);
+
+        enum State {
+            Word,
+            Punct,
+        }
+
+        use State::*;
+        let mut state = Word;
+
+        while let Some((tokens, delimiter)) = stack.last_mut() {
+            match tokens.next() {
+                Some(TokenTree::Ident(ident)) => {
+                    if let Word = state {
+                        space(self);
+                    }
+                    self.ident(&ident);
+                    state = Word;
+                }
+                Some(TokenTree::Punct(punct)) => {
+                    let ch = punct.as_char();
+                    if let (Word, '=') = (state, ch) {
+                        space(self);
+                    }
+                    self.token_punct(ch);
+                    if let '=' | ',' = ch {
+                        space(self);
+                    }
+                    state = Punct;
+                }
+                Some(TokenTree::Literal(literal)) => {
+                    if let Word = state {
+                        space(self);
+                    }
+                    self.token_literal(&literal);
+                    state = Word;
+                }
+                Some(TokenTree::Group(group)) => {
+                    let delimiter = group.delimiter();
+                    let stream = group.stream();
+                    match delimiter {
+                        Delimiter::Parenthesis => {
+                            self.word("(");
+                            self.cbox(INDENT);
+                            self.zerobreak();
+                            state = Punct;
+                        }
+                        Delimiter::Brace => {
+                            self.word("{");
+                            state = Punct;
+                        }
+                        Delimiter::Bracket => {
+                            self.word("[");
+                            state = Punct;
+                        }
+                        Delimiter::None => {}
+                    }
+                    stack.push((stream.into_iter(), delimiter));
+                    space = Self::space;
+                }
+                None => {
+                    match delimiter {
+                        Delimiter::Parenthesis => {
+                            self.zerobreak();
+                            self.offset(-INDENT);
+                            self.end();
+                            self.word(")");
+                            state = Punct;
+                        }
+                        Delimiter::Brace => {
+                            self.word("}");
+                            state = Punct;
+                        }
+                        Delimiter::Bracket => {
+                            self.word("]");
+                            state = Punct;
+                        }
+                        Delimiter::None => {}
+                    }
+                    stack.pop();
+                    if stack.is_empty() {
+                        space = Self::nbsp;
+                    }
+                }
+            }
+        }
+    }
+}
+
+fn value_of_attribute(requested: &str, attr: &Attribute) -> Option<String> {
+    let is_doc = attr.path.leading_colon.is_none()
+        && attr.path.segments.len() == 1
+        && matches!(attr.path.segments[0].arguments, PathArguments::None)
+        && attr.path.segments[0].ident == requested;
+    if !is_doc {
+        return None;
+    }
+    let mut tokens = attr.tokens.clone().into_iter();
+    match tokens.next() {
+        Some(TokenTree::Punct(punct)) if punct.as_char() == '=' => {}
+        _ => return None,
+    }
+    let literal = match tokens.next() {
+        Some(TokenTree::Literal(literal)) => literal,
+        _ => return None,
+    };
+    if tokens.next().is_some() {
+        return None;
+    }
+    match Lit::new(literal) {
+        Lit::Str(string) => Some(string.value()),
+        _ => None,
+    }
+}
diff --git a/prettyplease/src/convenience.rs b/prettyplease/src/convenience.rs
new file mode 100644
index 0000000000..bc4add6e08
--- /dev/null
+++ b/prettyplease/src/convenience.rs
@@ -0,0 +1,98 @@
+use crate::algorithm::{self, BeginToken, BreakToken, Breaks, Printer};
+use std::borrow::Cow;
+
+impl Printer {
+    pub fn ibox(&mut self, indent: isize) {
+        self.scan_begin(BeginToken {
+            offset: indent,
+            breaks: Breaks::Inconsistent,
+        });
+    }
+
+    pub fn cbox(&mut self, indent: isize) {
+        self.scan_begin(BeginToken {
+            offset: indent,
+            breaks: Breaks::Consistent,
+        });
+    }
+
+    pub fn end(&mut self) {
+        self.scan_end();
+    }
+
+    pub fn word<S: Into<Cow<'static, str>>>(&mut self, wrd: S) {
+        let s = wrd.into();
+        self.scan_string(s);
+    }
+
+    fn spaces(&mut self, n: usize) {
+        self.scan_break(BreakToken {
+            blank_space: n,
+            ..BreakToken::default()
+        });
+    }
+
+    pub fn zerobreak(&mut self) {
+        self.spaces(0);
+    }
+
+    pub fn space(&mut self) {
+        self.spaces(1);
+    }
+
+    pub fn nbsp(&mut self) {
+        self.word(" ");
+    }
+
+    pub fn hardbreak(&mut self) {
+        self.spaces(algorithm::SIZE_INFINITY as usize);
+    }
+
+    pub fn space_if_nonempty(&mut self) {
+        self.scan_break(BreakToken {
+            blank_space: 1,
+            if_nonempty: true,
+            ..BreakToken::default()
+        });
+    }
+
+    pub fn hardbreak_if_nonempty(&mut self) {
+        self.scan_break(BreakToken {
+            blank_space: algorithm::SIZE_INFINITY as usize,
+            if_nonempty: true,
+            ..BreakToken::default()
+        });
+    }
+
+    pub fn trailing_comma(&mut self, is_last: bool) {
+        if is_last {
+            self.scan_break(BreakToken {
+                pre_break: Some(','),
+                ..BreakToken::default()
+            });
+        } else {
+            self.word(",");
+            self.space();
+        }
+    }
+
+    pub fn trailing_comma_or_space(&mut self, is_last: bool) {
+        if is_last {
+            self.scan_break(BreakToken {
+                blank_space: 1,
+                pre_break: Some(','),
+                ..BreakToken::default()
+            });
+        } else {
+            self.word(",");
+            self.space();
+        }
+    }
+
+    pub fn neverbreak(&mut self) {
+        self.scan_break(BreakToken {
+            never_break: true,
+            ..BreakToken::default()
+        });
+    }
+}
diff --git a/prettyplease/src/data.rs b/prettyplease/src/data.rs
new file mode 100644
index 0000000000..66b289f604
--- /dev/null
+++ b/prettyplease/src/data.rs
@@ -0,0 +1,87 @@
+use crate::algorithm::Printer;
+use crate::iter::IterDelimited;
+use crate::INDENT;
+use syn::{Field, Fields, FieldsUnnamed, Variant, VisCrate, VisPublic, VisRestricted, Visibility};
+
+impl Printer {
+    pub fn variant(&mut self, variant: &Variant) {
+        self.outer_attrs(&variant.attrs);
+        self.ident(&variant.ident);
+        match &variant.fields {
+            Fields::Named(fields) => {
+                self.nbsp();
+                self.word("{");
+                self.cbox(INDENT);
+                self.space();
+                for field in fields.named.iter().delimited() {
+                    self.field(&field);
+                    self.trailing_comma_or_space(field.is_last);
+                }
+                self.offset(-INDENT);
+                self.end();
+                self.word("}");
+            }
+            Fields::Unnamed(fields) => {
+                self.cbox(INDENT);
+                self.fields_unnamed(fields);
+                self.end();
+            }
+            Fields::Unit => {}
+        }
+        if let Some((_eq_token, discriminant)) = &variant.discriminant {
+            self.word(" = ");
+            self.expr(discriminant);
+        }
+    }
+
+    pub fn fields_unnamed(&mut self, fields: &FieldsUnnamed) {
+        self.word("(");
+        self.zerobreak();
+        for field in fields.unnamed.iter().delimited() {
+            self.field(&field);
+            self.trailing_comma(field.is_last);
+        }
+        self.offset(-INDENT);
+        self.word(")");
+    }
+
+    pub fn field(&mut self, field: &Field) {
+        self.outer_attrs(&field.attrs);
+        self.visibility(&field.vis);
+        if let Some(ident) = &field.ident {
+            self.ident(ident);
+            self.word(": ");
+        }
+        self.ty(&field.ty);
+    }
+
+    pub fn visibility(&mut self, vis: &Visibility) {
+        match vis {
+            Visibility::Public(vis) => self.vis_public(vis),
+            Visibility::Crate(vis) => self.vis_crate(vis),
+            Visibility::Restricted(vis) => self.vis_restricted(vis),
+            Visibility::Inherited => {}
+        }
+    }
+
+    fn vis_public(&mut self, vis: &VisPublic) {
+        let _ = vis;
+        self.word("pub ");
+    }
+
+    fn vis_crate(&mut self, vis: &VisCrate) {
+        let _ = vis;
+        self.word("crate ");
+    }
+
+    fn vis_restricted(&mut self, vis: &VisRestricted) {
+        self.word("pub(");
+        // TODO: If we have a path which is not "self" or "super" or "crate",
+        // automatically add the "in" token.
+        if vis.in_token.is_some() {
+            self.word("in ");
+        }
+        self.path(&vis.path);
+        self.word(") ");
+    }
+}
diff --git a/prettyplease/src/expr.rs b/prettyplease/src/expr.rs
new file mode 100644
index 0000000000..5c302dc470
--- /dev/null
+++ b/prettyplease/src/expr.rs
@@ -0,0 +1,974 @@
+use crate::algorithm::{BreakToken, Printer};
+use crate::iter::IterDelimited;
+use crate::stmt;
+use crate::INDENT;
+use proc_macro2::TokenStream;
+use syn::punctuated::Punctuated;
+use syn::{
+    token, Arm, Attribute, BinOp, Block, Expr, ExprArray, ExprAssign, ExprAssignOp, ExprAsync,
+    ExprAwait, ExprBinary, ExprBlock, ExprBox, ExprBreak, ExprCall, ExprCast, ExprClosure,
+    ExprContinue, ExprField, ExprForLoop, ExprGroup, ExprIf, ExprIndex, ExprLet, ExprLit, ExprLoop,
+    ExprMacro, ExprMatch, ExprMethodCall, ExprParen, ExprPath, ExprRange, ExprReference,
+    ExprRepeat, ExprReturn, ExprStruct, ExprTry, ExprTryBlock, ExprTuple, ExprType, ExprUnary,
+    ExprUnsafe, ExprWhile, ExprYield, FieldValue, GenericMethodArgument, Index, Label, Member,
+    MethodTurbofish, RangeLimits, ReturnType, Stmt, Token, UnOp,
+};
+
+impl Printer {
+    pub fn expr(&mut self, expr: &Expr) {
+        match expr {
+            Expr::Array(expr) => self.expr_array(expr),
+            Expr::Assign(expr) => self.expr_assign(expr),
+            Expr::AssignOp(expr) => self.expr_assign_op(expr),
+            Expr::Async(expr) => self.expr_async(expr),
+            Expr::Await(expr) => self.expr_await(expr),
+            Expr::Binary(expr) => self.expr_binary(expr),
+            Expr::Block(expr) => self.expr_block(expr),
+            Expr::Box(expr) => self.expr_box(expr),
+            Expr::Break(expr) => self.expr_break(expr),
+            Expr::Call(expr) => self.expr_call(expr),
+            Expr::Cast(expr) => self.expr_cast(expr),
+            Expr::Closure(expr) => self.expr_closure(expr),
+            Expr::Continue(expr) => self.expr_continue(expr),
+            Expr::Field(expr) => self.expr_field(expr),
+            Expr::ForLoop(expr) => self.expr_for_loop(expr),
+            Expr::Group(expr) => self.expr_group(expr),
+            Expr::If(expr) => self.expr_if(expr),
+            Expr::Index(expr) => self.expr_index(expr),
+            Expr::Let(expr) => self.expr_let(expr),
+            Expr::Lit(expr) => self.expr_lit(expr),
+            Expr::Loop(expr) => self.expr_loop(expr),
+            Expr::Macro(expr) => self.expr_macro(expr),
+            Expr::Match(expr) => self.expr_match(expr),
+            Expr::MethodCall(expr) => self.expr_method_call(expr),
+            Expr::Paren(expr) => self.expr_paren(expr),
+            Expr::Path(expr) => self.expr_path(expr),
+            Expr::Range(expr) => self.expr_range(expr),
+            Expr::Reference(expr) => self.expr_reference(expr),
+            Expr::Repeat(expr) => self.expr_repeat(expr),
+            Expr::Return(expr) => self.expr_return(expr),
+            Expr::Struct(expr) => self.expr_struct(expr),
+            Expr::Try(expr) => self.expr_try(expr),
+            Expr::TryBlock(expr) => self.expr_try_block(expr),
+            Expr::Tuple(expr) => self.expr_tuple(expr),
+            Expr::Type(expr) => self.expr_type(expr),
+            Expr::Unary(expr) => self.expr_unary(expr),
+            Expr::Unsafe(expr) => self.expr_unsafe(expr),
+            Expr::Verbatim(expr) => self.expr_verbatim(expr),
+            Expr::While(expr) => self.expr_while(expr),
+            Expr::Yield(expr) => self.expr_yield(expr),
+            #[cfg(test)]
+            Expr::__TestExhaustive(_) => unreachable!(),
+            #[cfg(not(test))]
+            _ => unimplemented!("unknown Expr"),
+        }
+    }
+
+    fn subexpr(&mut self, expr: &Expr) {
+        match expr {
+            Expr::Await(expr) => self.subexpr_await(expr),
+            Expr::Call(expr) => self.subexpr_call(expr),
+            Expr::Field(expr) => self.subexpr_field(expr),
+            Expr::Index(expr) => self.subexpr_index(expr),
+            Expr::MethodCall(expr) => self.subexpr_method_call(expr),
+            Expr::Try(expr) => self.subexpr_try(expr),
+            _ => {
+                self.cbox(-INDENT);
+                self.expr(expr);
+                self.end();
+            }
+        }
+    }
+
+    // If the given expression is a bare `ExprStruct`, wraps it in parenthesis
+    // before appending it to `TokenStream`.
+    fn wrap_exterior_struct(&mut self, expr: &Expr) {
+        let needs_paren = contains_exterior_struct_lit(expr);
+        if needs_paren {
+            self.word("(");
+        }
+        self.cbox(0);
+        self.expr(expr);
+        if needs_paren {
+            self.word(")");
+        }
+        if needs_newline_if_wrap(expr) {
+            self.space();
+        } else {
+            self.nbsp();
+        }
+        self.end();
+    }
+
+    fn expr_array(&mut self, expr: &ExprArray) {
+        self.outer_attrs(&expr.attrs);
+        self.word("[");
+        self.cbox(INDENT);
+        self.zerobreak();
+        self.inner_attrs(&expr.attrs);
+        for element in expr.elems.iter().delimited() {
+            self.expr(&element);
+            self.trailing_comma(element.is_last);
+        }
+        self.offset(-INDENT);
+        self.end();
+        self.word("]");
+    }
+
+    fn expr_assign(&mut self, expr: &ExprAssign) {
+        self.outer_attrs(&expr.attrs);
+        self.ibox(0);
+        self.expr(&expr.left);
+        self.word(" = ");
+        self.expr(&expr.right);
+        self.end();
+    }
+
+    fn expr_assign_op(&mut self, expr: &ExprAssignOp) {
+        self.outer_attrs(&expr.attrs);
+        self.ibox(INDENT);
+        self.ibox(-INDENT);
+        self.expr(&expr.left);
+        self.end();
+        self.space();
+        self.binary_operator(&expr.op);
+        self.nbsp();
+        self.expr(&expr.right);
+        self.end();
+    }
+
+    fn expr_async(&mut self, expr: &ExprAsync) {
+        self.outer_attrs(&expr.attrs);
+        self.word("async ");
+        if expr.capture.is_some() {
+            self.word("move ");
+        }
+        self.cbox(INDENT);
+        self.small_block(&expr.block, &expr.attrs);
+        self.end();
+    }
+
+    fn expr_await(&mut self, expr: &ExprAwait) {
+        self.outer_attrs(&expr.attrs);
+        self.cbox(INDENT);
+        self.subexpr_await(expr);
+        self.end();
+    }
+
+    fn subexpr_await(&mut self, expr: &ExprAwait) {
+        self.subexpr(&expr.base);
+        self.zerobreak();
+        self.word(".await");
+    }
+
+    fn expr_binary(&mut self, expr: &ExprBinary) {
+        self.outer_attrs(&expr.attrs);
+        self.ibox(INDENT);
+        self.ibox(-INDENT);
+        self.expr(&expr.left);
+        self.end();
+        self.space();
+        self.binary_operator(&expr.op);
+        self.nbsp();
+        self.expr(&expr.right);
+        self.end();
+    }
+
+    pub fn expr_block(&mut self, expr: &ExprBlock) {
+        self.outer_attrs(&expr.attrs);
+        if let Some(label) = &expr.label {
+            self.label(label);
+        }
+        self.cbox(INDENT);
+        self.small_block(&expr.block, &expr.attrs);
+        self.end();
+    }
+
+    fn expr_box(&mut self, expr: &ExprBox) {
+        self.outer_attrs(&expr.attrs);
+        self.word("box ");
+        self.expr(&expr.expr);
+    }
+
+    fn expr_break(&mut self, expr: &ExprBreak) {
+        self.outer_attrs(&expr.attrs);
+        self.word("break");
+        if let Some(lifetime) = &expr.label {
+            self.nbsp();
+            self.lifetime(lifetime);
+        }
+        if let Some(value) = &expr.expr {
+            self.nbsp();
+            self.expr(value);
+        }
+    }
+
+    fn expr_call(&mut self, expr: &ExprCall) {
+        self.outer_attrs(&expr.attrs);
+        self.expr(&expr.func);
+        self.call_args(&expr.args);
+    }
+
+    fn subexpr_call(&mut self, expr: &ExprCall) {
+        self.subexpr(&expr.func);
+        self.call_args(&expr.args);
+    }
+
+    fn expr_cast(&mut self, expr: &ExprCast) {
+        self.outer_attrs(&expr.attrs);
+        self.ibox(INDENT);
+        self.ibox(-INDENT);
+        self.expr(&expr.expr);
+        self.end();
+        self.space();
+        self.word("as ");
+        self.ty(&expr.ty);
+        self.end();
+    }
+
+    fn expr_closure(&mut self, expr: &ExprClosure) {
+        self.outer_attrs(&expr.attrs);
+        self.ibox(0);
+        if expr.asyncness.is_some() {
+            self.word("async ");
+        }
+        if expr.movability.is_some() {
+            self.word("static ");
+        }
+        if expr.capture.is_some() {
+            self.word("move ");
+        }
+        self.cbox(INDENT);
+        self.word("|");
+        for pat in expr.inputs.iter().delimited() {
+            if pat.is_first {
+                self.zerobreak();
+            }
+            self.pat(&pat);
+            if !pat.is_last {
+                self.word(",");
+                self.space();
+            }
+        }
+        match &expr.output {
+            ReturnType::Default => {
+                self.word("|");
+                self.space();
+                self.offset(-INDENT);
+                self.end();
+            }
+            ReturnType::Type(_arrow, ty) => {
+                if !expr.inputs.is_empty() {
+                    self.trailing_comma(true);
+                    self.offset(-INDENT);
+                }
+                self.word("|");
+                self.end();
+                self.word(" -> ");
+                self.ty(ty);
+                self.nbsp();
+            }
+        }
+        self.neverbreak();
+        self.expr(&expr.body);
+        self.end();
+    }
+
+    fn expr_continue(&mut self, expr: &ExprContinue) {
+        self.outer_attrs(&expr.attrs);
+        self.word("continue");
+        if let Some(lifetime) = &expr.label {
+            self.nbsp();
+            self.lifetime(lifetime);
+        }
+    }
+
+    fn expr_field(&mut self, expr: &ExprField) {
+        self.outer_attrs(&expr.attrs);
+        self.cbox(INDENT);
+        self.subexpr_field(expr);
+        self.end();
+    }
+
+    fn subexpr_field(&mut self, expr: &ExprField) {
+        self.subexpr(&expr.base);
+        self.zerobreak();
+        self.word(".");
+        self.member(&expr.member);
+    }
+
+    fn expr_for_loop(&mut self, expr: &ExprForLoop) {
+        self.outer_attrs(&expr.attrs);
+        self.ibox(0);
+        if let Some(label) = &expr.label {
+            self.label(label);
+        }
+        self.word("for ");
+        self.pat(&expr.pat);
+        self.word(" in ");
+        self.neverbreak();
+        self.wrap_exterior_struct(&expr.expr);
+        self.word("{");
+        self.neverbreak();
+        self.cbox(INDENT);
+        self.hardbreak_if_nonempty();
+        self.inner_attrs(&expr.attrs);
+        for stmt in &expr.body.stmts {
+            self.stmt(stmt);
+        }
+        self.offset(-INDENT);
+        self.end();
+        self.word("}");
+        self.end();
+    }
+
+    fn expr_group(&mut self, expr: &ExprGroup) {
+        self.outer_attrs(&expr.attrs);
+        self.expr(&expr.expr);
+    }
+
+    fn expr_if(&mut self, expr: &ExprIf) {
+        self.outer_attrs(&expr.attrs);
+        self.cbox(INDENT);
+        self.word("if ");
+        self.cbox(-INDENT);
+        self.wrap_exterior_struct(&expr.cond);
+        self.end();
+        if let Some((_else_token, else_branch)) = &expr.else_branch {
+            let mut else_branch = &**else_branch;
+            self.small_block(&expr.then_branch, &[]);
+            loop {
+                self.word(" else ");
+                match else_branch {
+                    Expr::If(expr) => {
+                        self.word("if ");
+                        self.wrap_exterior_struct(&expr.cond);
+                        self.small_block(&expr.then_branch, &[]);
+                        if let Some((_else_token, next)) = &expr.else_branch {
+                            else_branch = next;
+                            continue;
+                        }
+                    }
+                    Expr::Block(expr) => {
+                        self.small_block(&expr.block, &[]);
+                    }
+                    // If not one of the valid expressions to exist in an else
+                    // clause, wrap in a block.
+                    other => {
+                        self.word("{");
+                        self.space();
+                        self.ibox(INDENT);
+                        self.expr(other);
+                        self.end();
+                        self.space();
+                        self.offset(-INDENT);
+                        self.word("}");
+                    }
+                }
+                break;
+            }
+        } else if expr.then_branch.stmts.is_empty() {
+            self.word("{}");
+        } else {
+            self.word("{");
+            self.hardbreak();
+            for stmt in &expr.then_branch.stmts {
+                self.stmt(stmt);
+            }
+            self.offset(-INDENT);
+            self.word("}");
+        }
+        self.end();
+    }
+
+    fn expr_index(&mut self, expr: &ExprIndex) {
+        self.outer_attrs(&expr.attrs);
+        self.expr(&expr.expr);
+        self.word("[");
+        self.expr(&expr.index);
+        self.word("]");
+    }
+
+    fn subexpr_index(&mut self, expr: &ExprIndex) {
+        self.subexpr(&expr.expr);
+        self.word("[");
+        self.expr(&expr.index);
+        self.word("]");
+    }
+
+    fn expr_let(&mut self, expr: &ExprLet) {
+        self.outer_attrs(&expr.attrs);
+        self.ibox(INDENT);
+        self.word("let ");
+        self.ibox(-INDENT);
+        self.pat(&expr.pat);
+        self.end();
+        self.space();
+        self.word("= ");
+        let needs_paren = contains_exterior_struct_lit(&expr.expr);
+        if needs_paren {
+            self.word("(");
+        }
+        self.expr(&expr.expr);
+        if needs_paren {
+            self.word(")");
+        }
+        self.end();
+    }
+
+    pub fn expr_lit(&mut self, expr: &ExprLit) {
+        self.outer_attrs(&expr.attrs);
+        self.lit(&expr.lit);
+    }
+
+    fn expr_loop(&mut self, expr: &ExprLoop) {
+        self.outer_attrs(&expr.attrs);
+        if let Some(label) = &expr.label {
+            self.label(label);
+        }
+        self.word("loop {");
+        self.cbox(INDENT);
+        self.hardbreak_if_nonempty();
+        self.inner_attrs(&expr.attrs);
+        for stmt in &expr.body.stmts {
+            self.stmt(stmt);
+        }
+        self.offset(-INDENT);
+        self.end();
+        self.word("}");
+    }
+
+    fn expr_macro(&mut self, expr: &ExprMacro) {
+        self.outer_attrs(&expr.attrs);
+        self.mac(&expr.mac, None);
+    }
+
+    fn expr_match(&mut self, expr: &ExprMatch) {
+        self.outer_attrs(&expr.attrs);
+        self.ibox(0);
+        self.word("match ");
+        self.wrap_exterior_struct(&expr.expr);
+        self.word("{");
+        self.neverbreak();
+        self.cbox(INDENT);
+        self.hardbreak_if_nonempty();
+        self.inner_attrs(&expr.attrs);
+        for arm in &expr.arms {
+            self.arm(arm);
+            self.hardbreak();
+        }
+        self.offset(-INDENT);
+        self.end();
+        self.word("}");
+        self.end();
+    }
+
+    fn expr_method_call(&mut self, expr: &ExprMethodCall) {
+        self.outer_attrs(&expr.attrs);
+        self.cbox(INDENT);
+        self.subexpr_method_call(expr);
+        self.end();
+    }
+
+    fn subexpr_method_call(&mut self, expr: &ExprMethodCall) {
+        self.subexpr(&expr.receiver);
+        self.zerobreak();
+        self.word(".");
+        self.ident(&expr.method);
+        if let Some(turbofish) = &expr.turbofish {
+            self.method_turbofish(turbofish);
+        }
+        self.call_args(&expr.args);
+    }
+
+    fn expr_paren(&mut self, expr: &ExprParen) {
+        self.outer_attrs(&expr.attrs);
+        self.word("(");
+        self.inner_attrs(&expr.attrs);
+        self.expr(&expr.expr);
+        self.word(")");
+    }
+
+    fn expr_path(&mut self, expr: &ExprPath) {
+        self.outer_attrs(&expr.attrs);
+        self.qpath(&expr.qself, &expr.path);
+    }
+
+    fn expr_range(&mut self, expr: &ExprRange) {
+        self.outer_attrs(&expr.attrs);
+        if let Some(from) = &expr.from {
+            self.expr(from);
+        }
+        self.word(match expr.limits {
+            RangeLimits::HalfOpen(_) => "..",
+            RangeLimits::Closed(_) => "..=",
+        });
+        if let Some(to) = &expr.to {
+            self.expr(to);
+        }
+    }
+
+    fn expr_reference(&mut self, expr: &ExprReference) {
+        self.outer_attrs(&expr.attrs);
+        self.word("&");
+        if expr.mutability.is_some() {
+            self.word("mut ");
+        }
+        self.expr(&expr.expr);
+    }
+
+    fn expr_repeat(&mut self, expr: &ExprRepeat) {
+        self.outer_attrs(&expr.attrs);
+        self.word("[");
+        self.inner_attrs(&expr.attrs);
+        self.expr(&expr.expr);
+        self.word("; ");
+        self.expr(&expr.len);
+        self.word("]");
+    }
+
+    fn expr_return(&mut self, expr: &ExprReturn) {
+        self.outer_attrs(&expr.attrs);
+        self.word("return");
+        if let Some(value) = &expr.expr {
+            self.nbsp();
+            self.expr(value);
+        }
+    }
+
+    fn expr_struct(&mut self, expr: &ExprStruct) {
+        self.outer_attrs(&expr.attrs);
+        self.cbox(INDENT);
+        self.path(&expr.path);
+        self.word(" {");
+        self.space_if_nonempty();
+        self.inner_attrs(&expr.attrs);
+        for field_value in expr.fields.iter().delimited() {
+            self.field_value(&field_value);
+            self.trailing_comma_or_space(field_value.is_last && expr.rest.is_none());
+        }
+        if let Some(rest) = &expr.rest {
+            self.word("..");
+            self.expr(rest);
+            self.space();
+        }
+        self.offset(-INDENT);
+        self.end_with_max_width(34);
+        self.word("}");
+    }
+
+    fn expr_try(&mut self, expr: &ExprTry) {
+        self.outer_attrs(&expr.attrs);
+        self.expr(&expr.expr);
+        self.word("?");
+    }
+
+    fn subexpr_try(&mut self, expr: &ExprTry) {
+        self.subexpr(&expr.expr);
+        self.word("?");
+    }
+
+    fn expr_try_block(&mut self, expr: &ExprTryBlock) {
+        self.outer_attrs(&expr.attrs);
+        self.word("try ");
+        self.cbox(INDENT);
+        self.small_block(&expr.block, &expr.attrs);
+        self.end();
+    }
+
+    fn expr_tuple(&mut self, expr: &ExprTuple) {
+        self.outer_attrs(&expr.attrs);
+        self.word("(");
+        self.cbox(INDENT);
+        self.zerobreak();
+        self.inner_attrs(&expr.attrs);
+        for elem in expr.elems.iter().delimited() {
+            self.expr(&elem);
+            if expr.elems.len() == 1 {
+                self.word(",");
+                self.zerobreak();
+            } else {
+                self.trailing_comma(elem.is_last);
+            }
+        }
+        self.offset(-INDENT);
+        self.end();
+        self.word(")");
+    }
+
+    fn expr_type(&mut self, expr: &ExprType) {
+        self.outer_attrs(&expr.attrs);
+        self.ibox(INDENT);
+        self.ibox(-INDENT);
+        self.expr(&expr.expr);
+        self.end();
+        self.space();
+        self.word(": ");
+        self.ty(&expr.ty);
+        self.end();
+    }
+
+    fn expr_unary(&mut self, expr: &ExprUnary) {
+        self.outer_attrs(&expr.attrs);
+        self.unary_operator(&expr.op);
+        self.expr(&expr.expr);
+    }
+
+    fn expr_unsafe(&mut self, expr: &ExprUnsafe) {
+        self.outer_attrs(&expr.attrs);
+        self.word("unsafe {");
+        self.cbox(INDENT);
+        self.space_if_nonempty();
+        self.inner_attrs(&expr.attrs);
+        for stmt in expr.block.stmts.iter().delimited() {
+            if stmt.is_first && stmt.is_last {
+                if let Stmt::Expr(expr) = &*stmt {
+                    self.expr(expr);
+                    self.space();
+                    continue;
+                }
+            }
+            self.stmt(&stmt);
+        }
+        self.offset(-INDENT);
+        self.end();
+        self.word("}");
+    }
+
+    fn expr_verbatim(&mut self, expr: &TokenStream) {
+        if !expr.is_empty() {
+            unimplemented!("Expr::Verbatim `{}`", expr);
+        }
+    }
+
+    fn expr_while(&mut self, expr: &ExprWhile) {
+        self.outer_attrs(&expr.attrs);
+        if let Some(label) = &expr.label {
+            self.label(label);
+        }
+        self.word("while ");
+        self.wrap_exterior_struct(&expr.cond);
+        self.word("{");
+        self.neverbreak();
+        self.cbox(INDENT);
+        self.hardbreak_if_nonempty();
+        self.inner_attrs(&expr.attrs);
+        for stmt in &expr.body.stmts {
+            self.stmt(stmt);
+        }
+        self.offset(-INDENT);
+        self.end();
+        self.word("}");
+    }
+
+    fn expr_yield(&mut self, expr: &ExprYield) {
+        self.outer_attrs(&expr.attrs);
+        self.word("yield");
+        if let Some(value) = &expr.expr {
+            self.nbsp();
+            self.expr(value);
+        }
+    }
+
+    fn label(&mut self, label: &Label) {
+        self.lifetime(&label.name);
+        self.word(": ");
+    }
+
+    fn field_value(&mut self, field_value: &FieldValue) {
+        self.outer_attrs(&field_value.attrs);
+        self.member(&field_value.member);
+        if field_value.colon_token.is_some() {
+            self.word(": ");
+            self.ibox(0);
+            self.expr(&field_value.expr);
+            self.end();
+        }
+    }
+
+    fn arm(&mut self, arm: &Arm) {
+        self.outer_attrs(&arm.attrs);
+        self.ibox(0);
+        self.pat(&arm.pat);
+        if let Some((_if_token, guard)) = &arm.guard {
+            self.word(" if ");
+            self.expr(guard);
+        }
+        self.word(" =>");
+        let empty_block;
+        let mut body = &*arm.body;
+        while let Expr::Block(expr) = body {
+            if expr.attrs.is_empty() && expr.label.is_none() {
+                let mut stmts = expr.block.stmts.iter();
+                if let (Some(Stmt::Expr(inner)), None) = (stmts.next(), stmts.next()) {
+                    body = inner;
+                    continue;
+                }
+            }
+            break;
+        }
+        if let Expr::Tuple(expr) = body {
+            if expr.elems.is_empty() && expr.attrs.is_empty() {
+                empty_block = Expr::Block(ExprBlock {
+                    attrs: Vec::new(),
+                    label: None,
+                    block: Block {
+                        brace_token: token::Brace::default(),
+                        stmts: Vec::new(),
+                    },
+                });
+                body = &empty_block;
+            }
+        }
+        if let Expr::Block(body) = body {
+            self.nbsp();
+            if let Some(label) = &body.label {
+                self.label(label);
+            }
+            self.word("{");
+            self.neverbreak();
+            self.cbox(INDENT);
+            self.hardbreak_if_nonempty();
+            self.inner_attrs(&body.attrs);
+            for stmt in &body.block.stmts {
+                self.stmt(stmt);
+            }
+            self.offset(-INDENT);
+            self.end();
+            self.word("}");
+            self.end();
+        } else {
+            self.nbsp();
+            self.neverbreak();
+            self.cbox(INDENT);
+            self.scan_break(BreakToken {
+                pre_break: Some('{'),
+                ..BreakToken::default()
+            });
+            self.expr(body);
+            self.scan_break(BreakToken {
+                offset: -INDENT,
+                pre_break: stmt::add_semi(body).then(|| ';'),
+                post_break: Some('}'),
+                no_break: requires_terminator(body).then(|| ','),
+                ..BreakToken::default()
+            });
+            self.end();
+            self.end();
+        }
+    }
+
+    fn method_turbofish(&mut self, turbofish: &MethodTurbofish) {
+        self.word("::<");
+        self.cbox(0);
+        self.zerobreak();
+        for arg in turbofish.args.iter().delimited() {
+            self.generic_method_argument(&arg);
+            self.trailing_comma(arg.is_last);
+        }
+        self.offset(-INDENT);
+        self.end();
+        self.word(">");
+    }
+
+    fn generic_method_argument(&mut self, generic: &GenericMethodArgument) {
+        match generic {
+            GenericMethodArgument::Type(arg) => self.ty(arg),
+            GenericMethodArgument::Const(arg) => self.expr(arg),
+        }
+    }
+
+    fn call_args(&mut self, args: &Punctuated<Expr, Token![,]>) {
+        self.word("(");
+        let mut iter = args.iter();
+        if let (Some(expr @ (Expr::Closure(_) | Expr::Struct(_))), None) =
+            (iter.next(), iter.next())
+        {
+            self.expr(expr);
+        } else {
+            self.cbox(INDENT);
+            self.zerobreak();
+            for arg in args.iter().delimited() {
+                self.expr(&arg);
+                self.trailing_comma(arg.is_last);
+            }
+            self.offset(-INDENT);
+            self.end();
+        }
+        self.word(")");
+    }
+
+    fn small_block(&mut self, block: &Block, attrs: &[Attribute]) {
+        self.word("{");
+        self.space_if_nonempty();
+        self.inner_attrs(attrs);
+        if let (Some(Stmt::Expr(expr)), None) = (block.stmts.get(0), block.stmts.get(1)) {
+            self.ibox(0);
+            self.expr(expr);
+            self.end();
+            self.space();
+        } else {
+            for stmt in &block.stmts {
+                self.stmt(stmt);
+            }
+        }
+        self.offset(-INDENT);
+        self.word("}");
+    }
+
+    pub fn member(&mut self, member: &Member) {
+        match member {
+            Member::Named(ident) => self.ident(ident),
+            Member::Unnamed(index) => self.index(index),
+        }
+    }
+
+    fn index(&mut self, member: &Index) {
+        self.word(member.index.to_string());
+    }
+
+    fn binary_operator(&mut self, op: &BinOp) {
+        self.word(match op {
+            BinOp::Add(_) => "+",
+            BinOp::Sub(_) => "-",
+            BinOp::Mul(_) => "*",
+            BinOp::Div(_) => "/",
+            BinOp::Rem(_) => "%",
+            BinOp::And(_) => "&&",
+            BinOp::Or(_) => "||",
+            BinOp::BitXor(_) => "^",
+            BinOp::BitAnd(_) => "&",
+            BinOp::BitOr(_) => "|",
+            BinOp::Shl(_) => "<<",
+            BinOp::Shr(_) => ">>",
+            BinOp::Eq(_) => "==",
+            BinOp::Lt(_) => "<",
+            BinOp::Le(_) => "<=",
+            BinOp::Ne(_) => "!=",
+            BinOp::Ge(_) => ">=",
+            BinOp::Gt(_) => ">",
+            BinOp::AddEq(_) => "+=",
+            BinOp::SubEq(_) => "-=",
+            BinOp::MulEq(_) => "*=",
+            BinOp::DivEq(_) => "/=",
+            BinOp::RemEq(_) => "%=",
+            BinOp::BitXorEq(_) => "^=",
+            BinOp::BitAndEq(_) => "&=",
+            BinOp::BitOrEq(_) => "|=",
+            BinOp::ShlEq(_) => "<<=",
+            BinOp::ShrEq(_) => ">>=",
+        });
+    }
+
+    fn unary_operator(&mut self, op: &UnOp) {
+        self.word(match op {
+            UnOp::Deref(_) => "*",
+            UnOp::Not(_) => "!",
+            UnOp::Neg(_) => "-",
+        });
+    }
+}
+
+pub fn requires_terminator(expr: &Expr) -> bool {
+    // see https://github.com/rust-lang/rust/blob/2679c38fc/src/librustc_ast/util/classify.rs#L7-L25
+    match expr {
+        Expr::Unsafe(_)
+        | Expr::Block(_)
+        | Expr::If(_)
+        | Expr::Match(_)
+        | Expr::While(_)
+        | Expr::Loop(_)
+        | Expr::ForLoop(_)
+        | Expr::Async(_)
+        | Expr::TryBlock(_) => false,
+        _ => true,
+    }
+}
+
+// Expressions that syntactically contain an "exterior" struct literal i.e. not
+// surrounded by any parens or other delimiters. For example `X { y: 1 }`, `X {
+// y: 1 }.method()`, `foo == X { y: 1 }` and `X { y: 1 } == foo` all do, but `(X
+// { y: 1 }) == foo` does not.
+fn contains_exterior_struct_lit(expr: &Expr) -> bool {
+    match expr {
+        Expr::Struct(_) => true,
+
+        Expr::Assign(ExprAssign { left, right, .. })
+        | Expr::AssignOp(ExprAssignOp { left, right, .. })
+        | Expr::Binary(ExprBinary { left, right, .. }) => {
+            // X { y: 1 } + X { y: 2 }
+            contains_exterior_struct_lit(left) || contains_exterior_struct_lit(right)
+        }
+
+        Expr::Await(ExprAwait { base: e, .. })
+        | Expr::Box(ExprBox { expr: e, .. })
+        | Expr::Cast(ExprCast { expr: e, .. })
+        | Expr::Field(ExprField { base: e, .. })
+        | Expr::Index(ExprIndex { expr: e, .. })
+        | Expr::MethodCall(ExprMethodCall { receiver: e, .. })
+        | Expr::Reference(ExprReference { expr: e, .. })
+        | Expr::Type(ExprType { expr: e, .. })
+        | Expr::Unary(ExprUnary { expr: e, .. }) => {
+            // &X { y: 1 }, X { y: 1 }.y
+            contains_exterior_struct_lit(e)
+        }
+
+        _ => false,
+    }
+}
+
+fn needs_newline_if_wrap(expr: &Expr) -> bool {
+    match expr {
+        Expr::Array(_)
+        | Expr::Async(_)
+        | Expr::Block(_)
+        | Expr::Break(ExprBreak { expr: None, .. })
+        | Expr::Closure(_)
+        | Expr::Continue(_)
+        | Expr::ForLoop(_)
+        | Expr::If(_)
+        | Expr::Lit(_)
+        | Expr::Loop(_)
+        | Expr::Macro(_)
+        | Expr::Match(_)
+        | Expr::Path(_)
+        | Expr::Range(ExprRange { to: None, .. })
+        | Expr::Repeat(_)
+        | Expr::Return(ExprReturn { expr: None, .. })
+        | Expr::Struct(_)
+        | Expr::TryBlock(_)
+        | Expr::Tuple(_)
+        | Expr::Unsafe(_)
+        | Expr::Verbatim(_)
+        | Expr::While(_)
+        | Expr::Yield(ExprYield { expr: None, .. }) => false,
+
+        Expr::Assign(_)
+        | Expr::AssignOp(_)
+        | Expr::Await(_)
+        | Expr::Binary(_)
+        | Expr::Cast(_)
+        | Expr::Field(_)
+        | Expr::Index(_)
+        | Expr::MethodCall(_)
+        | Expr::Type(_) => true,
+
+        Expr::Box(ExprBox { expr: e, .. })
+        | Expr::Break(ExprBreak { expr: Some(e), .. })
+        | Expr::Call(ExprCall { func: e, .. })
+        | Expr::Group(ExprGroup { expr: e, .. })
+        | Expr::Let(ExprLet { expr: e, .. })
+        | Expr::Paren(ExprParen { expr: e, .. })
+        | Expr::Range(ExprRange { to: Some(e), .. })
+        | Expr::Reference(ExprReference { expr: e, .. })
+        | Expr::Return(ExprReturn { expr: Some(e), .. })
+        | Expr::Try(ExprTry { expr: e, .. })
+        | Expr::Unary(ExprUnary { expr: e, .. })
+        | Expr::Yield(ExprYield { expr: Some(e), .. }) => needs_newline_if_wrap(e),
+
+        #[cfg(test)]
+        Expr::__TestExhaustive(_) => unreachable!(),
+        #[cfg(not(test))]
+        _ => false,
+    }
+}
diff --git a/prettyplease/src/file.rs b/prettyplease/src/file.rs
new file mode 100644
index 0000000000..e23bd120fe
--- /dev/null
+++ b/prettyplease/src/file.rs
@@ -0,0 +1,17 @@
+use crate::algorithm::Printer;
+use syn::File;
+
+impl Printer {
+    pub fn file(&mut self, file: &File) {
+        self.cbox(0);
+        if let Some(shebang) = &file.shebang {
+            self.word(shebang.clone());
+            self.hardbreak();
+        }
+        self.inner_attrs(&file.attrs);
+        for item in &file.items {
+            self.item(item);
+        }
+        self.end();
+    }
+}
diff --git a/prettyplease/src/generics.rs b/prettyplease/src/generics.rs
new file mode 100644
index 0000000000..5da37c59cc
--- /dev/null
+++ b/prettyplease/src/generics.rs
@@ -0,0 +1,276 @@
+use crate::algorithm::Printer;
+use crate::iter::IterDelimited;
+use crate::INDENT;
+use syn::{
+    BoundLifetimes, ConstParam, GenericParam, Generics, LifetimeDef, PredicateEq,
+    PredicateLifetime, PredicateType, TraitBound, TraitBoundModifier, TypeParam, TypeParamBound,
+    WhereClause, WherePredicate,
+};
+
+impl Printer {
+    pub fn generics(&mut self, generics: &Generics) {
+        if generics.params.is_empty() {
+            return;
+        }
+
+        self.word("<");
+        self.cbox(0);
+        self.zerobreak();
+
+        // Print lifetimes before types and consts, regardless of their
+        // order in self.params.
+        //
+        // TODO: ordering rules for const parameters vs type parameters have
+        // not been settled yet. https://github.com/rust-lang/rust/issues/44580
+        for param in generics.params.iter().delimited() {
+            if let GenericParam::Lifetime(_) = *param {
+                self.generic_param(&param);
+                self.trailing_comma(param.is_last);
+            }
+        }
+        for param in generics.params.iter().delimited() {
+            match *param {
+                GenericParam::Type(_) | GenericParam::Const(_) => {
+                    self.generic_param(&param);
+                    self.trailing_comma(param.is_last);
+                }
+                GenericParam::Lifetime(_) => {}
+            }
+        }
+
+        self.offset(-INDENT);
+        self.end();
+        self.word(">");
+    }
+
+    pub fn generic_param(&mut self, generic_param: &GenericParam) {
+        match generic_param {
+            GenericParam::Type(type_param) => self.type_param(type_param),
+            GenericParam::Lifetime(lifetime_def) => self.lifetime_def(lifetime_def),
+            GenericParam::Const(const_param) => self.const_param(const_param),
+        }
+    }
+
+    pub fn bound_lifetimes(&mut self, bound_lifetimes: &BoundLifetimes) {
+        self.word("for<");
+        for lifetime_def in bound_lifetimes.lifetimes.iter().delimited() {
+            self.lifetime_def(&lifetime_def);
+            if !lifetime_def.is_last {
+                self.word(", ");
+            }
+        }
+        self.word("> ");
+    }
+
+    fn lifetime_def(&mut self, lifetime_def: &LifetimeDef) {
+        self.outer_attrs(&lifetime_def.attrs);
+        self.lifetime(&lifetime_def.lifetime);
+        for lifetime in lifetime_def.bounds.iter().delimited() {
+            if lifetime.is_first {
+                self.word(": ");
+            } else {
+                self.word(" + ");
+            }
+            self.lifetime(&lifetime);
+        }
+    }
+
+    fn type_param(&mut self, type_param: &TypeParam) {
+        self.outer_attrs(&type_param.attrs);
+        self.ident(&type_param.ident);
+        self.ibox(INDENT);
+        for type_param_bound in type_param.bounds.iter().delimited() {
+            if type_param_bound.is_first {
+                self.word(": ");
+            } else {
+                self.space();
+                self.word("+ ");
+            }
+            self.type_param_bound(&type_param_bound);
+        }
+        if let Some(default) = &type_param.default {
+            self.space();
+            self.word("= ");
+            self.ty(default);
+        }
+        self.end();
+    }
+
+    pub fn type_param_bound(&mut self, type_param_bound: &TypeParamBound) {
+        match type_param_bound {
+            TypeParamBound::Trait(trait_bound) => self.trait_bound(trait_bound),
+            TypeParamBound::Lifetime(lifetime) => self.lifetime(lifetime),
+        }
+    }
+
+    fn trait_bound(&mut self, trait_bound: &TraitBound) {
+        if trait_bound.paren_token.is_some() {
+            self.word("(");
+        }
+        let skip = match trait_bound.path.segments.first() {
+            Some(segment) if segment.ident == "const" => {
+                self.word("~const ");
+                1
+            }
+            _ => 0,
+        };
+        self.trait_bound_modifier(&trait_bound.modifier);
+        if let Some(bound_lifetimes) = &trait_bound.lifetimes {
+            self.bound_lifetimes(bound_lifetimes);
+        }
+        for segment in trait_bound.path.segments.iter().skip(skip).delimited() {
+            if !segment.is_first || trait_bound.path.leading_colon.is_some() {
+                self.word("::");
+            }
+            self.path_segment(&segment);
+        }
+        if trait_bound.paren_token.is_some() {
+            self.word(")");
+        }
+    }
+
+    fn trait_bound_modifier(&mut self, trait_bound_modifier: &TraitBoundModifier) {
+        match trait_bound_modifier {
+            TraitBoundModifier::None => {}
+            TraitBoundModifier::Maybe(_question_mark) => self.word("?"),
+        }
+    }
+
+    fn const_param(&mut self, const_param: &ConstParam) {
+        self.outer_attrs(&const_param.attrs);
+        self.word("const ");
+        self.ident(&const_param.ident);
+        self.word(": ");
+        self.ty(&const_param.ty);
+        if let Some(default) = &const_param.default {
+            self.word(" = ");
+            self.expr(default);
+        }
+    }
+
+    pub fn where_clause_for_body(&mut self, where_clause: &Option<WhereClause>) {
+        let hardbreaks = true;
+        let semi = false;
+        self.where_clause_impl(where_clause, hardbreaks, semi);
+    }
+
+    pub fn where_clause_semi(&mut self, where_clause: &Option<WhereClause>) {
+        let hardbreaks = true;
+        let semi = true;
+        self.where_clause_impl(where_clause, hardbreaks, semi);
+    }
+
+    pub fn where_clause_oneline(&mut self, where_clause: &Option<WhereClause>) {
+        let hardbreaks = false;
+        let semi = false;
+        self.where_clause_impl(where_clause, hardbreaks, semi);
+    }
+
+    pub fn where_clause_oneline_semi(&mut self, where_clause: &Option<WhereClause>) {
+        let hardbreaks = false;
+        let semi = true;
+        self.where_clause_impl(where_clause, hardbreaks, semi);
+    }
+
+    fn where_clause_impl(
+        &mut self,
+        where_clause: &Option<WhereClause>,
+        hardbreaks: bool,
+        semi: bool,
+    ) {
+        let where_clause = match where_clause {
+            Some(where_clause) if !where_clause.predicates.is_empty() => where_clause,
+            _ => {
+                if semi {
+                    self.word(";");
+                } else {
+                    self.nbsp();
+                }
+                return;
+            }
+        };
+        if hardbreaks {
+            self.hardbreak();
+            self.offset(-INDENT);
+            self.word("where");
+            self.hardbreak();
+            for predicate in where_clause.predicates.iter().delimited() {
+                self.where_predicate(&predicate);
+                if predicate.is_last && semi {
+                    self.word(";");
+                } else {
+                    self.word(",");
+                    self.hardbreak();
+                }
+            }
+            if !semi {
+                self.offset(-INDENT);
+            }
+        } else {
+            self.space();
+            self.offset(-INDENT);
+            self.word("where");
+            self.space();
+            for predicate in where_clause.predicates.iter().delimited() {
+                self.where_predicate(&predicate);
+                if predicate.is_last && semi {
+                    self.word(";");
+                } else {
+                    self.trailing_comma_or_space(predicate.is_last);
+                }
+            }
+            if !semi {
+                self.offset(-INDENT);
+            }
+        }
+    }
+
+    fn where_predicate(&mut self, predicate: &WherePredicate) {
+        match predicate {
+            WherePredicate::Type(predicate) => self.predicate_type(predicate),
+            WherePredicate::Lifetime(predicate) => self.predicate_lifetime(predicate),
+            WherePredicate::Eq(predicate) => self.predicate_eq(predicate),
+        }
+    }
+
+    fn predicate_type(&mut self, predicate: &PredicateType) {
+        if let Some(bound_lifetimes) = &predicate.lifetimes {
+            self.bound_lifetimes(bound_lifetimes);
+        }
+        self.ty(&predicate.bounded_ty);
+        self.word(":");
+        self.ibox(INDENT);
+        for type_param_bound in predicate.bounds.iter().delimited() {
+            if type_param_bound.is_first {
+                self.nbsp();
+            } else {
+                self.space();
+                self.word("+ ");
+            }
+            self.type_param_bound(&type_param_bound);
+        }
+        self.end();
+    }
+
+    fn predicate_lifetime(&mut self, predicate: &PredicateLifetime) {
+        self.lifetime(&predicate.lifetime);
+        self.word(":");
+        self.ibox(INDENT);
+        for lifetime in predicate.bounds.iter().delimited() {
+            if lifetime.is_first {
+                self.nbsp();
+            } else {
+                self.space();
+                self.word("+ ");
+            }
+            self.lifetime(&lifetime);
+        }
+        self.end();
+    }
+
+    fn predicate_eq(&mut self, predicate: &PredicateEq) {
+        self.ty(&predicate.lhs_ty);
+        self.word(" = ");
+        self.ty(&predicate.rhs_ty);
+    }
+}
diff --git a/prettyplease/src/item.rs b/prettyplease/src/item.rs
new file mode 100644
index 0000000000..b2d88cede0
--- /dev/null
+++ b/prettyplease/src/item.rs
@@ -0,0 +1,750 @@
+use crate::algorithm::Printer;
+use crate::iter::IterDelimited;
+use crate::INDENT;
+use proc_macro2::TokenStream;
+use syn::{
+    Fields, FnArg, ForeignItem, ForeignItemFn, ForeignItemMacro, ForeignItemStatic,
+    ForeignItemType, ImplItem, ImplItemConst, ImplItemMacro, ImplItemMethod, ImplItemType, Item,
+    ItemConst, ItemEnum, ItemExternCrate, ItemFn, ItemForeignMod, ItemImpl, ItemMacro, ItemMacro2,
+    ItemMod, ItemStatic, ItemStruct, ItemTrait, ItemTraitAlias, ItemType, ItemUnion, ItemUse, Pat,
+    Receiver, Signature, Stmt, TraitItem, TraitItemConst, TraitItemMacro, TraitItemMethod,
+    TraitItemType, Type, UseGlob, UseGroup, UseName, UsePath, UseRename, UseTree,
+};
+
+impl Printer {
+    pub fn item(&mut self, item: &Item) {
+        match item {
+            Item::Const(item) => self.item_const(item),
+            Item::Enum(item) => self.item_enum(item),
+            Item::ExternCrate(item) => self.item_extern_crate(item),
+            Item::Fn(item) => self.item_fn(item),
+            Item::ForeignMod(item) => self.item_foreign_mod(item),
+            Item::Impl(item) => self.item_impl(item),
+            Item::Macro(item) => self.item_macro(item),
+            Item::Macro2(item) => self.item_macro2(item),
+            Item::Mod(item) => self.item_mod(item),
+            Item::Static(item) => self.item_static(item),
+            Item::Struct(item) => self.item_struct(item),
+            Item::Trait(item) => self.item_trait(item),
+            Item::TraitAlias(item) => self.item_trait_alias(item),
+            Item::Type(item) => self.item_type(item),
+            Item::Union(item) => self.item_union(item),
+            Item::Use(item) => self.item_use(item),
+            Item::Verbatim(item) => self.item_verbatim(item),
+            #[cfg(test)]
+            Item::__TestExhaustive(_) => unreachable!(),
+            #[cfg(not(test))]
+            _ => unimplemented!("unknown Item"),
+        }
+    }
+
+    fn item_const(&mut self, item: &ItemConst) {
+        self.outer_attrs(&item.attrs);
+        self.cbox(0);
+        self.visibility(&item.vis);
+        self.word("const ");
+        self.ident(&item.ident);
+        self.word(": ");
+        self.ty(&item.ty);
+        self.word(" = ");
+        self.neverbreak();
+        self.expr(&item.expr);
+        self.word(";");
+        self.end();
+        self.hardbreak();
+    }
+
+    fn item_enum(&mut self, item: &ItemEnum) {
+        self.outer_attrs(&item.attrs);
+        self.cbox(INDENT);
+        self.visibility(&item.vis);
+        self.word("enum ");
+        self.ident(&item.ident);
+        self.generics(&item.generics);
+        self.where_clause_for_body(&item.generics.where_clause);
+        self.word("{");
+        self.hardbreak_if_nonempty();
+        self.inner_attrs(&item.attrs);
+        for variant in &item.variants {
+            self.variant(variant);
+            self.word(",");
+            self.hardbreak();
+        }
+        self.offset(-INDENT);
+        self.end();
+        self.word("}");
+        self.hardbreak();
+    }
+
+    fn item_extern_crate(&mut self, item: &ItemExternCrate) {
+        self.outer_attrs(&item.attrs);
+        self.visibility(&item.vis);
+        self.word("extern crate ");
+        self.ident(&item.ident);
+        if let Some((_as_token, rename)) = &item.rename {
+            self.word(" as ");
+            self.ident(rename);
+        }
+        self.word(";");
+        self.hardbreak();
+    }
+
+    fn item_fn(&mut self, item: &ItemFn) {
+        self.outer_attrs(&item.attrs);
+        self.cbox(INDENT);
+        self.visibility(&item.vis);
+        self.signature(&item.sig);
+        self.where_clause_for_body(&item.sig.generics.where_clause);
+        self.word("{");
+        self.hardbreak_if_nonempty();
+        self.inner_attrs(&item.attrs);
+        for stmt in &item.block.stmts {
+            self.stmt(stmt);
+        }
+        self.offset(-INDENT);
+        self.end();
+        self.word("}");
+        self.hardbreak();
+    }
+
+    fn item_foreign_mod(&mut self, item: &ItemForeignMod) {
+        self.outer_attrs(&item.attrs);
+        self.cbox(INDENT);
+        self.abi(&item.abi);
+        self.word("{");
+        self.hardbreak_if_nonempty();
+        self.inner_attrs(&item.attrs);
+        for foreign_item in &item.items {
+            self.foreign_item(foreign_item);
+        }
+        self.offset(-INDENT);
+        self.end();
+        self.word("}");
+        self.hardbreak();
+    }
+
+    fn item_impl(&mut self, item: &ItemImpl) {
+        self.outer_attrs(&item.attrs);
+        self.cbox(INDENT);
+        self.ibox(-INDENT);
+        self.cbox(INDENT);
+        if item.defaultness.is_some() {
+            self.word("default ");
+        }
+        if item.unsafety.is_some() {
+            self.word("unsafe ");
+        }
+        self.word("impl");
+        self.generics(&item.generics);
+        self.end();
+        self.nbsp();
+        if let Some((negative_polarity, path, _for_token)) = &item.trait_ {
+            if negative_polarity.is_some() {
+                self.word("!");
+            }
+            self.path(path);
+            self.space();
+            self.word("for ");
+        }
+        self.ty(&item.self_ty);
+        self.end();
+        self.where_clause_for_body(&item.generics.where_clause);
+        self.word("{");
+        self.hardbreak_if_nonempty();
+        self.inner_attrs(&item.attrs);
+        for impl_item in &item.items {
+            self.impl_item(impl_item);
+        }
+        self.offset(-INDENT);
+        self.end();
+        self.word("}");
+        self.hardbreak();
+    }
+
+    fn item_macro(&mut self, item: &ItemMacro) {
+        self.outer_attrs(&item.attrs);
+        self.mac(&item.mac, item.ident.as_ref());
+        self.mac_semi_if_needed(&item.mac.delimiter);
+        self.hardbreak();
+    }
+
+    fn item_macro2(&mut self, item: &ItemMacro2) {
+        unimplemented!("Item::Macro2 `macro {} {}`", item.ident, item.rules);
+    }
+
+    fn item_mod(&mut self, item: &ItemMod) {
+        self.outer_attrs(&item.attrs);
+        self.cbox(INDENT);
+        self.visibility(&item.vis);
+        self.word("mod ");
+        self.ident(&item.ident);
+        if let Some((_brace, items)) = &item.content {
+            self.word(" {");
+            self.hardbreak_if_nonempty();
+            self.inner_attrs(&item.attrs);
+            for item in items {
+                self.item(item);
+            }
+            self.offset(-INDENT);
+            self.end();
+            self.word("}");
+        } else {
+            self.word(";");
+            self.end();
+        }
+        self.hardbreak();
+    }
+
+    fn item_static(&mut self, item: &ItemStatic) {
+        self.outer_attrs(&item.attrs);
+        self.cbox(0);
+        self.visibility(&item.vis);
+        self.word("static ");
+        if item.mutability.is_some() {
+            self.word("mut ");
+        }
+        self.ident(&item.ident);
+        self.word(": ");
+        self.ty(&item.ty);
+        self.word(" = ");
+        self.neverbreak();
+        self.expr(&item.expr);
+        self.word(";");
+        self.end();
+        self.hardbreak();
+    }
+
+    fn item_struct(&mut self, item: &ItemStruct) {
+        self.outer_attrs(&item.attrs);
+        self.cbox(INDENT);
+        self.visibility(&item.vis);
+        self.word("struct ");
+        self.ident(&item.ident);
+        self.generics(&item.generics);
+        match &item.fields {
+            Fields::Named(fields) => {
+                self.where_clause_for_body(&item.generics.where_clause);
+                self.word("{");
+                self.hardbreak_if_nonempty();
+                for field in &fields.named {
+                    self.field(field);
+                    self.word(",");
+                    self.hardbreak();
+                }
+                self.offset(-INDENT);
+                self.end();
+                self.word("}");
+            }
+            Fields::Unnamed(fields) => {
+                self.fields_unnamed(fields);
+                self.where_clause_semi(&item.generics.where_clause);
+                self.end();
+            }
+            Fields::Unit => {
+                self.where_clause_semi(&item.generics.where_clause);
+                self.end();
+            }
+        }
+        self.hardbreak();
+    }
+
+    fn item_trait(&mut self, item: &ItemTrait) {
+        self.outer_attrs(&item.attrs);
+        self.cbox(INDENT);
+        self.visibility(&item.vis);
+        if item.unsafety.is_some() {
+            self.word("unsafe ");
+        }
+        if item.auto_token.is_some() {
+            self.word("auto ");
+        }
+        self.word("trait ");
+        self.ident(&item.ident);
+        self.generics(&item.generics);
+        for supertrait in item.supertraits.iter().delimited() {
+            if supertrait.is_first {
+                self.word(": ");
+            } else {
+                self.word(" + ");
+            }
+            self.type_param_bound(&supertrait);
+        }
+        self.where_clause_for_body(&item.generics.where_clause);
+        self.word("{");
+        self.hardbreak_if_nonempty();
+        self.inner_attrs(&item.attrs);
+        for trait_item in &item.items {
+            self.trait_item(trait_item);
+        }
+        self.offset(-INDENT);
+        self.end();
+        self.word("}");
+        self.hardbreak();
+    }
+
+    fn item_trait_alias(&mut self, item: &ItemTraitAlias) {
+        self.outer_attrs(&item.attrs);
+        self.cbox(INDENT);
+        self.visibility(&item.vis);
+        self.word("trait ");
+        self.ident(&item.ident);
+        self.generics(&item.generics);
+        self.word(" = ");
+        self.neverbreak();
+        for bound in item.bounds.iter().delimited() {
+            if !bound.is_first {
+                self.space();
+                self.word("+ ");
+            }
+            self.type_param_bound(&bound);
+        }
+        self.where_clause_semi(&item.generics.where_clause);
+        self.end();
+        self.hardbreak();
+    }
+
+    fn item_type(&mut self, item: &ItemType) {
+        self.outer_attrs(&item.attrs);
+        self.cbox(INDENT);
+        self.visibility(&item.vis);
+        self.word("type ");
+        self.ident(&item.ident);
+        self.generics(&item.generics);
+        self.where_clause_oneline(&item.generics.where_clause);
+        self.word("= ");
+        self.neverbreak();
+        self.ibox(-INDENT);
+        self.ty(&item.ty);
+        self.end();
+        self.word(";");
+        self.end();
+        self.hardbreak();
+    }
+
+    fn item_union(&mut self, item: &ItemUnion) {
+        self.outer_attrs(&item.attrs);
+        self.cbox(INDENT);
+        self.visibility(&item.vis);
+        self.word("union ");
+        self.ident(&item.ident);
+        self.generics(&item.generics);
+        self.where_clause_for_body(&item.generics.where_clause);
+        self.word("{");
+        self.hardbreak_if_nonempty();
+        for field in &item.fields.named {
+            self.field(field);
+            self.word(",");
+            self.hardbreak();
+        }
+        self.offset(-INDENT);
+        self.end();
+        self.word("}");
+        self.hardbreak();
+    }
+
+    fn item_use(&mut self, item: &ItemUse) {
+        self.outer_attrs(&item.attrs);
+        self.visibility(&item.vis);
+        self.word("use ");
+        if item.leading_colon.is_some() {
+            self.word("::");
+        }
+        self.use_tree(&item.tree);
+        self.word(";");
+        self.hardbreak();
+    }
+
+    fn item_verbatim(&mut self, item: &TokenStream) {
+        unimplemented!("Item::Verbatim `{}`", item);
+    }
+
+    fn use_tree(&mut self, use_tree: &UseTree) {
+        match use_tree {
+            UseTree::Path(use_path) => self.use_path(use_path),
+            UseTree::Name(use_name) => self.use_name(use_name),
+            UseTree::Rename(use_rename) => self.use_rename(use_rename),
+            UseTree::Glob(use_glob) => self.use_glob(use_glob),
+            UseTree::Group(use_group) => self.use_group(use_group),
+        }
+    }
+
+    fn use_path(&mut self, use_path: &UsePath) {
+        self.ident(&use_path.ident);
+        self.word("::");
+        self.use_tree(&use_path.tree);
+    }
+
+    fn use_name(&mut self, use_name: &UseName) {
+        self.ident(&use_name.ident);
+    }
+
+    fn use_rename(&mut self, use_rename: &UseRename) {
+        self.ident(&use_rename.ident);
+        self.word(" as ");
+        self.ident(&use_rename.rename);
+    }
+
+    fn use_glob(&mut self, use_glob: &UseGlob) {
+        let _ = use_glob;
+        self.word("*");
+    }
+
+    fn use_group(&mut self, use_group: &UseGroup) {
+        if use_group.items.len() == 1 {
+            self.use_tree(&use_group.items[0]);
+        } else {
+            self.cbox(INDENT);
+            self.word("{");
+            self.zerobreak();
+            self.ibox(0);
+            for use_tree in use_group.items.iter().delimited() {
+                self.use_tree(&use_tree);
+                if !use_tree.is_last {
+                    self.word(",");
+                    let mut use_tree = *use_tree;
+                    while let UseTree::Path(use_path) = use_tree {
+                        use_tree = &use_path.tree;
+                    }
+                    if let UseTree::Group(_) = use_tree {
+                        self.hardbreak();
+                    } else {
+                        self.space();
+                    }
+                }
+            }
+            self.end();
+            self.trailing_comma(true);
+            self.offset(-INDENT);
+            self.word("}");
+            self.end();
+        }
+    }
+
+    pub fn foreign_item(&mut self, foreign_item: &ForeignItem) {
+        match foreign_item {
+            ForeignItem::Fn(item) => self.foreign_item_fn(item),
+            ForeignItem::Static(item) => self.foreign_item_static(item),
+            ForeignItem::Type(item) => self.foreign_item_type(item),
+            ForeignItem::Macro(item) => self.foreign_item_macro(item),
+            ForeignItem::Verbatim(item) => self.foreign_item_verbatim(item),
+            #[cfg(test)]
+            ForeignItem::__TestExhaustive(_) => unreachable!(),
+            #[cfg(not(test))]
+            _ => unimplemented!("unknown ForeignItem"),
+        }
+    }
+
+    fn foreign_item_fn(&mut self, foreign_item: &ForeignItemFn) {
+        self.outer_attrs(&foreign_item.attrs);
+        self.cbox(INDENT);
+        self.visibility(&foreign_item.vis);
+        self.signature(&foreign_item.sig);
+        self.where_clause_semi(&foreign_item.sig.generics.where_clause);
+        self.end();
+        self.hardbreak();
+    }
+
+    fn foreign_item_static(&mut self, foreign_item: &ForeignItemStatic) {
+        self.outer_attrs(&foreign_item.attrs);
+        self.cbox(0);
+        self.visibility(&foreign_item.vis);
+        self.word("static ");
+        if foreign_item.mutability.is_some() {
+            self.word("mut ");
+        }
+        self.ident(&foreign_item.ident);
+        self.word(": ");
+        self.ty(&foreign_item.ty);
+        self.word(";");
+        self.end();
+        self.hardbreak();
+    }
+
+    fn foreign_item_type(&mut self, foreign_item: &ForeignItemType) {
+        self.outer_attrs(&foreign_item.attrs);
+        self.cbox(0);
+        self.visibility(&foreign_item.vis);
+        self.word("type ");
+        self.ident(&foreign_item.ident);
+        self.word(";");
+        self.end();
+        self.hardbreak();
+    }
+
+    fn foreign_item_macro(&mut self, foreign_item: &ForeignItemMacro) {
+        self.outer_attrs(&foreign_item.attrs);
+        self.mac(&foreign_item.mac, None);
+        self.mac_semi_if_needed(&foreign_item.mac.delimiter);
+        self.hardbreak();
+    }
+
+    fn foreign_item_verbatim(&mut self, foreign_item: &TokenStream) {
+        unimplemented!("ForeignItem::Verbatim `{}`", foreign_item);
+    }
+
+    pub fn trait_item(&mut self, trait_item: &TraitItem) {
+        match trait_item {
+            TraitItem::Const(item) => self.trait_item_const(item),
+            TraitItem::Method(item) => self.trait_item_method(item),
+            TraitItem::Type(item) => self.trait_item_type(item),
+            TraitItem::Macro(item) => self.trait_item_macro(item),
+            TraitItem::Verbatim(item) => self.trait_item_verbatim(item),
+            #[cfg(test)]
+            TraitItem::__TestExhaustive(_) => unreachable!(),
+            #[cfg(not(test))]
+            _ => unimplemented!("unknown TraitItem"),
+        }
+    }
+
+    fn trait_item_const(&mut self, trait_item: &TraitItemConst) {
+        self.outer_attrs(&trait_item.attrs);
+        self.cbox(0);
+        self.word("const ");
+        self.ident(&trait_item.ident);
+        self.word(": ");
+        self.ty(&trait_item.ty);
+        if let Some((_eq_token, default)) = &trait_item.default {
+            self.word(" = ");
+            self.neverbreak();
+            self.expr(default);
+        }
+        self.word(";");
+        self.end();
+        self.hardbreak();
+    }
+
+    fn trait_item_method(&mut self, trait_item: &TraitItemMethod) {
+        self.outer_attrs(&trait_item.attrs);
+        self.cbox(INDENT);
+        self.signature(&trait_item.sig);
+        if let Some(block) = &trait_item.default {
+            self.where_clause_for_body(&trait_item.sig.generics.where_clause);
+            self.word("{");
+            self.hardbreak_if_nonempty();
+            self.inner_attrs(&trait_item.attrs);
+            for stmt in &block.stmts {
+                self.stmt(stmt);
+            }
+            self.offset(-INDENT);
+            self.end();
+            self.word("}");
+        } else {
+            self.where_clause_semi(&trait_item.sig.generics.where_clause);
+            self.end();
+        }
+        self.hardbreak();
+    }
+
+    fn trait_item_type(&mut self, trait_item: &TraitItemType) {
+        self.outer_attrs(&trait_item.attrs);
+        self.cbox(INDENT);
+        self.word("type ");
+        self.ident(&trait_item.ident);
+        self.generics(&trait_item.generics);
+        for bound in trait_item.bounds.iter().delimited() {
+            if bound.is_first {
+                self.word(": ");
+            } else {
+                self.space();
+                self.word("+ ");
+            }
+            self.type_param_bound(&bound);
+        }
+        if let Some((_eq_token, default)) = &trait_item.default {
+            self.where_clause_oneline(&trait_item.generics.where_clause);
+            self.word("= ");
+            self.neverbreak();
+            self.ty(default);
+        } else {
+            self.where_clause_oneline_semi(&trait_item.generics.where_clause);
+        }
+        self.end();
+        self.hardbreak();
+    }
+
+    fn trait_item_macro(&mut self, trait_item: &TraitItemMacro) {
+        self.outer_attrs(&trait_item.attrs);
+        self.mac(&trait_item.mac, None);
+        self.mac_semi_if_needed(&trait_item.mac.delimiter);
+        self.hardbreak();
+    }
+
+    fn trait_item_verbatim(&mut self, trait_item: &TokenStream) {
+        unimplemented!("TraitItem::Verbatim `{}`", trait_item);
+    }
+
+    pub fn impl_item(&mut self, impl_item: &ImplItem) {
+        match impl_item {
+            ImplItem::Const(item) => self.impl_item_const(item),
+            ImplItem::Method(item) => self.impl_item_method(item),
+            ImplItem::Type(item) => self.impl_item_type(item),
+            ImplItem::Macro(item) => self.impl_item_macro(item),
+            ImplItem::Verbatim(item) => self.impl_item_verbatim(item),
+            #[cfg(test)]
+            ImplItem::__TestExhaustive(_) => unreachable!(),
+            #[cfg(not(test))]
+            _ => unimplemented!("unknown ImplItem"),
+        }
+    }
+
+    fn impl_item_const(&mut self, impl_item: &ImplItemConst) {
+        self.outer_attrs(&impl_item.attrs);
+        self.cbox(0);
+        self.visibility(&impl_item.vis);
+        if impl_item.defaultness.is_some() {
+            self.word("default ");
+        }
+        self.word("const ");
+        self.ident(&impl_item.ident);
+        self.word(": ");
+        self.ty(&impl_item.ty);
+        self.word(" = ");
+        self.neverbreak();
+        self.expr(&impl_item.expr);
+        self.word(";");
+        self.end();
+        self.hardbreak();
+    }
+
+    fn impl_item_method(&mut self, impl_item: &ImplItemMethod) {
+        self.outer_attrs(&impl_item.attrs);
+        self.cbox(INDENT);
+        self.visibility(&impl_item.vis);
+        if impl_item.defaultness.is_some() {
+            self.word("default ");
+        }
+        self.signature(&impl_item.sig);
+        if impl_item.block.stmts.len() == 1 {
+            if let Stmt::Item(Item::Verbatim(verbatim)) = &impl_item.block.stmts[0] {
+                if verbatim.to_string() == ";" {
+                    self.where_clause_semi(&impl_item.sig.generics.where_clause);
+                    self.end();
+                    self.hardbreak();
+                    return;
+                }
+            }
+        }
+        self.where_clause_for_body(&impl_item.sig.generics.where_clause);
+        self.word("{");
+        self.hardbreak_if_nonempty();
+        self.inner_attrs(&impl_item.attrs);
+        for stmt in &impl_item.block.stmts {
+            self.stmt(stmt);
+        }
+        self.offset(-INDENT);
+        self.end();
+        self.word("}");
+        self.hardbreak();
+    }
+
+    fn impl_item_type(&mut self, impl_item: &ImplItemType) {
+        self.outer_attrs(&impl_item.attrs);
+        self.cbox(INDENT);
+        self.visibility(&impl_item.vis);
+        if impl_item.defaultness.is_some() {
+            self.word("default ");
+        }
+        self.word("type ");
+        self.ident(&impl_item.ident);
+        self.generics(&impl_item.generics);
+        self.where_clause_oneline(&impl_item.generics.where_clause);
+        self.word("= ");
+        self.neverbreak();
+        self.ty(&impl_item.ty);
+        self.word(";");
+        self.end();
+        self.hardbreak();
+    }
+
+    fn impl_item_macro(&mut self, impl_item: &ImplItemMacro) {
+        self.outer_attrs(&impl_item.attrs);
+        self.mac(&impl_item.mac, None);
+        self.mac_semi_if_needed(&impl_item.mac.delimiter);
+        self.hardbreak();
+    }
+
+    fn impl_item_verbatim(&mut self, impl_item: &TokenStream) {
+        unimplemented!("ImplItem::Verbatim `{}`", impl_item);
+    }
+
+    pub fn maybe_variadic(&mut self, arg: &FnArg) -> bool {
+        let pat_type = match arg {
+            FnArg::Typed(pat_type) => pat_type,
+            FnArg::Receiver(receiver) => {
+                self.receiver(receiver);
+                return false;
+            }
+        };
+
+        match pat_type.ty.as_ref() {
+            Type::Verbatim(ty) if ty.to_string() == "..." => {
+                match pat_type.pat.as_ref() {
+                    Pat::Verbatim(pat) if pat.to_string() == "..." => {
+                        self.outer_attrs(&pat_type.attrs);
+                        self.word("...");
+                    }
+                    _ => self.pat_type(pat_type),
+                }
+                true
+            }
+            _ => {
+                self.pat_type(pat_type);
+                false
+            }
+        }
+    }
+
+    fn signature(&mut self, signature: &Signature) {
+        if signature.constness.is_some() {
+            self.word("const ");
+        }
+        if signature.asyncness.is_some() {
+            self.word("async ");
+        }
+        if signature.unsafety.is_some() {
+            self.word("unsafe ");
+        }
+        if let Some(abi) = &signature.abi {
+            self.abi(abi);
+        }
+        self.word("fn ");
+        self.ident(&signature.ident);
+        self.generics(&signature.generics);
+        self.word("(");
+        self.neverbreak();
+        self.cbox(0);
+        self.zerobreak();
+        let mut last_is_variadic = false;
+        for input in signature.inputs.iter().delimited() {
+            last_is_variadic = self.maybe_variadic(&input);
+            if last_is_variadic {
+                self.zerobreak();
+            } else {
+                self.trailing_comma(input.is_last);
+            }
+        }
+        if signature.variadic.is_some() && !last_is_variadic {
+            self.word("...");
+            self.zerobreak();
+        }
+        self.offset(-INDENT);
+        self.end();
+        self.word(")");
+        self.return_type(&signature.output);
+    }
+
+    fn receiver(&mut self, receiver: &Receiver) {
+        self.outer_attrs(&receiver.attrs);
+        if let Some((_ampersand, lifetime)) = &receiver.reference {
+            self.word("&");
+            if let Some(lifetime) = lifetime {
+                self.lifetime(lifetime);
+                self.nbsp();
+            }
+        }
+        if receiver.mutability.is_some() {
+            self.word("mut ");
+        }
+        self.word("self");
+    }
+}
diff --git a/prettyplease/src/iter.rs b/prettyplease/src/iter.rs
new file mode 100644
index 0000000000..702c653f52
--- /dev/null
+++ b/prettyplease/src/iter.rs
@@ -0,0 +1,46 @@
+use std::iter::Peekable;
+use std::ops::Deref;
+
+pub struct Delimited<I: Iterator> {
+    is_first: bool,
+    iter: Peekable<I>,
+}
+
+pub trait IterDelimited: Iterator + Sized {
+    fn delimited(self) -> Delimited<Self> {
+        Delimited {
+            is_first: true,
+            iter: self.peekable(),
+        }
+    }
+}
+
+impl<I: Iterator> IterDelimited for I {}
+
+pub struct IteratorItem<T> {
+    value: T,
+    pub is_first: bool,
+    pub is_last: bool,
+}
+
+impl<I: Iterator> Iterator for Delimited<I> {
+    type Item = IteratorItem<I::Item>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let item = IteratorItem {
+            value: self.iter.next()?,
+            is_first: self.is_first,
+            is_last: self.iter.peek().is_none(),
+        };
+        self.is_first = false;
+        Some(item)
+    }
+}
+
+impl<T> Deref for IteratorItem<T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        &self.value
+    }
+}
diff --git a/prettyplease/src/lib.rs b/prettyplease/src/lib.rs
new file mode 100644
index 0000000000..97e2dd150d
--- /dev/null
+++ b/prettyplease/src/lib.rs
@@ -0,0 +1,374 @@
+//! [![github]](https://github.com/dtolnay/prettyplease)&ensp;[![crates-io]](https://crates.io/crates/prettyplease)&ensp;[![docs-rs]](https://docs.rs/prettyplease)
+//!
+//! [github]: https://img.shields.io/badge/github-8da0cb?style=for-the-badge&labelColor=555555&logo=github
+//! [crates-io]: https://img.shields.io/badge/crates.io-fc8d62?style=for-the-badge&labelColor=555555&logo=rust
+//! [docs-rs]: https://img.shields.io/badge/docs.rs-66c2a5?style=for-the-badge&labelColor=555555&logoColor=white&logo=data:image/svg+xml;base64,PHN2ZyByb2xlPSJpbWciIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyIgdmlld0JveD0iMCAwIDUxMiA1MTIiPjxwYXRoIGZpbGw9IiNmNWY1ZjUiIGQ9Ik00ODguNiAyNTAuMkwzOTIgMjE0VjEwNS41YzAtMTUtOS4zLTI4LjQtMjMuNC0zMy43bC0xMDAtMzcuNWMtOC4xLTMuMS0xNy4xLTMuMS0yNS4zIDBsLTEwMCAzNy41Yy0xNC4xIDUuMy0yMy40IDE4LjctMjMuNCAzMy43VjIxNGwtOTYuNiAzNi4yQzkuMyAyNTUuNSAwIDI2OC45IDAgMjgzLjlWMzk0YzAgMTMuNiA3LjcgMjYuMSAxOS45IDMyLjJsMTAwIDUwYzEwLjEgNS4xIDIyLjEgNS4xIDMyLjIgMGwxMDMuOS01MiAxMDMuOSA1MmMxMC4xIDUuMSAyMi4xIDUuMSAzMi4yIDBsMTAwLTUwYzEyLjItNi4xIDE5LjktMTguNiAxOS45LTMyLjJWMjgzLjljMC0xNS05LjMtMjguNC0yMy40LTMzLjd6TTM1OCAyMTQuOGwtODUgMzEuOXYtNjguMmw4NS0zN3Y3My4zek0xNTQgMTA0LjFsMTAyLTM4LjIgMTAyIDM4LjJ2LjZsLTEwMiA0MS40LTEwMi00MS40di0uNnptODQgMjkxLjFsLTg1IDQyLjV2LTc5LjFsODUtMzguOHY3NS40em0wLTExMmwtMTAyIDQxLjQtMTAyLTQxLjR2LS42bDEwMi0zOC4yIDEwMiAzOC4ydi42em0yNDAgMTEybC04NSA0Mi41di03OS4xbDg1LTM4Ljh2NzUuNHptMC0xMTJsLTEwMiA0MS40LTEwMi00MS40di0uNmwxMDItMzguMiAxMDIgMzguMnYuNnoiPjwvcGF0aD48L3N2Zz4K
+//!
+//! <br>
+//!
+//! **prettyplease::unparse** &mdash; a minimal `syn` syntax tree pretty-printer
+//!
+//! <br>
+//!
+//! # Overview
+//!
+//! This is a pretty-printer to turn a `syn` syntax tree into a `String` of
+//! well-formatted source code. In contrast to rustfmt, this library is intended
+//! to be suitable for arbitrary generated code.
+//!
+//! Rustfmt prioritizes high-quality output that is impeccable enough that you'd
+//! be comfortable spending your career staring at its output &mdash; but that
+//! means some heavyweight algorithms, and it has a tendency to bail out on code
+//! that is hard to format (for example [rustfmt#3697], and there are dozens
+//! more issues like it). That's not necessarily a big deal for human-generated
+//! code because when code gets highly nested, the human will naturally be
+//! inclined to refactor into more easily formattable code. But for generated
+//! code, having the formatter just give up leaves it totally unreadable.
+//!
+//! [rustfmt#3697]: https://github.com/rust-lang/rustfmt/issues/3697
+//!
+//! This library is designed using the simplest possible algorithm and data
+//! structures that can deliver about 95% of the quality of rustfmt-formatted
+//! output. In my experience testing real-world code, approximately 97-98% of
+//! output lines come out identical between rustfmt's formatting and this
+//! crate's. The rest have slightly different linebreak decisions, but still
+//! clearly follow the dominant modern Rust style.
+//!
+//! The tradeoffs made by this crate are a good fit for generated code that you
+//! will *not* spend your career staring at. For example, the output of
+//! `bindgen`, or the output of `cargo-expand`. In those cases it's more
+//! important that the whole thing be formattable without the formatter giving
+//! up, than that it be flawless.
+//!
+//! <br>
+//!
+//! # Feature matrix
+//!
+//! Here are a few superficial comparisons of this crate against the AST
+//! pretty-printer built into rustc, and rustfmt. The sections below go into
+//! more detail comparing the output of each of these libraries.
+//!
+//! | | prettyplease | rustc | rustfmt |
+//! | --- | --- | --- | --- |
+//! | non-pathological behavior on big or generated code | ✅ | ❌ | ❌ |
+//! | idiomatic modern formatting ("locally indistinguishable from rustfmt") | ✅ | ❌ | ✅ |
+//! | throughput | 60 MB/s | 39 MB/s | 2.8 MB/s |
+//! | number of dependencies | 3 | 72 | 66 |
+//! | compile time including dependencies | 2.4 sec | 23.1 sec | 29.8 sec |
+//! | buildable using a stable Rust compiler | ✅ | ❌ | ❌ |
+//! | published to crates.io | ✅ | ❌ | ❌ |
+//! | extensively configurable output | ❌ | ❌ | ✅ |
+//! | intended to accommodate hand-maintained source code | ❌ | ❌ | ✅ |
+//!
+//! <br>
+//!
+//! # Comparison to rustfmt
+//!
+//! - [input.rs](https://github.com/dtolnay/prettyplease/blob/0.1.0/examples/input.rs)
+//! - [output.prettyplease.rs](https://github.com/dtolnay/prettyplease/blob/0.1.0/examples/output.prettyplease.rs)
+//! - [output.rustfmt.rs](https://github.com/dtolnay/prettyplease/blob/0.1.0/examples/output.rustfmt.rs)
+//!
+//! If you weren't told which output file is which, it would be practically
+//! impossible to tell &mdash; **except** for line 435 in the rustfmt output,
+//! which is more than 1000 characters long because rustfmt just gave up
+//! formatting that part of the file:
+//!
+//! ```
+//! # const _: &str = stringify! {{{
+//!             match segments[5] {
+//!                 0 => write!(f, "::{}", ipv4),
+//!                 0xffff => write!(f, "::ffff:{}", ipv4),
+//!                 _ => unreachable!(),
+//!             }
+//!         } else { # [derive (Copy , Clone , Default)] struct Span { start : usize , len : usize , } let zeroes = { let mut longest = Span :: default () ; let mut current = Span :: default () ; for (i , & segment) in segments . iter () . enumerate () { if segment == 0 { if current . len == 0 { current . start = i ; } current . len += 1 ; if current . len > longest . len { longest = current ; } } else { current = Span :: default () ; } } longest } ; # [doc = " Write a colon-separated part of the address"] # [inline] fn fmt_subslice (f : & mut fmt :: Formatter < '_ > , chunk : & [u16]) -> fmt :: Result { if let Some ((first , tail)) = chunk . split_first () { write ! (f , "{:x}" , first) ? ; for segment in tail { f . write_char (':') ? ; write ! (f , "{:x}" , segment) ? ; } } Ok (()) } if zeroes . len > 1 { fmt_subslice (f , & segments [.. zeroes . start]) ? ; f . write_str ("::") ? ; fmt_subslice (f , & segments [zeroes . start + zeroes . len ..]) } else { fmt_subslice (f , & segments) } }
+//!     } else {
+//!         const IPV6_BUF_LEN: usize = (4 * 8) + 7;
+//!         let mut buf = [0u8; IPV6_BUF_LEN];
+//!         let mut buf_slice = &mut buf[..];
+//! # }};
+//! ```
+//!
+//! This is a pretty typical manifestation of rustfmt bailing out in generated
+//! code &mdash; a chunk of the input ends up on one line. The other
+//! manifestation is that you're working on some code, running rustfmt on save
+//! like a conscientious developer, but after a while notice it isn't doing
+//! anything. You introduce an intentional formatting issue, like a stray indent
+//! or semicolon, and run rustfmt to check your suspicion. Nope, it doesn't get
+//! cleaned up &mdash; rustfmt is just not formatting the part of the file you
+//! are working on.
+//!
+//! The prettyplease library is designed to have no pathological cases that
+//! force a bail out; the entire input you give it will get formatted in some
+//! "good enough" form.
+//!
+//! Separately, rustfmt can be problematic to integrate into projects. It's
+//! written using rustc's internal syntax tree, so it can't be built by a stable
+//! compiler. Its releases are not regularly published to crates.io, so in Cargo
+//! builds you'd need to depend on it as a git dependency, which precludes
+//! publishing your crate to crates.io also. You can shell out to a `rustfmt`
+//! binary, but that'll be whatever rustfmt version is installed on each
+//! developer's system (if any), which can lead to spurious diffs in checked-in
+//! generated code formatted by different versions. In contrast prettyplease is
+//! designed to be easy to pull in as a library, and compiles fast.
+//!
+//! <br>
+//!
+//! # Comparison to rustc_ast_pretty
+//!
+//! - [input.rs](https://github.com/dtolnay/prettyplease/blob/0.1.0/examples/input.rs)
+//! - [output.prettyplease.rs](https://github.com/dtolnay/prettyplease/blob/0.1.0/examples/output.prettyplease.rs)
+//! - [output.rustc.rs](https://github.com/dtolnay/prettyplease/blob/0.1.0/examples/output.rustc.rs)
+//!
+//! This is the pretty-printer that gets used when rustc prints source code,
+//! such as `rustc -Zunpretty=expanded`. It's used also by the standard
+//! library's `stringify!` when stringifying an interpolated macro_rules AST
+//! fragment, like an $:expr, and transitively by `dbg!` and many macros in the
+//! ecosystem.
+//!
+//! Rustc's formatting is mostly okay, but does not hew closely to the dominant
+//! contemporary style of Rust formatting. Some things wouldn't ever be written
+//! on one line, like this `match` expression, and certainly not with a comma in
+//! front of the closing brace:
+//!
+//! ```
+//! # const _: &str = stringify! {
+//! fn eq(&self, other: &IpAddr) -> bool {
+//!     match other { IpAddr::V4(v4) => self == v4, IpAddr::V6(_) => false, }
+//! }
+//! # };
+//! ```
+//!
+//! Some places use non-multiple-of-4 indentation, which is definitely not the
+//! norm:
+//!
+//! ```
+//! # const _: &str = stringify! {
+//! pub const fn to_ipv6_mapped(&self) -> Ipv6Addr {
+//!     let [a, b, c, d] = self.octets();
+//!     Ipv6Addr{inner:
+//!                  c::in6_addr{s6_addr:
+//!                                  [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF,
+//!                                   0xFF, a, b, c, d],},}
+//! }
+//! # };
+//! ```
+//!
+//! And although there isn't an egregious example of it in the link because the
+//! input code is pretty tame, in general rustc_ast_pretty has pathological
+//! behavior on generated code. It has a tendency to use excessive horizontal
+//! indentation and rapidly run out of width:
+//!
+//! ```
+//! # const _: &str = stringify! {
+//! ::std::io::_print(::core::fmt::Arguments::new_v1(&[""],
+//!                                                  &match (&msg,) {
+//!                                                       _args =>
+//!                                                       [::core::fmt::ArgumentV1::new(_args.0,
+//!                                                                                     ::core::fmt::Display::fmt)],
+//!                                                   }));
+//! # };
+//! ```
+//!
+//! The snippets above are clearly different from modern rustfmt style. In
+//! contrast, prettyplease is designed to have output that is practically
+//! indistinguishable from rustfmt-formatted code.
+//!
+//! <br>
+//!
+//! # Example
+//!
+//! ```
+//! // [dependencies]
+//! // prettyplease = "0.1"
+//! // syn = { version = "1", default-features = false, features = ["full", "parsing"] }
+//!
+//! const INPUT: &str = stringify! {
+//!     use crate::{
+//!           lazy::{Lazy, SyncLazy, SyncOnceCell}, panic,
+//!         sync::{ atomic::{AtomicUsize, Ordering::SeqCst},
+//!             mpsc::channel, Mutex, },
+//!       thread,
+//!     };
+//!     impl<T, U> Into<U> for T where U: From<T> {
+//!         fn into(self) -> U { U::from(self) }
+//!     }
+//! };
+//!
+//! fn main() {
+//!     let syntax_tree = syn::parse_file(INPUT).unwrap();
+//!     let formatted = prettyplease::unparse(&syntax_tree);
+//!     print!("{}", formatted);
+//! }
+//! ```
+//!
+//! <br>
+//!
+//! # Algorithm notes
+//!
+//! The approach and terminology used in the implementation are derived from
+//! [*Derek C. Oppen, "Pretty Printing" (1979)*][paper], on which
+//! rustc_ast_pretty is also based, and from rustc_ast_pretty's implementation
+//! written by Graydon Hoare in 2011 (and modernized over the years by dozens of
+//! volunteer maintainers).
+//!
+//! [paper]: http://i.stanford.edu/pub/cstr/reports/cs/tr/79/770/CS-TR-79-770.pdf
+//!
+//! The paper describes two language-agnostic interacting procedures `Scan()`
+//! and `Print()`. Language-specific code decomposes an input data structure
+//! into a stream of `string` and `break` tokens, and `begin` and `end` tokens
+//! for grouping. Each `begin`&ndash;`end` range may be identified as either
+//! "consistent breaking" or "inconsistent breaking". If a group is consistently
+//! breaking, then if the whole contents do not fit on the line, *every* `break`
+//! token in the group will receive a linebreak. This is appropriate, for
+//! example, for Rust struct literals, or arguments of a function call. If a
+//! group is inconsistently breaking, then the `string` tokens in the group are
+//! greedily placed on the line until out of space, and linebroken only at those
+//! `break` tokens for which the next string would not fit. For example, this is
+//! appropriate for the contents of a braced `use` statement in Rust.
+//!
+//! Scan's job is to efficiently accumulate sizing information about groups and
+//! breaks. For every `begin` token we compute the distance to the matched `end`
+//! token, and for every `break` we compute the distance to the next `break`.
+//! The algorithm uses a ringbuffer to hold tokens whose size is not yet
+//! ascertained. The maximum size of the ringbuffer is bounded by the target
+//! line length and does not grow indefinitely, regardless of deep nesting in
+//! the input stream. That's because once a group is sufficiently big, the
+//! precise size can no longer make a difference to linebreak decisions and we
+//! can effectively treat it as "infinity".
+//!
+//! Print's job is to use the sizing information to efficiently assign a
+//! "broken" or "not broken" status to every `begin` token. At that point the
+//! output is easily constructed by concatenating `string` tokens and breaking
+//! at `break` tokens contained within a broken group.
+//!
+//! Leveraging these primitives (i.e. cleverly placing the all-or-nothing
+//! consistent breaks and greedy inconsistent breaks) to yield
+//! rustfmt-compatible formatting for all of Rust's syntax tree nodes is a fun
+//! challenge.
+//!
+//! Here is a visualization of some Rust tokens fed into the pretty printing
+//! algorithm. Consistently breaking `begin`&mdash;`end` pairs are represented
+//! by `«`&#8288;`»`, inconsistently breaking by `‹`&#8288;`›`, `break` by `·`,
+//! and the rest of the non-whitespace are `string`.
+//!
+//! ```text
+//! use crate::«{·
+//! ‹    lazy::«{·‹Lazy,· SyncLazy,· SyncOnceCell›·}»,·
+//!     panic,·
+//!     sync::«{·
+//! ‹        atomic::«{·‹AtomicUsize,· Ordering::SeqCst›·}»,·
+//!         mpsc::channel,· Mutex›,·
+//!     }»,·
+//!     thread›,·
+//! }»;·
+//! «‹«impl<«·T‹›,· U‹›·»>» Into<«·U·»>· for T›·
+//! where·
+//!     U:‹ From<«·T·»>›,·
+//! {·
+//! «    fn into(·«·self·») -> U {·
+//! ‹        U::from(«·self·»)›·
+//! »    }·
+//! »}·
+//! ```
+//!
+//! The algorithm described in the paper is not quite sufficient for producing
+//! well-formatted Rust code that is locally indistinguishable from rustfmt's
+//! style. The reason is that in the paper, the complete non-whitespace contents
+//! are assumed to be independent of linebreak decisions, with Scan and Print
+//! being only in control of the whitespace (spaces and line breaks). In Rust as
+//! idiomatically formattted by rustfmt, that is not the case. Trailing commas
+//! are one example; the punctuation is only known *after* the broken vs
+//! non-broken status of the surrounding group is known:
+//!
+//! ```
+//! # struct Struct { x: u64, y: bool }
+//! # let xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx = 0;
+//! # let yyyyyyyyyyyyyyyyyyyyyyyyyyyyyy = true;
+//! #
+//! let _ = Struct { x: 0, y: true };
+//!
+//! let _ = Struct {
+//!     x: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx,
+//!     y: yyyyyyyyyyyyyyyyyyyyyyyyyyyyyy,   //<- trailing comma if the expression wrapped
+//! };
+//! ```
+//!
+//! The formatting of `match` expressions is another case; we want small arms on
+//! the same line as the pattern, and big arms wrapped in a brace. The presence
+//! of the brace punctuation, comma, and semicolon are all dependent on whether
+//! the arm fits on the line:
+//!
+//! ```
+//! # struct Entry { nanos: u32 }
+//! # let total_nanos = 0u64;
+//! # let mut total_secs = 0u64;
+//! # let tmp;
+//! # let entry = Entry { nanos: 0 };
+//! # const NANOS_PER_SEC: u32 = 1_000_000_000;
+//! #
+//! match total_nanos.checked_add(entry.nanos as u64) {
+//!     Some(n) => tmp = n,   //<- small arm, inline with comma
+//!     None => {
+//!         total_secs = total_secs
+//!             .checked_add(total_nanos / NANOS_PER_SEC as u64)
+//!             .expect("overflow in iter::sum over durations");
+//!     }   //<- big arm, needs brace added, and also semicolon^
+//! }
+//! ```
+//!
+//! The printing algorithm implementation in this crate accommodates all of
+//! these situations with conditional punctuation tokens whose selection can be
+//! deferred and populated after it's known that the group is or is not broken.
+
+#![allow(
+    clippy::cast_possible_wrap,
+    clippy::cast_sign_loss,
+    clippy::doc_markdown,
+    clippy::enum_glob_use,
+    clippy::items_after_statements,
+    clippy::match_like_matches_macro,
+    clippy::match_same_arms,
+    clippy::module_name_repetitions,
+    clippy::must_use_candidate,
+    clippy::needless_pass_by_value,
+    clippy::similar_names,
+    clippy::unused_self,
+    clippy::vec_init_then_push
+)]
+
+mod algorithm;
+mod attr;
+mod convenience;
+mod data;
+mod expr;
+mod file;
+mod generics;
+mod item;
+mod iter;
+mod lifetime;
+mod lit;
+mod mac;
+mod pat;
+mod path;
+mod ring;
+mod stmt;
+mod token;
+mod ty;
+
+pub use crate::algorithm::Printer;
+use syn::File;
+
+// Target line width.
+const MARGIN: isize = 89;
+
+// Number of spaces increment at each level of block indentation.
+const INDENT: isize = 4;
+
+// Every line is allowed at least this much space, even if highly indented.
+const MIN_SPACE: isize = 60;
+
+pub fn unparse(file: &File) -> String {
+    let mut p = Printer::new();
+    p.file(file);
+    p.eof()
+}
diff --git a/prettyplease/src/lifetime.rs b/prettyplease/src/lifetime.rs
new file mode 100644
index 0000000000..665caa324c
--- /dev/null
+++ b/prettyplease/src/lifetime.rs
@@ -0,0 +1,9 @@
+use crate::algorithm::Printer;
+use syn::Lifetime;
+
+impl Printer {
+    pub fn lifetime(&mut self, lifetime: &Lifetime) {
+        self.word("'");
+        self.ident(&lifetime.ident);
+    }
+}
diff --git a/prettyplease/src/lit.rs b/prettyplease/src/lit.rs
new file mode 100644
index 0000000000..c64b8a14d0
--- /dev/null
+++ b/prettyplease/src/lit.rs
@@ -0,0 +1,50 @@
+use crate::algorithm::Printer;
+use proc_macro2::Literal;
+use syn::{Lit, LitBool, LitByte, LitByteStr, LitChar, LitFloat, LitInt, LitStr};
+
+impl Printer {
+    pub fn lit(&mut self, lit: &Lit) {
+        match lit {
+            Lit::Str(lit) => self.lit_str(lit),
+            Lit::ByteStr(lit) => self.lit_byte_str(lit),
+            Lit::Byte(lit) => self.lit_byte(lit),
+            Lit::Char(lit) => self.lit_char(lit),
+            Lit::Int(lit) => self.lit_int(lit),
+            Lit::Float(lit) => self.lit_float(lit),
+            Lit::Bool(lit) => self.lit_bool(lit),
+            Lit::Verbatim(lit) => self.lit_verbatim(lit),
+        }
+    }
+
+    pub fn lit_str(&mut self, lit: &LitStr) {
+        self.word(lit.token().to_string());
+    }
+
+    fn lit_byte_str(&mut self, lit: &LitByteStr) {
+        self.word(lit.token().to_string());
+    }
+
+    fn lit_byte(&mut self, lit: &LitByte) {
+        self.word(lit.token().to_string());
+    }
+
+    fn lit_char(&mut self, lit: &LitChar) {
+        self.word(lit.token().to_string());
+    }
+
+    fn lit_int(&mut self, lit: &LitInt) {
+        self.word(lit.token().to_string());
+    }
+
+    fn lit_float(&mut self, lit: &LitFloat) {
+        self.word(lit.token().to_string());
+    }
+
+    fn lit_bool(&mut self, lit: &LitBool) {
+        self.word(if lit.value { "true" } else { "false" });
+    }
+
+    fn lit_verbatim(&mut self, token: &Literal) {
+        self.word(token.to_string());
+    }
+}
diff --git a/prettyplease/src/mac.rs b/prettyplease/src/mac.rs
new file mode 100644
index 0000000000..cbd2a4f63f
--- /dev/null
+++ b/prettyplease/src/mac.rs
@@ -0,0 +1,210 @@
+use crate::algorithm::Printer;
+use crate::token::Token;
+use crate::INDENT;
+use proc_macro2::{Delimiter, Spacing, TokenStream};
+use syn::{Ident, Macro, MacroDelimiter, PathArguments};
+
+impl Printer {
+    pub fn mac(&mut self, mac: &Macro, ident: Option<&Ident>) {
+        let is_macro_rules = mac.path.leading_colon.is_none()
+            && mac.path.segments.len() == 1
+            && matches!(mac.path.segments[0].arguments, PathArguments::None)
+            && mac.path.segments[0].ident == "macro_rules";
+        if is_macro_rules {
+            if let Some(ident) = ident {
+                self.macro_rules(ident, &mac.tokens);
+                return;
+            }
+        }
+        self.path(&mac.path);
+        self.word("!");
+        if let Some(ident) = ident {
+            self.nbsp();
+            self.ident(ident);
+        }
+        let (open, close, delimiter_break) = match mac.delimiter {
+            MacroDelimiter::Paren(_) => ("(", ")", Self::zerobreak as fn(&mut Self)),
+            MacroDelimiter::Brace(_) => (" {", "}", Self::hardbreak as fn(&mut Self)),
+            MacroDelimiter::Bracket(_) => ("[", "]", Self::zerobreak as fn(&mut Self)),
+        };
+        self.word(open);
+        self.cbox(INDENT);
+        delimiter_break(self);
+        self.ibox(0);
+        self.macro_rules_tokens(mac.tokens.clone(), false);
+        self.end();
+        delimiter_break(self);
+        self.offset(-INDENT);
+        self.end();
+        self.word(close);
+    }
+
+    pub fn mac_semi_if_needed(&mut self, delimiter: &MacroDelimiter) {
+        match delimiter {
+            MacroDelimiter::Paren(_) | MacroDelimiter::Bracket(_) => self.word(";"),
+            MacroDelimiter::Brace(_) => {}
+        }
+    }
+
+    fn macro_rules(&mut self, name: &Ident, rules: &TokenStream) {
+        enum State {
+            Start,
+            Matcher,
+            Equal,
+            Greater,
+            Expander,
+        }
+
+        use State::*;
+
+        self.word("macro_rules! ");
+        self.ident(name);
+        self.word(" {");
+        self.cbox(INDENT);
+        self.hardbreak_if_nonempty();
+        let mut state = State::Start;
+        for tt in rules.clone() {
+            let token = Token::from(tt);
+            match (state, token) {
+                (Start, Token::Group(delimiter, stream)) => {
+                    self.delimiter_open(delimiter);
+                    if !stream.is_empty() {
+                        self.cbox(INDENT);
+                        self.zerobreak();
+                        self.ibox(0);
+                        self.macro_rules_tokens(stream, true);
+                        self.end();
+                        self.zerobreak();
+                        self.offset(-INDENT);
+                        self.end();
+                    }
+                    self.delimiter_close(delimiter);
+                    state = Matcher;
+                }
+                (Matcher, Token::Punct('=', Spacing::Joint)) => {
+                    self.word(" =");
+                    state = Equal;
+                }
+                (Equal, Token::Punct('>', Spacing::Alone)) => {
+                    self.word(">");
+                    state = Greater;
+                }
+                (Greater, Token::Group(_delimiter, stream)) => {
+                    self.word(" {");
+                    self.neverbreak();
+                    if !stream.is_empty() {
+                        self.cbox(INDENT);
+                        self.hardbreak();
+                        self.ibox(0);
+                        self.macro_rules_tokens(stream, false);
+                        self.end();
+                        self.hardbreak();
+                        self.offset(-INDENT);
+                        self.end();
+                    }
+                    self.word("}");
+                    state = Expander;
+                }
+                (Expander, Token::Punct(';', Spacing::Alone)) => {
+                    self.word(";");
+                    self.hardbreak();
+                    state = Start;
+                }
+                _ => unimplemented!("bad macro_rules syntax"),
+            }
+        }
+        match state {
+            Start => {}
+            Expander => {
+                self.word(";");
+                self.hardbreak();
+            }
+            _ => self.hardbreak(),
+        }
+        self.offset(-INDENT);
+        self.end();
+        self.word("}");
+    }
+
+    pub fn macro_rules_tokens(&mut self, stream: TokenStream, matcher: bool) {
+        #[derive(PartialEq)]
+        enum State {
+            Start,
+            Dollar,
+            DollarIdent,
+            DollarIdentColon,
+            DollarParen,
+            DollarParenSep,
+            Pound,
+            PoundBang,
+            Dot,
+            Colon,
+            Colon2,
+            Ident,
+            Other,
+        }
+
+        use State::*;
+
+        let mut state = Start;
+        let mut previous_is_joint = true;
+        for tt in stream {
+            let token = Token::from(tt);
+            let (needs_space, next_state) = match (&state, &token) {
+                (Dollar, Token::Ident(_)) => (false, if matcher { DollarIdent } else { Other }),
+                (DollarIdent, Token::Punct(':', Spacing::Alone)) => (false, DollarIdentColon),
+                (DollarIdentColon, Token::Ident(_)) => (false, Other),
+                (DollarParen, Token::Punct('+' | '*' | '?', Spacing::Alone)) => (false, Other),
+                (DollarParen, Token::Ident(_) | Token::Literal(_)) => (false, DollarParenSep),
+                (DollarParen, Token::Punct(_, Spacing::Joint)) => (false, DollarParen),
+                (DollarParen, Token::Punct(_, Spacing::Alone)) => (false, DollarParenSep),
+                (DollarParenSep, Token::Punct('+' | '*', _)) => (false, Other),
+                (Pound, Token::Punct('!', _)) => (false, PoundBang),
+                (Start, Token::Group(..)) => (false, Other),
+                (Dollar, Token::Group(Delimiter::Parenthesis, _)) => (false, DollarParen),
+                (Pound | PoundBang, Token::Group(Delimiter::Bracket, _)) => (false, Other),
+                (Ident, Token::Group(Delimiter::Parenthesis | Delimiter::Bracket, _)) => {
+                    (false, Other)
+                }
+                (Colon, Token::Punct(':', _)) => (false, Colon2),
+                (_, Token::Group(..)) => (true, Other),
+                (_, Token::Ident(ident)) if !is_keyword(ident) => {
+                    (state != Dot && state != Colon2, Ident)
+                }
+                (_, Token::Literal(_)) => (state != Dot, Ident),
+                (_, Token::Punct(',' | ';', _)) => (false, Other),
+                (_, Token::Punct('.', _)) if !matcher => (state != Ident, Dot),
+                (_, Token::Punct(':', Spacing::Joint)) => (state != Ident, Colon),
+                (_, Token::Punct('$', _)) => (true, Dollar),
+                (_, Token::Punct('#', _)) => (true, Pound),
+                (_, _) => (true, Other),
+            };
+            if !previous_is_joint && needs_space {
+                self.space();
+            }
+            previous_is_joint = match token {
+                Token::Punct(_, Spacing::Joint) | Token::Punct('$', _) => true,
+                _ => false,
+            };
+            self.single_token(
+                token,
+                if matcher {
+                    |printer, stream| printer.macro_rules_tokens(stream, true)
+                } else {
+                    |printer, stream| printer.macro_rules_tokens(stream, false)
+                },
+            );
+            state = next_state;
+        }
+    }
+}
+
+fn is_keyword(ident: &Ident) -> bool {
+    match ident.to_string().as_str() {
+        "as" | "box" | "break" | "const" | "continue" | "crate" | "else" | "enum" | "extern"
+        | "fn" | "for" | "if" | "impl" | "in" | "let" | "loop" | "macro" | "match" | "mod"
+        | "move" | "mut" | "pub" | "ref" | "return" | "static" | "struct" | "trait" | "type"
+        | "unsafe" | "use" | "where" | "while" | "yield" => true,
+        _ => false,
+    }
+}
diff --git a/prettyplease/src/pat.rs b/prettyplease/src/pat.rs
new file mode 100644
index 0000000000..a73c5e7a00
--- /dev/null
+++ b/prettyplease/src/pat.rs
@@ -0,0 +1,195 @@
+use crate::algorithm::Printer;
+use crate::iter::IterDelimited;
+use crate::INDENT;
+use proc_macro2::TokenStream;
+use syn::{
+    FieldPat, Pat, PatBox, PatIdent, PatLit, PatMacro, PatOr, PatPath, PatRange, PatReference,
+    PatRest, PatSlice, PatStruct, PatTuple, PatTupleStruct, PatType, PatWild, RangeLimits,
+};
+
+impl Printer {
+    pub fn pat(&mut self, pat: &Pat) {
+        match pat {
+            Pat::Box(pat) => self.pat_box(pat),
+            Pat::Ident(pat) => self.pat_ident(pat),
+            Pat::Lit(pat) => self.pat_lit(pat),
+            Pat::Macro(pat) => self.pat_macro(pat),
+            Pat::Or(pat) => self.pat_or(pat),
+            Pat::Path(pat) => self.pat_path(pat),
+            Pat::Range(pat) => self.pat_range(pat),
+            Pat::Reference(pat) => self.pat_reference(pat),
+            Pat::Rest(pat) => self.pat_rest(pat),
+            Pat::Slice(pat) => self.pat_slice(pat),
+            Pat::Struct(pat) => self.pat_struct(pat),
+            Pat::Tuple(pat) => self.pat_tuple(pat),
+            Pat::TupleStruct(pat) => self.pat_tuple_struct(pat),
+            Pat::Type(pat) => self.pat_type(pat),
+            Pat::Verbatim(pat) => self.pat_verbatim(pat),
+            Pat::Wild(pat) => self.pat_wild(pat),
+            #[cfg(test)]
+            Pat::__TestExhaustive(_) => unreachable!(),
+            #[cfg(not(test))]
+            _ => unimplemented!("unknown Pat"),
+        }
+    }
+
+    fn pat_box(&mut self, pat: &PatBox) {
+        self.outer_attrs(&pat.attrs);
+        self.word("box ");
+        self.pat(&pat.pat);
+    }
+
+    fn pat_ident(&mut self, pat: &PatIdent) {
+        self.outer_attrs(&pat.attrs);
+        if pat.by_ref.is_some() {
+            self.word("ref ");
+        }
+        if pat.mutability.is_some() {
+            self.word("mut ");
+        }
+        self.ident(&pat.ident);
+        if let Some((_at_token, subpat)) = &pat.subpat {
+            self.word(" @ ");
+            self.pat(subpat);
+        }
+    }
+
+    fn pat_lit(&mut self, pat: &PatLit) {
+        self.outer_attrs(&pat.attrs);
+        self.expr(&pat.expr);
+    }
+
+    fn pat_macro(&mut self, pat: &PatMacro) {
+        self.outer_attrs(&pat.attrs);
+        self.mac(&pat.mac, None);
+    }
+
+    fn pat_or(&mut self, pat: &PatOr) {
+        self.outer_attrs(&pat.attrs);
+        for case in pat.cases.iter().delimited() {
+            if !case.is_first {
+                self.word(" | ");
+            }
+            self.pat(&case);
+        }
+    }
+
+    fn pat_path(&mut self, pat: &PatPath) {
+        self.outer_attrs(&pat.attrs);
+        self.qpath(&pat.qself, &pat.path);
+    }
+
+    fn pat_range(&mut self, pat: &PatRange) {
+        self.outer_attrs(&pat.attrs);
+        self.expr(&pat.lo);
+        match &pat.limits {
+            RangeLimits::HalfOpen(_) => self.word(".."),
+            RangeLimits::Closed(_) => self.word("..="),
+        }
+        self.expr(&pat.hi);
+    }
+
+    fn pat_reference(&mut self, pat: &PatReference) {
+        self.outer_attrs(&pat.attrs);
+        self.word("&");
+        if pat.mutability.is_some() {
+            self.word("mut ");
+        }
+        self.pat(&pat.pat);
+    }
+
+    fn pat_rest(&mut self, pat: &PatRest) {
+        self.outer_attrs(&pat.attrs);
+        self.word("..");
+    }
+
+    fn pat_slice(&mut self, pat: &PatSlice) {
+        self.outer_attrs(&pat.attrs);
+        self.word("[");
+        for elem in pat.elems.iter().delimited() {
+            self.pat(&elem);
+            self.trailing_comma(elem.is_last);
+        }
+        self.word("]");
+    }
+
+    fn pat_struct(&mut self, pat: &PatStruct) {
+        self.outer_attrs(&pat.attrs);
+        self.cbox(INDENT);
+        self.path(&pat.path);
+        self.word(" {");
+        self.space_if_nonempty();
+        for field in pat.fields.iter().delimited() {
+            self.field_pat(&field);
+            self.trailing_comma_or_space(field.is_last && pat.dot2_token.is_none());
+        }
+        if pat.dot2_token.is_some() {
+            self.word("..");
+            self.space();
+        }
+        self.offset(-INDENT);
+        self.end();
+        self.word("}");
+    }
+
+    fn pat_tuple(&mut self, pat: &PatTuple) {
+        self.outer_attrs(&pat.attrs);
+        self.word("(");
+        self.cbox(INDENT);
+        self.zerobreak();
+        self.inner_attrs(&pat.attrs);
+        for elem in pat.elems.iter().delimited() {
+            self.pat(&elem);
+            if pat.elems.len() == 1 {
+                self.word(",");
+                self.zerobreak();
+            } else {
+                self.trailing_comma(elem.is_last);
+            }
+        }
+        self.offset(-INDENT);
+        self.end();
+        self.word(")");
+    }
+
+    fn pat_tuple_struct(&mut self, pat: &PatTupleStruct) {
+        self.outer_attrs(&pat.attrs);
+        self.path(&pat.path);
+        self.word("(");
+        self.cbox(INDENT);
+        self.zerobreak();
+        self.inner_attrs(&pat.attrs);
+        for elem in pat.pat.elems.iter().delimited() {
+            self.pat(&elem);
+            self.trailing_comma(elem.is_last);
+        }
+        self.offset(-INDENT);
+        self.end();
+        self.word(")");
+    }
+
+    pub fn pat_type(&mut self, pat: &PatType) {
+        self.outer_attrs(&pat.attrs);
+        self.pat(&pat.pat);
+        self.word(": ");
+        self.ty(&pat.ty);
+    }
+
+    fn pat_verbatim(&mut self, pat: &TokenStream) {
+        unimplemented!("Pat::Verbatim `{}`", pat);
+    }
+
+    fn pat_wild(&mut self, pat: &PatWild) {
+        self.outer_attrs(&pat.attrs);
+        self.word("_");
+    }
+
+    fn field_pat(&mut self, field_pat: &FieldPat) {
+        self.outer_attrs(&field_pat.attrs);
+        if field_pat.colon_token.is_some() {
+            self.member(&field_pat.member);
+            self.word(": ");
+        }
+        self.pat(&field_pat.pat);
+    }
+}
diff --git a/prettyplease/src/path.rs b/prettyplease/src/path.rs
new file mode 100644
index 0000000000..78f46ccda2
--- /dev/null
+++ b/prettyplease/src/path.rs
@@ -0,0 +1,180 @@
+use crate::algorithm::Printer;
+use crate::iter::IterDelimited;
+use crate::INDENT;
+use std::cmp;
+use syn::{
+    AngleBracketedGenericArguments, Binding, Constraint, Expr, GenericArgument,
+    ParenthesizedGenericArguments, Path, PathArguments, PathSegment, QSelf,
+};
+
+impl Printer {
+    pub fn path(&mut self, path: &Path) {
+        for segment in path.segments.iter().delimited() {
+            if !segment.is_first || path.leading_colon.is_some() {
+                self.word("::");
+            }
+            self.path_segment(&segment);
+        }
+    }
+
+    pub fn path_segment(&mut self, segment: &PathSegment) {
+        self.ident(&segment.ident);
+        self.path_arguments(&segment.arguments);
+    }
+
+    fn path_arguments(&mut self, arguments: &PathArguments) {
+        match arguments {
+            PathArguments::None => {}
+            PathArguments::AngleBracketed(arguments) => {
+                self.angle_bracketed_generic_arguments(arguments);
+            }
+            PathArguments::Parenthesized(arguments) => {
+                self.parenthesized_generic_arguments(arguments);
+            }
+        }
+    }
+
+    fn generic_argument(&mut self, arg: &GenericArgument) {
+        match arg {
+            GenericArgument::Lifetime(lifetime) => self.lifetime(lifetime),
+            GenericArgument::Type(ty) => self.ty(ty),
+            GenericArgument::Binding(binding) => self.binding(binding),
+            GenericArgument::Constraint(constraint) => self.constraint(constraint),
+            GenericArgument::Const(expr) => {
+                match expr {
+                    Expr::Lit(expr) => self.expr_lit(expr),
+                    Expr::Block(expr) => self.expr_block(expr),
+                    // ERROR CORRECTION: Add braces to make sure that the
+                    // generated code is valid.
+                    _ => {
+                        self.word("{");
+                        self.expr(expr);
+                        self.word("}");
+                    }
+                }
+            }
+        }
+    }
+
+    fn angle_bracketed_generic_arguments(&mut self, generic: &AngleBracketedGenericArguments) {
+        if generic.colon2_token.is_some() {
+            self.word("::");
+        }
+        self.word("<");
+        self.cbox(INDENT);
+        self.zerobreak();
+
+        // Print lifetimes before types and consts, all before bindings,
+        // regardless of their order in self.args.
+        //
+        // TODO: ordering rules for const arguments vs type arguments have
+        // not been settled yet. https://github.com/rust-lang/rust/issues/44580
+        for arg in generic.args.iter().delimited() {
+            match *arg {
+                GenericArgument::Lifetime(_) => {
+                    self.generic_argument(&arg);
+                    self.trailing_comma(arg.is_last);
+                }
+                GenericArgument::Type(_)
+                | GenericArgument::Binding(_)
+                | GenericArgument::Constraint(_)
+                | GenericArgument::Const(_) => {}
+            }
+        }
+        for arg in generic.args.iter().delimited() {
+            match *arg {
+                GenericArgument::Type(_) | GenericArgument::Const(_) => {
+                    self.generic_argument(&arg);
+                    self.trailing_comma(arg.is_last);
+                }
+                GenericArgument::Lifetime(_)
+                | GenericArgument::Binding(_)
+                | GenericArgument::Constraint(_) => {}
+            }
+        }
+        for arg in generic.args.iter().delimited() {
+            match *arg {
+                GenericArgument::Binding(_) | GenericArgument::Constraint(_) => {
+                    self.generic_argument(&arg);
+                    self.trailing_comma(arg.is_last);
+                }
+                GenericArgument::Lifetime(_)
+                | GenericArgument::Type(_)
+                | GenericArgument::Const(_) => {}
+            }
+        }
+
+        self.offset(-INDENT);
+        self.end();
+        self.word(">");
+    }
+
+    fn binding(&mut self, binding: &Binding) {
+        self.ident(&binding.ident);
+        self.word(" = ");
+        self.ty(&binding.ty);
+    }
+
+    fn constraint(&mut self, constraint: &Constraint) {
+        self.ident(&constraint.ident);
+        self.ibox(INDENT);
+        for bound in constraint.bounds.iter().delimited() {
+            if bound.is_first {
+                self.word(": ");
+            } else {
+                self.space();
+                self.word("+ ");
+            }
+            self.type_param_bound(&bound);
+        }
+        self.end();
+    }
+
+    fn parenthesized_generic_arguments(&mut self, arguments: &ParenthesizedGenericArguments) {
+        self.cbox(INDENT);
+        self.word("(");
+        self.zerobreak();
+        for ty in arguments.inputs.iter().delimited() {
+            self.ty(&ty);
+            self.trailing_comma(ty.is_last);
+        }
+        self.offset(-INDENT);
+        self.word(")");
+        self.return_type(&arguments.output);
+        self.end();
+    }
+
+    pub fn qpath(&mut self, qself: &Option<QSelf>, path: &Path) {
+        let qself = match qself {
+            Some(qself) => qself,
+            None => {
+                self.path(path);
+                return;
+            }
+        };
+
+        self.word("<");
+        self.ty(&qself.ty);
+
+        let pos = cmp::min(qself.position, path.segments.len());
+        let mut segments = path.segments.iter();
+        if pos > 0 {
+            self.word(" as ");
+            for segment in segments.by_ref().take(pos).delimited() {
+                if !segment.is_first || path.leading_colon.is_some() {
+                    self.word("::");
+                }
+                self.path_segment(&segment);
+                if segment.is_last {
+                    self.word(">");
+                }
+            }
+        } else {
+            self.word(">");
+        }
+        for segment in segments {
+            self.word("::");
+            self.path_segment(segment);
+        }
+    }
+}
diff --git a/prettyplease/src/ring.rs b/prettyplease/src/ring.rs
new file mode 100644
index 0000000000..aff92589a5
--- /dev/null
+++ b/prettyplease/src/ring.rs
@@ -0,0 +1,81 @@
+use std::collections::VecDeque;
+use std::ops::{Index, IndexMut};
+
+pub struct RingBuffer<T> {
+    data: VecDeque<T>,
+    // Abstract index of data[0] in infinitely sized queue
+    offset: usize,
+}
+
+impl<T> RingBuffer<T> {
+    pub fn new() -> Self {
+        RingBuffer {
+            data: VecDeque::new(),
+            offset: 0,
+        }
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.data.is_empty()
+    }
+
+    pub fn len(&self) -> usize {
+        self.data.len()
+    }
+
+    pub fn push(&mut self, value: T) -> usize {
+        let index = self.offset + self.data.len();
+        self.data.push_back(value);
+        index
+    }
+
+    pub fn clear(&mut self) {
+        self.data.clear();
+    }
+
+    pub fn index_of_first(&self) -> usize {
+        self.offset
+    }
+
+    pub fn first(&self) -> &T {
+        &self.data[0]
+    }
+
+    pub fn first_mut(&mut self) -> &mut T {
+        &mut self.data[0]
+    }
+
+    pub fn pop_first(&mut self) -> T {
+        self.offset += 1;
+        self.data.pop_front().unwrap()
+    }
+
+    pub fn last(&self) -> &T {
+        self.data.back().unwrap()
+    }
+
+    pub fn last_mut(&mut self) -> &mut T {
+        self.data.back_mut().unwrap()
+    }
+
+    pub fn second_last(&self) -> &T {
+        &self.data[self.data.len() - 2]
+    }
+
+    pub fn pop_last(&mut self) {
+        self.data.pop_back().unwrap();
+    }
+}
+
+impl<T> Index<usize> for RingBuffer<T> {
+    type Output = T;
+    fn index(&self, index: usize) -> &Self::Output {
+        &self.data[index.checked_sub(self.offset).unwrap()]
+    }
+}
+
+impl<T> IndexMut<usize> for RingBuffer<T> {
+    fn index_mut(&mut self, index: usize) -> &mut Self::Output {
+        &mut self.data[index.checked_sub(self.offset).unwrap()]
+    }
+}
diff --git a/prettyplease/src/stmt.rs b/prettyplease/src/stmt.rs
new file mode 100644
index 0000000000..da9e3a0931
--- /dev/null
+++ b/prettyplease/src/stmt.rs
@@ -0,0 +1,72 @@
+use crate::algorithm::Printer;
+use syn::{Expr, Stmt};
+
+impl Printer {
+    pub fn stmt(&mut self, stmt: &Stmt) {
+        match stmt {
+            Stmt::Local(local) => {
+                self.outer_attrs(&local.attrs);
+                self.ibox(0);
+                self.word("let ");
+                self.pat(&local.pat);
+                if let Some((_eq, init)) = &local.init {
+                    self.word(" = ");
+                    self.neverbreak();
+                    self.expr(init);
+                }
+                self.word(";");
+                self.end();
+                self.hardbreak();
+            }
+            Stmt::Item(item) => self.item(item),
+            Stmt::Expr(expr) => {
+                self.ibox(0);
+                self.expr(expr);
+                if add_semi(expr) {
+                    self.word(";");
+                }
+                self.end();
+                self.hardbreak();
+            }
+            Stmt::Semi(expr, _semi) => {
+                if let Expr::Verbatim(tokens) = expr {
+                    if tokens.is_empty() {
+                        return;
+                    }
+                }
+                self.ibox(0);
+                self.expr(expr);
+                if !remove_semi(expr) {
+                    self.word(";");
+                }
+                self.end();
+                self.hardbreak();
+            }
+        }
+    }
+}
+
+pub fn add_semi(expr: &Expr) -> bool {
+    match expr {
+        Expr::Assign(_)
+        | Expr::AssignOp(_)
+        | Expr::Break(_)
+        | Expr::Continue(_)
+        | Expr::Return(_)
+        | Expr::Yield(_) => true,
+        Expr::Group(group) => add_semi(&group.expr),
+        _ => false,
+    }
+}
+
+fn remove_semi(expr: &Expr) -> bool {
+    match expr {
+        Expr::ForLoop(_) | Expr::While(_) => true,
+        Expr::Group(group) => remove_semi(&group.expr),
+        Expr::If(expr) => match &expr.else_branch {
+            Some((_else_token, else_branch)) => remove_semi(else_branch),
+            None => true,
+        },
+        _ => false,
+    }
+}
diff --git a/prettyplease/src/token.rs b/prettyplease/src/token.rs
new file mode 100644
index 0000000000..e41fd728a6
--- /dev/null
+++ b/prettyplease/src/token.rs
@@ -0,0 +1,80 @@
+use crate::algorithm::Printer;
+use proc_macro2::{Delimiter, Ident, Literal, Spacing, TokenStream, TokenTree};
+
+impl Printer {
+    pub fn single_token(&mut self, token: Token, group_contents: fn(&mut Self, TokenStream)) {
+        match token {
+            Token::Group(delimiter, stream) => self.token_group(delimiter, stream, group_contents),
+            Token::Ident(ident) => self.ident(&ident),
+            Token::Punct(ch, _spacing) => self.token_punct(ch),
+            Token::Literal(literal) => self.token_literal(&literal),
+        }
+    }
+
+    fn token_group(
+        &mut self,
+        delimiter: Delimiter,
+        stream: TokenStream,
+        group_contents: fn(&mut Self, TokenStream),
+    ) {
+        self.delimiter_open(delimiter);
+        if !stream.is_empty() {
+            if delimiter == Delimiter::Brace {
+                self.space();
+            }
+            group_contents(self, stream);
+            if delimiter == Delimiter::Brace {
+                self.space();
+            }
+        }
+        self.delimiter_close(delimiter);
+    }
+
+    pub fn ident(&mut self, ident: &Ident) {
+        self.word(ident.to_string());
+    }
+
+    pub fn token_punct(&mut self, ch: char) {
+        self.word(ch.to_string());
+    }
+
+    pub fn token_literal(&mut self, literal: &Literal) {
+        self.word(literal.to_string());
+    }
+
+    pub fn delimiter_open(&mut self, delimiter: Delimiter) {
+        self.word(match delimiter {
+            Delimiter::Parenthesis => "(",
+            Delimiter::Brace => "{",
+            Delimiter::Bracket => "[",
+            Delimiter::None => return,
+        });
+    }
+
+    pub fn delimiter_close(&mut self, delimiter: Delimiter) {
+        self.word(match delimiter {
+            Delimiter::Parenthesis => ")",
+            Delimiter::Brace => "}",
+            Delimiter::Bracket => "]",
+            Delimiter::None => return,
+        });
+    }
+}
+
+pub enum Token {
+    Group(Delimiter, TokenStream),
+    Ident(Ident),
+    Punct(char, Spacing),
+    Literal(Literal),
+}
+
+impl From<TokenTree> for Token {
+    fn from(tt: TokenTree) -> Self {
+        match tt {
+            TokenTree::Group(group) => Token::Group(group.delimiter(), group.stream()),
+            TokenTree::Ident(ident) => Token::Ident(ident),
+            TokenTree::Punct(punct) => Token::Punct(punct.as_char(), punct.spacing()),
+            TokenTree::Literal(literal) => Token::Literal(literal),
+        }
+    }
+}
diff --git a/prettyplease/src/ty.rs b/prettyplease/src/ty.rs
new file mode 100644
index 0000000000..2d7d8c72c7
--- /dev/null
+++ b/prettyplease/src/ty.rs
@@ -0,0 +1,204 @@
+use crate::algorithm::Printer;
+use crate::iter::IterDelimited;
+use crate::INDENT;
+use proc_macro2::TokenStream;
+use syn::{
+    Abi, BareFnArg, ReturnType, Type, TypeArray, TypeBareFn, TypeGroup, TypeImplTrait, TypeInfer,
+    TypeMacro, TypeNever, TypeParen, TypePath, TypePtr, TypeReference, TypeSlice, TypeTraitObject,
+    TypeTuple, Variadic,
+};
+
+impl Printer {
+    pub fn ty(&mut self, ty: &Type) {
+        match ty {
+            Type::Array(ty) => self.type_array(ty),
+            Type::BareFn(ty) => self.type_bare_fn(ty),
+            Type::Group(ty) => self.type_group(ty),
+            Type::ImplTrait(ty) => self.type_impl_trait(ty),
+            Type::Infer(ty) => self.type_infer(ty),
+            Type::Macro(ty) => self.type_macro(ty),
+            Type::Never(ty) => self.type_never(ty),
+            Type::Paren(ty) => self.type_paren(ty),
+            Type::Path(ty) => self.type_path(ty),
+            Type::Ptr(ty) => self.type_ptr(ty),
+            Type::Reference(ty) => self.type_reference(ty),
+            Type::Slice(ty) => self.type_slice(ty),
+            Type::TraitObject(ty) => self.type_trait_object(ty),
+            Type::Tuple(ty) => self.type_tuple(ty),
+            Type::Verbatim(ty) => self.type_verbatim(ty),
+            #[cfg(test)]
+            Type::__TestExhaustive(_) => unreachable!(),
+            #[cfg(not(test))]
+            _ => unimplemented!("unknown Type"),
+        }
+    }
+
+    fn type_array(&mut self, ty: &TypeArray) {
+        self.word("[");
+        self.ty(&ty.elem);
+        self.word("; ");
+        self.expr(&ty.len);
+        self.word("]");
+    }
+
+    fn type_bare_fn(&mut self, ty: &TypeBareFn) {
+        if let Some(bound_lifetimes) = &ty.lifetimes {
+            self.bound_lifetimes(bound_lifetimes);
+        }
+        if ty.unsafety.is_some() {
+            self.word("unsafe ");
+        }
+        if let Some(abi) = &ty.abi {
+            self.abi(abi);
+        }
+        self.word("fn(");
+        self.cbox(INDENT);
+        self.zerobreak();
+        for bare_fn_arg in ty.inputs.iter().delimited() {
+            self.bare_fn_arg(&bare_fn_arg);
+            self.trailing_comma(bare_fn_arg.is_last && ty.variadic.is_none());
+        }
+        if let Some(variadic) = &ty.variadic {
+            self.variadic(variadic);
+            self.zerobreak();
+        }
+        self.offset(-INDENT);
+        self.end();
+        self.word(")");
+        self.return_type(&ty.output);
+    }
+
+    fn type_group(&mut self, ty: &TypeGroup) {
+        self.ty(&ty.elem);
+    }
+
+    fn type_impl_trait(&mut self, ty: &TypeImplTrait) {
+        self.word("impl ");
+        for type_param_bound in ty.bounds.iter().delimited() {
+            if !type_param_bound.is_first {
+                self.word(" + ");
+            }
+            self.type_param_bound(&type_param_bound);
+        }
+    }
+
+    fn type_infer(&mut self, ty: &TypeInfer) {
+        let _ = ty;
+        self.word("_");
+    }
+
+    fn type_macro(&mut self, ty: &TypeMacro) {
+        self.mac(&ty.mac, None);
+    }
+
+    fn type_never(&mut self, ty: &TypeNever) {
+        let _ = ty;
+        self.word("!");
+    }
+
+    fn type_paren(&mut self, ty: &TypeParen) {
+        self.word("(");
+        self.ty(&ty.elem);
+        self.word(")");
+    }
+
+    fn type_path(&mut self, ty: &TypePath) {
+        self.qpath(&ty.qself, &ty.path);
+    }
+
+    fn type_ptr(&mut self, ty: &TypePtr) {
+        self.word("*");
+        if ty.mutability.is_some() {
+            self.word("mut ");
+        } else {
+            self.word("const ");
+        }
+        self.ty(&ty.elem);
+    }
+
+    fn type_reference(&mut self, ty: &TypeReference) {
+        self.word("&");
+        if let Some(lifetime) = &ty.lifetime {
+            self.lifetime(lifetime);
+            self.nbsp();
+        }
+        if ty.mutability.is_some() {
+            self.word("mut ");
+        }
+        self.ty(&ty.elem);
+    }
+
+    fn type_slice(&mut self, ty: &TypeSlice) {
+        self.word("[");
+        self.ty(&ty.elem);
+        self.word("]");
+    }
+
+    fn type_trait_object(&mut self, ty: &TypeTraitObject) {
+        self.word("dyn ");
+        for type_param_bound in ty.bounds.iter().delimited() {
+            if !type_param_bound.is_first {
+                self.word(" + ");
+            }
+            self.type_param_bound(&type_param_bound);
+        }
+    }
+
+    fn type_tuple(&mut self, ty: &TypeTuple) {
+        self.word("(");
+        self.cbox(INDENT);
+        self.zerobreak();
+        for elem in ty.elems.iter().delimited() {
+            self.ty(&elem);
+            if ty.elems.len() == 1 {
+                self.word(",");
+                self.zerobreak();
+            } else {
+                self.trailing_comma(elem.is_last);
+            }
+        }
+        self.offset(-INDENT);
+        self.end();
+        self.word(")");
+    }
+
+    fn type_verbatim(&mut self, ty: &TokenStream) {
+        if ty.to_string() == "..." {
+            self.word("...")
+        } else {
+            unimplemented!("Type::Verbatim `{}`", ty);
+        }
+    }
+
+    pub fn return_type(&mut self, ty: &ReturnType) {
+        match ty {
+            ReturnType::Default => {}
+            ReturnType::Type(_arrow, ty) => {
+                self.word(" -> ");
+                self.ty(ty);
+            }
+        }
+    }
+
+    fn bare_fn_arg(&mut self, bare_fn_arg: &BareFnArg) {
+        self.outer_attrs(&bare_fn_arg.attrs);
+        if let Some((name, _colon)) = &bare_fn_arg.name {
+            self.ident(name);
+            self.word(": ");
+        }
+        self.ty(&bare_fn_arg.ty);
+    }
+
+    fn variadic(&mut self, variadic: &Variadic) {
+        self.outer_attrs(&variadic.attrs);
+        self.word("...");
+    }
+
+    pub fn abi(&mut self, abi: &Abi) {
+        self.word("extern ");
+        if let Some(name) = &abi.name {
+            self.lit_str(name);
+            self.nbsp();
+        }
+    }
+}
diff --git a/rust-toolchain b/rust-toolchain
index fc40182b3c..93af1dcbfe 100644
--- a/rust-toolchain
+++ b/rust-toolchain
@@ -1 +1 @@
-nightly-2019-12-05
+nightly-2021-11-22
diff --git a/scripts/common.py b/scripts/common.py
index 41c813b26a..9b3b47e517 100644
--- a/scripts/common.py
+++ b/scripts/common.py
@@ -97,7 +97,7 @@ class Config:
 
     CC_DB_JSON = "compile_commands.json"
 
-    CUSTOM_RUST_NAME = 'nightly-2019-12-05'
+    CUSTOM_RUST_NAME = 'nightly-2021-11-22'
 
     LLVM_SKIP_SIGNATURE_CHECKS  = False
 
@@ -172,17 +172,21 @@ def update_args(self, args=None):
         # update dependent variables
         self._init_llvm_ver_deps()
 
-        self.TRANSPILER = "target/{}/c2rust-transpile".format(build_type)
-        self.TRANSPILER = os.path.join(self.ROOT_DIR, self.TRANSPILER)
+        env_target_dir = os.getenv('CARGO_TARGET_DIR')
+        self.TARGET_DIR = "{}/".format(build_type)
+        if env_target_dir:
+            self.TARGET_DIR = os.path.join(env_target_dir, self.TARGET_DIR)
+        else:
+            self.TARGET_DIR = os.path.join(self.ROOT_DIR, "target", self.TARGET_DIR)
 
-        self.RREF_BIN = "target/{}/c2rust-refactor".format(build_type)
-        self.RREF_BIN = os.path.join(self.ROOT_DIR, self.RREF_BIN)
+        self.TRANSPILER = "c2rust-transpile"
+        self.TRANSPILER = os.path.join(self.TARGET_DIR, self.TRANSPILER)
 
-        self.C2RUST_BIN = "target/{}/c2rust".format(build_type)
-        self.C2RUST_BIN = os.path.join(self.ROOT_DIR, self.C2RUST_BIN)
+        self.RREF_BIN = "c2rust-refactor"
+        self.RREF_BIN = os.path.join(self.TARGET_DIR, self.RREF_BIN)
 
-        self.TARGET_DIR = "target/{}/".format(build_type)
-        self.TARGET_DIR = os.path.join(self.ROOT_DIR, self.TARGET_DIR)
+        self.C2RUST_BIN = "c2rust"
+        self.C2RUST_BIN = os.path.join(self.TARGET_DIR, self.C2RUST_BIN)
 
         has_skip_sig = args and hasattr(args, 'llvm_skip_signature_checks') 
         self.LLVM_SKIP_SIGNATURE_CHECKS = args.llvm_skip_signature_checks \
diff --git a/scripts/test_translator.py b/scripts/test_translator.py
index bb9efd1eda..5d04d3e88f 100755
--- a/scripts/test_translator.py
+++ b/scripts/test_translator.py
@@ -344,7 +344,6 @@ def run(self) -> List[TestOutcome]:
             "extern_types",
             "simd_ffi",
             "stdsimd",
-            "const_transmute",
             "nll",
             "linkage",
             "register_tool",
diff --git a/tests/README.md b/tests/README.md
index caab57538d..b83edfe1eb 100644
--- a/tests/README.md
+++ b/tests/README.md
@@ -19,7 +19,6 @@ use self::libc::c_int;
 
 #[link(name = "test")]
 extern "C" {
-    #[no_mangle]
     fn example(_: c_uint, _: *mut c_int);
 }
 
diff --git a/tests/arrays/src/test_arrays.rs b/tests/arrays/src/test_arrays.rs
index dd41aca1bd..c08a909ba1 100644
--- a/tests/arrays/src/test_arrays.rs
+++ b/tests/arrays/src/test_arrays.rs
@@ -7,22 +7,16 @@ use self::libc::{c_int, c_uint};
 
 #[link(name = "test")]
 extern "C" {
-    #[no_mangle]
     fn entry(_: c_uint, _: *mut c_int);
 
-    #[no_mangle]
     fn entry2(_: c_uint, _: *mut c_int);
 
-    #[no_mangle]
     fn test_sized_array() -> c_uint;
 
-    #[no_mangle]
     fn variable_arrays(_: *mut c_int);
 
-    #[no_mangle]
     fn alloca_arrays(_: *mut c_int);
 
-    #[no_mangle]
     fn check_some_ints() -> bool;
 }
 
diff --git a/tests/builtins/src/test_builtins.rs b/tests/builtins/src/test_builtins.rs
index 375c81fea9..e9a4ce79a5 100644
--- a/tests/builtins/src/test_builtins.rs
+++ b/tests/builtins/src/test_builtins.rs
@@ -8,23 +8,14 @@ use self::libc::{c_int, c_uint, c_char, c_long, c_longlong, c_double};
 
 #[link(name = "test")]
 extern "C" {
-    #[no_mangle]
     fn atomics_entry(_: c_uint, _: *mut c_int);
-    #[no_mangle]
     fn new_atomics(_: c_uint, _: *mut c_int);
-    #[no_mangle]
     fn mem_x(_: *const c_char, _: *mut c_char);
-    #[no_mangle]
     fn ffs(_: c_int) -> c_int;
-    #[no_mangle]
     fn ffsl(_: c_long) -> c_int;
-    #[no_mangle]
     fn ffsll(_: c_longlong) -> c_int;
-    #[no_mangle]
     fn isfinite(_: c_double) -> c_int;
-    #[no_mangle]
     fn isnan(_: c_double) -> c_int;
-    #[no_mangle]
     fn isinf_sign(_: c_double) -> c_int;
 }
 
diff --git a/tests/casts/src/test_casts.rs b/tests/casts/src/test_casts.rs
index 5f58860918..8e3e92422d 100644
--- a/tests/casts/src/test_casts.rs
+++ b/tests/casts/src/test_casts.rs
@@ -9,16 +9,12 @@ use std::mem::transmute;
 
 #[link(name = "test")]
 extern "C" {
-    #[no_mangle]
     fn cast_stuff();
 
-    #[no_mangle]
     fn identity(_: c_int) -> c_int;
 
-    #[no_mangle]
     fn get_identity() -> *mut c_void;
 
-    #[no_mangle]
     fn entry(_: c_uint, _: *mut c_int);
 }
 
diff --git a/tests/conditionals/src/test_conditionals.rs b/tests/conditionals/src/test_conditionals.rs
index fe69a39704..de437e942d 100644
--- a/tests/conditionals/src/test_conditionals.rs
+++ b/tests/conditionals/src/test_conditionals.rs
@@ -8,20 +8,14 @@ use self::libc::{c_int, c_uint};
 
 #[link(name = "test")]
 extern "C" {
-    #[no_mangle]
     fn entry(_: c_uint, _: *mut c_int);
 
-    #[no_mangle]
     fn entry2(_: c_uint, _: *mut c_int);
 
-    #[no_mangle]
     fn entry3(_: c_uint, _: *mut c_int);
 
-    #[no_mangle]
     fn unused_conditional1() -> c_int;
-    #[no_mangle]
     fn unused_conditional2() -> c_int;
-    #[no_mangle]
     fn unused_conditional3() -> c_int;
 }
 
diff --git a/tests/enums/src/test_enums.rs b/tests/enums/src/test_enums.rs
index fdbc2a5b94..b5fca4ab8e 100644
--- a/tests/enums/src/test_enums.rs
+++ b/tests/enums/src/test_enums.rs
@@ -12,19 +12,14 @@ use self::libc::{c_int, c_uint};
 
 #[link(name = "test")]
 extern "C" {
-    #[no_mangle]
     fn entry(_: c_uint, _: *mut c_int);
 
-    #[no_mangle]
     fn entry2(_: c_uint, _: *mut c_int);
 
-    #[no_mangle]
     fn entry3(_: c_uint, _: *mut c_int);
 
-    #[no_mangle]
     fn entry4(_: c_uint, _: *mut c_int);
 
-    #[no_mangle]
     fn entry5(_: c_uint, _: *mut c_int);
 }
 
diff --git a/tests/example/src/test_add.rs b/tests/example/src/test_add.rs
index 49e5428bc0..0f052790e9 100644
--- a/tests/example/src/test_add.rs
+++ b/tests/example/src/test_add.rs
@@ -5,7 +5,6 @@ use self::libc::c_uint;
 
 #[link(name = "test")]
 extern "C" {
-    #[no_mangle]
     fn add(left: c_uint, right: c_uint) -> c_uint;
 }
 
diff --git a/tests/example/src/test_sub.rs b/tests/example/src/test_sub.rs
index aac0ac6f98..5dd8b7e4ef 100644
--- a/tests/example/src/test_sub.rs
+++ b/tests/example/src/test_sub.rs
@@ -5,7 +5,6 @@ use self::libc::c_uint;
 
 #[link(name = "test")]
 extern "C" {
-    #[no_mangle]
     fn sub(left: c_uint, right: c_uint) -> c_uint;
 }
 
diff --git a/tests/floats/src/test_no_wrapping_neg.rs b/tests/floats/src/test_no_wrapping_neg.rs
index 8ce1929c5f..a40b6e1631 100644
--- a/tests/floats/src/test_no_wrapping_neg.rs
+++ b/tests/floats/src/test_no_wrapping_neg.rs
@@ -5,11 +5,8 @@ use self::libc::{c_double, c_float};
 
 #[link(name = "test")]
 extern "C" {
-    #[no_mangle]
     fn no_wrapping_neg() -> c_double;
-    #[no_mangle]
     fn float_inc_dec() -> c_float;
-    #[no_mangle]
     fn double_inc_dec() -> c_double;
 }
 
diff --git a/tests/gotos/src/test_irreducible.rs b/tests/gotos/src/test_irreducible.rs
index 0041cafbfd..b361c96272 100644
--- a/tests/gotos/src/test_irreducible.rs
+++ b/tests/gotos/src/test_irreducible.rs
@@ -5,7 +5,6 @@ use irreducible::rust_irreducible;
 
 #[link(name = "test")]
 extern "C" {
-    #[no_mangle]
     fn irreducible(_: c_int) -> c_int;
 }
 
diff --git a/tests/ints/src/test_arithmetic.rs b/tests/ints/src/test_arithmetic.rs
index ebc326b733..bf93aad826 100644
--- a/tests/ints/src/test_arithmetic.rs
+++ b/tests/ints/src/test_arithmetic.rs
@@ -5,7 +5,6 @@ use self::libc::{c_uint, c_int};
 
 #[link(name = "test")]
 extern "C" {
-    #[no_mangle]
     fn entry2(_: c_uint, _: *mut c_int);
 }
 
diff --git a/tests/ints/src/test_compound_assigment.rs b/tests/ints/src/test_compound_assigment.rs
index 484eeddd4d..a4e00d599b 100644
--- a/tests/ints/src/test_compound_assigment.rs
+++ b/tests/ints/src/test_compound_assigment.rs
@@ -6,7 +6,6 @@ use self::libc::{c_int, c_uint};
 
 #[link(name = "test")]
 extern "C" {
-    #[no_mangle]
     fn compound_assignment(_: c_uint, _: *mut c_int);
 }
 
diff --git a/tests/ints/src/test_const.rs b/tests/ints/src/test_const.rs
index 5bbba86ea0..aab65a86c2 100644
--- a/tests/ints/src/test_const.rs
+++ b/tests/ints/src/test_const.rs
@@ -5,7 +5,6 @@ use self::libc::{c_int, c_uint};
 
 #[link(name = "test")]
 extern "C" {
-    #[no_mangle]
     fn entry4(_: c_uint, _: *mut c_int);
 }
 
diff --git a/tests/ints/src/test_implicit_ints.rs b/tests/ints/src/test_implicit_ints.rs
index 5fe56a12c3..3e54b2d08b 100644
--- a/tests/ints/src/test_implicit_ints.rs
+++ b/tests/ints/src/test_implicit_ints.rs
@@ -5,10 +5,8 @@ use implicit_int::{identity as rust_identity, implicit_int as rust_implicit_int}
 use self::libc::{c_int, c_uint};
 
 extern "C" {
-    #[no_mangle]
     fn identity(_: c_int) -> c_int;
 
-    #[no_mangle]
     fn implicit_int();
 }
 
diff --git a/tests/ints/src/test_ints.rs b/tests/ints/src/test_ints.rs
index 73185773de..6c1c86b741 100644
--- a/tests/ints/src/test_ints.rs
+++ b/tests/ints/src/test_ints.rs
@@ -6,10 +6,8 @@ use self::libc::{c_int, c_uint};
 
 #[link(name = "test")]
 extern "C" {
-    #[no_mangle]
     fn entry(_: c_uint, _: *mut c_int);
 
-    #[no_mangle]
     fn multibyte_chars(_: c_uint, _: *mut c_int) -> c_int;
 }
 
diff --git a/tests/ints/src/test_sieve_of_eratosthenes.rs b/tests/ints/src/test_sieve_of_eratosthenes.rs
index be379178fe..ee45b5af96 100644
--- a/tests/ints/src/test_sieve_of_eratosthenes.rs
+++ b/tests/ints/src/test_sieve_of_eratosthenes.rs
@@ -5,7 +5,6 @@ use self::libc::c_int;
 
 #[link(name = "test")]
 extern "C" {
-    #[no_mangle]
     fn sieve_of_eratosthenes(_: *mut c_int);
 }
 
diff --git a/tests/ints/src/test_volatile.rs b/tests/ints/src/test_volatile.rs
index d715729c16..c5f8e8b0a2 100644
--- a/tests/ints/src/test_volatile.rs
+++ b/tests/ints/src/test_volatile.rs
@@ -5,7 +5,6 @@ use self::libc::{c_int, c_uint};
 
 #[link(name = "test")]
 extern "C" {
-    #[no_mangle]
     fn entry3(_: c_uint, _: *mut c_int);
 }
 
diff --git a/tests/items/src/test_fn_attrs.rs b/tests/items/src/test_fn_attrs.rs
index 695eea4806..580d7ae530 100644
--- a/tests/items/src/test_fn_attrs.rs
+++ b/tests/items/src/test_fn_attrs.rs
@@ -52,6 +52,6 @@ pub fn test_fn_attrs() {
 
     if cfg!(not(target_os = "macos")) {
         // aliased_fn is aliased to the inline_extern function
-        assert!(src.contains("#[no_mangle]\n    #[link_name = \"inline_extern\"]\n    fn aliased_fn();"));
+        assert!(src.contains("extern \"C\" {\n    #[link_name = \"inline_extern\"]\n    fn aliased_fn();"));
     }
 }
diff --git a/tests/items/src/test_functions.rs b/tests/items/src/test_functions.rs
index 87b020516d..c085ea7f54 100644
--- a/tests/items/src/test_functions.rs
+++ b/tests/items/src/test_functions.rs
@@ -2,7 +2,6 @@ use functions::rust_coreutils_static_assert;
 
 #[link(name = "test")]
 extern "C" {
-    #[no_mangle]
     fn coreutils_static_assert();
 }
 
diff --git a/tests/items/src/test_linking.rs b/tests/items/src/test_linking.rs
index 68b74d3b3c..9121c221df 100644
--- a/tests/items/src/test_linking.rs
+++ b/tests/items/src/test_linking.rs
@@ -5,10 +5,8 @@ use self::libc::c_int;
 
 #[link(name = "test")]
 extern "C" {
-    #[no_mangle]
     fn l() -> c_int;
 
-    #[no_mangle]
     fn w() -> c_int;
 }
 
diff --git a/tests/items/src/test_noop.rs b/tests/items/src/test_noop.rs
index 226a5787fd..9bb12b8dd0 100644
--- a/tests/items/src/test_noop.rs
+++ b/tests/items/src/test_noop.rs
@@ -7,10 +7,8 @@ use self::libc::c_int;
 
 #[link(name = "test")]
 extern "C" {
-    #[no_mangle]
     fn noop();
 
-    #[no_mangle]
     fn nofnargs() -> c_int;
 }
 
diff --git a/tests/items/src/test_varargs.rs b/tests/items/src/test_varargs.rs
index 0c254bbd89..2ad8f83a15 100644
--- a/tests/items/src/test_varargs.rs
+++ b/tests/items/src/test_varargs.rs
@@ -9,22 +9,16 @@ use self::libc::c_char;
 
 #[link(name = "test")]
 extern "C" {
-    #[no_mangle]
     fn call_printf();
 
-    #[no_mangle]
     fn call_vprintf(_: *const c_char, ...);
 
-    #[no_mangle]
     fn my_printf(_: *const c_char, ...);
 
-    #[no_mangle]
     fn simple_vacopy(_: *const c_char, ...);
 
-    #[no_mangle]
     fn restart_valist(_: *const c_char, ...);
 
-    #[no_mangle]
     fn sample_stddev(count: i32, ...) -> f64;
 }
 
diff --git a/tests/loops/src/test_goto.rs b/tests/loops/src/test_goto.rs
index b044d19b28..ea97b0fc82 100644
--- a/tests/loops/src/test_goto.rs
+++ b/tests/loops/src/test_goto.rs
@@ -8,13 +8,10 @@ use self::libc::{c_int, c_uint};
 
 #[link(name = "test")]
 extern "C" {
-    #[no_mangle]
     fn goto_linear(_: c_uint, _: *mut c_int);
 
-    #[no_mangle]
     fn goto_loop(_: c_uint, _: *mut c_int);
 
-    #[no_mangle]
     fn goto_switch(_: c_uint, _: *mut c_int);
 }
 
diff --git a/tests/loops/src/test_loops.rs b/tests/loops/src/test_loops.rs
index d836622085..99611d9993 100644
--- a/tests/loops/src/test_loops.rs
+++ b/tests/loops/src/test_loops.rs
@@ -5,7 +5,6 @@ use self::libc::{c_int, c_uint};
 
 #[link(name = "test")]
 extern "C" {
-    #[no_mangle]
     fn entry(_: c_uint, _: *mut c_int);
 }
 
diff --git a/tests/loops/src/test_switch.rs b/tests/loops/src/test_switch.rs
index d696297c6b..fe3178476c 100644
--- a/tests/loops/src/test_switch.rs
+++ b/tests/loops/src/test_switch.rs
@@ -5,7 +5,6 @@ use self::libc::c_int;
 
 #[link(name = "test")]
 extern "C" {
-    #[no_mangle]
     fn switch_val(_: c_int) -> c_int;
 }
 
diff --git a/tests/macros/src/test_define.rs b/tests/macros/src/test_define.rs
index 8b1429398c..07ba265e1c 100644
--- a/tests/macros/src/test_define.rs
+++ b/tests/macros/src/test_define.rs
@@ -7,7 +7,6 @@ use self::libc::{c_int, c_uint, c_ulong};
 
 #[link(name = "test")]
 extern "C" {
-    #[no_mangle]
     fn reference_define() -> c_uint;
 }
 
diff --git a/tests/misc/src/test_lvalues.rs b/tests/misc/src/test_lvalues.rs
index 2a94f4d9db..0e343e6d76 100644
--- a/tests/misc/src/test_lvalues.rs
+++ b/tests/misc/src/test_lvalues.rs
@@ -5,7 +5,6 @@ use self::libc::c_int;
 
 #[link(name = "test")]
 extern "C" {
-    #[no_mangle]
     fn lvalue(_: *mut c_int);
 }
 
diff --git a/tests/misc/src/test_memory.rs b/tests/misc/src/test_memory.rs
index 229deeadb0..82840f39a8 100644
--- a/tests/misc/src/test_memory.rs
+++ b/tests/misc/src/test_memory.rs
@@ -6,10 +6,8 @@ use self::libc::{c_int, c_uint};
 
 #[link(name = "test")]
 extern "C" {
-    #[no_mangle]
     fn malloc_test(_: c_uint, _: *mut c_int);
 
-    #[no_mangle]
     fn setmem(_: c_uint, _: *mut c_int);
 }
 
diff --git a/tests/misc/src/test_quicksort.rs b/tests/misc/src/test_quicksort.rs
index 70dbffa5e1..6b38e9aea3 100644
--- a/tests/misc/src/test_quicksort.rs
+++ b/tests/misc/src/test_quicksort.rs
@@ -5,13 +5,10 @@ use self::libc::c_int;
 
 #[link(name = "test")]
 extern "C" {
-    #[no_mangle]
     fn swap(_: *mut c_int, _: *mut c_int);
 
-    #[no_mangle]
     fn partition(_: *mut c_int, _: c_int, _: c_int);
 
-    #[no_mangle]
     fn quickSort(_: *mut c_int, _: c_int, _: c_int);
 }
 
diff --git a/tests/misc/src/test_shadowing.rs b/tests/misc/src/test_shadowing.rs
index 8da3172338..cab6601658 100644
--- a/tests/misc/src/test_shadowing.rs
+++ b/tests/misc/src/test_shadowing.rs
@@ -5,10 +5,8 @@ use self::libc::{c_int, c_uint};
 
 #[link(name = "test")]
 extern "C" {
-    #[no_mangle]
     fn twice(_: c_int) -> c_int;
 
-    #[no_mangle]
     fn shadow(_: c_uint, _: *mut c_int);
 }
 
diff --git a/tests/misc/src/test_sizeofs.rs b/tests/misc/src/test_sizeofs.rs
index 51103dadff..5f843c7d69 100644
--- a/tests/misc/src/test_sizeofs.rs
+++ b/tests/misc/src/test_sizeofs.rs
@@ -7,7 +7,6 @@ use self::libc::c_uint;
 
 #[link(name = "test")]
 extern "C" {
-    #[no_mangle]
     fn sizeofs(_: c_uint, _: *mut c_int);
 }
 
diff --git a/tests/misc/src/test_typedef.rs b/tests/misc/src/test_typedef.rs
index 9f775d342c..bd934c3963 100644
--- a/tests/misc/src/test_typedef.rs
+++ b/tests/misc/src/test_typedef.rs
@@ -6,7 +6,6 @@ use self::libc::c_int;
 
 #[link(name = "test")]
 extern "C" {
-    #[no_mangle]
     fn entry() -> c_int;
 }
 
diff --git a/tests/misc/src/test_uninitialized.rs b/tests/misc/src/test_uninitialized.rs
index d9c80a2276..befd100e18 100644
--- a/tests/misc/src/test_uninitialized.rs
+++ b/tests/misc/src/test_uninitialized.rs
@@ -4,7 +4,6 @@ use uninitialized::{rust_entry2, /*myint, myintp,*/ u, e, s, foo, bar, baz};
 use self::libc::{c_int, c_uint};
 
 extern "C" {
-    #[no_mangle]
     fn entry2(_: c_uint, _: *mut c_int);
 }
 
diff --git a/tests/modules/src/test_modules.rs b/tests/modules/src/test_modules.rs
index d0b6e1a72e..3708fd8d8e 100644
--- a/tests/modules/src/test_modules.rs
+++ b/tests/modules/src/test_modules.rs
@@ -5,7 +5,6 @@ use self::libc::c_uint;
 
 #[link(name = "test")]
 extern "C" {
-    #[no_mangle]
     fn modules();
 }
 
diff --git a/tests/pointers/src/test_pointers.rs b/tests/pointers/src/test_pointers.rs
index 9b68885b33..40773c35e8 100644
--- a/tests/pointers/src/test_pointers.rs
+++ b/tests/pointers/src/test_pointers.rs
@@ -1,4 +1,4 @@
-//! feature_c_variadic, feature_ptr_wrapping_offset_from
+//! feature_c_variadic
 
 extern crate libc;
 
@@ -10,13 +10,10 @@ use self::libc::{c_int, c_uint};
 
 #[link(name = "test")]
 extern "C" {
-    #[no_mangle]
     fn entry(_: c_uint, _: *mut c_int);
 
-    #[no_mangle]
     fn entry2(_: c_uint, _: *mut c_int);
 
-    #[no_mangle]
     fn entry3(_: c_uint, _: *mut c_int);
 }
 
diff --git a/tests/simd/src/test_x86.rs b/tests/simd/src/test_x86.rs
index a9cce4f14f..4a0b4165d2 100644
--- a/tests/simd/src/test_x86.rs
+++ b/tests/simd/src/test_x86.rs
@@ -17,37 +17,26 @@ use std::fmt::{Debug, Formatter, Error};
 
 #[link(name = "test")]
 extern "C" {
-    #[no_mangle]
     fn unpack_128_2x128(data: __m128i, data_lo: *mut __m128i, data_hi: *mut __m128i);
 
-    #[no_mangle]
     fn call_all() -> ShuffleVectors;
 
-    #[no_mangle]
     fn call_all_used() -> ShuffleVectors;
 
-    #[no_mangle]
     fn vector_init_lists() -> VectorInitLists;
 
-    #[no_mangle]
     fn vector_init_lists_used() -> VectorInitLists;
 
-    #[no_mangle]
     static static_m128: __m128;
 
-    #[no_mangle]
     static static_m256: __m256;
 
-    #[no_mangle]
     static static_m128d: __m128d;
 
-    #[no_mangle]
     static static_m256d: __m256d;
 
-    #[no_mangle]
     static static_m128i: __m128i;
 
-    #[no_mangle]
     static static_m256i: __m256i;
 }
 
@@ -75,6 +64,7 @@ macro_rules! cmp_vector_fields {
 impl PartialEq for ShuffleVectors {
     fn eq(&self, other: &ShuffleVectors) -> bool {
         cmp_vector_fields!(self, other: [
+            #[cfg(target_feature = "mmx")]
             a: u64,
             b: u128,
             c: u128,
@@ -89,6 +79,7 @@ impl PartialEq for ShuffleVectors {
             j: (u128, u128),
             #[cfg(target_feature = "avx2")]
             k: (u128, u128),
+            #[cfg(target_feature = "mmx")]
             l: u64,
             m: u128,
             #[cfg(target_feature = "avx2")]
diff --git a/tests/simd/src/x86.c b/tests/simd/src/x86.c
index c76b6c0837..ba1318cc1c 100644
--- a/tests/simd/src/x86.c
+++ b/tests/simd/src/x86.c
@@ -3,9 +3,13 @@
 #include <immintrin.h>
 
 // Our travis-ci machines don't support AVX2 so we conditionally compile those bits out
+// Additionally, rust std::arch removed MMX support, so we conditionally compile
+// out uses of __m64 and MMX intrinsics pending an alternative translation
 
 typedef struct {
+#ifdef MMX
     __m64 a;
+#endif
     __m128 b;
     __m128d c;
     __m256 d;
@@ -14,7 +18,9 @@ typedef struct {
 #ifdef __AVX2__
     __m256i i, j, k;
 #endif
+#ifdef MMX
     __m64 l;
+#endif
     __m128i m;
 #ifdef __AVX2__
     __m256i n, p, q;
@@ -44,21 +50,27 @@ void zero_init_all(void) {
     __m128i d;
     __m256d e;
     __m256i f;
+#ifdef MMX
     __m64 g;
+#endif
 }
 
 ShuffleVectors call_all(void) {
     __m128 a = _mm_setr_ps(7.8, 5.6, 3.4, 1.2);
     __m128d b = _mm_set1_pd(4.13);
+#ifdef MMX
     __m64 c = _mm_set_pi32(1, 2);
+#endif
     __m256 d = _mm256_set1_ps(45.2);
     __m256d e = _mm256_set_pd(1.1, 2.2, 3.3, 4.4);
     __m128i f = _mm_set1_epi8(123);
     __m256i g = _mm256_set_epi32(14, 18, 22, 33, -11, -3, 8, 300);
 
     ShuffleVectors sv = {
+#ifdef MMX
         // Actual Builtin:
         _mm_shuffle_pi16(c, _MM_SHUFFLE(0, 1, 2, 3)),
+#endif
 
         // Super builtins(in clang 6, but actual in 7):
         _mm_shuffle_ps(a, a, _MM_SHUFFLE(3, 2, 1, 0)),
@@ -75,7 +87,9 @@ ShuffleVectors call_all(void) {
         _mm256_shufflelo_epi16(g, _MM_SHUFFLE(2, 3, 2, 3)),
 #endif
         // Functions:
+#ifdef MMX
         _mm_shuffle_pi8(c, c),
+#endif
         _mm_shuffle_epi8(f, f),
 #ifdef __AVX2__
         _mm256_shuffle_epi8(g, g),
@@ -91,28 +105,36 @@ ShuffleVectors call_all(void) {
 ShuffleVectors call_all_used(void) {
     __m128 aa = _mm_setr_ps(1.2, 3.4, 5.6, 7.8);
     __m128d bb = _mm_set1_pd(3.14);
+#ifdef MMX
     __m64 cc = _mm_set_pi32(1, 2);
+#endif
     __m256 dd = _mm256_set1_ps(3.34);
     __m256d ee = _mm256_set_pd(4.4, 3.3, 2.2, 1.1);
     __m128i ff = _mm_set1_epi8(13);
     __m256i gg = _mm256_set_epi32(-12, 33, 44, 100, -44, 42, -33, -100);
 
+#ifdef MMX
     __m64 a;
+#endif
     __m128 b;
     __m128d c;
     __m256 d;
     __m256d e;
     __m128i f, g, h, o;
     __m256i i, j, k;
+#ifdef MMX
     __m64 l;
+#endif
     __m128i m;
     __m256i n;
     __m256i p;
     __m256i q;
     __m128i r;
 
+#ifdef MMX
     // Actual Builtin:
     a = _mm_shuffle_pi16(cc, _MM_SHUFFLE(0, 1, 2, 3));
+#endif
 
     // Super builtins(in clang 6, but actual in 7):
     b = _mm_shuffle_ps(aa, aa, _MM_SHUFFLE(3, 2, 1, 0));
@@ -130,7 +152,9 @@ ShuffleVectors call_all_used(void) {
     o = _mm_slli_si128(g, 2);
 
     // Functions:
+#ifdef MMX
     l = _mm_shuffle_pi8(cc, cc);
+#endif
     m = _mm_shuffle_epi8(ff, ff);
 #ifdef __AVX2__
     n = _mm256_shuffle_epi8(gg, gg);
@@ -140,12 +164,18 @@ ShuffleVectors call_all_used(void) {
     r = _mm_alignr_epi8(ff, ff, 2);
 
     ShuffleVectors sv = {
-        a, b, c, d, e, f, g, h, o,
+#ifdef MMX
+        a,
+#endif
+        b, c, d, e, f, g, h, o,
 
 #ifdef __AVX2__
         i, j, k,
 #endif
-        l, m,
+#ifdef MMX
+        l,
+#endif
+        m,
 
 #ifdef __AVX2__
         n, p, q,
diff --git a/tests/statics/src/test_sections.rs b/tests/statics/src/test_sections.rs
index 49908fb735..6e19f4864a 100644
--- a/tests/statics/src/test_sections.rs
+++ b/tests/statics/src/test_sections.rs
@@ -1,4 +1,3 @@
-//! feature_const_raw_ptr_to_usize_cast
 extern crate libc;
 
 #[cfg(not(target_os = "macos"))]
@@ -51,6 +50,6 @@ pub fn test_sectioned_used_static() {
 
         // This static is pub, but we want to ensure it has attributes applied
         assert!(src.contains("#[link_section = \"fb\"]\npub static mut rust_initialized_extern: libc::c_int = 1 as libc::c_int;"));
-        assert!(src.contains("#[no_mangle]\n    #[link_name = \"no_attrs\"]\n    static mut rust_aliased_static: libc::c_int;"))
+        assert!(src.contains("extern \"C\" {\n    #[link_name = \"no_attrs\"]\n    static mut rust_aliased_static: libc::c_int;"))
     }
 }
diff --git a/tests/statics/src/test_storage.rs b/tests/statics/src/test_storage.rs
index 29769d0aed..ee056b020d 100644
--- a/tests/statics/src/test_storage.rs
+++ b/tests/statics/src/test_storage.rs
@@ -5,7 +5,6 @@ use self::libc::{c_int, c_uint};
 
 #[link(name = "test")]
 extern "C" {
-    #[no_mangle]
     fn entry(_: c_uint, _: *mut c_int);
 }
 
diff --git a/tests/statics/src/test_thread_locals.rs b/tests/statics/src/test_thread_locals.rs
index b18a23f59b..e486442a51 100644
--- a/tests/statics/src/test_thread_locals.rs
+++ b/tests/statics/src/test_thread_locals.rs
@@ -8,7 +8,6 @@ use thread_locals::rust_thread_entry;
 
 #[link(name = "test")]
 extern "C" {
-    #[no_mangle]
     fn thread_entry(_: c_uint, _: *mut c_int);
 }
 
diff --git a/tests/structs/src/test_bitfields.rs b/tests/structs/src/test_bitfields.rs
index e21133284d..66cd3b40ba 100644
--- a/tests/structs/src/test_bitfields.rs
+++ b/tests/structs/src/test_bitfields.rs
@@ -10,33 +10,19 @@ use bitfields::{
 };
 
 extern "C" {
-    #[no_mangle]
     fn size_of_three_byte_date() -> usize;
-    #[no_mangle]
     fn compare_three_byte_date(_: *const three_byte_date, _: u8, _: u8, _: u16) -> u8;
-    #[no_mangle]
     fn write_three_byte_date(_: *mut three_byte_date, _: u8, _: u8, _: u16);
-    #[no_mangle]
     fn size_of_padded_bitfield() -> usize;
-    #[no_mangle]
     fn ops_padded_bitfield(_: *mut padded_bitfield);
-    #[no_mangle]
     static mut static_date: three_byte_date;
-    #[no_mangle]
     fn size_of_mixed_bitfields() -> usize;
-    #[no_mangle]
     fn zeroed_mixed_bitfields() -> mixed_bitfields;
-    #[no_mangle]
     fn zeroed_padded_bitfield() -> padded_bitfield;
-    #[no_mangle]
     fn zeroed_three_byte_date() -> three_byte_date;
-    #[no_mangle]
     fn size_of_from_csmith() -> usize;
-    #[no_mangle]
     fn size_of_two_eight_bits() -> usize;
-    #[no_mangle]
     fn multiple_assignments();
-    #[no_mangle]
     static ma_results: [u8; 17];
 }
 
diff --git a/tests/structs/src/test_flex_array_members.rs b/tests/structs/src/test_flex_array_members.rs
index b696cb8bec..9b9e7918f2 100644
--- a/tests/structs/src/test_flex_array_members.rs
+++ b/tests/structs/src/test_flex_array_members.rs
@@ -5,7 +5,6 @@ use self::libc::{c_int, c_uint, size_t};
 
 #[link(name = "test")]
 extern "C" {
-    #[no_mangle]
     fn exercise_flex_arrays(_: c_uint, _: *mut c_int);
 }
 
diff --git a/tests/structs/src/test_forward.rs b/tests/structs/src/test_forward.rs
index 2cac2e9b54..71891b6e9c 100644
--- a/tests/structs/src/test_forward.rs
+++ b/tests/structs/src/test_forward.rs
@@ -5,7 +5,6 @@ use self::libc::{c_int, c_uint};
 
 #[link(name = "test")]
 extern "C" {
-    #[no_mangle]
     fn forward(_: c_uint, _: *mut c_int);
 }
 
diff --git a/tests/structs/src/test_self_referential.rs b/tests/structs/src/test_self_referential.rs
index f613ebc3c5..cf0e88ae55 100644
--- a/tests/structs/src/test_self_referential.rs
+++ b/tests/structs/src/test_self_referential.rs
@@ -4,7 +4,6 @@ use self_referential::Node;
 
 #[link(name = "test")]
 extern "C" {
-    #[no_mangle]
     fn whatever(np: *mut Node);
 }
 
diff --git a/tests/structs/src/test_structs.rs b/tests/structs/src/test_structs.rs
index 7b1e378b38..2a797a9627 100644
--- a/tests/structs/src/test_structs.rs
+++ b/tests/structs/src/test_structs.rs
@@ -6,11 +6,8 @@ use self::libc::{c_int, c_uint, size_t};
 
 #[link(name = "test")]
 extern "C" {
-    #[no_mangle]
     fn entry(_: c_uint, _: *mut c_int);
-    #[no_mangle]
     fn alignment_of_aligned8_struct() -> size_t;
-    #[no_mangle]
     fn alignment_entry(_: c_uint, _: *mut c_int);
 }
 
diff --git a/tests/structs/src/test_variable_offsetof.rs b/tests/structs/src/test_variable_offsetof.rs
index 78787dab88..b24019532f 100644
--- a/tests/structs/src/test_variable_offsetof.rs
+++ b/tests/structs/src/test_variable_offsetof.rs
@@ -6,9 +6,7 @@ use variable_offsetof::{rust_get_offset, rust_get_offset2, size_t};
 
 #[link(name = "test")]
 extern "C" {
-    #[no_mangle]
     fn get_offset(_: size_t) -> size_t;
-    #[no_mangle]
     fn get_offset2(_: size_t) -> size_t;
 }
 
diff --git a/tests/unions/src/test_unions.rs b/tests/unions/src/test_unions.rs
index 8bdde4256b..9d49765258 100644
--- a/tests/unions/src/test_unions.rs
+++ b/tests/unions/src/test_unions.rs
@@ -5,7 +5,6 @@ use self::libc::{c_int, c_uint};
 
 #[link(name = "test")]
 extern "C" {
-    #[no_mangle]
     fn entry(_: c_uint, _: *mut c_int);
 }