Rollup of 20 pull requests

compiler/rustc_attr_parsing/src/attributes/cfg.rs

@@ -306,7 +306,8 @@ pub fn parse_cfg_attr(
     features: Option<&Features>,
     lint_node_id: ast::NodeId,
 ) -> Option<(CfgEntry, Vec<(WithTokens<AttrItem>, Span)>)> {
-    match &cfg_attr.get_normal_item().args {
+    let item = cfg_attr.get_normal_item();
+    match &item.args {
         ast::AttrArgs::Delimited(ast::DelimArgs { dspan, delim, tokens }) if !tokens.is_empty() => {
             check_cfg_attr_bad_delim(&sess.psess, *dspan, *delim);
             match parse_in(&sess.psess, tokens.clone(), "`cfg_attr` input", |p| {
@@ -316,11 +317,11 @@ pub fn parse_cfg_attr(
                 Err(e) => {
                     let suggestions = CFG_ATTR_TEMPLATE.suggestions(
                         ParsedDescription::Attribute,
-                        cfg_attr.get_normal_item().unsafety,
+                        item.unsafety,
                         sym::cfg_attr,
                     );
                     e.with_span_suggestions(
-                        cfg_attr.get_normal_item().span,
+                        item.span,
                         "must be of the form",
                         suggestions,
                         Applicability::HasPlaceholders,
@@ -334,25 +335,24 @@ pub fn parse_cfg_attr(
             }
         }
         _ => {
-            let (span, reason) = if let ast::AttrArgs::Delimited(ast::DelimArgs { dspan, .. }) =
-                cfg_attr.get_normal_item().args
-            {
-                (dspan.entire(), AttributeParseErrorReason::ExpectedAtLeastOneArgument)
-            } else {
-                (cfg_attr.get_normal_item().span, AttributeParseErrorReason::ExpectedList)
-            };
+            let (span, reason) =
+                if let ast::AttrArgs::Delimited(ast::DelimArgs { dspan, .. }) = item.args {
+                    (dspan.entire(), AttributeParseErrorReason::ExpectedAtLeastOneArgument)
+                } else {
+                    (item.span, AttributeParseErrorReason::ExpectedList)
+                };
 
             sess.dcx().emit_err(AttributeParseError {
                 span,
-                inner_span: cfg_attr.get_normal_item().span,
+                inner_span: item.span,
                 template: CFG_ATTR_TEMPLATE,
-                path: AttrPath::from_ast(&cfg_attr.get_normal_item().path, identity),
+                path: AttrPath::from_ast(&item.path, identity),
                 description: ParsedDescription::Attribute,
                 reason,
                 suggestions: diagnostics::AttributeParseErrorSuggestions::CreatedByTemplate(
                     CFG_ATTR_TEMPLATE.suggestions(
                         ParsedDescription::Attribute,
-                        cfg_attr.get_normal_item().unsafety,
+                        item.unsafety,
                         sym::cfg_attr,
                     ),
                 ),
@@ -389,13 +389,14 @@ fn parse_cfg_attr_internal<'a>(
     )?;
     let pred_span = pred_start.with_hi(parser.token.span.hi());
 
+    let item = attribute.get_normal_item();
     let cfg_predicate = AttributeParser::parse_single_args(
         sess,
         attribute.span,
-        attribute.get_normal_item().span,
+        item.span,
         attribute.style,
         AttrPath { segments: attribute.path().into_boxed_slice(), span: attribute.span },
-        Some(attribute.get_normal_item().unsafety),
+        Some(item.unsafety),
         AttributeSafety::Normal,
         ParsedDescription::Attribute,
         pred_span,

compiler/rustc_attr_parsing/src/diagnostics.rs

@@ -1235,7 +1235,7 @@ pub(crate) struct UnknownVersionLiteral {
 #[diag("multiple `{$name}` attributes")]
 pub(crate) struct UnusedMultiple {
     #[primary_span]
-    #[suggestion("remove this attribute", code = "", applicability = "machine-applicable")]
+    #[suggestion("remove this attribute", code = "", applicability = "unspecified")]
     pub this: Span,
     #[note("attribute also specified here")]
     pub other: Span,
@@ -2061,7 +2061,7 @@ pub(crate) struct AdditionalCommaSuggestion {
 #[derive(Diagnostic)]
 #[diag("unused attribute")]
 pub(crate) struct UnusedDuplicate {
-    #[suggestion("remove this attribute", code = "", applicability = "machine-applicable")]
+    #[suggestion("remove this attribute", code = "", applicability = "unspecified")]
     pub this: Span,
     #[note("attribute also specified here")]
     pub other: Span,

compiler/rustc_borrowck/src/diagnostics/explain_borrow.rs

@@ -415,7 +415,7 @@ impl<'tcx> BorrowExplanation<'tcx> {
                 let mut preds = path
                     .iter()
                     .filter_map(|constraint| match constraint.category {
-                        ConstraintCategory::Predicate(pred) if !pred.is_dummy() => Some(pred),
+                        ConstraintCategory::Predicate(pred, _) if !pred.is_dummy() => Some(pred),
                         _ => None,
                     })
                     .collect::<Vec<Span>>();

compiler/rustc_borrowck/src/diagnostics/region_errors.rs

@@ -58,7 +58,7 @@ impl<'tcx> ConstraintDescription for ConstraintCategory<'tcx> {
             ConstraintCategory::ClosureUpvar(_) => "closure capture ",
             ConstraintCategory::Usage => "this usage ",
             ConstraintCategory::SolverRegionConstraint(_)
-            | ConstraintCategory::Predicate(_)
+            | ConstraintCategory::Predicate(_, _)
             | ConstraintCategory::Boring
             | ConstraintCategory::BoringNoLocation
             | ConstraintCategory::Internal

compiler/rustc_borrowck/src/lib.rs

@@ -232,7 +232,7 @@ pub struct ClosureOutlivesRequirement<'tcx> {
 
 // Make sure this enum doesn't unintentionally grow
 #[cfg(target_pointer_width = "64")]
-rustc_data_structures::static_assert_size!(ConstraintCategory<'_>, 16);
+rustc_data_structures::static_assert_size!(ConstraintCategory<'_>, 24);
 
 /// The subject of a `ClosureOutlivesRequirement` -- that is, the thing
 /// that must outlive some region.

compiler/rustc_borrowck/src/region_infer/mod.rs

@@ -275,11 +275,11 @@ impl<'tcx> BestBlame<'tcx> {
             .path
             .iter()
             .find_map(|constraint| {
-                if let ConstraintCategory::Predicate(predicate_span) = constraint.category {
+                if let ConstraintCategory::Predicate(predicate_span, def_id) = constraint.category {
                     // We currently do not store the `DefId` in the `ConstraintCategory`
                     // for performances reasons. The error reporting code used by NLL only
                     // uses the span, so this doesn't cause any problems at the moment.
-                    Some(ObligationCauseCode::WhereClause(CRATE_DEF_ID.to_def_id(), predicate_span))
+                    Some(ObligationCauseCode::WhereClause(def_id, predicate_span))
                 } else {
                     None
                 }

compiler/rustc_borrowck/src/region_infer/region_context.rs

@@ -742,7 +742,7 @@ impl<'tcx> RegionInferenceContextInner<'tcx> {
                 // Generic arguments are unlikely to be what relates regions together
                 ConstraintCategory::TypeAnnotation(AnnotationSource::GenericArg) => 3,
                 // We handle predicates and opaque types specially; don't prioritize them here.
-                ConstraintCategory::Predicate(_) | ConstraintCategory::OpaqueType => 4,
+                ConstraintCategory::Predicate(_, _) | ConstraintCategory::OpaqueType => 4,
                 // `Boring` constraints can correspond to user-written code and have useful spans,
                 // but don't provide any other useful information for diagnostics.
                 ConstraintCategory::Boring => 5,

compiler/rustc_borrowck/src/type_check/canonical.rs

@@ -142,15 +142,13 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
     #[instrument(level = "debug", skip(self))]
     pub(super) fn normalize_and_prove_instantiated_clauses(
         &mut self,
-        // Keep this parameter for now, in case we start using
-        // it in `ConstraintCategory` at some point.
-        _def_id: DefId,
+        def_id: DefId,
         instantiated_clauses: ty::InstantiatedClauses<'tcx>,
         locations: Locations,
     ) {
         for (clause, span) in instantiated_clauses {
             debug!(?span, ?clause);
-            let category = ConstraintCategory::Predicate(span);
+            let category = ConstraintCategory::Predicate(span, def_id);
             let clause = self.normalize_with_category(clause, locations, category);
             self.prove_clause(clause, locations, category);
         }

compiler/rustc_borrowck/src/type_check/mod.rs

@@ -1361,7 +1361,7 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
                         let cast_ty_from = CastTy::from_ty(ty_from);
                         let cast_ty_to = CastTy::from_ty(*ty);
                         match (cast_ty_from, cast_ty_to) {
-                            (Some(CastTy::Ptr(_) | CastTy::FnPtr), Some(CastTy::Int(_))) => (),
+                            (Some(CastTy::Ptr(_) | CastTy::FnPtr), Some(CastTy::Int)) => (),
                             _ => {
                                 span_mirbug!(
                                     self,
@@ -1379,7 +1379,7 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
                         let cast_ty_from = CastTy::from_ty(ty_from);
                         let cast_ty_to = CastTy::from_ty(*ty);
                         match (cast_ty_from, cast_ty_to) {
-                            (Some(CastTy::Int(_)), Some(CastTy::Ptr(_))) => (),
+                            (Some(CastTy::Int), Some(CastTy::Ptr(_))) => (),
                             _ => {
                                 span_mirbug!(
                                     self,
@@ -1396,7 +1396,7 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
                         let cast_ty_from = CastTy::from_ty(ty_from);
                         let cast_ty_to = CastTy::from_ty(*ty);
                         match (cast_ty_from, cast_ty_to) {
-                            (Some(CastTy::Int(_)), Some(CastTy::Int(_))) => (),
+                            (Some(from), Some(to)) if from.is_int_like() && to.is_int_like() => (),
                             _ => {
                                 span_mirbug!(
                                     self,
@@ -1413,7 +1413,7 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
                         let cast_ty_from = CastTy::from_ty(ty_from);
                         let cast_ty_to = CastTy::from_ty(*ty);
                         match (cast_ty_from, cast_ty_to) {
-                            (Some(CastTy::Int(_)), Some(CastTy::Float)) => (),
+                            (Some(CastTy::Int), Some(CastTy::Float)) => (),
                             _ => {
                                 span_mirbug!(
                                     self,
@@ -1430,7 +1430,7 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
                         let cast_ty_from = CastTy::from_ty(ty_from);
                         let cast_ty_to = CastTy::from_ty(*ty);
                         match (cast_ty_from, cast_ty_to) {
-                            (Some(CastTy::Float), Some(CastTy::Int(_))) => (),
+                            (Some(CastTy::Float), Some(CastTy::Int)) => (),
                             _ => {
                                 span_mirbug!(
                                     self,

compiler/rustc_builtin_macros/src/format.rs

@@ -339,7 +339,9 @@ fn make_format_args(
             parse::Suggestion::UsePositional => {
                 let captured_arg_span =
                     fmt_span.from_inner(InnerSpan::new(err.span.start, err.span.end));
-                if let Ok(arg) = ecx.source_map().span_to_snippet(captured_arg_span) {
+                if is_source_literal
+                    && let Ok(arg) = ecx.source_map().span_to_snippet(captured_arg_span)
+                {
                     let span = match args.unnamed_args().last() {
                         Some(arg) => arg.expr.span,
                         None => fmt_span,
@@ -360,17 +362,21 @@ fn make_format_args(
                 }
             }
             parse::Suggestion::ReorderFormatParameter(span, replacement) => {
-                let span = fmt_span.from_inner(InnerSpan::new(span.start, span.end));
-                e.sugg_ =
-                    Some(diagnostics::InvalidFormatStringSuggestion::ReorderFormatParameter {
-                        span,
-                        replacement,
-                    });
+                if is_source_literal {
+                    let span = fmt_span.from_inner(InnerSpan::new(span.start, span.end));
+                    e.sugg_ =
+                        Some(diagnostics::InvalidFormatStringSuggestion::ReorderFormatParameter {
+                            span,
+                            replacement,
+                        });
+                }
             }
             parse::Suggestion::AddMissingColon(span) => {
-                let span = fmt_span.from_inner(InnerSpan::new(span.start, span.end));
-                e.sugg_ =
-                    Some(diagnostics::InvalidFormatStringSuggestion::AddMissingColon { span });
+                if is_source_literal {
+                    let span = fmt_span.from_inner(InnerSpan::new(span.start, span.end));
+                    e.sugg_ =
+                        Some(diagnostics::InvalidFormatStringSuggestion::AddMissingColon { span });
+                }
             }
             parse::Suggestion::UseRustDebugPrintingMacro => {
                 // This targets `println!("{=}", x);` and `println!("{0=}", x);`

compiler/rustc_data_structures/src/fx.rs

@@ -28,7 +28,7 @@ macro_rules! define_stable_id_collections {
 }
 
 pub mod default {
-    use super::{FxBuildHasher, FxHashMap, FxHashSet};
+    use super::{FxBuildHasher, FxHashMap, FxHashSet, FxIndexMap, FxIndexSet};
 
     // FIXME: These two functions will become unnecessary after
     // <https://github.com/rust-lang/rustc-hash/pull/63> lands and we start using the corresponding
@@ -40,4 +40,12 @@ pub mod default {
     pub const fn fx_hash_set<V>() -> FxHashSet<V> {
         FxHashSet::with_hasher(FxBuildHasher)
     }
+
+    pub const fn fx_index_map<K, V>() -> FxIndexMap<K, V> {
+        FxIndexMap::with_hasher(FxBuildHasher)
+    }
+
+    pub const fn fx_index_set<V>() -> FxIndexSet<V> {
+        FxIndexSet::with_hasher(FxBuildHasher)
+    }
 }

compiler/rustc_hir_analysis/src/coherence/builtin.rs

@@ -115,7 +115,11 @@ fn visit_implementation_of_copy(checker: &Checker<'_>) -> Result<(), ErrorGuaran
         Err(CopyImplementationError::HasDestructor(did)) => {
             let span = tcx.hir_expect_item(impl_did).expect_impl().self_ty.span;
             let impl_ = tcx.def_span(did);
-            Err(tcx.dcx().emit_err(diagnostics::CopyImplOnTypeWithDtor { span, impl_ }))
+            Err(tcx.dcx().emit_err(diagnostics::TraitImplOnTypeWithDtor {
+                span,
+                impl_,
+                trait_name: sym::Copy,
+            }))
         }
         Err(CopyImplementationError::HasUnsafeFields) => {
             let span = tcx.hir_expect_item(impl_did).expect_impl().self_ty.span;
@@ -537,6 +541,15 @@ pub(crate) fn reborrow_info<'tcx>(
         assert_field_type_is_copy(tcx, &infcx, impl_did, param_env, field.ty, field.span)?;
     }
 
+    if let Some(did) = def.destructor(tcx).map(|dtor| dtor.did) {
+        let impl_ = tcx.def_span(did);
+        return Err(tcx.dcx().emit_err(diagnostics::TraitImplOnTypeWithDtor {
+            span,
+            impl_,
+            trait_name: sym::Reborrow,
+        }));
+    }
+
     Ok(())
 }
 

compiler/rustc_hir_analysis/src/diagnostics.rs

@@ -296,13 +296,14 @@ pub(crate) struct FieldAlreadyDeclaredNestedHelp {
 }
 
 #[derive(Diagnostic)]
-#[diag("the trait `Copy` cannot be implemented for this type; the type has a destructor", code = E0184)]
-pub(crate) struct CopyImplOnTypeWithDtor {
+#[diag("the trait `{$trait_name}` cannot be implemented for this type; the type has a destructor", code = E0184)]
+pub(crate) struct TraitImplOnTypeWithDtor {
     #[primary_span]
-    #[label("`Copy` not allowed on types with destructors")]
+    #[label("`{$trait_name}` not allowed on types with destructors")]
     pub span: Span,
     #[note("destructor declared here")]
     pub impl_: Span,
+    pub trait_name: Symbol,
 }
 
 #[derive(Diagnostic)]