Rollup of 7 pull requests

compiler/rustc_borrowck/src/handle_placeholders.rs

@@ -344,7 +344,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/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

@@ -253,6 +253,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;
         }
@@ -276,6 +280,7 @@ fn collect_defining_uses<'tcx>(
     defining_uses
 }
 
+#[instrument(level = "debug", skip(rcx, hidden_types, defining_uses, errors))]
 fn compute_definition_site_hidden_types_from_defining_uses<'tcx>(
     rcx: &RegionCtxt<'_, 'tcx>,
     hidden_types: &mut DefinitionSiteHiddenTypes<'tcx>,
@@ -287,13 +292,15 @@ fn compute_definition_site_hidden_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_hir_analysis/src/check/region.rs

@@ -498,7 +498,8 @@ fn resolve_local<'tcx>(
             // Iterate up to the enclosing destruction scope to find the same scope that will also
             // be used for the result of the block itself.
             if let Some(inner_scope) = visitor.cx.var_parent {
-                (visitor.cx.var_parent, _) = visitor.scope_tree.default_temporary_scope(inner_scope)
+                visitor.cx.var_parent =
+                    Some(visitor.scope_tree.default_temporary_scope(inner_scope).0)
             }
             // Don't lifetime-extend child `super let`s or block tail expressions' temporaries in
             // the initializer when this `super let` is not itself extended by a parent `let`
@@ -752,10 +753,10 @@ impl<'tcx> Visitor<'tcx> for ScopeResolutionVisitor<'tcx> {
                 // The body of the every fn is a root scope.
                 resolve_expr(this, body.value, true);
             } else {
-                // Only functions have an outer terminating (drop) scope, while
-                // temporaries in constant initializers may be 'static, but only
-                // according to rvalue lifetime semantics, using the same
-                // syntactical rules used for let initializers.
+                // All bodies have an outer temporary drop scope, but temporaries
+                // and `super let` bindings in constant initializers may be extended
+                // to have 'static lifetimes, using the same syntactical rules used
+                // for `let` initializers.
                 //
                 // e.g., in `let x = &f();`, the temporary holding the result from
                 // the `f()` call lives for the entirety of the surrounding block.

compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs

@@ -3636,7 +3636,11 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 .must_apply_modulo_regions()
         {
             let sm = self.tcx.sess.source_map();
-            if let Ok(rhs_snippet) = sm.span_to_snippet(rhs_expr.span)
+            // If the span of rhs_expr or lhs_expr is in an external macro,
+            // we just suppress the suggestion. See issue #139050
+            if !rhs_expr.span.in_external_macro(sm)
+                && !lhs_expr.span.in_external_macro(sm)
+                && let Ok(rhs_snippet) = sm.span_to_snippet(rhs_expr.span)
                 && let Ok(lhs_snippet) = sm.span_to_snippet(lhs_expr.span)
             {
                 err.note(format!("`{rhs_ty}` implements `PartialEq<{lhs_ty}>`"));

compiler/rustc_log/src/lib.rs

@@ -39,11 +39,11 @@ use std::io::{self, IsTerminal};
 
 use tracing::dispatcher::SetGlobalDefaultError;
 use tracing::{Event, Subscriber};
+use tracing_subscriber::Registry;
 use tracing_subscriber::filter::{Directive, EnvFilter, LevelFilter};
 use tracing_subscriber::fmt::FmtContext;
 use tracing_subscriber::fmt::format::{self, FormatEvent, FormatFields};
 use tracing_subscriber::layer::SubscriberExt;
-use tracing_subscriber::{Layer, Registry};
 
 /// The values of all the environment variables that matter for configuring a logger.
 /// Errors are explicitly preserved so that we can share error handling.
@@ -152,18 +152,19 @@ where
         }
     }
 
-    let subscriber = build_subscriber().with(layer.with_filter(filter));
+    let subscriber = build_subscriber();
+    // NOTE: It is important to make sure that the filter is applied on the last layer
     match cfg.backtrace {
         Ok(backtrace_target) => {
             let fmt_layer = tracing_subscriber::fmt::layer()
                 .with_writer(io::stderr)
                 .without_time()
                 .event_format(BacktraceFormatter { backtrace_target });
-            let subscriber = subscriber.with(fmt_layer);
+            let subscriber = subscriber.with(layer).with(fmt_layer).with(filter);
             tracing::subscriber::set_global_default(subscriber)?;
         }
         Err(_) => {
-            tracing::subscriber::set_global_default(subscriber)?;
+            tracing::subscriber::set_global_default(subscriber.with(layer).with(filter))?;
         }
     };
 

compiler/rustc_middle/src/middle/region.rs

@@ -16,7 +16,7 @@ use rustc_macros::{HashStable, TyDecodable, TyEncodable};
 use rustc_span::{DUMMY_SP, Span};
 use tracing::debug;
 
-use crate::ty::TyCtxt;
+use crate::ty::{self, TyCtxt};
 
 /// Represents a statically-describable scope that can be used to
 /// bound the lifetime/region for values.
@@ -302,20 +302,20 @@ impl ScopeTree {
 
     /// Returns the scope of non-lifetime-extended temporaries within a given scope, as well as
     /// whether we've recorded a potential backwards-incompatible change to lint on.
-    /// Returns `None` when no enclosing temporary scope is found, such as for static items.
-    pub fn default_temporary_scope(&self, inner: Scope) -> (Option<Scope>, Option<Scope>) {
+    /// Panics if no enclosing temporary scope is found.
+    pub fn default_temporary_scope(&self, inner: Scope) -> (Scope, Option<Scope>) {
         let mut id = inner;
         let mut backwards_incompatible = None;
 
         while let Some(&p) = self.parent_map.get(&id) {
             match p.data {
                 ScopeData::Destruction => {
                     debug!("temporary_scope({inner:?}) = {id:?} [enclosing]");
-                    return (Some(id), backwards_incompatible);
+                    return (id, backwards_incompatible);
                 }
                 ScopeData::IfThenRescope | ScopeData::MatchGuard => {
                     debug!("temporary_scope({inner:?}) = {p:?} [enclosing]");
-                    return (Some(p), backwards_incompatible);
+                    return (p, backwards_incompatible);
                 }
                 ScopeData::Node
                 | ScopeData::CallSite
@@ -335,7 +335,6 @@ impl ScopeTree {
             }
         }
 
-        debug!("temporary_scope({inner:?}) = None");
-        (None, backwards_incompatible)
+        span_bug!(ty::tls::with(|tcx| inner.span(tcx, self)), "no enclosing temporary scope")
     }
 }

compiler/rustc_middle/src/ty/rvalue_scopes.rs

@@ -31,12 +31,10 @@ impl RvalueScopes {
             return (s, None);
         }
 
-        // Otherwise, locate the innermost terminating scope
-        // if there's one. Static items, for instance, won't
-        // have an enclosing scope, hence no scope will be
-        // returned.
-        region_scope_tree
-            .default_temporary_scope(Scope { local_id: expr_id, data: ScopeData::Node })
+        // Otherwise, locate the innermost terminating scope.
+        let (scope, backward_incompatible) = region_scope_tree
+            .default_temporary_scope(Scope { local_id: expr_id, data: ScopeData::Node });
+        (Some(scope), backward_incompatible)
     }
 
     /// Make an association between a sub-expression and an extended lifetime