Rollup of 14 pull requests

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_codegen_ssa/src/back/archive.rs

@@ -1,18 +1,16 @@
+use std::env;
 use std::error::Error;
 use std::ffi::OsString;
 use std::fs::{self, File};
 use std::io::{self, BufWriter, Write};
 use std::path::{Path, PathBuf};
-use std::{env, mem};
 
 use ar_archive_writer::{
     ArchiveKind, COFFShortExport, MachineTypes, NewArchiveMember, write_archive_to_stream,
 };
 pub use ar_archive_writer::{DEFAULT_OBJECT_READER, ObjectReader};
 use object::read::archive::{ArchiveFile, ArchiveKind as ObjectArchiveKind};
-use object::read::elf::Sym as _;
-use object::read::macho::{FatArch, Nlist};
-use object::{Endianness, elf, macho};
+use object::read::macho::FatArch;
 use rustc_data_structures::fx::{FxHashSet, FxIndexSet};
 use rustc_data_structures::memmap::Mmap;
 use rustc_fs_util::TempDirBuilder;
@@ -24,6 +22,7 @@ use tracing::trace;
 
 use super::metadata::{create_compressed_metadata_file, search_for_section};
 use super::rmeta_link;
+use super::symbol_edit::apply_hide;
 use crate::common;
 // Public for ArchiveBuilderBuilder::extract_bundled_libs
 pub use crate::errors::ExtractBundledLibsError;
