Auto merge of #157726 - jhpratt:rollup-UIfbKIF, r=jhpratt

Rollup of 23 pull requests

Successful merges:

 - #157280 (traits: Allow escaping self types in ExistentialTraitRef::with_self_ty)
 - #157282 (Fix post-monomorphization error note race in the parallel frontend)
 - #157352 (Make the retained dep graph deterministic under the parallel frontend)
 - #157601 (Emit error for unused target expression in glob and list delegations)
 - #157611 (Update `browser-ui-test` version to `0.24.0`)
 - #157620 (Add a strategy FnMut to inject behavior into the flush cycle)
 - #157645 (Windows TLS - Only register the `atexit` hook when `cleanup` can be unloaded)
 - #157647 (Start using comptime for reflection intrinsics and their wrapper functions)
 - #157719 (resolve: Partially revert "Remove a special case for dummy imports")
 - #156497 (fix-155516: Don't suggest wrong unwrap expect)
 - #156583 (Support defaults for static EIIs)
 - #157013 (Ensure inferred let pattern types are well-formed)
 - #157230 (borrowck: avoid ICE describing fields on generic params)
 - #157288 (platform support: add SNaN erratum to MIPS targets)
 - #157350 (compiletest: ignore SVG `y` offset in by-lines comparison)
 - #157355 (Add `or_try_*` variants for `HashMap` and `BTreeMap` Entry APIs)
 - #157384 (Add `#[rustc_dump_generics]` attribute)
 - #157577 (Fix parser error recovery treating 'dyn' as a strict keyword in Rust 2015 when used in `dyn + dyn`)
 - #157670 (Rename `errors.rs` file to `diagnostics.rs` (4/N))
 - #157691 (Move symbol hiding code to a new file)
 - #157697 (Add more tests that exercise the well-formedness checking of lazy type aliases)
 - #157700 (Rename `errors.rs` file to `diagnostics.rs` (5/N))
 - #157703 (Fix doc link to Instant sub in saturating caveat)

Failed merges:

 - #157699 (Arg splat experiment - hir FnDecl impl)

Author: bors

compiler/rustc_ast/src/ast.rs

@@ -31,7 +31,8 @@ use rustc_data_structures::tagged_ptr::Tag;
 use rustc_macros::{Decodable, Encodable, StableHash, Walkable};
 pub use rustc_span::AttrId;
 use rustc_span::{
-    ByteSymbol, DUMMY_SP, ErrorGuaranteed, Ident, Span, Spanned, Symbol, kw, respan, sym,
+    ByteSymbol, DUMMY_SP, ErrorGuaranteed, Ident, LocalExpnId, Span, Spanned, Symbol, kw, respan,
+    sym,
 };
 use thin_vec::{ThinVec, thin_vec};
 
@@ -3906,10 +3907,10 @@ pub struct EiiImpl {
     pub is_default: bool,
 }
 
-#[derive(Clone, Encodable, Decodable, Debug, Walkable, PartialEq, Eq)]
+#[derive(Clone, Copy, Encodable, Decodable, Debug, PartialEq, Eq)]
 pub enum DelegationSource {
     Single,
-    List,
+    List(LocalExpnId),
     Glob,
 }
 
@@ -3923,6 +3924,7 @@ pub struct Delegation {
     pub rename: Option<Ident>,
     pub body: Option<Box<Block>>,
     /// The item was expanded from a glob delegation item.
+    #[visitable(ignore)]
     pub source: DelegationSource,
 }
 

compiler/rustc_ast/src/visit.rs

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

compiler/rustc_ast_lowering/src/delegation.rs

@@ -62,7 +62,7 @@ use crate::diagnostics::{
 };
 use crate::{
     AllowReturnTypeNotation, ImplTraitContext, ImplTraitPosition, LoweringContext, ParamMode,
-    ResolverAstLoweringExt, index_crate,
+    index_crate,
 };
 
 mod generics;
