Skip to content

Commit 956e2bc

Browse files
borsbors
committed
Auto merge of #39572 - jseyfried:fix_inert_attributes, r=nrc
macros: fix inert attributes from `proc_macro_derives` with `#![feature(proc_macro)]` This PR refactors collection of `proc_macro_derive` invocations to fix #39347. After this PR, the input to a `#[proc_macro_derive]` function no longer sees `#[derive]`s on the underlying item. For example, consider: ```rust extern crate my_derives; use my_derives::{Trait, Trait2}; #[derive(Copy, Clone)] #[derive(Trait)] #[derive(Trait2)] struct S; ``` Today, the input to the `Trait` derive is `#[derive(Copy, Clone, Trait2)] struct S;`, and the input to the `Trait2` derive is `#[derive(Copy, Clone)] struct S;`. More generally, a `proc_macro_derive` sees all builtin derives, as well as all `proc_macro_derive`s listed *after* the one being invoked. After this PR, both `Trait` and `Trait2` will see `struct S;`. This is a [breaking-change], but I believe it is highly unlikely to cause breakage in practice. r? @nrc
2 parents 81bd267 + 2cc61ee commit 956e2bc

File tree

18 files changed

+325
-313
lines changed

18 files changed

+325
-313
lines changed

‎src/librustc_metadata/creader.rs

