Tweak spans for trait bounds on associated types

compiler/rustc_borrowck/src/type_check/canonical.rs

@@ -95,6 +95,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
                 trait_ref,
                 constness: ty::BoundConstness::NotConst,
                 polarity: ty::ImplPolarity::Positive,
+                // implicit: ty::ImplicitBound::No,
             }))),
             locations,
             category,

compiler/rustc_const_eval/src/transform/check_consts/check.rs

@@ -813,6 +813,7 @@ impl Visitor<'tcx> for Checker<'mir, 'tcx> {
                             trait_ref,
                             constness: ty::BoundConstness::ConstIfConst,
                             polarity: ty::ImplPolarity::Positive,
+                            // implicit: ty::ImplicitBound::No,
                         }),
                     );
 

compiler/rustc_const_eval/src/transform/check_consts/qualifs.rs

@@ -162,6 +162,7 @@ impl Qualif for NeedsNonConstDrop {
                 trait_ref,
                 constness: ty::BoundConstness::ConstIfConst,
                 polarity: ty::ImplPolarity::Positive,
+                // implicit: ty::ImplicitBound::No,
             }),
         );
 

compiler/rustc_infer/src/infer/outlives/obligations.rs

@@ -103,7 +103,8 @@ impl<'cx, 'tcx> InferCtxt<'cx, 'tcx> {
                 cause.span,
                 sup_type,
                 match cause.code.peel_derives() {
-                    ObligationCauseCode::BindingObligation(_, span) => Some(*span),
+                    ObligationCauseCode::BindingObligation(_, span)
+                    | ObligationCauseCode::ImplicitSizedObligation(_, span) => Some(*span),
                     _ => None,
                 },
             )

compiler/rustc_middle/src/traits/mod.rs

@@ -204,6 +204,9 @@ pub enum ObligationCauseCode<'tcx> {
     /// Like `ItemObligation`, but with extra detail on the source of the obligation.
     BindingObligation(DefId, Span),
 
+    /// Like `ItemObligation`, but with extra detail on the source of the obligation.
+    ImplicitSizedObligation(DefId, Span),
+
     /// A type like `&'a T` is WF only if `T: 'a`.
     ReferenceOutlivesReferent(Ty<'tcx>),
 

compiler/rustc_middle/src/ty/mod.rs

@@ -165,6 +165,25 @@ pub struct ImplHeader<'tcx> {
     pub predicates: Vec<Predicate<'tcx>>,
 }
 
+// #[derive(
+//     Copy,
+//     Clone,
+//     PartialEq,
+//     Eq,
+//     Hash,
+//     TyEncodable,
+//     TyDecodable,
+//     HashStable,
+//     Debug,
+//     TypeFoldable
+// )]
+// pub enum ImplicitBound {
+//     /// `T: Trait`
+//     No,
+//     /// implicit `T: Sized`
+//     Yes,
+// }
+
 #[derive(
     Copy,
     Clone,
@@ -518,13 +537,17 @@ impl<'tcx> Predicate<'tcx> {
             .inner
             .kind
             .map_bound(|kind| match kind {
-                PredicateKind::Trait(TraitPredicate { trait_ref, constness, polarity }) => {
-                    Some(PredicateKind::Trait(TraitPredicate {
-                        trait_ref,
-                        constness,
-                        polarity: polarity.flip()?,
-                    }))
-                }
+                PredicateKind::Trait(TraitPredicate {
+                    trait_ref,
+                    constness,
+                    polarity,
+                    // implicit,
+                }) => Some(PredicateKind::Trait(TraitPredicate {
+                    trait_ref,
+                    constness,
+                    polarity: polarity.flip()?,
+                    // implicit,
+                })),
 
                 _ => None,
             })
@@ -729,6 +752,8 @@ pub struct TraitPredicate<'tcx> {
     pub constness: BoundConstness,
 
     pub polarity: ImplPolarity,
+
+    // pub implicit: ImplicitBound,
 }
 
 pub type PolyTraitPredicate<'tcx> = ty::Binder<'tcx, TraitPredicate<'tcx>>;
@@ -1425,6 +1450,7 @@ impl PolyTraitRef<'tcx> {
             trait_ref,
             constness,
             polarity: ty::ImplPolarity::Positive,
+            // implicit: ty::ImplicitBound::No,
         })
     }
     #[inline]

compiler/rustc_middle/src/ty/relate.rs

@@ -788,6 +788,21 @@ impl<'tcx> Relate<'tcx> for GenericArg<'tcx> {
     }
 }
 
