[beta-1.91] Add more context to the temporary lifetime extension FCW

Cargo.lock

@@ -3275,7 +3275,6 @@ dependencies = [
  "rustc_driver_impl",
  "rustc_public",
  "rustc_public_bridge",
- "rustc_windows_rc",
  "tikv-jemalloc-sys",
 ]
 
@@ -3651,7 +3650,6 @@ name = "rustc_driver"
 version = "0.0.0"
 dependencies = [
  "rustc_driver_impl",
- "rustc_windows_rc",
 ]
 
 [[package]]
@@ -4748,13 +4746,6 @@ dependencies = [
  "semver",
 ]
 
-[[package]]
-name = "rustc_windows_rc"
-version = "0.0.0"
-dependencies = [
- "cc",
-]
-
 [[package]]
 name = "rustdoc"
 version = "0.0.0"

compiler/rustc/Cargo.toml

@@ -33,8 +33,3 @@ llvm = ['rustc_driver_impl/llvm']
 max_level_info = ['rustc_driver_impl/max_level_info']
 rustc_randomized_layouts = ['rustc_driver_impl/rustc_randomized_layouts']
 # tidy-alphabetical-end
-
-[build-dependencies]
-# tidy-alphabetical-start
-rustc_windows_rc = { path = "../rustc_windows_rc" }
-# tidy-alphabetical-end

compiler/rustc/build.rs

@@ -1,6 +1,4 @@
-use std::{env, path};
-
-use rustc_windows_rc::{VersionInfoFileType, compile_windows_resource_file};
+use std::env;
 
 fn main() {
     let target_os = env::var("CARGO_CFG_TARGET_OS");
@@ -15,18 +13,6 @@ fn main() {
 
 // Add a manifest file to rustc.exe.
 fn set_windows_exe_options() {
-    set_windows_resource();
-    set_windows_manifest();
-}
-
-fn set_windows_resource() {
-    let stem = path::PathBuf::from("rustc_main_resource");
-    let file_description = "rustc";
-    let res_file = compile_windows_resource_file(&stem, file_description, VersionInfoFileType::App);
-    println!("cargo:rustc-link-arg={}", res_file.display());
-}
-
-fn set_windows_manifest() {
     static WINDOWS_MANIFEST_FILE: &str = "Windows Manifest.xml";
 
     let mut manifest = env::current_dir().unwrap();

compiler/rustc_attr_parsing/src/attributes/link_attrs.rs

@@ -65,10 +65,22 @@ impl<S: Stage> CombineAttributeParser<S> for LinkParser {
         cx: &'c mut AcceptContext<'_, '_, S>,
         args: &'c ArgParser<'_>,
     ) -> impl IntoIterator<Item = Self::Item> + 'c {
-        let mut result = None;
-        let Some(items) = args.list() else {
-            cx.expected_list(cx.attr_span);
-            return result;
+        let items = match args {
+            ArgParser::List(list) => list,
+            // This is an edgecase added because making this a hard error would break too many crates
+            // Specifically `#[link = "dl"]` is accepted with a FCW
+            // For more information, see https://github.com/rust-lang/rust/pull/143193
+            ArgParser::NameValue(nv) if nv.value_as_str().is_some_and(|v| v == sym::dl) => {
+                let suggestions = <Self as CombineAttributeParser<S>>::TEMPLATE
+                    .suggestions(cx.attr_style, "link");
+                let span = cx.attr_span;
+                cx.emit_lint(AttributeLintKind::IllFormedAttributeInput { suggestions }, span);
+                return None;
+            }
+            _ => {
+                cx.expected_list(cx.attr_span);
+                return None;
+            }
         };
 
         let sess = cx.sess();
@@ -113,7 +125,7 @@ impl<S: Stage> CombineAttributeParser<S> for LinkParser {
                 }
             };
             if !cont {
-                return result;
+                return None;
             }
         }
 
@@ -202,7 +214,7 @@ impl<S: Stage> CombineAttributeParser<S> for LinkParser {
         }
         let Some((name, name_span)) = name else {
             cx.emit_err(LinkRequiresName { span: cx.attr_span });
-            return result;
+            return None;
         };
 
         // Do this outside of the loop so that `import_name_type` can be specified before `kind`.
@@ -218,15 +230,14 @@ impl<S: Stage> CombineAttributeParser<S> for LinkParser {
             cx.emit_err(RawDylibNoNul { span: name_span });
         }
 
-        result = Some(LinkEntry {
+        Some(LinkEntry {
             span: cx.attr_span,
             kind: kind.unwrap_or(NativeLibKind::Unspecified),
             name,
             cfg,
             verbatim,
             import_name_type,
-        });
-        result
+        })
     }
 }
 