@@ -126,7 +126,7 @@ pub(crate) fn delegations_resolutions(
         let delegation = ast_index[def_id].delegation().expect("processing delegations");
         let span = delegation.last_segment_span();
 
-        if let Some(info) = resolver.delegation_info(def_id) {
+        if let Some(info) = tcx.resolutions(()).delegation_infos.get(&def_id) {
             let res = info.resolution_id.map(|id| check_for_cycles(tcx, id, span).map(|_| id));
             result.insert(def_id, res.flatten());
         } else {
@@ -143,16 +143,14 @@ pub(crate) fn delegations_resolutions(
 fn check_for_cycles(tcx: TyCtxt<'_>, mut def_id: DefId, span: Span) -> Result<(), ErrorGuaranteed> {
     let mut visited: FxHashSet<DefId> = Default::default();
 
-    let (resolver, _) = &*tcx.hir_crate(()).delayed_resolver.borrow();
-
     loop {
         visited.insert(def_id);
 
         // If def_id is in local crate and it corresponds to another delegation
         // it means that we refer to another delegation as a callee, so in order to obtain
         // a signature DefId we obtain NodeId of the callee delegation and try to get signature from it.
         if let Some(local_id) = def_id.as_local()
-            && let Some(info) = resolver.delegation_info(local_id)
+            && let Some(info) = tcx.resolutions(()).delegation_infos.get(&local_id)
             && let Ok(id) = info.resolution_id
         {
             def_id = id;
@@ -209,17 +207,19 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
         let mut generics = self.uplift_delegation_generics(delegation, sig_id, is_method);
 
-        let (body_id, call_expr_id) =
+        let (body_id, call_expr_id, unused_target_expr) =
             self.lower_delegation_body(delegation, sig_id, param_count, &mut generics, span);
 
         let decl = self.lower_delegation_decl(
+            delegation.source,
             sig_id,
             param_count,
             c_variadic,
             span,
             &generics,
             delegation.id,
             call_expr_id,
+            unused_target_expr,
         );
 
         let sig = self.lower_delegation_sig(sig_id, decl, span);
@@ -375,13 +375,15 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
     fn lower_delegation_decl(
         &mut self,
+        source: DelegationSource,
         sig_id: DefId,
         param_count: usize,
         c_variadic: bool,
         span: Span,
         generics: &GenericsGenerationResults<'hir>,
         call_path_node_id: NodeId,
         call_expr_id: HirId,
+        unused_target_expr: bool,
     ) -> &'hir hir::FnDecl<'hir> {
         // The last parameter in C variadic functions is skipped in the signature,
         // like during regular lowering.
@@ -406,6 +408,17 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     parent_args_segment_id: generics.parent.args_segment_id,
                     self_ty_id: generics.self_ty_id,
                     propagate_self_ty: generics.propagate_self_ty,
+                    group_id: {
+                        let id = match source {
+                            DelegationSource::Single => None,
+                            DelegationSource::List(expn_id) => Some(expn_id),
+                            DelegationSource::Glob => {
+                                Some(self.tcx.expn_that_defined(self.owner.def_id).expect_local())
+                            }
+                        };
+
+                        id.map(|id| (id, unused_target_expr))
+                    },
                 })),
             )),
             span,
@@ -504,16 +517,23 @@ impl<'hir> LoweringContext<'_, 'hir> {
         param_count: usize,
         generics: &mut GenericsGenerationResults<'hir>,
         span: Span,
-    ) -> (BodyId, HirId) {
+    ) -> (BodyId, HirId, bool) {
         let block = delegation.body.as_deref();
         let mut call_expr_id = HirId::INVALID;
+        let mut unused_target_expr = false;
 
         let block_id = self.lower_body(|this| {
             let mut parameters: Vec<hir::Param<'_>> = Vec::with_capacity(param_count);
             let mut args: Vec<hir::Expr<'_>> = Vec::with_capacity(param_count);
             let mut stmts: &[hir::Stmt<'hir>] = &[];
 
             let is_method = this.is_method(sig_id, span);
+            let should_generate_block = this.should_generate_block(delegation, sig_id, is_method);
+
+            // Consider non-specified target expression as generated,
+            // as we do not want to emit error when target expression is
+            // not specified.
+            unused_target_expr = block.is_some() && (param_count == 0 || !should_generate_block);
 
             for idx in 0..param_count {
                 let (param, pat_node_id) = this.generate_param(is_method, idx, span);
@@ -524,7 +544,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
                 let arg = if let Some(block) = block
                     && idx == 0
-                    && this.should_generate_block(delegation, sig_id, is_method)
+                    && should_generate_block
                 {
                     let mut self_resolver = SelfResolver {
                         ctxt: this,
@@ -565,7 +585,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
         debug_assert_ne!(call_expr_id, HirId::INVALID);
 
-        (block_id, call_expr_id)
+        (block_id, call_expr_id, unused_target_expr)
     }
 
     fn finalize_body_lowering(

compiler/rustc_ast_lowering/src/lib.rs

@@ -63,7 +63,7 @@ use rustc_macros::extension;
 use rustc_middle::hir::{self as mid_hir};
 use rustc_middle::queries::Providers;
 use rustc_middle::span_bug;
-use rustc_middle::ty::{DelegationInfo, PerOwnerResolverData, ResolverAstLowering, TyCtxt};
+use rustc_middle::ty::{PerOwnerResolverData, ResolverAstLowering, TyCtxt};
 use rustc_session::errors::add_feature_diagnostics;
 use rustc_span::symbol::{Ident, Symbol, kw, sym};
 use rustc_span::{DUMMY_SP, DesugaringKind, Span};
@@ -307,10 +307,6 @@ impl<'tcx> ResolverAstLowering<'tcx> {
         self.extra_lifetime_params_map.get(&id).map_or(&[], |v| &v[..])
     }
 
-    fn delegation_info(&self, id: LocalDefId) -> Option<&DelegationInfo> {
-        self.delegation_infos.get(&id)
-    }
-
     fn owner_def_id(&self, id: NodeId) -> LocalDefId {
         self.owners[&id].def_id
     }

compiler/rustc_attr_parsing/src/attributes/rustc_dump.rs

@@ -45,6 +45,35 @@ impl SingleAttributeParser for RustcDumpDefPathParser {
     }
 }
 
+pub(crate) struct RustcDumpGenericsParser;
+
+impl NoArgsAttributeParser for RustcDumpGenericsParser {
+    const PATH: &[Symbol] = &[sym::rustc_dump_generics];
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[
+        Allow(Target::Struct),
+        Allow(Target::Enum),
+        Allow(Target::Union),
+        Allow(Target::Trait),
+        Allow(Target::TraitAlias),
+        Allow(Target::Fn),
+        Allow(Target::Closure),
+        Allow(Target::TyAlias),
+        Allow(Target::Const),
+        Allow(Target::AssocConst),
+        Allow(Target::AssocTy),
+        Allow(Target::Impl { of_trait: false }),
+        Allow(Target::Impl { of_trait: true }),
+        Allow(Target::Method(MethodKind::Inherent)),
+        Allow(Target::Method(MethodKind::Trait { body: false })),
+        Allow(Target::Method(MethodKind::Trait { body: true })),
+        Allow(Target::Method(MethodKind::TraitImpl)),
+        Allow(Target::Delegation { mac: false }),
+        Allow(Target::Delegation { mac: true }),
+    ]);
+    const STABILITY: AttributeStability = unstable!(rustc_attrs);
+    const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::RustcDumpGenerics;
+}
+
 pub(crate) struct RustcDumpHiddenTypeOfOpaquesParser;
 
 impl NoArgsAttributeParser for RustcDumpHiddenTypeOfOpaquesParser {

compiler/rustc_attr_parsing/src/context.rs

@@ -278,6 +278,7 @@ attribute_parsers!(
         Single<WithoutArgs<RustcDenyExplicitImplParser>>,
         Single<WithoutArgs<RustcDoNotConstCheckParser>>,
         Single<WithoutArgs<RustcDumpDefParentsParser>>,
+        Single<WithoutArgs<RustcDumpGenericsParser>>,
         Single<WithoutArgs<RustcDumpHiddenTypeOfOpaquesParser>>,
         Single<WithoutArgs<RustcDumpInferredOutlivesParser>>,
         Single<WithoutArgs<RustcDumpItemBoundsParser>>,

compiler/rustc_borrowck/src/diagnostics/mod.rs

@@ -537,9 +537,9 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
                     Some(self.infcx.tcx.hir_name(var_id).to_string())
                 }
                 _ => {
-                    // Might need a revision when the fields in trait RFC is implemented
-                    // (https://github.com/rust-lang/rfcs/pull/1546)
-                    bug!("End-user description not implemented for field access on `{:?}`", ty);
+                    // This can happen for field accesses on `Box<T>`: the field is
+                    // described from the boxed type, which may have no named fields
+                    Some(field.index().to_string())
                 }
             }
         }

compiler/rustc_builtin_macros/src/diagnostics.rs

@@ -1135,8 +1135,9 @@ pub(crate) struct EiiStaticMultipleImplementations {
 }
 
 #[derive(Diagnostic)]
-#[diag("`#[{$name}]` cannot be used on statics with a value")]
-pub(crate) struct EiiStaticDefault {
+#[diag("`#[{$name}]` cannot be used on statics with a value on Apple targets")]
+#[note("see issue #157649 <https://github.com/rust-lang/rust/issues/157649> for more information")]
+pub(crate) struct EiiStaticDefaultApple {
     #[primary_span]
     pub span: Span,
     pub name: String,