+// impl<'tcx> Relate<'tcx> for ty::ImplicitBound {
+//     fn relate<R: TypeRelation<'tcx>>(
+//         _relation: &mut R,
+//         a: ty::ImplicitBound,
+//         b: ty::ImplicitBound,
+//     ) -> RelateResult<'tcx, ty::ImplicitBound> {
+//         match (a, b) {
+//             (ty::ImplicitBound::No, ty::ty::ImplicitBound::No) => Ok(ty::ImplicitBound::No),
+//             (ty::ImplicitBound::Yes, ty::ty::ImplicitBound::Yes)
+//             | (ty::ImplicitBound::Yes, ty::ty::ImplicitBound::No)
+//             | (ty::ImplicitBound::No, ty::ty::ImplicitBound::Yes) => Ok(ty::ImplicitBound::Yes),
+//         }
+//     }
+// }
+
 impl<'tcx> Relate<'tcx> for ty::ImplPolarity {
     fn relate<R: TypeRelation<'tcx>>(
         relation: &mut R,
@@ -812,6 +827,7 @@ impl<'tcx> Relate<'tcx> for ty::TraitPredicate<'tcx> {
             trait_ref: relation.relate(a.trait_ref, b.trait_ref)?,
             constness: relation.relate(a.constness, b.constness)?,
             polarity: relation.relate(a.polarity, b.polarity)?,
+            // implicit: relation.relate(a.implicit, b.implicit)?,
         })
     }
 }

compiler/rustc_middle/src/ty/structural_impls.rs

@@ -369,6 +369,7 @@ impl<'a, 'tcx> Lift<'tcx> for ty::TraitPredicate<'a> {
             trait_ref,
             constness: self.constness,
             polarity: self.polarity,
+            // implicit: ty::ImplicitBound::No,
         })
     }
 }

compiler/rustc_middle/src/ty/sty.rs

@@ -944,6 +944,7 @@ impl<'tcx> PolyTraitRef<'tcx> {
             trait_ref,
             constness: ty::BoundConstness::NotConst,
             polarity: ty::ImplPolarity::Positive,
+            // implicit: ty::ImplicitBound::No,
         })
     }
 }

compiler/rustc_privacy/src/lib.rs

@@ -128,6 +128,7 @@ where
                 trait_ref,
                 constness: _,
                 polarity: _,
+                // implicit: _,
             }) => self.visit_trait(trait_ref),
             ty::PredicateKind::Projection(ty::ProjectionPredicate { projection_ty, ty }) => {
                 ty.visit_with(self)?;

compiler/rustc_trait_selection/src/traits/auto_trait.rs

@@ -290,6 +290,7 @@ impl AutoTraitFinder<'tcx> {
             constness: ty::BoundConstness::NotConst,
             // Auto traits are positive
             polarity: ty::ImplPolarity::Positive,
+            // implicit: ty::ImplicitBound::No,
         }));
 
         let computed_preds = param_env.caller_bounds().iter();

compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs

@@ -1307,6 +1307,7 @@ impl<'a, 'tcx> InferCtxtPrivExt<'tcx> for InferCtxt<'a, 'tcx> {
                     obligation.cause.code.peel_derives(),
                     ObligationCauseCode::ItemObligation(_)
                         | ObligationCauseCode::BindingObligation(_, _)
+                        | ObligationCauseCode::ImplicitSizedObligation(_, _)
                         | ObligationCauseCode::ObjectCastObligation(_)
                         | ObligationCauseCode::OpaqueType
                 );
