From 12505bf21083294c8dad5dbcf4f1fba649b5e398 Mon Sep 17 00:00:00 2001
From: David Tolnay <dtolnay@gmail.com>
Date: Sun, 14 May 2023 11:40:21 +0200
Subject: [PATCH] Support builtin# expr syntax

---
 Cargo.toml  |  4 ++--
 src/expr.rs | 32 ++++++++++++++++++++++++++++++++
 2 files changed, 34 insertions(+), 2 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 4aa5ae5..99a31cb 100644
--- a/Cargo.toml
+++ b/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
diff --git a/src/expr.rs b/src/expr.rs
index f012288..6e2c8be 100644
--- a/src/expr.rs
+++ b/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 " });