Auto merge of #157142 - JonathanBrouwer:rollup-epQjoOE, r=<try>

Rollup of 9 pull requests


try-job: dist-various-1
try-job: test-various
try-job: x86_64-gnu-aux
try-job: x86_64-gnu-llvm-21-3
try-job: x86_64-msvc-1
try-job: aarch64-apple
try-job: x86_64-mingw-1
try-job: i686-msvc-2

Author: bors

compiler/rustc_ast_lowering/src/expr.rs

@@ -1549,7 +1549,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
     fn lower_loop_destination(&mut self, destination: Option<(NodeId, Label)>) -> hir::Destination {
         let target_id = match destination {
             Some((id, _)) => {
-                if let Some(loop_id) = self.resolver.get_label_res(id) {
+                if let Some(loop_id) = self.owner.get_label_res(id) {
                     let local_id = self.ident_and_label_to_local_id[&loop_id];
                     let loop_hir_id = HirId { owner: self.current_hir_id_owner, local_id };
                     Ok(loop_hir_id)

compiler/rustc_ast_lowering/src/lib.rs

@@ -293,16 +293,6 @@ impl<'tcx> ResolverAstLowering<'tcx> {
         self.import_res_map.get(&id).copied().unwrap_or_default()
     }
 
-    /// Obtains resolution for a label with the given `NodeId`.
-    fn get_label_res(&self, id: NodeId) -> Option<NodeId> {
-        self.label_res_map.get(&id).copied()
-    }
-
-    /// Obtains resolution for a lifetime with the given `NodeId`.
-    fn get_lifetime_res(&self, id: NodeId) -> Option<LifetimeRes> {
-        self.lifetimes_res_map.get(&id).copied()
-    }
-
     /// Obtain the list of lifetimes parameters to add to an item.
     ///
     /// Extra lifetime parameters should only be added in places that can appear
@@ -321,10 +311,6 @@ impl<'tcx> ResolverAstLowering<'tcx> {
     fn owner_def_id(&self, id: NodeId) -> LocalDefId {
         self.owners[&id].def_id
     }
-
-    fn lifetime_elision_allowed(&self, id: NodeId) -> bool {
-        self.lifetime_elision_allowed.contains(&id)
-    }
 }
 
 /// How relaxed bounds `?Trait` should be treated.
@@ -1625,7 +1611,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
             None => {
                 let id = if let Some(LifetimeRes::ElidedAnchor { start, end }) =
-                    self.resolver.get_lifetime_res(t.id)
+                    self.owner.get_lifetime_res(t.id)
                 {
                     assert_eq!(start.plus(1), end);
                     start
@@ -1866,7 +1852,9 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     _ => hir::ImplicitSelfKind::None,
                 }
             }))
-            .set_lifetime_elision_allowed(self.resolver.lifetime_elision_allowed(fn_node_id))
+            .set_lifetime_elision_allowed(
+                self.owner.id == fn_node_id && self.owner.lifetime_elision_allowed,
+            )
             .set_c_variadic(c_variadic);
 
         self.arena.alloc(hir::FnDecl { inputs, output, fn_decl_kind })
@@ -2032,7 +2020,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         source: LifetimeSource,
         syntax: LifetimeSyntax,
     ) -> &'hir hir::Lifetime {
-        let res = if let Some(res) = self.resolver.get_lifetime_res(id) {
+        let res = if let Some(res) = self.owner.get_lifetime_res(id) {
             match res {
                 LifetimeRes::Param { param, .. } => hir::LifetimeKind::Param(param),
                 LifetimeRes::Fresh { param, .. } => {
@@ -2118,13 +2106,12 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 // AST resolution emitted an error on those parameters, so we lower them using
                 // `ParamName::Error`.
                 let ident = self.lower_ident(param.ident);
-                let param_name = if let Some(LifetimeRes::Error(..)) =
-                    self.resolver.get_lifetime_res(param.id)
-                {
-                    ParamName::Error(ident)
-                } else {
-                    ParamName::Plain(ident)
-                };
+                let param_name =
+                    if let Some(LifetimeRes::Error(..)) = self.owner.get_lifetime_res(param.id) {
+                        ParamName::Error(ident)
+                    } else {
+                        ParamName::Plain(ident)
+                    };
                 let kind =
                     hir::GenericParamKind::Lifetime { kind: hir::LifetimeParamKind::Explicit };
 

compiler/rustc_ast_lowering/src/path.rs

@@ -17,7 +17,7 @@ use super::errors::{
 };
 use super::{
     AllowReturnTypeNotation, GenericArgsCtor, GenericArgsMode, ImplTraitContext, ImplTraitPosition,
-    LifetimeRes, LoweringContext, ParamMode, ResolverAstLoweringExt,
+    LifetimeRes, LoweringContext, ParamMode,
 };
 
 impl<'hir> LoweringContext<'_, 'hir> {
@@ -422,7 +422,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         segment_ident_span: Span,
         generic_args: &mut GenericArgsCtor<'hir>,
     ) {
-        let (start, end) = match self.resolver.get_lifetime_res(segment_id) {
+        let (start, end) = match self.owner.get_lifetime_res(segment_id) {
             Some(LifetimeRes::ElidedAnchor { start, end }) => (start, end),
             None => return,
             Some(res) => {

compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs

@@ -4023,63 +4023,60 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
             && decl.can_be_made_mutable()
         {
             let mut is_for_loop = false;
-            let mut is_ref_pattern = false;
+            let mut is_immut_ref_pattern = false;
             if let LocalInfo::User(BindingForm::Var(VarBindingForm {
                 opt_match_place: Some((_, match_span)),
                 ..
             })) = *decl.local_info()
             {
                 if matches!(match_span.desugaring_kind(), Some(DesugaringKind::ForLoop)) {
                     is_for_loop = true;
+                }
 
-                    if let Some(body) = self.infcx.tcx.hir_maybe_body_owned_by(self.mir_def_id()) {
-                        struct RefPatternFinder<'tcx> {
-                            tcx: TyCtxt<'tcx>,
-                            binding_span: Span,
-                            is_ref_pattern: bool,
-                        }
+                if let Some(body) = self.infcx.tcx.hir_maybe_body_owned_by(self.mir_def_id()) {
+                    struct RefPatternFinder<'tcx> {
+                        tcx: TyCtxt<'tcx>,
+                        binding_span: Span,
+                        is_immut_ref_pattern: bool,
+                    }
 
-                        impl<'tcx> Visitor<'tcx> for RefPatternFinder<'tcx> {
-                            type NestedFilter = OnlyBodies;
+                    impl<'tcx> Visitor<'tcx> for RefPatternFinder<'tcx> {
+                        type NestedFilter = OnlyBodies;
 
-                            fn maybe_tcx(&mut self) -> Self::MaybeTyCtxt {
-                                self.tcx
-                            }
+                        fn maybe_tcx(&mut self) -> Self::MaybeTyCtxt {
+                            self.tcx
+                        }
 
-                            fn visit_pat(&mut self, pat: &'tcx hir::Pat<'tcx>) {
-                                if !self.is_ref_pattern
-                                    && let hir::PatKind::Binding(_, _, ident, _) = pat.kind
-                                    && ident.span == self.binding_span
-                                {
-                                    self.is_ref_pattern =
-                                        self.tcx.hir_parent_iter(pat.hir_id).any(|(_, node)| {
-                                            matches!(
-                                                node,
-                                                hir::Node::Pat(hir::Pat {
-                                                    kind: hir::PatKind::Ref(..),
-                                                    ..
-                                                })
-                                            )
-                                        });
-                                }
-                                hir::intravisit::walk_pat(self, pat);
+                        fn visit_pat(&mut self, pat: &'tcx hir::Pat<'tcx>) {
+                            if !self.is_immut_ref_pattern
+                                && let hir::PatKind::Binding(_, _, ident, _) = pat.kind
+                                && ident.span == self.binding_span
+                                && matches!(
+                                    self.tcx.parent_hir_node(pat.hir_id),
+                                    hir::Node::Pat(hir::Pat {
+                                        kind: hir::PatKind::Ref(_, _, hir::Mutability::Not),
+                                        ..
+                                    })
+                                )
+                            {
+                                self.is_immut_ref_pattern = true;
                             }
+                            hir::intravisit::walk_pat(self, pat);
                         }
+                    }
 
-                        let mut finder = RefPatternFinder {
-                            tcx: self.infcx.tcx,
-                            binding_span: decl.source_info.span,
-                            is_ref_pattern: false,
-                        };
+                    let mut finder = RefPatternFinder {
+                        tcx: self.infcx.tcx,
+                        binding_span: decl.source_info.span,
+                        is_immut_ref_pattern: false,
+                    };
 
-                        finder.visit_body(body);
-                        is_ref_pattern = finder.is_ref_pattern;
-                    }
+                    finder.visit_body(body);
+                    is_immut_ref_pattern = finder.is_immut_ref_pattern;
                 }
             }
 
-            let (span, message) = if is_for_loop
-                && is_ref_pattern
+            let (span, message) = if is_immut_ref_pattern
                 && let Ok(binding_name) =
                     self.infcx.tcx.sess.source_map().span_to_snippet(decl.source_info.span)
             {

compiler/rustc_codegen_cranelift/src/driver/aot.rs

@@ -35,8 +35,7 @@ fn disable_incr_cache() -> bool {
 }
 
 struct ModuleCodegenResult {
-    module_regular: CompiledModule,
-    module_global_asm: Option<CompiledModule>,
+    module: CompiledModule,
     existing_work_product: Option<(WorkProductId, WorkProduct)>,
 }
 
@@ -80,29 +79,25 @@ impl OngoingCodegen {
                 Ok(module_codegen_result) => module_codegen_result,
                 Err(err) => sess.dcx().fatal(err),
             };
-            let ModuleCodegenResult { module_regular, module_global_asm, existing_work_product } =
-                module_codegen_result;
+            let ModuleCodegenResult { module, existing_work_product } = module_codegen_result;
 
             if let Some((work_product_id, work_product)) = existing_work_product {
                 work_products.insert(work_product_id, work_product);
             } else {
                 let work_product = if disable_incr_cache {
                     None
-                } else if let Some(module_global_asm) = &module_global_asm {
+                } else if let Some(global_asm_object) = &module.global_asm_object {
                     rustc_incremental::copy_cgu_workproduct_to_incr_comp_cache_dir(
                         sess,
-                        &module_regular.name,
-                        &[
-                            ("o", module_regular.object.as_ref().unwrap()),
-                            ("asm.o", module_global_asm.object.as_ref().unwrap()),
-                        ],
+                        &module.name,
+                        &[("o", module.object.as_ref().unwrap()), ("asm.o", global_asm_object)],
                         &[],
                     )
                 } else {
                     rustc_incremental::copy_cgu_workproduct_to_incr_comp_cache_dir(
                         sess,
-                        &module_regular.name,
-                        &[("o", module_regular.object.as_ref().unwrap())],
+                        &module.name,
+                        &[("o", module.object.as_ref().unwrap())],
                         &[],
                     )
                 };
@@ -111,10 +106,7 @@ impl OngoingCodegen {
                 }
             }
 
-            modules.push(module_regular);
-            if let Some(module_global_asm) = module_global_asm {
-                modules.push(module_global_asm);
-            }
+            modules.push(module);
         }
 
         self.concurrency_limiter.finished();
@@ -163,29 +155,17 @@ fn emit_cgu(
         debug.emit(&mut product);
     }
 
-    let module_regular = emit_module(
+    let module = emit_module(
         output_filenames,
         prof,
         product.object,
         ModuleKind::Regular,
         name.clone(),
+        global_asm_object_file,
         producer,
     )?;
 
-    Ok(ModuleCodegenResult {
-        module_regular,
-        module_global_asm: global_asm_object_file.map(|global_asm_object_file| CompiledModule {
-            name: format!("{name}.asm"),
-            kind: ModuleKind::Regular,
-            object: Some(global_asm_object_file),
-            dwarf_object: None,
-            bytecode: None,
-            assembly: None,
-            llvm_ir: None,
-            links_from_incr_cache: Vec::new(),
-        }),
-        existing_work_product: None,
-    })
+    Ok(ModuleCodegenResult { module, existing_work_product: None })
 }
 
 fn emit_module(
@@ -194,6 +174,7 @@ fn emit_module(
     mut object: cranelift_object::object::write::Object<'_>,
     kind: ModuleKind,
     name: String,
+    global_asm_object: Option<PathBuf>,
     producer_str: &str,
 ) -> Result<CompiledModule, String> {
     if object.format() == cranelift_object::object::BinaryFormat::Elf {
@@ -235,6 +216,7 @@ fn emit_module(
         name,
         kind,
         object: Some(tmp_file),
+        global_asm_object,
         dwarf_object: None,
         bytecode: None,
         assembly: None,
@@ -265,7 +247,7 @@ fn reuse_workproduct_for_cgu(
     }
 
     let obj_out_global_asm =
-        crate::global_asm::add_file_stem_postfix(obj_out_regular.clone(), ".asm");
+        tcx.output_filenames(()).temp_path_ext_for_cgu("asm.o", cgu.name().as_str());
     let source_file_global_asm = if let Some(asm_o) = work_product.saved_files.get("asm.o") {
         let source_file_global_asm = rustc_incremental::in_incr_comp_dir_sess(tcx.sess, asm_o);
         if let Err(err) = rustc_fs_util::link_or_copy(&source_file_global_asm, &obj_out_global_asm)
@@ -283,26 +265,21 @@ fn reuse_workproduct_for_cgu(
     };
 
     Ok(ModuleCodegenResult {
-        module_regular: CompiledModule {
+        module: CompiledModule {
             name: cgu.name().to_string(),
             kind: ModuleKind::Regular,
             object: Some(obj_out_regular),
+            global_asm_object: source_file_global_asm.as_ref().map(|_| obj_out_global_asm),
             dwarf_object: None,
             bytecode: None,
             assembly: None,
             llvm_ir: None,
-            links_from_incr_cache: vec![source_file_regular],
+            links_from_incr_cache: if let Some(source_file_global_asm) = source_file_global_asm {
+                vec![source_file_regular, source_file_global_asm]
+            } else {
+                vec![source_file_regular]
+            },
         },
-        module_global_asm: source_file_global_asm.map(|source_file| CompiledModule {
-            name: cgu.name().to_string(),
-            kind: ModuleKind::Regular,
-            object: Some(obj_out_global_asm),
-            dwarf_object: None,
-            bytecode: None,
-            assembly: None,
-            llvm_ir: None,
-            links_from_incr_cache: vec![source_file],
-        }),
         existing_work_product: Some((cgu.work_product_id(), work_product)),
     })
 }
@@ -447,6 +424,7 @@ fn emit_allocator_module(tcx: TyCtxt<'_>) -> Option<CompiledModule> {
             product.object,
             ModuleKind::Allocator,
             "allocator_shim".to_owned(),
+            None,
             &crate::debuginfo::producer(tcx.sess),
         ) {
             Ok(allocator_module) => Some(allocator_module),

compiler/rustc_codegen_cranelift/src/global_asm.rs

@@ -12,7 +12,7 @@ use rustc_middle::ty::TyCtxt;
 use rustc_middle::ty::layout::{
     FnAbiError, FnAbiOfHelpers, FnAbiRequest, HasTyCtxt, HasTypingEnv, LayoutError, LayoutOfHelpers,
 };
-use rustc_session::config::{OutputFilenames, OutputType};
+use rustc_session::config::OutputFilenames;
 use rustc_target::asm::InlineAsmArch;
 
 use crate::prelude::*;
@@ -198,10 +198,7 @@ pub(crate) fn compile_global_asm(
         .join("\n");
     global_asm.push('\n');
 
-    let global_asm_object_file = add_file_stem_postfix(
-        config.output_filenames.temp_path_for_cgu(OutputType::Object, cgu_name),
-        ".asm",
-    );
+    let global_asm_object_file = config.output_filenames.temp_path_ext_for_cgu("asm.o", cgu_name);
 
     // Assemble `global_asm`
     if option_env!("CG_CLIF_FORCE_GNU_AS").is_some() {
@@ -271,14 +268,3 @@ pub(crate) fn compile_global_asm(
 
     Ok(Some(global_asm_object_file))
 }
-
-pub(crate) fn add_file_stem_postfix(mut path: PathBuf, postfix: &str) -> PathBuf {
-    let mut new_filename = path.file_stem().unwrap().to_owned();
-    new_filename.push(postfix);
-    if let Some(extension) = path.extension() {
-        new_filename.push(".");
-        new_filename.push(extension);
-    }
-    path.set_file_name(new_filename);
-    path
-}