Rollup merge of rust-lang#154049 - petrochenkov:deleglobspan, r=jackh726

delegation: Track more precise spans for glob delegations

The last commit also fixes a macro hygiene issue with `self` in delegations found in rust-lang#154002.

Author: JonathanBrouwer

compiler/rustc_ast/src/ast.rs

@@ -3901,12 +3901,17 @@ pub struct Delegation {
     pub from_glob: bool,
 }
 
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
+pub enum DelegationSuffixes {
+    List(ThinVec<(Ident, Option<Ident>)>),
+    Glob(Span),
+}
+
 #[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub struct DelegationMac {
     pub qself: Option<Box<QSelf>>,
     pub prefix: Path,
-    // Some for list delegation, and None for glob delegation.
-    pub suffixes: Option<ThinVec<(Ident, Option<Ident>)>>,
+    pub suffixes: DelegationSuffixes,
     pub body: Option<Box<Block>>,
 }
 

compiler/rustc_ast/src/visit.rs

@@ -430,6 +430,7 @@ macro_rules! common_visitor_and_walkers {
             Defaultness,
             Delegation,
             DelegationMac,
+            DelegationSuffixes,
             DelimArgs,
             DelimSpan,
             EnumDef,

compiler/rustc_ast_pretty/src/pprust/state/item.rs

@@ -435,7 +435,10 @@ impl<'a> State<'a> {
                 &item.vis,
                 &deleg.qself,
                 &deleg.prefix,
-                deleg.suffixes.as_ref().map_or(DelegationKind::Glob, |s| DelegationKind::List(s)),
+                match &deleg.suffixes {
+                    ast::DelegationSuffixes::List(s) => DelegationKind::List(s),
+                    ast::DelegationSuffixes::Glob(_) => DelegationKind::Glob,
+                },
                 &deleg.body,
             ),
         }
@@ -641,7 +644,10 @@ impl<'a> State<'a> {
                 vis,
                 &deleg.qself,
                 &deleg.prefix,
-                deleg.suffixes.as_ref().map_or(DelegationKind::Glob, |s| DelegationKind::List(s)),
+                match &deleg.suffixes {
+                    ast::DelegationSuffixes::List(s) => DelegationKind::List(s),
+                    ast::DelegationSuffixes::Glob(_) => DelegationKind::Glob,
+                },
                 &deleg.body,
             ),
         }

compiler/rustc_expand/src/base.rs