+3-4
Original file line numberDiff line numberDiff line change
@@ -616,10 +616,9 @@ impl<'a> CrateLoader<'a> {
616616
trait_name: &str,
617617
expand: fn(TokenStream) -> TokenStream,
618618
attributes: &[&'static str]) {
619-
let attrs = attributes.iter().cloned().map(Symbol::intern).collect();
620-
let derive = SyntaxExtension::ProcMacroDerive(
621-
Box::new(ProcMacroDerive::new(expand, attrs))
622-
);
619+
let attrs = attributes.iter().cloned().map(Symbol::intern).collect::<Vec<_>>();
620+
let derive = ProcMacroDerive::new(expand, attrs.clone());
621+
let derive = SyntaxExtension::ProcMacroDerive(Box::new(derive), attrs);
623622
self.0.push((Symbol::intern(trait_name), Rc::new(derive)));
624623
}
625624

‎src/librustc_resolve/macros.rs

+62-14
Original file line numberDiff line numberDiff line change
@@ -27,10 +27,10 @@ use syntax::ext::base::{NormalTT, Resolver as SyntaxResolver, SyntaxExtension};
2727
use syntax::ext::expand::{Expansion, mark_tts};
2828
use syntax::ext::hygiene::Mark;
2929
use syntax::ext::tt::macro_rules;
30-
use syntax::feature_gate::{emit_feature_err, GateIssue, is_builtin_attr};
30+
use syntax::feature_gate::{self, emit_feature_err, GateIssue};
3131
use syntax::fold::{self, Folder};
3232
use syntax::ptr::P;
33-
use syntax::symbol::keywords;
33+
use syntax::symbol::{Symbol, keywords};
3434
use syntax::util::lev_distance::find_best_match_for_name;
3535
use syntax::visit::Visitor;
3636
use syntax_pos::{Span, DUMMY_SP};
@@ -130,12 +130,16 @@ impl<'a> base::Resolver for Resolver<'a> {
130130
self.whitelisted_legacy_custom_derives.contains(&name)
131131
}
132132

133-
fn visit_expansion(&mut self, mark: Mark, expansion: &Expansion) {
133+
fn visit_expansion(&mut self, mark: Mark, expansion: &Expansion, derives: &[Mark]) {
134134
let invocation = self.invocations[&mark];
135135
self.collect_def_ids(invocation, expansion);
136136

137137
self.current_module = invocation.module.get();
138138
self.current_module.unresolved_invocations.borrow_mut().remove(&mark);
139+
self.current_module.unresolved_invocations.borrow_mut().extend(derives);
140+
for &derive in derives {
141+
self.invocations.insert(derive, invocation);
142+
}
139143
let mut visitor = BuildReducedGraphVisitor {
140144
resolver: self,
141145
legacy_scope: LegacyScope::Invocation(invocation),
@@ -172,7 +176,9 @@ impl<'a> base::Resolver for Resolver<'a> {
172176
ImportResolver { resolver: self }.resolve_imports()
173177
}
174178

175-
fn find_attr_invoc(&mut self, attrs: &mut Vec<ast::Attribute>) -> Option<ast::Attribute> {
179+
// Resolves attribute and derive legacy macros from `#![plugin(..)]`.
180+
fn find_legacy_attr_invoc(&mut self, attrs: &mut Vec<ast::Attribute>)
181+
-> Option<ast::Attribute> {
176182
for i in 0..attrs.len() {
177183
match self.builtin_macros.get(&attrs[i].name()).cloned() {
178184
Some(binding) => match *binding.get_macro(self) {
@@ -183,11 +189,50 @@ impl<'a> base::Resolver for Resolver<'a> {
183189
},
184190
None => {}
185191
}
192+
}
186193

187-
if self.proc_macro_enabled && !is_builtin_attr(&attrs[i]) {
188-
return Some(attrs.remove(i));
194+
// Check for legacy derives
195+
for i in 0..attrs.len() {
196+
if attrs[i].name() == "derive" {
197+
let mut traits = match attrs[i].meta_item_list() {
198+
Some(traits) if !traits.is_empty() => traits.to_owned(),
199+
_ => continue,
200+
};
201+
202+
for j in 0..traits.len() {
203+
let legacy_name = Symbol::intern(&match traits[j].word() {
204+
Some(..) => format!("derive_{}", traits[j].name().unwrap()),
205+
None => continue,
206+
});
207+
if !self.builtin_macros.contains_key(&legacy_name) {
208+
continue
209+
}
210+
let span = traits.remove(j).span;
211+
self.gate_legacy_custom_derive(legacy_name, span);
212+
if traits.is_empty() {
213+
attrs.remove(i);
214+
} else {
215+
attrs[i].value = ast::MetaItem {
216+
name: attrs[i].name(),
217+
span: attrs[i].span,
218+
node: ast::MetaItemKind::List(traits),
219+
};
220+
}
221+
return Some(ast::Attribute {
222+
value: ast::MetaItem {
223+
name: legacy_name,
224+
span: span,
225+
node: ast::MetaItemKind::Word,
226+
},
227+
id: attr::mk_attr_id(),
228+
style: ast::AttrStyle::Outer,
229+
is_sugared_doc: false,
230+
span: span,
231+
});
232+
}
189233
}
190234
}
235+
191236
None
192237
}
193238

@@ -236,7 +281,7 @@ impl<'a> base::Resolver for Resolver<'a> {
236281
Ok(binding) => Ok(binding.get_macro(self)),
237282
Err(Determinacy::Undetermined) if !force => return Err(Determinacy::Undetermined),
238283
_ => {
239-
let msg = format!("macro undefined: '{}!'", name);
284+
let msg = format!("macro undefined: `{}`", name);
240285
let mut err = self.session.struct_span_err(span, &msg);
241286
self.suggest_macro_name(&name.as_str(), &mut err);
242287
err.emit();
@@ -251,13 +296,6 @@ impl<'a> base::Resolver for Resolver<'a> {
251296
result
252297
}
253298

254-
fn resolve_builtin_macro(&mut self, tname: Name) -> Result<Rc<SyntaxExtension>, Determinacy> {
255-
match self.builtin_macros.get(&tname).cloned() {
256-
Some(binding) => Ok(binding.get_macro(self)),
257-
None => Err(Determinacy::Undetermined),
258-
}
259-
}
260-
261299
fn resolve_derive_macro(&mut self, scope: Mark, path: &ast::Path, force: bool)
262300
-> Result<Rc<SyntaxExtension>, Determinacy> {
263301
let ast::Path { span, .. } = *path;
@@ -540,4 +578,14 @@ impl<'a> Resolver<'a> {
540578
`use {}::{};`", crate_name, name))
541579
.emit();
542580
}
581+
582+
fn gate_legacy_custom_derive(&mut self, name: Symbol, span: Span) {
583+
if !self.session.features.borrow().custom_derive {
584+
let sess = &self.session.parse_sess;
585+
let explain = feature_gate::EXPLAIN_CUSTOM_DERIVE;
586+
emit_feature_err(sess, "custom_derive", span, GateIssue::Language, explain);
587+
} else if !self.is_whitelisted_legacy_custom_derive(name) {
588+
self.session.span_warn(span, feature_gate::EXPLAIN_DEPR_CUSTOM_DERIVE);
589+
}
590+
}
543591
}

‎src/libsyntax/ext/base.rs

+6-9
Original file line numberDiff line numberDiff line change
@@ -514,7 +514,7 @@ pub enum SyntaxExtension {
514514
/// The input is the annotated item.
515515
/// Allows generating code to implement a Trait for a given struct
516516
/// or enum item.
517-
ProcMacroDerive(Box<MultiItemModifier>),
517+
ProcMacroDerive(Box<MultiItemModifier>, Vec<Symbol> /* inert attribute names */),
518518

519519
/// An attribute-like procedural macro that derives a builtin trait.
520520
BuiltinDerive(BuiltinDeriveFn),
@@ -528,15 +528,15 @@ pub trait Resolver {
528528
fn eliminate_crate_var(&mut self, item: P<ast::Item>) -> P<ast::Item>;
529529
fn is_whitelisted_legacy_custom_derive(&self, name: Name) -> bool;
530530

531-
fn visit_expansion(&mut self, mark: Mark, expansion: &Expansion);
531+
fn visit_expansion(&mut self, mark: Mark, expansion: &Expansion, derives: &[Mark]);
532532
fn add_ext(&mut self, ident: ast::Ident, ext: Rc<SyntaxExtension>);
533533
fn add_expansions_at_stmt(&mut self, id: ast::NodeId, macros: Vec<Mark>);
534534

535535
fn resolve_imports(&mut self);
536-
fn find_attr_invoc(&mut self, attrs: &mut Vec<Attribute>) -> Option<Attribute>;
536+
// Resolves attribute and derive legacy macros from `#![plugin(..)]`.
537+
fn find_legacy_attr_invoc(&mut self, attrs: &mut Vec<Attribute>) -> Option<Attribute>;
537538
fn resolve_macro(&mut self, scope: Mark, path: &ast::Path, force: bool)
538539
-> Result<Rc<SyntaxExtension>, Determinacy>;
539-
fn resolve_builtin_macro(&mut self, tname: Name) -> Result<Rc<SyntaxExtension>, Determinacy>;
540540
fn resolve_derive_macro(&mut self, scope: Mark, path: &ast::Path, force: bool)
541541
-> Result<Rc<SyntaxExtension>, Determinacy>;
542542
}
@@ -555,19 +555,16 @@ impl Resolver for DummyResolver {
555555
fn eliminate_crate_var(&mut self, item: P<ast::Item>) -> P<ast::Item> { item }
556556
fn is_whitelisted_legacy_custom_derive(&self, _name: Name) -> bool { false }
557557

558-
fn visit_expansion(&mut self, _invoc: Mark, _expansion: &Expansion) {}
558+
fn visit_expansion(&mut self, _invoc: Mark, _expansion: &Expansion, _derives: &[Mark]) {}
559559
fn add_ext(&mut self, _ident: ast::Ident, _ext: Rc<SyntaxExtension>) {}
560560
fn add_expansions_at_stmt(&mut self, _id: ast::NodeId, _macros: Vec<Mark>) {}
561561

562562
fn resolve_imports(&mut self) {}
563-
fn find_attr_invoc(&mut self, _attrs: &mut Vec<Attribute>) -> Option<Attribute> { None }
563+
fn find_legacy_attr_invoc(&mut self, _attrs: &mut Vec<Attribute>) -> Option<Attribute> { None }
564564
fn resolve_macro(&mut self, _scope: Mark, _path: &ast::Path, _force: bool)
565565
-> Result<Rc<SyntaxExtension>, Determinacy> {
566566
Err(Determinacy::Determined)
567567
}
568-
fn resolve_builtin_macro(&mut self, _tname: Name) -> Result<Rc<SyntaxExtension>, Determinacy> {
569-
Err(Determinacy::Determined)
570-
}
571568
fn resolve_derive_macro(&mut self, _scope: Mark, _path: &ast::Path, _force: bool)
572569
-> Result<Rc<SyntaxExtension>, Determinacy> {
573570
Err(Determinacy::Determined)

0 commit comments

Comments
 (0)