Upgrade rust/crates/proc-macro-hack to 0.5.19
Test: make
Change-Id: I3ca9b7f663f7fa6b81473e30e37940593c0c4af9
diff --git a/.cargo_vcs_info.json b/.cargo_vcs_info.json
index 24bc86c..083f3c7 100644
--- a/.cargo_vcs_info.json
+++ b/.cargo_vcs_info.json
@@ -1,5 +1,5 @@
{
"git": {
- "sha1": "3da1be8f9519c725b1f425a954b06a1a0a8b25ac"
+ "sha1": "758784bb05c3d68569ca5001972fe5c31b8175c5"
}
}
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index ca24eac..c4d0fa9 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -12,7 +12,7 @@
strategy:
fail-fast: false
matrix:
- rust: [nightly, beta, stable, 1.42.0, 1.31.0]
+ rust: [nightly, beta, stable, 1.45.0, 1.42.0, 1.31.0]
steps:
- uses: actions/checkout@v2
- uses: dtolnay/rust-toolchain@master
diff --git a/Cargo.toml b/Cargo.toml
index 67fadfc..0fc674b 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -13,7 +13,7 @@
[package]
edition = "2018"
name = "proc-macro-hack"
-version = "0.5.18"
+version = "0.5.19"
authors = ["David Tolnay <[email protected]>"]
description = "Procedural macros in expression position"
readme = "README.md"
diff --git a/Cargo.toml.orig b/Cargo.toml.orig
index 153d880..61150b4 100644
--- a/Cargo.toml.orig
+++ b/Cargo.toml.orig
@@ -1,6 +1,6 @@
[package]
name = "proc-macro-hack"
-version = "0.5.18"
+version = "0.5.19"
authors = ["David Tolnay <[email protected]>"]
edition = "2018"
license = "MIT OR Apache-2.0"
diff --git a/METADATA b/METADATA
index 39647e9..5511864 100644
--- a/METADATA
+++ b/METADATA
@@ -7,13 +7,13 @@
}
url {
type: ARCHIVE
- value: "https://static.crates.io/crates/proc-macro-hack/proc-macro-hack-0.5.18.crate"
+ value: "https://static.crates.io/crates/proc-macro-hack/proc-macro-hack-0.5.19.crate"
}
- version: "0.5.18"
+ version: "0.5.19"
license_type: NOTICE
last_upgrade_date {
year: 2020
- month: 7
- day: 26
+ month: 10
+ day: 28
}
}
diff --git a/README.md b/README.md
index df7a2ec..c734710 100644
--- a/README.md
+++ b/README.md
@@ -126,6 +126,13 @@
macro input, use `#[proc_macro_hack(fake_call_site)]` on the re-export in your
declaration crate. *Most macros won't need this.*
+- On compilers that are new enough to natively support proc macros in expression
+ position, proc-macro-hack does not automatically use that support, since the
+ hygiene can be subtly different between the two implementations. To opt in to
+ compiling your macro to native `#[proc_macro]` on sufficiently new compilers,
+ use `#[proc_macro_hack(only_hack_old_rustc)]` on the re-export in your
+ declaration crate.
+
[#10]: https://github.com/dtolnay/proc-macro-hack/issues/10
[#20]: https://github.com/dtolnay/proc-macro-hack/issues/20
[`proc-macro-nested`]: https://docs.rs/proc-macro-nested
diff --git a/build.rs b/build.rs
new file mode 100644
index 0000000..6ab4098
--- /dev/null
+++ b/build.rs
@@ -0,0 +1,31 @@
+use std::env;
+use std::process::Command;
+use std::str;
+
+// The rustc-cfg strings below are *not* public API. Please let us know by
+// opening a GitHub issue if your build environment requires some way to enable
+// these cfgs other than by executing our build script.
+fn main() {
+ let minor = match rustc_minor_version() {
+ Some(minor) => minor,
+ None => return,
+ };
+
+ // Function-like procedural macros in expressions, patterns, and statements
+ // stabilized in Rust 1.45:
+ // https://blog.rust-lang.org/2020/07/16/Rust-1.45.0.html#stabilizing-function-like-procedural-macros-in-expressions-patterns-and-statements
+ if minor < 45 {
+ println!("cargo:rustc-cfg=need_proc_macro_hack");
+ }
+}
+
+fn rustc_minor_version() -> Option<u32> {
+ let rustc = env::var_os("RUSTC")?;
+ let output = Command::new(rustc).arg("--version").output().ok()?;
+ let version = str::from_utf8(&output.stdout).ok()?;
+ let mut pieces = version.split('.');
+ if pieces.next() != Some("rustc 1") {
+ return None;
+ }
+ pieces.next()?.parse().ok()
+}
diff --git a/src/lib.rs b/src/lib.rs
index 901a719..90b04fd 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -132,6 +132,14 @@
//! in the macro input, use `#[proc_macro_hack(fake_call_site)]` on the
//! re-export in your declaration crate. *Most macros won't need this.*
//!
+//! - On compilers that are new enough to natively support proc macros in
+//! expression position, proc-macro-hack does not automatically use that
+//! support, since the hygiene can be subtly different between the two
+//! implementations. To opt in to compiling your macro to native
+//! `#[proc_macro]` on sufficiently new compilers, use
+//! `#[proc_macro_hack(only_hack_old_rustc)]` on the re-export in your
+//! declaration crate.
+//!
//! [#10]: https://github.com/dtolnay/proc-macro-hack/issues/10
//! [#20]: https://github.com/dtolnay/proc-macro-hack/issues/20
//! [`proc-macro-nested`]: https://docs.rs/proc-macro-nested
@@ -156,7 +164,7 @@
use proc_macro::{Ident, Punct, Spacing, Span, TokenStream, TokenTree};
use std::fmt::Write;
-type Visibility = Option<Span>;
+type Visibility = Option<Ident>;
enum Input {
Export(Export),
@@ -244,13 +252,18 @@
support_nested: bool,
internal_macro_calls: u16,
fake_call_site: bool,
+ only_hack_old_rustc: bool,
}
fn expand_export(export: Export, args: ExportArgs) -> TokenStream {
+ if args.only_hack_old_rustc && cfg!(not(need_proc_macro_hack)) {
+ return expand_export_nohack(export);
+ }
+
let dummy = dummy_name_for_export(&export);
let attrs = export.attrs;
- let ref vis = export.vis.map(|span| Ident::new("pub", span));
+ let vis = export.vis;
let macro_export = match vis {
Some(_) => quote!(#[macro_export]),
None => quote!(),
@@ -273,14 +286,14 @@
let mut export_call_site = TokenStream::new();
let mut macro_rules = TokenStream::new();
for Macro { name, export_as } in &export.macros {
- let actual_name = actual_proc_macro_name(&name);
+ let hacked = hacked_proc_macro_name(&name);
let dispatch = dispatch_macro_name(&name);
let call_site = call_site_macro_name(&name);
if !actual_names.is_empty() {
actual_names.extend(quote!(,));
}
- actual_names.extend(quote!(#actual_name));
+ actual_names.extend(quote!(#hacked));
if !export_dispatch.is_empty() {
export_dispatch.extend(quote!(,));
@@ -294,18 +307,18 @@
let do_derive = if !args.fake_call_site {
quote! {
- #[derive(#crate_prefix #actual_name)]
+ #[derive(#crate_prefix #hacked)]
}
} else if crate_prefix.is_some() {
quote! {
- use #crate_prefix #actual_name;
+ use #crate_prefix #hacked;
#[#crate_prefix #call_site ($($proc_macro)*)]
- #[derive(#actual_name)]
+ #[derive(#hacked)]
}
} else {
quote! {
#[#call_site ($($proc_macro)*)]
- #[derive(#actual_name)]
+ #[derive(#hacked)]
}
};
@@ -375,21 +388,47 @@
wrap_in_enum_hack(dummy, expanded)
}
+fn expand_export_nohack(export: Export) -> TokenStream {
+ let attrs = export.attrs;
+ let vis = export.vis;
+ let from = export.from;
+ let mut names = TokenStream::new();
+
+ for Macro { name, export_as } in &export.macros {
+ let pub_name = pub_proc_macro_name(&name);
+ if !names.is_empty() {
+ names.extend(quote!(,));
+ }
+ names.extend(quote!(#pub_name as #export_as));
+ }
+
+ if export.macros.len() != 1 {
+ names = quote!({#names});
+ }
+
+ quote! {
+ #attrs
+ #vis use #from::#names;
+ }
+}
+
fn expand_define(define: Define) -> TokenStream {
let attrs = define.attrs;
let name = define.name;
- let dummy = actual_proc_macro_name(&name);
+ let pub_name = pub_proc_macro_name(&name);
+ let hacked = hacked_proc_macro_name(&name);
let body = define.body;
quote! {
- mod #dummy {
+ mod #pub_name {
extern crate proc_macro;
pub use self::proc_macro::*;
}
#attrs
- #[proc_macro_derive(#dummy)]
- pub fn #dummy(input: #dummy::TokenStream) -> #dummy::TokenStream {
+ #[doc(hidden)]
+ #[proc_macro_derive(#hacked)]
+ pub fn #hacked(input: #pub_name::TokenStream) -> #pub_name::TokenStream {
use std::iter::FromIterator;
let mut iter = input.into_iter();
@@ -399,7 +438,7 @@
iter.next().unwrap(); // `[allow(dead_code)]`
let mut braces = match iter.next().unwrap() {
- #dummy::TokenTree::Group(group) => group.stream().into_iter(),
+ #pub_name::TokenTree::Group(group) => group.stream().into_iter(),
_ => unimplemented!(),
};
let variant = braces.next().unwrap(); // `Value` or `Nested`
@@ -408,29 +447,29 @@
braces.next().unwrap(); // `=`
let mut parens = match braces.next().unwrap() {
- #dummy::TokenTree::Group(group) => group.stream().into_iter(),
+ #pub_name::TokenTree::Group(group) => group.stream().into_iter(),
_ => unimplemented!(),
};
parens.next().unwrap(); // `stringify`
parens.next().unwrap(); // `!`
let inner = match parens.next().unwrap() {
- #dummy::TokenTree::Group(group) => group.stream(),
+ #pub_name::TokenTree::Group(group) => group.stream(),
_ => unimplemented!(),
};
- let output: #dummy::TokenStream = #name(inner.clone());
+ let output: #pub_name::TokenStream = #name(inner.clone());
- fn count_bangs(input: #dummy::TokenStream) -> usize {
+ fn count_bangs(input: #pub_name::TokenStream) -> usize {
let mut count = 0;
for token in input {
match token {
- #dummy::TokenTree::Punct(punct) => {
+ #pub_name::TokenTree::Punct(punct) => {
if punct.as_char() == '!' {
count += 1;
}
}
- #dummy::TokenTree::Group(group) => {
+ #pub_name::TokenTree::Group(group) => {
count += count_bangs(group.stream());
}
_ => {}
@@ -442,15 +481,15 @@
// macro_rules! proc_macro_call {
// () => { #output }
// }
- #dummy::TokenStream::from_iter(vec![
- #dummy::TokenTree::Ident(
- #dummy::Ident::new("macro_rules", #dummy::Span::call_site()),
+ #pub_name::TokenStream::from_iter(vec![
+ #pub_name::TokenTree::Ident(
+ #pub_name::Ident::new("macro_rules", #pub_name::Span::call_site()),
),
- #dummy::TokenTree::Punct(
- #dummy::Punct::new('!', #dummy::Spacing::Alone),
+ #pub_name::TokenTree::Punct(
+ #pub_name::Punct::new('!', #pub_name::Spacing::Alone),
),
- #dummy::TokenTree::Ident(
- #dummy::Ident::new(
+ #pub_name::TokenTree::Ident(
+ #pub_name::Ident::new(
&if support_nested {
let extra_bangs = if varname == "Nested" {
0
@@ -461,39 +500,52 @@
} else {
String::from("proc_macro_call")
},
- #dummy::Span::call_site(),
+ #pub_name::Span::call_site(),
),
),
- #dummy::TokenTree::Group(
- #dummy::Group::new(#dummy::Delimiter::Brace, #dummy::TokenStream::from_iter(vec![
- #dummy::TokenTree::Group(
- #dummy::Group::new(#dummy::Delimiter::Parenthesis, #dummy::TokenStream::new()),
+ #pub_name::TokenTree::Group(
+ #pub_name::Group::new(#pub_name::Delimiter::Brace, #pub_name::TokenStream::from_iter(vec![
+ #pub_name::TokenTree::Group(
+ #pub_name::Group::new(#pub_name::Delimiter::Parenthesis, #pub_name::TokenStream::new()),
),
- #dummy::TokenTree::Punct(
- #dummy::Punct::new('=', #dummy::Spacing::Joint),
+ #pub_name::TokenTree::Punct(
+ #pub_name::Punct::new('=', #pub_name::Spacing::Joint),
),
- #dummy::TokenTree::Punct(
- #dummy::Punct::new('>', #dummy::Spacing::Alone),
+ #pub_name::TokenTree::Punct(
+ #pub_name::Punct::new('>', #pub_name::Spacing::Alone),
),
- #dummy::TokenTree::Group(
- #dummy::Group::new(#dummy::Delimiter::Brace, output),
+ #pub_name::TokenTree::Group(
+ #pub_name::Group::new(#pub_name::Delimiter::Brace, output),
),
])),
),
])
}
+ #attrs
+ #[proc_macro]
+ pub fn #pub_name(input: #pub_name::TokenStream) -> #pub_name::TokenStream {
+ #name(input)
+ }
+
fn #name #body
}
}
-fn actual_proc_macro_name(conceptual: &Ident) -> Ident {
+fn pub_proc_macro_name(conceptual: &Ident) -> Ident {
Ident::new(
&format!("proc_macro_hack_{}", conceptual),
conceptual.span(),
)
}
+fn hacked_proc_macro_name(conceptual: &Ident) -> Ident {
+ Ident::new(
+ &format!("_proc_macro_hack_{}", conceptual),
+ conceptual.span(),
+ )
+}
+
fn dispatch_macro_name(conceptual: &Ident) -> Ident {
Ident::new(
&format!("proc_macro_call_{}", conceptual),
diff --git a/src/parse.rs b/src/parse.rs
index de7c599..fe074f1 100644
--- a/src/parse.rs
+++ b/src/parse.rs
@@ -139,7 +139,10 @@
fn parse_visibility(tokens: Iter) -> Result<Visibility, Error> {
if let Some(TokenTree::Ident(ident)) = tokens.peek() {
if ident.to_string() == "pub" {
- return Ok(Some(tokens.next().unwrap().span()));
+ match tokens.next().unwrap() {
+ TokenTree::Ident(vis) => return Ok(Some(vis)),
+ _ => unreachable!(),
+ }
}
}
Ok(None)
@@ -168,6 +171,7 @@
support_nested: false,
internal_macro_calls: 0,
fake_call_site: false,
+ only_hack_old_rustc: false,
};
while let Some(tt) = tokens.next() {
@@ -185,11 +189,14 @@
TokenTree::Ident(ident) if ident.to_string() == "fake_call_site" => {
args.fake_call_site = true;
}
+ TokenTree::Ident(ident) if ident.to_string() == "only_hack_old_rustc" => {
+ args.only_hack_old_rustc = true;
+ }
_ => {
return Err(Error::new(
tt.span(),
- "expected one of: `support_nested`, `internal_macro_calls`, `fake_call_site`",
- ))
+ "expected one of: `support_nested`, `internal_macro_calls`, `fake_call_site`, `only_hack_old_rustc`",
+ ));
}
}
if tokens.peek().is_none() {
@@ -202,10 +209,12 @@
}
pub(crate) fn parse_define_args(tokens: Iter) -> Result<(), Error> {
- if tokens.peek().is_none() {
- Ok(())
- } else {
- Err(Error::new(Span::call_site(), "unexpected input"))
+ match tokens.peek() {
+ None => Ok(()),
+ Some(token) => Err(Error::new(
+ token.span(),
+ "unexpected argument to proc_macro_hack macro implementation; args are only accepted on the macro declaration (the `pub use`)",
+ )),
}
}
diff --git a/tests/ui/unexpected-arg.rs b/tests/ui/unexpected-arg.rs
new file mode 100644
index 0000000..376fc0d
--- /dev/null
+++ b/tests/ui/unexpected-arg.rs
@@ -0,0 +1,8 @@
+use proc_macro_hack::proc_macro_hack;
+
+#[proc_macro_hack(fake_call_site)]
+pub fn my_macro(input: TokenStream) -> TokenStream {
+ unimplemented!()
+}
+
+fn main() {}
diff --git a/tests/ui/unexpected-arg.stderr b/tests/ui/unexpected-arg.stderr
new file mode 100644
index 0000000..6895e82
--- /dev/null
+++ b/tests/ui/unexpected-arg.stderr
@@ -0,0 +1,5 @@
+error: unexpected argument to proc_macro_hack macro implementation; args are only accepted on the macro declaration (the `pub use`)
+ --> $DIR/unexpected-arg.rs:3:19
+ |
+3 | #[proc_macro_hack(fake_call_site)]
+ | ^^^^^^^^^^^^^^
diff --git a/tests/ui/unknown-arg.stderr b/tests/ui/unknown-arg.stderr
index d3cd8c9..ffe3705 100644
--- a/tests/ui/unknown-arg.stderr
+++ b/tests/ui/unknown-arg.stderr
@@ -1,4 +1,4 @@
-error: expected one of: `support_nested`, `internal_macro_calls`, `fake_call_site`
+error: expected one of: `support_nested`, `internal_macro_calls`, `fake_call_site`, `only_hack_old_rustc`
--> $DIR/unknown-arg.rs:3:35
|
3 | #[proc_macro_hack(fake_call_site, support_nexted)]