@@ -1702,7 +1703,8 @@ impl<'a, 'tcx> InferCtxtPrivExt<'tcx> for InferCtxt<'a, 'tcx> {
                     self.suggest_fully_qualified_path(&mut err, def_id, span, trait_ref.def_id());
                 } else if let (
                     Ok(ref snippet),
-                    ObligationCauseCode::BindingObligation(ref def_id, _),
+                    ObligationCauseCode::BindingObligation(ref def_id, _)
+                    | ObligationCauseCode::ImplicitSizedObligation(ref def_id, _),
                 ) =
                     (self.tcx.sess.source_map().span_to_snippet(span), &obligation.cause.code)
                 {
@@ -2005,7 +2007,8 @@ impl<'a, 'tcx> InferCtxtPrivExt<'tcx> for InferCtxt<'a, 'tcx> {
             {
                 (
                     ty::PredicateKind::Trait(pred),
-                    &ObligationCauseCode::BindingObligation(item_def_id, span),
+                    &ObligationCauseCode::BindingObligation(item_def_id, span)
+                    | &ObligationCauseCode::ImplicitSizedObligation(item_def_id, span),
                 ) => (pred, item_def_id, span),
                 _ => return,
             };

compiler/rustc_trait_selection/src/traits/error_reporting/on_unimplemented.rs

@@ -141,7 +141,8 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> {
         }
 
         if let ObligationCauseCode::ItemObligation(item)
-        | ObligationCauseCode::BindingObligation(item, _) = obligation.cause.code
+        | ObligationCauseCode::BindingObligation(item, _)
+        | ObligationCauseCode::ImplicitSizedObligation(item, _) = obligation.cause.code
         {
             // FIXME: maybe also have some way of handling methods
             // from other traits? That would require name resolution,

compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs

@@ -802,6 +802,7 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> {
         if let ObligationCauseCode::ImplDerivedObligation(obligation) = &*code {
             try_borrowing(obligation.parent_trait_ref, &[])
         } else if let ObligationCauseCode::BindingObligation(_, _)
+        | ObligationCauseCode::ImplicitSizedObligation(..)
         | ObligationCauseCode::ItemObligation(_) = &*code
         {
             try_borrowing(*poly_trait_ref, &never_suggest_borrow)
@@ -1961,6 +1962,62 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> {
                 // We hold the `DefId` of the item introducing the obligation, but displaying it
                 // doesn't add user usable information. It always point at an associated item.
             }
+            ObligationCauseCode::ImplicitSizedObligation(item_def_id, span) => {
+                let item_name = tcx.def_path_str(item_def_id);
+                let mut sp: MultiSpan = span.into();
+                match self.tcx.hir().get_if_local(item_def_id) {
+                    Some(hir::Node::TraitItem(hir::TraitItem {
+                        kind: hir::TraitItemKind::Type(bounds, _),
+                        ident,
+                        ..
+                    })) => {
+                        sp.push_span_label(
+                            span,
+                            format!("required by associated type `{}`", item_name),
+                        );
+                        err.span_note(sp, "associated types have an implicit `Sized` obligation");
+
+                        let sized_trait = self.tcx.lang_items().sized_trait();
+                        if bounds.len() == 0 {
+                            err.span_suggestion_verbose(
+                                ident.span.shrink_to_hi(),
+                                "consider relaxing the `Sized` obligation",
+                                ": ?Sized".to_string(),
+                                Applicability::MaybeIncorrect,
+                            );
+                        } else if bounds.iter().all(|bound| {
+                            bound.trait_ref().and_then(|tr| tr.trait_def_id()) != sized_trait
+                        }) {
+                            err.span_suggestion_verbose(
+                                bounds.iter().last().unwrap().span().shrink_to_hi(),
+                                "consider relaxing the `Sized` obligation",
+                                " + ?Sized".to_string(),
+                                Applicability::MaybeIncorrect,
+                            );
+                        }
+                    }
+                    Some(hir::Node::ImplItem(hir::ImplItem {
+                        kind: hir::ImplItemKind::TyAlias(_),
+                        ..
+                    })) => {
+                        let msg = "associated types on `impl` blocks for types, have an implicit \
+                            mandatory `Sized` obligation; associated types from `trait`s can be \
+                            relaxed to `?Sized`";
+                        sp.push_span_label(
+                            span,
+                            format!("required by associated type `{}`", item_name),
+                        );
+                        err.span_note(sp, msg);
+                    }
+                    _ => {
+                        sp.push_span_label(
+                            span,
+                            format!("required by this bound in `{}`", item_name),
+                        );
+                        err.span_note(sp, "type parameters have an implicit `Sized` obligation");
+                    }
+                }
+            }
             ObligationCauseCode::BindingObligation(item_def_id, span) => {
                 let item_name = tcx.def_path_str(item_def_id);
                 let mut multispan = MultiSpan::from(span);

compiler/rustc_trait_selection/src/traits/mod.rs

@@ -826,6 +826,7 @@ pub fn vtable_trait_upcasting_coercion_new_vptr_slot(
             trait_ref,
             constness: ty::BoundConstness::NotConst,
             polarity: ty::ImplPolarity::Positive,
+            // implicit: ty::ImplicitBound::No,
         }),
     );
 

compiler/rustc_trait_selection/src/traits/relationships.rs

@@ -45,6 +45,7 @@ pub(crate) fn update<'tcx, T>(
                                 trait_ref,
                                 constness: predicate.constness,
                                 polarity: predicate.polarity,
+                                // implicit: predicate.implicit,
                             })
                         })
                         .to_predicate(infcx.tcx),

compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs

@@ -935,6 +935,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                     },
                     constness: ty::BoundConstness::NotConst,
                     polarity: ty::ImplPolarity::Positive,
+                    // implicit: ty::ImplicitBound::No,
                 }));
             copy_obligation.recursion_depth = depth + 1;
             self.assemble_candidates_from_impls(&copy_obligation, &mut new_candidates);
@@ -951,6 +952,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                     },
                     constness: ty::BoundConstness::ConstIfConst,
                     polarity: ty::ImplPolarity::Positive,
+                    // implicit: ty::ImplicitBound::No,
                 }));
 
             let const_drop_stack = self.push_stack(obligation_stack.list(), &const_drop_obligation);

compiler/rustc_trait_selection/src/traits/util.rs

@@ -236,7 +236,13 @@ pub fn predicates_for_generics<'tcx>(
             traits::ItemObligation(def_id) if !span.is_dummy() => traits::ObligationCause::new(
                 cause.span,
                 cause.body_id,
-                traits::BindingObligation(def_id, span),
+                match predicate.kind().skip_binder() {
+                    // ty::PredicateKind::Trait(ty::TraitPredicate {
+                    //     implicit: ty::ImplicitBound::Yes,
+                    //     ..
+                    // }) => traits::ImplicitSizedObligation(def_id, span),
+                    _ => traits::BindingObligation(def_id, span),
+                },
             ),
             _ => cause.clone(),
         };

compiler/rustc_trait_selection/src/traits/wf.rs

@@ -710,10 +710,13 @@ impl<'a, 'tcx> WfPredicates<'a, 'tcx> {
 
         iter::zip(iter::zip(predicates.predicates, predicates.spans), origins.into_iter().rev())
             .map(|((pred, span), origin_def_id)| {
-                let code = if span.is_dummy() {
-                    traits::MiscObligation
-                } else {
-                    traits::BindingObligation(origin_def_id, span)
+                let code = match () {// pred.kind().skip_binder() {
+                    _ if span.is_dummy() => traits::MiscObligation,
+                    // ty::PredicateKind::Trait(ty::TraitPredicate {
+                    //     implicit: ty::ImplicitBound::Yes,
+                    //     ..
+                    // }) => traits::ImplicitSizedObligation(origin_def_id, span),
+                    _ => traits::BindingObligation(origin_def_id, span),
                 };
                 let cause = self.cause(code);
                 traits::Obligation::with_depth(cause, self.recursion_depth, self.param_env, pred)

compiler/rustc_typeck/src/bounds.rs

@@ -56,11 +56,17 @@ impl<'tcx> Bounds<'tcx> {
         // If it could be sized, and is, add the `Sized` predicate.
         let sized_predicate = self.implicitly_sized.and_then(|span| {
             tcx.lang_items().sized_trait().map(|sized| {
-                let trait_ref = ty::Binder::dummy(ty::TraitRef {
-                    def_id: sized,
-                    substs: tcx.mk_substs_trait(param_ty, &[]),
-                });
-                (trait_ref.without_const().to_predicate(tcx), span)
+                let pred = ty::Binder::dummy(ty::PredicateKind::Trait(ty::TraitPredicate {
+                    trait_ref: ty::TraitRef {
+                        def_id: sized,
+                        substs: tcx.mk_substs_trait(param_ty, &[]),
+                    },
+                    constness: ty::BoundConstness::NotConst,
+                    polarity: ty::ImplPolarity::Positive,
+                    // implicit: ty::ImplicitBound::Yes,
+                }))
+                .to_predicate(tcx);
+                (pred, span)
             })
         });
 

compiler/rustc_typeck/src/check/_match.rs

@@ -531,6 +531,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                                     },
                                     constness: t.constness,
                                     polarity: t.polarity,
+                                    // implicit: t.implicit,
                                 }));
                             let obl = Obligation::new(
                                 o.cause.clone(),

compiler/rustc_typeck/src/check/cast.rs

@@ -625,8 +625,7 @@ impl<'a, 'tcx> CastCheck<'tcx> {
                 fcx.ty_to_string(t_cast)
             ))
             .help(&format!(
-                "cast can be replaced by coercion; this might \
-                                   require {}a temporary variable",
+                "cast can be replaced by coercion; this might require {}a temporary variable",
                 type_asc_or
             ))
             .emit();