@@ -455,8 +466,14 @@ impl<S: Stage> SingleAttributeParser<S> for LinkSectionParser {
     const PATH: &[Symbol] = &[sym::link_section];
     const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepInnermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::WarnButFutureError;
-    const ALLOWED_TARGETS: AllowedTargets =
-        AllowedTargets::AllowListWarnRest(&[Allow(Target::Static), Allow(Target::Fn)]);
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowListWarnRest(&[
+        Allow(Target::Static),
+        Allow(Target::Fn),
+        Allow(Target::Method(MethodKind::Inherent)),
+        Allow(Target::Method(MethodKind::Trait { body: false })),
+        Allow(Target::Method(MethodKind::Trait { body: true })),
+        Allow(Target::Method(MethodKind::TraitImpl)),
+    ]);
     const TEMPLATE: AttributeTemplate = template!(
         NameValueStr: "name",
         "https://doc.rust-lang.org/reference/abi.html#the-link_section-attribute"

compiler/rustc_borrowck/src/diagnostics/mod.rs

@@ -21,6 +21,7 @@ use rustc_middle::ty::print::Print;
 use rustc_middle::ty::{self, Ty, TyCtxt};
 use rustc_middle::{bug, span_bug};
 use rustc_mir_dataflow::move_paths::{InitLocation, LookupResult, MoveOutIndex};
+use rustc_session::lint::builtin::MACRO_EXTENDED_TEMPORARY_SCOPES;
 use rustc_span::def_id::LocalDefId;
 use rustc_span::source_map::Spanned;
 use rustc_span::{DUMMY_SP, ErrorGuaranteed, Span, Symbol, sym};
@@ -1580,4 +1581,33 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
     pub(crate) fn local_excluded_from_unused_mut_lint(&self, index: Local) -> bool {
         self.local_name(index).is_none_or(|name| name.as_str().starts_with('_'))
     }
+
+    /// Report a temporary whose scope will shorten in Rust 1.92 due to #145838.
+    pub(crate) fn lint_macro_extended_temporary_scope(
+        &self,
+        future_drop: Location,
+        borrow: &BorrowData<'tcx>,
+    ) {
+        let tcx = self.infcx.tcx;
+        let temp_decl = &self.body.local_decls[borrow.borrowed_place.local];
+        let temp_span = temp_decl.source_info.span;
+        let lint_root = self.body.source_scopes[temp_decl.source_info.scope]
+            .local_data
+            .as_ref()
+            .unwrap_crate_local()
+            .lint_root;
+
+        let mut labels = MultiSpan::from_span(temp_span);
+        labels.push_span_label(temp_span, "this expression creates a temporary value...");
+        labels.push_span_label(
+            self.body.source_info(future_drop).span,
+            "...which will be dropped at the end of this block in Rust 1.92",
+        );
+
+        tcx.node_span_lint(MACRO_EXTENDED_TEMPORARY_SCOPES, lint_root, labels, |diag| {
+            diag.primary_message("temporary lifetime will be shortened in Rust 1.92");
+            diag.note("consider using a `let` binding to create a longer lived value");
+            diag.note("some temporaries were previously incorrectly lifetime-extended since Rust 1.89 in formatting macros, and since Rust 1.88 in `pin!()`");
+        });
+    }
 }

compiler/rustc_borrowck/src/handle_placeholders.rs

@@ -348,7 +348,7 @@ pub(crate) fn compute_sccs_applying_placeholder_outlives_constraints<'tcx>(
     }
 }
 
-fn rewrite_placeholder_outlives<'tcx>(
+pub(crate) fn rewrite_placeholder_outlives<'tcx>(
     sccs: &Sccs<RegionVid, ConstraintSccIndex>,
     annotations: &SccAnnotations<'_, '_, RegionTracker>,
     fr_static: RegionVid,

compiler/rustc_borrowck/src/lib.rs

@@ -843,8 +843,8 @@ impl<'a, 'tcx> ResultsVisitor<'tcx, Borrowck<'a, 'tcx>> for MirBorrowckCtxt<'a,
             | StatementKind::ConstEvalCounter
             | StatementKind::StorageLive(..) => {}
             // This does not affect borrowck