@@ -1019,26 +1019,32 @@ impl SyntaxExtension {
     pub fn glob_delegation(
         trait_def_id: DefId,
         impl_def_id: LocalDefId,
+        star_span: Span,
         edition: Edition,
     ) -> SyntaxExtension {
         struct GlobDelegationExpanderImpl {
             trait_def_id: DefId,
             impl_def_id: LocalDefId,
+            star_span: Span,
         }
         impl GlobDelegationExpander for GlobDelegationExpanderImpl {
             fn expand(
                 &self,
                 ecx: &mut ExtCtxt<'_>,
             ) -> ExpandResult<Vec<(Ident, Option<Ident>)>, ()> {
-                match ecx.resolver.glob_delegation_suffixes(self.trait_def_id, self.impl_def_id) {
+                match ecx.resolver.glob_delegation_suffixes(
+                    self.trait_def_id,
+                    self.impl_def_id,
+                    self.star_span,
+                ) {
                     Ok(suffixes) => ExpandResult::Ready(suffixes),
                     Err(Indeterminate) if ecx.force_mode => ExpandResult::Ready(Vec::new()),
                     Err(Indeterminate) => ExpandResult::Retry(()),
                 }
             }
         }
 
-        let expander = GlobDelegationExpanderImpl { trait_def_id, impl_def_id };
+        let expander = GlobDelegationExpanderImpl { trait_def_id, impl_def_id, star_span };
         SyntaxExtension::default(SyntaxExtensionKind::GlobDelegation(Arc::new(expander)), edition)
     }
 
@@ -1170,6 +1176,7 @@ pub trait ResolverExpand {
         &self,
         trait_def_id: DefId,
         impl_def_id: LocalDefId,
+        star_span: Span,
     ) -> Result<Vec<(Ident, Option<Ident>)>, Indeterminate>;
 
     /// Record the name of an opaque `Ty::ImplTrait` pre-expansion so that it can be used

compiler/rustc_expand/src/expand.rs

@@ -8,9 +8,9 @@ use rustc_ast::tokenstream::TokenStream;
 use rustc_ast::visit::{self, AssocCtxt, Visitor, VisitorResult, try_visit, walk_list};
 use rustc_ast::{
     self as ast, AssocItemKind, AstNodeWrapper, AttrArgs, AttrItemKind, AttrStyle, AttrVec,
-    DUMMY_NODE_ID, EarlyParsedAttribute, ExprKind, ForeignItemKind, HasAttrs, HasNodeId, Inline,
-    ItemKind, MacStmtStyle, MetaItemInner, MetaItemKind, ModKind, NodeId, PatKind, StmtKind,
-    TyKind, token,
+    DUMMY_NODE_ID, DelegationSuffixes, EarlyParsedAttribute, ExprKind, ForeignItemKind, HasAttrs,
+    HasNodeId, Inline, ItemKind, MacStmtStyle, MetaItemInner, MetaItemKind, ModKind, NodeId,
+    PatKind, StmtKind, TyKind, token,
 };
 use rustc_ast_pretty::pprust;
 use rustc_attr_parsing::parser::AllowExprMetavar;
@@ -2401,7 +2401,7 @@ impl<'a, 'b> InvocationCollector<'a, 'b> {
                     res
                 }
                 None if let Some((deleg, item)) = node.delegation() => {
-                    let Some(suffixes) = &deleg.suffixes else {
+                    let DelegationSuffixes::List(suffixes) = &deleg.suffixes else {
                         let traitless_qself =
                             matches!(&deleg.qself, Some(qself) if qself.position == 0);
                         let (item, of_trait) = match node.to_annotatable() {

compiler/rustc_parse/src/parser/item.rs

@@ -857,7 +857,7 @@ impl<'a> Parser<'a> {
             kind: AssocItemKind::DelegationMac(Box::new(DelegationMac {
                 qself: None,
                 prefix: of_trait.trait_ref.path.clone(),
-                suffixes: None,
+                suffixes: DelegationSuffixes::Glob(whole_reuse_span),
                 body,
             })),
         }));
@@ -879,10 +879,12 @@ impl<'a> Parser<'a> {
 
         Ok(if self.eat_path_sep() {
             let suffixes = if self.eat(exp!(Star)) {
-                None
+                DelegationSuffixes::Glob(self.prev_token.span)
             } else {
                 let parse_suffix = |p: &mut Self| Ok((p.parse_path_segment_ident()?, rename(p)?));
-                Some(self.parse_delim_comma_seq(exp!(OpenBrace), exp!(CloseBrace), parse_suffix)?.0)
+                DelegationSuffixes::List(
+                    self.parse_delim_comma_seq(exp!(OpenBrace), exp!(CloseBrace), parse_suffix)?.0,
+                )
             };
 
             ItemKind::DelegationMac(Box::new(DelegationMac {
@@ -1517,7 +1519,10 @@ impl<'a> Parser<'a> {
         let span = self.psess.source_map().guess_head_span(span);
         let descr = kind.descr();
         let help = match kind {
-            ItemKind::DelegationMac(deleg) if deleg.suffixes.is_none() => false,
+            ItemKind::DelegationMac(box DelegationMac {
+                suffixes: DelegationSuffixes::Glob(_),
+                ..
+            }) => false,
             _ => true,
         };
         self.dcx().emit_err(errors::BadItemKind { span, descr, ctx, help });

compiler/rustc_resolve/src/late.rs

@@ -3873,8 +3873,7 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
 
         let Some(body) = &delegation.body else { return };
         self.with_rib(ValueNS, RibKind::FnOrCoroutine, |this| {
-            let span = delegation.path.segments.last().unwrap().ident.span;
-            let ident = Ident::new(kw::SelfLower, span.normalize_to_macro_rules());
+            let ident = Ident::new(kw::SelfLower, body.span.normalize_to_macro_rules());
             let res = Res::Local(delegation.id);
             this.innermost_rib_bindings(ValueNS).insert(ident, res);
 

compiler/rustc_resolve/src/macros.rs

@@ -4,7 +4,7 @@
 use std::mem;
 use std::sync::Arc;
 
-use rustc_ast::{self as ast, Crate, DUMMY_NODE_ID, NodeId};
+use rustc_ast::{self as ast, Crate, DUMMY_NODE_ID, DelegationSuffixes, NodeId};
 use rustc_ast_pretty::pprust;
 use rustc_attr_parsing::AttributeParser;
 use rustc_errors::{Applicability, DiagCtxtHandle, StashKey};
@@ -286,7 +286,8 @@ impl<'ra, 'tcx> ResolverExpand for Resolver<'ra, 'tcx> {
             InvocationKind::Derive { ref path, .. } => (path, MacroKind::Derive),
             InvocationKind::GlobDelegation { ref item, .. } => {
                 let ast::AssocItemKind::DelegationMac(deleg) = &item.kind else { unreachable!() };
-                deleg_impl = Some(self.invocation_parent(invoc_id));
+                let DelegationSuffixes::Glob(star_span) = deleg.suffixes else { unreachable!() };
+                deleg_impl = Some((self.invocation_parent(invoc_id), star_span));
                 // It is sufficient to consider glob delegation a bang macro for now.
                 (&deleg.prefix, MacroKind::Bang)
             }
@@ -530,6 +531,7 @@ impl<'ra, 'tcx> ResolverExpand for Resolver<'ra, 'tcx> {
         &self,
         trait_def_id: DefId,
         impl_def_id: LocalDefId,
+        star_span: Span,
     ) -> Result<Vec<(Ident, Option<Ident>)>, Indeterminate> {
         let target_trait = self.expect_module(trait_def_id);
         if !target_trait.unexpanded_invocations.borrow().is_empty() {
@@ -549,13 +551,13 @@ impl<'ra, 'tcx> ResolverExpand for Resolver<'ra, 'tcx> {
 
         let mut idents = Vec::new();
         target_trait.for_each_child(self, |this, ident, orig_ident_span, ns, _binding| {
-            // FIXME: Adjust hygiene for idents from globs, like for glob imports.
             if let Some(overriding_keys) = this.impl_binding_keys.get(&impl_def_id)
                 && overriding_keys.contains(&BindingKey::new(ident, ns))
             {
                 // The name is overridden, do not produce it from the glob delegation.
             } else {
-                idents.push((ident.orig(orig_ident_span), None));
+                // FIXME: Adjust hygiene for idents from globs, like for glob imports.
+                idents.push((ident.orig(star_span.with_ctxt(orig_ident_span.ctxt())), None));
             }
         });
         Ok(idents)
@@ -579,7 +581,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         parent_scope: &ParentScope<'ra>,
         node_id: NodeId,
         force: bool,
-        deleg_impl: Option<LocalDefId>,
+        deleg_impl: Option<(LocalDefId, Span)>,
         invoc_in_mod_inert_attr: Option<LocalDefId>,
         suggestion_span: Option<Span>,
     ) -> Result<(Arc<SyntaxExtension>, Res), Indeterminate> {
@@ -771,7 +773,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         kind: MacroKind,
         parent_scope: &ParentScope<'ra>,
         force: bool,
-        deleg_impl: Option<LocalDefId>,
+        deleg_impl: Option<(LocalDefId, Span)>,
         invoc_in_mod_inert_attr: Option<(LocalDefId, NodeId)>,
         ignore_import: Option<Import<'ra>>,
         suggestion_span: Option<Span>,
@@ -856,10 +858,15 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
 
         let res = res?;
         let ext = match deleg_impl {
-            Some(impl_def_id) => match res {
+            Some((impl_def_id, star_span)) => match res {
                 def::Res::Def(DefKind::Trait, def_id) => {
                     let edition = self.tcx.sess.edition();
-                    Some(Arc::new(SyntaxExtension::glob_delegation(def_id, impl_def_id, edition)))
+                    Some(Arc::new(SyntaxExtension::glob_delegation(
+                        def_id,
+                        impl_def_id,
+                        star_span,
+                        edition,
+                    )))
                 }
                 _ => None,
             },

tests/ui/delegation/generics/query-cycle-oom-154169.rs

@@ -20,7 +20,6 @@ mod test_2 {
     trait Trait {
         fn foo() -> Self::Assoc;
         //~^ ERROR: associated type `Assoc` not found for `Self`
-        //~| ERROR: this function takes 0 arguments but 1 argument was supplied
         fn bar(&self) -> u8;
     }
 
@@ -33,20 +32,21 @@ mod test_2 {
 
     impl Trait for S {
         reuse Trait::* { &self.0 }
+        //~^ ERROR this function takes 0 arguments but 1 argument was supplied
         fn bar(&self) -> u8 { 2 }
     }
 }
 
 mod test_3 {
     trait Trait {
         fn foo(&self) -> Self::Assoc<3> { //~ ERROR: associated type `Assoc` not found for `Self`
-        //~^ ERROR: no method named `foo` found for reference `&()` in the current scope
             [(); 3]
         }
     }
 
     impl () { //~ ERROR: cannot define inherent `impl` for primitive types
         reuse Trait::*;
+        //~^ ERROR no method named `foo` found for reference `&()` in the current scope
     }
 }
 

tests/ui/delegation/generics/query-cycle-oom-154169.stderr

@@ -27,7 +27,7 @@ LL |         fn foo(&self) -> Self::Assoc<3> {
    |                                ^^^^^ associated type `Assoc` not found
 
 error[E0046]: not all trait items implemented, missing: `foo`
-  --> $DIR/query-cycle-oom-154169.rs:27:5
+  --> $DIR/query-cycle-oom-154169.rs:26:5
    |
 LL |         fn foo() -> Self::Assoc;
    |         ------------------------ `foo` from trait
@@ -36,7 +36,7 @@ LL |     impl Trait for u8 {
    |     ^^^^^^^^^^^^^^^^^ missing `foo` in implementation
 
 error[E0390]: cannot define inherent `impl` for primitive types
-  --> $DIR/query-cycle-oom-154169.rs:48:5
+  --> $DIR/query-cycle-oom-154169.rs:47:5
    |
 LL |     impl () {
    |     ^^^^^^^
@@ -52,13 +52,10 @@ LL |         reuse to_reuse::foo { &self.0 }
    = help: you might be missing a crate named `to_reuse`
 
 error[E0061]: this function takes 0 arguments but 1 argument was supplied
-  --> $DIR/query-cycle-oom-154169.rs:21:12
+  --> $DIR/query-cycle-oom-154169.rs:34:22
    |
-LL |         fn foo() -> Self::Assoc;
-   |            ^^^
-...
 LL |         reuse Trait::* { &self.0 }
-   |                          ------- unexpected argument
+   |                      ^   ------- unexpected argument
    |
 note: associated function defined here
   --> $DIR/query-cycle-oom-154169.rs:21:12
@@ -67,29 +64,15 @@ LL |         fn foo() -> Self::Assoc;
    |            ^^^
 help: remove the extra argument
    |
-LL -         fn foo() -> Self::Assoc;
-LL -
-LL -
-LL -         fn bar(&self) -> u8;
-LL -     }
-LL - 
-LL -     impl Trait for u8 {
-LL -
-LL -         fn bar(&self) -> u8 { 1 }
-LL -     }
-LL - 
-LL -     struct S(u8);
-LL - 
-LL -     impl Trait for S {
 LL -         reuse Trait::* { &self.0 }
-LL +         fn fo&self.0 }
+LL +         reuse Trait::&self.0 }
    |
 
 error[E0599]: no method named `foo` found for reference `&()` in the current scope
-  --> $DIR/query-cycle-oom-154169.rs:42:12
+  --> $DIR/query-cycle-oom-154169.rs:48:22
    |
-LL |         fn foo(&self) -> Self::Assoc<3> {
-   |            ^^^ method not found in `&()`
+LL |         reuse Trait::*;
+   |                      ^ method not found in `&()`
    |
    = help: items from traits can only be used if the trait is implemented and in scope
    = note: the following traits define an item `foo`, perhaps you need to implement one of them: