Rollup of 20 pull requests

compiler/rustc_attr_ir/src/target.rs

@@ -6,13 +6,6 @@ pub use rustc_ast::visit::AssocCtxt;
 use rustc_ast::{AssocItemKind, ForeignItemKind, ast};
 use rustc_macros::StableHash;
 
-#[derive(Copy, Clone, PartialEq, Debug, Eq, StableHash)]
-pub enum GenericParamKind {
-    Type,
-    Lifetime,
-    Const,
-}
-
 #[derive(Copy, Clone, PartialEq, Debug, Eq, StableHash)]
 pub enum MethodKind {
     /// Method in a `trait Trait` block
@@ -55,7 +48,9 @@ pub enum Target {
     ForeignFn,
     ForeignStatic,
     ForeignTy,
-    GenericParam { kind: GenericParamKind, has_default: bool },
+    LifetimeParam,
+    TypeParam,
+    ConstParam,
     MacroDef,
     Param,
     PatField,
@@ -106,7 +101,9 @@ impl Target {
             | Target::ForeignFn
             | Target::ForeignStatic
             | Target::ForeignTy
-            | Target::GenericParam { .. }
+            | Target::TypeParam
+            | Target::LifetimeParam
+            | Target::ConstParam
             | Target::MacroDef
             | Target::Param
             | Target::PatField
@@ -222,11 +219,9 @@ impl Target {
             Target::ForeignFn => "foreign function",
             Target::ForeignStatic => "foreign static item",
             Target::ForeignTy => "foreign type",
-            Target::GenericParam { kind, .. } => match kind {
-                GenericParamKind::Type => "type parameter",
-                GenericParamKind::Lifetime => "lifetime parameter",
-                GenericParamKind::Const => "const parameter",
-            },
+            Target::TypeParam => "type parameter",
+            Target::LifetimeParam => "lifetime parameter",
+            Target::ConstParam => "const parameter",
             Target::MacroDef => "macro def",
             Target::Param => "function param",
             Target::PatField => "pattern field",
@@ -277,11 +272,9 @@ impl Target {
             Target::ForeignFn => "foreign functions",
             Target::ForeignStatic => "foreign statics",
             Target::ForeignTy => "foreign types",
-            Target::GenericParam { kind, has_default: _ } => match kind {
-                GenericParamKind::Type => "type parameters",
-                GenericParamKind::Lifetime => "lifetime parameters",
-                GenericParamKind::Const => "const parameters",
-            },
+            Target::TypeParam => "type parameters",
+            Target::LifetimeParam => "lifetime parameters",
+            Target::ConstParam => "const parameters",
             Target::MacroDef => "macro defs",
             Target::Param => "function params",
             Target::PatField => "pattern fields",

compiler/rustc_attr_parsing/src/attributes/rustc_internal.rs

@@ -2,7 +2,6 @@ use std::path::PathBuf;
 
 use rustc_ast::{LitIntType, LitKind, MetaItemLit};
 use rustc_attr_ir::lang_items::LangItem;
-use rustc_attr_ir::target::GenericParamKind;
 use rustc_attr_ir::{
     BorrowckGraphvizFormatKind, CguFields, CguKind, RustcCleanAttribute, RustcCleanQueries,
     RustcMirKind,
@@ -109,10 +108,8 @@ pub(crate) struct RustcPanicsWhenZeroParser;
 
 impl NoArgsAttributeParser for RustcPanicsWhenZeroParser {
     const PATH: &[Symbol] = &[sym::rustc_panics_when_zero];
-    const ALLOWED_TARGETS: AllowedTargets<'_> = AllowedTargets::AllowList(&[
-        Allow(Target::GenericParam { kind: GenericParamKind::Const, has_default: true }),
-        Allow(Target::GenericParam { kind: GenericParamKind::Const, has_default: false }),
-    ]);
+    const ALLOWED_TARGETS: AllowedTargets<'_> =
+        AllowedTargets::AllowList(&[Allow(Target::ConstParam)]);
     const STABILITY: AttributeStability = unstable!(rustc_attrs);
 
     const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::RustcPanicsWhenZero;

compiler/rustc_attr_parsing/src/attributes/semantics.rs

@@ -1,17 +1,12 @@
-use rustc_attr_ir::target::GenericParamKind;
 use rustc_feature::AttributeStability;
 
 use super::prelude::*;
 
 pub(crate) struct MayDangleParser;
 impl NoArgsAttributeParser for MayDangleParser {
     const PATH: &[Symbol] = &[sym::may_dangle];
-    const ALLOWED_TARGETS: AllowedTargets<'_> = AllowedTargets::AllowList(&[
-        Allow(Target::GenericParam { kind: GenericParamKind::Type, has_default: false }),
-        Allow(Target::GenericParam { kind: GenericParamKind::Type, has_default: true }),
-        Allow(Target::GenericParam { kind: GenericParamKind::Lifetime, has_default: false }),
-        Allow(Target::GenericParam { kind: GenericParamKind::Lifetime, has_default: true }),
-    ]);
+    const ALLOWED_TARGETS: AllowedTargets<'_> =
+        AllowedTargets::AllowList(&[Allow(Target::TypeParam), Allow(Target::LifetimeParam)]);
     const STABILITY: AttributeStability = unstable!(dropck_eyepatch);
     const CREATE: fn(span: Span) -> AttributeKind = AttributeKind::MayDangle;
 }

compiler/rustc_attr_parsing/src/attributes/stability.rs

@@ -1,6 +1,6 @@
 use std::num::NonZero;
 
-use rustc_attr_ir::target::{AssocCtxt, GenericParamKind, MethodKind, Target};
+use rustc_attr_ir::target::{AssocCtxt, MethodKind, Target};
 use rustc_attr_ir::{
     DefaultBodyStability, PartialConstStability, Stability, StabilityLevel, StableSince,
     UnstableReason, UnstableRemovedFeature, VERSION_PLACEHOLDER,
@@ -40,7 +40,7 @@ const ALLOWED_TARGETS: AllowedTargets<'_> = AllowedTargets::AllowList(&[
     Allow(Target::TyAlias),
     Allow(Target::Variant),
     Allow(Target::Field),
-    Allow(Target::GenericParam { kind: GenericParamKind::Type, has_default: true }),
+    Allow(Target::TypeParam),
     Allow(Target::Static),
     Allow(Target::ForeignFn),
     Allow(Target::ForeignStatic),

compiler/rustc_attr_parsing/src/target_checking.rs

@@ -532,30 +532,9 @@ pub(crate) const ALL_TARGETS: &[Policy] = {
         Allow(Target::Crate),
         Allow(Target::Delegation { mac: false }),
         Allow(Target::Delegation { mac: true }),
-        Allow(Target::GenericParam {
-            kind: rustc_attr_ir::target::GenericParamKind::Const,
-            has_default: false,
-        }),
-        Allow(Target::GenericParam {
-            kind: rustc_attr_ir::target::GenericParamKind::Const,
-            has_default: true,
-        }),
-        Allow(Target::GenericParam {
-            kind: rustc_attr_ir::target::GenericParamKind::Lifetime,
-            has_default: false,
-        }),
-        Allow(Target::GenericParam {
-            kind: rustc_attr_ir::target::GenericParamKind::Lifetime,
-            has_default: true,
-        }),
-        Allow(Target::GenericParam {
-            kind: rustc_attr_ir::target::GenericParamKind::Type,
-            has_default: false,
-        }),
-        Allow(Target::GenericParam {
-            kind: rustc_attr_ir::target::GenericParamKind::Type,
-            has_default: true,
-        }),
+        Allow(Target::ConstParam),
+        Allow(Target::LifetimeParam),
+        Allow(Target::TypeParam),
         Allow(Target::Loop),
         Allow(Target::ForLoop),
         Allow(Target::While),

compiler/rustc_borrowck/src/polonius/dump.rs

@@ -543,13 +543,15 @@ fn emit_loan_reachability(
             // It's useful to know whether the region we're reaching is live at this point.
             let node_liveness =
                 if liveness.is_live_at(node.region, location) { "live" } else { "not live" };
+            writeln!(out, "<span class='trace-suffix'>")?;
             writeln!(
                 out,
                 "/ at <code>{:?}</code>: <code>'{}</code> is {}",
                 location,
                 node.region.index(),
                 node_liveness,
             )?;
+            writeln!(out, "</span>")?;
             writeln!(out, "</li>")?;
         }
         writeln!(out, "</ul>")?;

compiler/rustc_borrowck/src/polonius/dump/polonius-mir-dump.template.html

@@ -3,8 +3,9 @@
 <head>
 <title>Polonius MIR dump</title>
 <style>
-.hidden {
-    display: none;
+pre {
+    margin-top: 0;
+    white-space: pre-wrap;
 }
 
 .section + .section {
@@ -13,8 +14,8 @@
     padding-top: 10px;
 }
 
-.traces .section-header {
-    margin-bottom: 10px;
+.section-header {
+    margin-bottom: 6px;
 }
 
 .trace + .trace {
@@ -25,43 +26,63 @@
     margin: 5px 0px;
     padding-left: 15px;
 }
+
+.trace-suffix {
+    opacity: 0.8;
+    margin-left: 10px;
+}
+
+.hidden {
+    display: none;
+}
 </style>
 </head>
 
 <body>
 
-<!-- The NLL + Polonius MIR -->
+<!-- Links to the other sections -->
 <div class="section">
+    <div class="section-header">Quick links</div>
+    <a href="#mir">Polonius MIR</a>
+    <a href="#polonius-region-graph">Polonius constraint graph</a>
+    <a href="#loan-traces">Loan traces</a>
+    <a href="#cfg-graph">Control-flow graph</a>
+    <a href="#nll-region-graph">NLL region graph</a>
+    <a href="#nll-scc-graph">NLL SCC graph</a>
+</div>
+
+<!-- The NLL + Polonius MIR -->
+<div class="section" id="mir">
     <div class="section-header">Raw MIR dump</div>
     <pre><code>$SECTION_MIR</code></pre>
 </div>
 
 <!-- Mermaid visualization of the polonius constraint graph -->
-<div class="section">
+<div class="section" id="polonius-region-graph">
     <div class="section-header">Polonius constraint graph</div>
     <pre class='mermaid'>$SECTION_POLONIUS_CONSTRAINTS</pre>
 </div>
 
 <!-- The reachability of loans while traversing the polonius constraint graph -->
-<div class="section traces">
+<div class="section traces" id="loan-traces">
     <div class="section-header">Loan Traces</div>
     $SECTION_POLONIUS_REACHABILITY
 </div>
 
 <!-- Mermaid visualization of the CFG -->
-<div class="section">
+<div class="section" id="cfg-graph">
     <div class="section-header">Control-flow graph</div>
     <pre class='mermaid'>$SECTION_CFG</pre>
 </div>
 
 <!-- Mermaid visualization of the NLL region graph -->
-<div class="section">
+<div class="section" id="nll-region-graph">
     <div class="section-header">NLL regions</div>
     <pre class='mermaid'>$SECTION_NLL_CONSTRAINTS</pre>
 </div>
 
 <!-- Mermaid visualization of the NLL SCC graph -->
-<div class="section">
+<div class="section" id="nll-scc-graph">
     <div class="section-header">NLL SCCs</div>
     <pre class='mermaid'>$SECTION_NLL_SCCS</pre>
 </div>

compiler/rustc_borrowck/src/type_check/liveness/trace.rs

@@ -6,7 +6,7 @@ use rustc_infer::infer::canonical::QueryRegionConstraints;
 use rustc_infer::traits::TraitErrors;
 use rustc_middle::mir::{BasicBlock, Body, ConstraintCategory, Local, Location};
 use rustc_middle::traits::query::DropckOutlivesResult;
-use rustc_middle::ty::{GenericArg, Ty, TypeVisitable, TypeVisitableExt};
+use rustc_middle::ty::{Ty, TyCtxt, TypeVisitable, TypeVisitableExt};
 use rustc_mir_dataflow::impls::MaybeInitializedPlaces;
 use rustc_mir_dataflow::move_paths::{HasMoveData, MoveData, MovePathIndex};
 use rustc_mir_dataflow::points::{DenseLocationMap, PointIndex};
@@ -553,8 +553,17 @@ impl<'tcx> LivenessContext<'_, '_, 'tcx> {
     /// points `live_at`.
     fn add_use_live_facts_for(&mut self, value: Ty<'tcx>, live_at: &IntervalSet<PointIndex>) {
         debug!("add_use_live_facts_for(value={:?})", value);
-        Self::record_region_variance(self.typeck, value.into());
-        Self::make_all_regions_live(self.location_map, self.typeck, value.into(), live_at);
+        Self::make_all_regions_live(self.location_map, self.typeck, value, live_at);
+
+        // When using `-Zpolonius=next`, we also record the variance of regions in this live type.
+        if let Some(polonius_context) = self.typeck.polonius_context.as_mut() {
+            record_live_region_variance(
+                self.typeck.infcx.tcx,
+                &mut polonius_context.live_region_variances,
+                self.typeck.universal_regions,
+                value,
+            );
+        }
     }
 
     /// Some variable with type `live_ty` is "drop live" at `location`
@@ -595,9 +604,6 @@ impl<'tcx> LivenessContext<'_, '_, 'tcx> {
             }
         }
 
-        // Since the entire dropped local is live, record the variance of its regions.
-        Self::record_region_variance(self.typeck, dropped_ty.into());
-
         // All things in the `outlives` array may be touched by
         // the destructor and must be live at this point.
         for &kind in &drop_data.dropck_result.kinds {
@@ -610,27 +616,24 @@ impl<'tcx> LivenessContext<'_, '_, 'tcx> {
                 self.typeck.polonius_facts,
             );
         }
-    }
 
-    /// `live_kind` is the type of a  (use- or drop-) live local.
-    /// Record the variance of any region(s) appearing in it for Polonius. Does
-    /// nothing if Polonius is not active.
-    fn record_region_variance(typeck: &mut TypeChecker<'_, 'tcx>, live_kind: GenericArg<'tcx>) {
-        // When using `-Zpolonius=next`, we record the variance of each live region.
-        if let Some(polonius_context) = typeck.polonius_context.as_mut() {
+        // For polonius: since the local is drop live, record the variance of the regions in its
+        // type, not the ones in the type's live components seen in the dropck results above. See
+        // issue #160670.
+        if let Some(polonius_context) = self.typeck.polonius_context.as_mut() {
             record_live_region_variance(
-                typeck.infcx.tcx,
+                self.typeck.infcx.tcx,
                 &mut polonius_context.live_region_variances,
-                typeck.universal_regions,
-                live_kind,
+                self.typeck.universal_regions,
+                dropped_ty,
             );
         }
     }
 
     fn make_all_regions_live(
         location_map: &DenseLocationMap,
         typeck: &mut TypeChecker<'_, 'tcx>,
-        value: GenericArg<'tcx>,
+        value: impl TypeVisitable<TyCtxt<'tcx>>,
         live_at: &IntervalSet<PointIndex>,
     ) {
         debug!("make_all_regions_live(value={:?})", value);
@@ -647,7 +650,6 @@ impl<'tcx> LivenessContext<'_, '_, 'tcx> {
                 typeck.constraints.liveness_constraints.add_points(live_region_vid, live_at);
             },
         });
-        Self::record_region_variance(typeck, value);
     }
 }
 

compiler/rustc_codegen_llvm/src/intrinsic.rs

@@ -347,8 +347,7 @@ impl<'ll, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'_, 'll, 'tcx> {
                         // 64-bit floats are always OK.
                     }
                     Primitive::Float(Float::F128) => {
-                        // FIXME(f128) figure out whether we should support this.
-                        bug!("the va_arg intrinsic does not support `f128`")
+                        // Supported on some targets, especially where long double is IEEE f128.
                     }
                 }
 

compiler/rustc_driver_impl/src/lib.rs

@@ -1600,7 +1600,7 @@ fn report_ice(
 
     let limit_frames = if backtrace { None } else { Some(2) };
 
-    interface::try_print_query_stack(dcx, limit_frames, file);
+    interface::try_print_query_stack(limit_frames, file);
 
     // We don't trust this callback not to panic itself, so run it at the end after we're sure we've
     // printed all the relevant info.

compiler/rustc_errors/src/lib.rs

@@ -1148,11 +1148,6 @@ impl<'a> DiagCtxtHandle<'a> {
         self.create_note(note).emit()
     }
 
-    #[track_caller]
-    pub fn struct_failure_note(self, msg: impl Into<DiagMessage>) -> Diag<'a, ()> {
-        Diag::new(self, FailureNote, msg)
-    }
-
     #[track_caller]
     pub fn struct_allow(self, msg: impl Into<DiagMessage>) -> Diag<'a, ()> {
         Diag::new(self, Allow, msg)