-            StatementKind::BackwardIncompatibleDropHint { place, reason: BackwardIncompatibleDropReason::Edition2024 } => {
-                self.check_backward_incompatible_drop(location, **place, state);
+            StatementKind::BackwardIncompatibleDropHint { place, reason } => {
+                self.check_backward_incompatible_drop(location, **place, state, *reason);
             }
             StatementKind::StorageDead(local) => {
                 self.access_place(
@@ -1386,6 +1386,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, '_, 'tcx> {
         location: Location,
         place: Place<'tcx>,
         state: &BorrowckDomain,
+        reason: BackwardIncompatibleDropReason,
     ) {
         let tcx = self.infcx.tcx;
         // If this type does not need `Drop`, then treat it like a `StorageDead`.
@@ -1412,21 +1413,29 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, '_, 'tcx> {
                 if matches!(borrow.kind, BorrowKind::Fake(_)) {
                     return ControlFlow::Continue(());
                 }
-                let borrowed = this.retrieve_borrow_spans(borrow).var_or_use_path_span();
-                let explain = this.explain_why_borrow_contains_point(
-                    location,
-                    borrow,
-                    Some((WriteKind::StorageDeadOrDrop, place)),
-                );
-                this.infcx.tcx.node_span_lint(
-                    TAIL_EXPR_DROP_ORDER,
-                    CRATE_HIR_ID,
-                    borrowed,
-                    |diag| {
-                        session_diagnostics::TailExprDropOrder { borrowed }.decorate_lint(diag);
-                        explain.add_explanation_to_diagnostic(&this, diag, "", None, None);
-                    },
-                );
+                match reason {
+                    BackwardIncompatibleDropReason::Edition2024 => {
+                        let borrowed = this.retrieve_borrow_spans(borrow).var_or_use_path_span();
+                        let explain = this.explain_why_borrow_contains_point(
+                            location,
+                            borrow,
+                            Some((WriteKind::StorageDeadOrDrop, place)),
+                        );
+                        this.infcx.tcx.node_span_lint(
+                            TAIL_EXPR_DROP_ORDER,
+                            CRATE_HIR_ID,
+                            borrowed,
+                            |diag| {
+                                session_diagnostics::TailExprDropOrder { borrowed }
+                                    .decorate_lint(diag);
+                                explain.add_explanation_to_diagnostic(&this, diag, "", None, None);
+                            },
+                        );
+                    }
+                    BackwardIncompatibleDropReason::MacroExtendedScope => {
+                        this.lint_macro_extended_temporary_scope(location, borrow);
+                    }
+                }
                 // We may stop at the first case
                 ControlFlow::Break(())
             },

compiler/rustc_borrowck/src/region_infer/opaque_types/member_constraints.rs

@@ -39,7 +39,7 @@ pub(super) fn apply_member_constraints<'tcx>(
     debug!(?member_constraints);
     for scc_a in rcx.constraint_sccs.all_sccs() {
         debug!(?scc_a);
-        // Start by  adding the region values required by outlives constraints. This
+        // Start by adding the region values required by outlives constraints. This
         // matches how we compute the final region values in `fn compute_regions`.
         //
         // We need to do this here to get a lower bound when applying member constraints.
@@ -64,6 +64,7 @@ fn apply_member_constraint<'tcx>(
     // If the member region lives in a higher universe, we currently choose
     // the most conservative option by leaving it unchanged.
     if !rcx.max_placeholder_universe_reached(member).is_root() {
+        debug!("member region reached non root universe, bailing");
         return;
     }
 

compiler/rustc_borrowck/src/region_infer/opaque_types/mod.rs

@@ -254,6 +254,10 @@ fn collect_defining_uses<'tcx>(
                 }
             } else {
                 errors.push(DeferredOpaqueTypeError::InvalidOpaqueTypeArgs(err));
+                debug!(
+                    "collect_defining_uses: InvalidOpaqueTypeArgs for {:?} := {:?}",
+                    non_nll_opaque_type_key, hidden_type
+                );
             }
             continue;
         }
@@ -277,6 +281,7 @@ fn collect_defining_uses<'tcx>(
     defining_uses
 }
 
+#[instrument(level = "debug", skip(rcx, concrete_opaque_types, defining_uses, errors))]
 fn compute_concrete_types_from_defining_uses<'tcx>(
     rcx: &RegionCtxt<'_, 'tcx>,
     concrete_opaque_types: &mut ConcreteOpaqueTypes<'tcx>,
@@ -288,13 +293,15 @@ fn compute_concrete_types_from_defining_uses<'tcx>(
     let mut decls_modulo_regions: FxIndexMap<OpaqueTypeKey<'tcx>, (OpaqueTypeKey<'tcx>, Span)> =
         FxIndexMap::default();
     for &DefiningUse { opaque_type_key, ref arg_regions, hidden_type } in defining_uses {
+        debug!(?opaque_type_key, ?arg_regions, ?hidden_type);
         // After applying member constraints, we now map all regions in the hidden type
         // to the `arg_regions` of this defining use. In case a region in the hidden type
         // ended up not being equal to any such region, we error.
         let hidden_type =
             match hidden_type.try_fold_with(&mut ToArgRegionsFolder::new(rcx, arg_regions)) {
                 Ok(hidden_type) => hidden_type,
                 Err(r) => {
+                    debug!("UnexpectedHiddenRegion: {:?}", r);
                     errors.push(DeferredOpaqueTypeError::UnexpectedHiddenRegion {
                         hidden_type,
                         opaque_type_key,

compiler/rustc_borrowck/src/region_infer/opaque_types/region_ctxt.rs

@@ -11,7 +11,9 @@ use crate::constraints::ConstraintSccIndex;
 use crate::handle_placeholders::{SccAnnotations, region_definitions};
 use crate::region_infer::reverse_sccs::ReverseSccGraph;
 use crate::region_infer::values::RegionValues;
-use crate::region_infer::{ConstraintSccs, RegionDefinition, RegionTracker, Representative};
+use crate::region_infer::{
+    ConstraintSccs, OutlivesConstraintSet, RegionDefinition, RegionTracker, Representative,
+};
 use crate::type_check::MirTypeckRegionConstraints;
 use crate::type_check::free_region_relations::UniversalRegionRelations;
 use crate::universal_regions::UniversalRegions;
@@ -39,16 +41,36 @@ impl<'a, 'tcx> RegionCtxt<'a, 'tcx> {
         location_map: Rc<DenseLocationMap>,
         constraints: &MirTypeckRegionConstraints<'tcx>,
     ) -> RegionCtxt<'a, 'tcx> {
+        let mut outlives_constraints = constraints.outlives_constraints.clone();
         let universal_regions = &universal_region_relations.universal_regions;
         let (definitions, _has_placeholders) = region_definitions(infcx, universal_regions);
+
+        let compute_sccs =
+            |outlives_constraints: &OutlivesConstraintSet<'tcx>,
+             annotations: &mut SccAnnotations<'_, 'tcx, RegionTracker>| {
+                ConstraintSccs::new_with_annotation(
+                    &outlives_constraints
+                        .graph(definitions.len())
+                        .region_graph(outlives_constraints, universal_regions.fr_static),
+                    annotations,
+                )
+            };
+
         let mut scc_annotations = SccAnnotations::init(&definitions);
-        let constraint_sccs = ConstraintSccs::new_with_annotation(
-            &constraints
-                .outlives_constraints
-                .graph(definitions.len())
-                .region_graph(&constraints.outlives_constraints, universal_regions.fr_static),
-            &mut scc_annotations,
+        let mut constraint_sccs = compute_sccs(&outlives_constraints, &mut scc_annotations);
+
+        let added_constraints = crate::handle_placeholders::rewrite_placeholder_outlives(
+            &constraint_sccs,
+            &scc_annotations,
+            universal_regions.fr_static,
+            &mut outlives_constraints,
         );
+
+        if added_constraints {
+            scc_annotations = SccAnnotations::init(&definitions);
+            constraint_sccs = compute_sccs(&outlives_constraints, &mut scc_annotations);
+        }
+
         let scc_annotations = scc_annotations.scc_to_annotation;
 
         // Unlike the `RegionInferenceContext`, we only care about free regions

compiler/rustc_codegen_llvm/src/attributes.rs

@@ -435,16 +435,6 @@ pub(crate) fn llfn_attrs_from_instance<'ll, 'tcx>(
         || codegen_fn_attrs.flags.contains(CodegenFnAttrFlags::ALLOCATOR_ZEROED)
     {
         to_add.push(create_alloc_family_attr(cx.llcx));
-        if let Some(zv) =
-            cx.tcx.get_attr(instance.def_id(), rustc_span::sym::rustc_allocator_zeroed_variant)
-            && let Some(name) = zv.value_str()
-        {
-            to_add.push(llvm::CreateAttrStringValue(
-                cx.llcx,
-                "alloc-variant-zeroed",
-                &mangle_internal_symbol(cx.tcx, name.as_str()),
-            ));
-        }
         // apply to argument place instead of function
         let alloc_align = AttributeKind::AllocAlign.create_attr(cx.llcx);
         attributes::apply_to_llfn(llfn, AttributePlace::Argument(1), &[alloc_align]);

compiler/rustc_codegen_ssa/Cargo.toml

@@ -9,7 +9,7 @@ ar_archive_writer = "0.5"
 bitflags = "2.4.1"
 bstr = "1.11.3"
 # `cc` updates often break things, so we pin it here. Cargo enforces "max 1 semver-compat version
-# per crate", so if you change this, you need to also change it in `rustc_llvm` and `rustc_windows_rc`.
+# per crate", so if you change this, you need to also change it in `rustc_llvm`.
 cc = "=1.2.16"
 itertools = "0.12"
 pathdiff = "0.2.0"