Support builtin# expr syntax

Cargo.toml

@@ -19,10 +19,10 @@ verbatim = ["syn/parsing"]
 
 [dependencies]
 proc-macro2 = { version = "1.0", default-features = false }
-syn = { version = "2.0.10", default-features = false, features = ["full"] }
+syn = { version = "2.0.16", default-features = false, features = ["full"] }
 
 [dev-dependencies]
-syn = { version = "2.0.10", default-features = false, features = ["parsing"] }
+syn = { version = "2.0.16", default-features = false, features = ["parsing"] }
 
 [lib]
 doc-scrape-examples = false

src/expr.rs

@@ -665,18 +665,26 @@ impl Printer {
     #[cfg(feature = "verbatim")]
     fn expr_verbatim(&mut self, tokens: &TokenStream) {
         use syn::parse::{Parse, ParseStream, Result};
+        use syn::{parenthesized, Ident};
 
         enum ExprVerbatim {
             Empty,
+            Builtin(Builtin),
             RawReference(RawReference),
         }
 
+        struct Builtin {
+            name: Ident,
+            args: TokenStream,
+        }
+
         struct RawReference {
             mutable: bool,
             expr: Expr,
         }
 
         mod kw {
+            syn::custom_keyword!(builtin);
             syn::custom_keyword!(raw);
         }
 
@@ -685,6 +693,14 @@ impl Printer {
                 let lookahead = input.lookahead1();
                 if input.is_empty() {
                     Ok(ExprVerbatim::Empty)
+                } else if lookahead.peek(kw::builtin) {
+                    input.parse::<kw::builtin>()?;
+                    input.parse::<Token![#]>()?;
+                    let name: Ident = input.parse()?;
+                    let args;
+                    parenthesized!(args in input);
+                    let args: TokenStream = args.parse()?;
+                    Ok(ExprVerbatim::Builtin(Builtin { name, args }))
                 } else if lookahead.peek(Token![&]) {
                     input.parse::<Token![&]>()?;
                     input.parse::<kw::raw>()?;
@@ -707,6 +723,22 @@ impl Printer {
 
         match expr {
             ExprVerbatim::Empty => {}
+            ExprVerbatim::Builtin(expr) => {
+                self.word("builtin # ");
+                self.ident(&expr.name);
+                self.word("(");
+                if !expr.args.is_empty() {
+                    self.cbox(INDENT);
+                    self.zerobreak();
+                    self.ibox(0);
+                    self.macro_rules_tokens(expr.args, false);
+                    self.end();
+                    self.zerobreak();
+                    self.offset(-INDENT);
+                    self.end();
+                }
+                self.word(")");
+            }
             ExprVerbatim::RawReference(expr) => {
                 self.word("&raw ");
                 self.word(if expr.mutable { "mut " } else { "const " });