@@ -671,153 +670,3 @@ impl<'a> ArArchiveBuilder<'a> {
 fn io_error_context(context: &str, err: io::Error) -> io::Error {
     io::Error::new(io::ErrorKind::Other, format!("{context}: {err}"))
 }
-
-// We use the `object` crate for the read-only pass over ELF/Mach-O object files
-// because its `Sym`/`Nlist` traits provide clean access to symbol properties without
-// manual byte parsing. However, `object` does not expose mutable views into the data,
-// so we cannot use it to modify symbol fields in place. Instead, the read-only pass
-// collects byte-level patches (offset + new value), and the write pass
-// (`apply_patches`) applies them to a copy of the byte buffer without any ELF/Mach-O
-// parsing — similar to how linker relocations work.
-
-/// A byte-level patch collected in the read-only pass and applied in the write pass.
-struct Patch {
-    offset: usize,
-    value: u8,
-}
-
-/// Apply a list of byte patches to `data`, returning the (possibly modified) bytes.
-fn apply_patches(data: &[u8], patches: &[Patch]) -> Vec<u8> {
-    let mut buf = data.to_vec();
-    for p in patches {
-        buf[p.offset] = p.value;
-    }
-    buf
-}
-
-// ---------------------------------------------------------------------------
-// ELF hide – read-only pass uses `object` crate, write pass uses `Patch` list
-// ---------------------------------------------------------------------------
-
-fn elf_hide_patches_impl<'data, Elf: object::read::elf::FileHeader<Endian = Endianness>>(
-    data: &'data [u8],
-    st_other_offset: usize,
-    exported: &FxHashSet<String>,
-) -> Option<Vec<Patch>>
-where
-    u64: From<Elf::Word>,
-{
-    let header = Elf::parse(data).ok()?;
-    let endian = header.endian().ok()?;
-    let sections = header.sections(endian, data).ok()?;
-    let symtab = sections.symbols(endian, data, elf::SHT_SYMTAB).ok()?;
-
-    let data_ptr = data.as_ptr() as usize;
-    let strings = symtab.strings();
-    let mut patches = Vec::new();
-
-    for sym in symtab.iter() {
-        let binding = sym.st_bind();
-        if binding != elf::STB_GLOBAL && binding != elf::STB_WEAK {
-            continue;
-        }
-        if sym.is_undefined(endian) {
-            continue;
-        }
-        let Ok(name_bytes) = sym.name(endian, strings) else { continue };
-        let Ok(name) = str::from_utf8(name_bytes) else { continue };
-        if !exported.contains(name) {
-            let sym_addr = sym as *const Elf::Sym as usize;
-            let offset = sym_addr - data_ptr + st_other_offset;
-            let new_vis = (sym.st_other() & !0x03) | elf::STV_HIDDEN;
-            patches.push(Patch { offset, value: new_vis });
-        }
-    }
-
-    Some(patches)
-}
-
-// ---------------------------------------------------------------------------
-// Mach-O hide – same architecture: read-only pass via `object`, write via patches
-// ---------------------------------------------------------------------------
-
-fn macho_hide_patches_impl<'data, Mach: object::read::macho::MachHeader<Endian = Endianness>>(
-    data: &'data [u8],
-    n_type_offset: usize,
-    exported: &FxHashSet<String>,
-) -> Option<Vec<Patch>> {
-    let header = Mach::parse(data, 0).ok()?;
-    let endian = header.endian().ok()?;
-    let mut commands = header.load_commands(endian, data, 0).ok()?;
-
-    let symtab_cmd = loop {
-        let cmd = commands.next().ok()??;
-        if let Some(st) = cmd.symtab().ok().flatten() {
-            break st;
-        }
-    };
-    let symtab: object::read::macho::SymbolTable<'_, Mach, &_> =
-        symtab_cmd.symbols(endian, data).ok()?;
-
-    let data_ptr = data.as_ptr() as usize;
-    let strings = symtab.strings();
-    let mut patches = Vec::new();
-
-    for nlist in symtab.iter() {
-        if nlist.is_stab() {
-            continue;
-        }
-        if nlist.is_undefined() {
-            continue;
-        }
-        if nlist.n_type() & macho::N_EXT == 0 {
-            continue;
-        }
-        let Ok(name_bytes) = nlist.name(endian, strings) else { continue };
-        let Ok(name) = str::from_utf8(name_bytes) else { continue };
-        let name = name.strip_prefix('_').unwrap_or(name);
-        if !exported.contains(name) {
-            let nlist_addr = nlist as *const Mach::Nlist as usize;
-            let offset = nlist_addr - data_ptr + n_type_offset;
-            patches.push(Patch { offset, value: nlist.n_type() | macho::N_PEXT });
-        }
-    }
-
-    Some(patches)
-}
-
-// ---------------------------------------------------------------------------
-// Unified dispatch: top-level detection via `object::File::parse`
-// ---------------------------------------------------------------------------
-
-fn hide_patches(data: &[u8], exported: &FxHashSet<String>) -> Option<Vec<Patch>> {
-    let file = object::File::parse(data).ok()?;
-    match file {
-        object::File::Elf64(_) => elf_hide_patches_impl::<elf::FileHeader64<Endianness>>(
-            data,
-            mem::offset_of!(elf::Sym64<Endianness>, st_other),
-            exported,
-        ),
-        object::File::Elf32(_) => elf_hide_patches_impl::<elf::FileHeader32<Endianness>>(
-            data,
-            mem::offset_of!(elf::Sym32<Endianness>, st_other),
-            exported,
-        ),
-        object::File::MachO64(_) => macho_hide_patches_impl::<macho::MachHeader64<Endianness>>(
-            data,
-            mem::offset_of!(macho::Nlist64<Endianness>, n_type),
-            exported,
-        ),
-        object::File::MachO32(_) => macho_hide_patches_impl::<macho::MachHeader32<Endianness>>(
-            data,
-            mem::offset_of!(macho::Nlist32<Endianness>, n_type),
-            exported,
-        ),
-        _ => None,
-    }
-}
-
-fn apply_hide(data: &[u8], exported: &FxHashSet<String>) -> Vec<u8> {
-    let patches = hide_patches(data, exported).unwrap_or_default();
-    apply_patches(data, &patches)
-}

compiler/rustc_codegen_ssa/src/back/mod.rs

@@ -11,6 +11,7 @@ pub mod lto;
 pub mod metadata;
 pub mod rmeta_link;
 pub(crate) mod rpath;
+mod symbol_edit;
 pub mod symbol_export;
 pub mod write;