Silence errors in expressions caused by bare traits in paths in 2021 edition

Cargo.lock

@@ -4200,6 +4200,7 @@ dependencies = [
 name = "rustc_infer"
 version = "0.0.0"
 dependencies = [
+ "rustc_ast",
  "rustc_ast_ir",
  "rustc_data_structures",
  "rustc_errors",

compiler/rustc_hir_analysis/src/check/wfcheck.rs

@@ -1270,7 +1270,7 @@ fn check_item_type(
                 traits::ObligationCause::new(
                     ty_span,
                     wfcx.body_def_id,
-                    ObligationCauseCode::WellFormed(None),
+                    ObligationCauseCode::WellFormed(Some(WellFormedLoc::Ty(item_id))),
                 ),
                 wfcx.param_env,
                 item_ty,

compiler/rustc_hir_analysis/src/hir_ty_lowering/lint.rs

@@ -1,7 +1,8 @@
 use rustc_ast::TraitObjectSyntax;
-use rustc_errors::{codes::*, Diag, EmissionGuarantee, StashKey};
+use rustc_errors::{codes::*, Diag, EmissionGuarantee, ErrorGuaranteed, StashKey};
 use rustc_hir as hir;
 use rustc_hir::def::{DefKind, Res};
+use rustc_infer::traits::error_reporting::suggest_path_on_bare_trait;
 use rustc_lint_defs::{builtin::BARE_TRAIT_OBJECTS, Applicability};
 use rustc_span::Span;
 use rustc_trait_selection::traits::error_reporting::suggestions::NextTypeParamName;
@@ -17,13 +18,14 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         &self,
         self_ty: &hir::Ty<'_>,
         in_path: bool,
-    ) {
+    ) -> Option<ErrorGuaranteed> {
         let tcx = self.tcx();
 
-        let hir::TyKind::TraitObject([poly_trait_ref, ..], _, TraitObjectSyntax::None) =
-            self_ty.kind
-        else {
-            return;
+        let hir::TyKind::TraitObject(traits, _, TraitObjectSyntax::None) = self_ty.kind else {
+            return None;
+        };
+        let [poly_trait_ref, ..] = traits else {
+            return None;
         };
 
         let needs_bracket = in_path
@@ -36,6 +38,11 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
 
         let is_global = poly_trait_ref.trait_ref.path.is_global();
 
+        let object_safe = traits.iter().all(|ptr| match ptr.trait_ref.path.res {
+            Res::Def(DefKind::Trait, def_id) => tcx.object_safety_violations(def_id).is_empty(),
+            _ => false,
+        });
+
         let mut sugg = vec![(
             self_ty.span.shrink_to_lo(),
             format!(
@@ -61,28 +68,74 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
             let label = "add `dyn` keyword before this trait";
             let mut diag =
                 rustc_errors::struct_span_code_err!(tcx.dcx(), self_ty.span, E0782, "{}", msg);
-            if self_ty.span.can_be_used_for_suggestions()
-                && !self.maybe_suggest_impl_trait(self_ty, &mut diag)
-            {
-                // FIXME: Only emit this suggestion if the trait is object safe.
-                diag.multipart_suggestion_verbose(label, sugg, Applicability::MachineApplicable);
+            if self_ty.span.can_be_used_for_suggestions() {
+                self.maybe_suggest_impl_trait(self_ty, &mut diag);
+                if object_safe {
+                    // Only emit this suggestion if the trait is object safe.
+                    diag.multipart_suggestion_verbose(
+                        label,
+                        sugg,
+                        Applicability::MachineApplicable,
+                    );
+                }
             }
+
+            if !object_safe && self_ty.span.can_be_used_for_suggestions() {
+                let parent = tcx.parent_hir_node(self_ty.hir_id);
+                suggest_path_on_bare_trait(tcx, &mut diag, parent);
+            }
+
             // Check if the impl trait that we are considering is an impl of a local trait.
             self.maybe_suggest_blanket_trait_impl(self_ty, &mut diag);
             self.maybe_suggest_assoc_ty_bound(self_ty, &mut diag);
-            diag.stash(self_ty.span, StashKey::TraitMissingMethod);
+
+            if object_safe {
+                let parents = self.tcx().hir().parent_iter(self_ty.hir_id);
+                for (_, parent) in parents {
+                    let hir::Node::Expr(expr) = parent else {
+                        break;
+                    };
+                    if let hir::ExprKind::Path(hir::QPath::TypeRelative(_, segment)) = expr.kind
+                        && let Res::Err = segment.res
+                    {
+                        // If the trait is object safe *and* there's a path segment that couldn't be
+                        // resolved, we know that we will have a resolve error later. If there's an
+                        // unresolved segment *and* the trait is not object safe, then no other
+                        // error would have been emitted, so we always emit an error in that case.
+                        diag.emit();
+                        return None;
+                    }
+                }
+            }
+            diag.stash(self_ty.span, StashKey::TraitMissingMethod)
         } else {
             tcx.node_span_lint(BARE_TRAIT_OBJECTS, self_ty.hir_id, self_ty.span, |lint| {
                 lint.primary_message("trait objects without an explicit `dyn` are deprecated");
-                if self_ty.span.can_be_used_for_suggestions() {
-                    lint.multipart_suggestion_verbose(
-                        "if this is an object-safe trait, use `dyn`",
-                        sugg,
-                        Applicability::MachineApplicable,
-                    );
+                match (object_safe, self_ty.span.can_be_used_for_suggestions()) {
+                    (true, true) => {
+                        lint.multipart_suggestion_verbose(
+                            "as this is an \"object safe\" trait, write `dyn` in front of the \
+                             trait",
+                            sugg,
+                            Applicability::MachineApplicable,
+                        );
+                    }
+                    (true, false) => {
+                        lint.note(
+                            "as this is an \"object safe\" trait, you can write `dyn` in front of \
+                             the trait",
+                        );
+                    }
+                    (false, _) => {
+                        lint.note(
+                            "you can't use write a trait object here because the trait isn't \
+                             \"object safe\"",
+                        );
+                    }
                 }
                 self.maybe_suggest_blanket_trait_impl(self_ty, lint);
             });
+            None
         }
     }
 
@@ -152,6 +205,8 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
     }
 
     /// Make sure that we are in the condition to suggest `impl Trait`.
+    ///
+    /// Returns whether a suggestion was provided and whether the error itself should not be emitted
     fn maybe_suggest_impl_trait(&self, self_ty: &hir::Ty<'_>, diag: &mut Diag<'_>) -> bool {
         let tcx = self.tcx();
         let parent_id = tcx.hir().get_parent_item(self_ty.hir_id).def_id;
@@ -174,6 +229,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         };
         let impl_sugg = vec![(self_ty.span.shrink_to_lo(), "impl ".to_string())];
         let mut is_downgradable = true;
+        let mut downgrade = false;
         let is_object_safe = match self_ty.kind {
             hir::TyKind::TraitObject(objects, ..) => {
                 objects.iter().all(|o| match o.trait_ref.path.res {
@@ -182,7 +238,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                             // For recursive traits, don't downgrade the error. (#119652)
                             is_downgradable = false;
                         }
-                        tcx.is_object_safe(id)
+                        tcx.object_safety_violations(id).is_empty()
                     }
                     _ => false,
                 })
@@ -213,9 +269,9 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                 );
             } else if is_downgradable {
                 // We'll emit the object safety error already, with a structured suggestion.
-                diag.downgrade_to_delayed_bug();
+                downgrade = true;
             }
-            return true;
+            return downgrade;
         }
         for ty in sig.decl.inputs {
             if ty.hir_id != self_ty.hir_id {
@@ -239,7 +295,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                 diag.note(format!("`{trait_name}` it is not object safe, so it can't be `dyn`"));
                 if is_downgradable {
                     // We'll emit the object safety error already, with a structured suggestion.
-                    diag.downgrade_to_delayed_bug();
+                    downgrade = true;
                 }
             } else {
                 let sugg = if let hir::TyKind::TraitObject([_, _, ..], _, _) = self_ty.kind {
@@ -260,9 +316,9 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                     Applicability::MachineApplicable,
                 );
             }
-            return true;
+            return downgrade;
         }
-        false
+        downgrade
     }
 
     fn maybe_suggest_assoc_ty_bound(&self, self_ty: &hir::Ty<'_>, diag: &mut Diag<'_>) {

compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs

@@ -2069,7 +2069,9 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                 )
             }
             hir::TyKind::TraitObject(bounds, lifetime, repr) => {
-                self.prohibit_or_lint_bare_trait_object_ty(hir_ty, in_path);
+                if let Some(guar) = self.prohibit_or_lint_bare_trait_object_ty(hir_ty, in_path) {
+                    return Ty::new_error(tcx, guar);
+                }
 
                 let repr = match repr {
                     TraitObjectSyntax::Dyn | TraitObjectSyntax::None => ty::Dyn,

compiler/rustc_hir_analysis/src/hir_wf_check.rs

@@ -25,6 +25,7 @@ fn diagnostic_hir_wf_check<'tcx>(
     let def_id = match loc {
         WellFormedLoc::Ty(def_id) => def_id,
         WellFormedLoc::Param { function, param_idx: _ } => function,
+        WellFormedLoc::Expr(_) => return None,
     };
     let hir_id = tcx.local_def_id_to_hir_id(def_id);
 
@@ -79,7 +80,9 @@ fn diagnostic_hir_wf_check<'tcx>(
             let cause = traits::ObligationCause::new(
                 ty.span,
                 self.def_id,
-                traits::ObligationCauseCode::WellFormed(None),
+                traits::ObligationCauseCode::WellFormed(Some(traits::WellFormedLoc::Expr(
+                    ty.hir_id,
+                ))),
             );
 
             ocx.register_obligation(traits::Obligation::new(
@@ -191,6 +194,7 @@ fn diagnostic_hir_wf_check<'tcx>(
                 vec![&fn_decl.inputs[param_idx as usize]]
             }
         }
+        WellFormedLoc::Expr(_) => return None,
     };
     for ty in tys {
         visitor.visit_ty(ty);

compiler/rustc_hir_typeck/src/_match.rs

@@ -387,7 +387,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             {
                 // check that the `if` expr without `else` is the fn body's expr
                 if expr.span == sp {
-                    return self.get_fn_decl(hir_id).map(|(_, fn_decl, _)| {
+                    return self.tcx.get_fn_decl(hir_id).map(|(_, fn_decl, _)| {
                         let (ty, span) = match fn_decl.output {
                             hir::FnRetTy::DefaultReturn(span) => ("()".to_string(), span),
                             hir::FnRetTy::Return(ty) => (ty_to_string(&self.tcx, ty), ty.span),

compiler/rustc_hir_typeck/src/callee.rs

@@ -122,7 +122,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         self.register_wf_obligation(
             output.into(),
             call_expr.span,
-            ObligationCauseCode::WellFormed(None),
+            ObligationCauseCode::WellFormed(Some(traits::WellFormedLoc::Expr(call_expr.hir_id))),
         );
 
         output

compiler/rustc_hir_typeck/src/coercion.rs

@@ -487,7 +487,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
     fn coerce_unsized(&self, mut source: Ty<'tcx>, mut target: Ty<'tcx>) -> CoerceResult<'tcx> {
         source = self.shallow_resolve(source);
         target = self.shallow_resolve(target);
-        debug!(?source, ?target);
+        debug!(?source, ?target, ?self.cause);
 
         // We don't apply any coercions incase either the source or target
         // aren't sufficiently well known but tend to instead just equate
@@ -565,11 +565,9 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
         let mut selcx = traits::SelectionContext::new(self);
 
         // Create an obligation for `Source: CoerceUnsized<Target>`.
-        let cause = ObligationCause::new(
-            self.cause.span,
-            self.body_id,
-            ObligationCauseCode::Coercion { source, target },
-        );
+        let mut cause =
+            ObligationCause::new(self.cause.span, self.body_id, self.cause.code().clone());
+        cause.map_code(|parent_code| ObligationCauseCode::Coercion { source, target, parent_code });
 
         // Use a FIFO queue for this custom fulfillment procedure.
         //
@@ -993,8 +991,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         }
         debug!("coercion::try({:?}: {:?} -> {:?})", expr, source, target);
 
-        let cause =
-            cause.unwrap_or_else(|| self.cause(expr.span, ObligationCauseCode::ExprAssignable));
+        let cause = cause.unwrap_or_else(|| {
+            self.cause(expr.span, ObligationCauseCode::ExprAssignable(Some(expr.hir_id)))
+        });
         let coerce = Coerce::new(self, cause, allow_two_phase);
         let ok = self.commit_if_ok(|_| coerce.coerce(source, target))?;
 
@@ -1016,7 +1015,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         let source = self.resolve_vars_with_obligations(expr_ty);
         debug!("coercion::can_with_predicates({:?} -> {:?})", source, target);
 
-        let cause = self.cause(DUMMY_SP, ObligationCauseCode::ExprAssignable);
+        let cause = self.cause(DUMMY_SP, ObligationCauseCode::ExprAssignable(None));
         // We don't ever need two-phase here since we throw out the result of the coercion
         let coerce = Coerce::new(self, cause, AllowTwoPhase::No);
         self.probe(|_| {
@@ -1033,7 +1032,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     /// how many dereference steps needed to achieve `expr_ty <: target`. If
     /// it's not possible, return `None`.
     pub fn deref_steps(&self, expr_ty: Ty<'tcx>, target: Ty<'tcx>) -> Option<usize> {
-        let cause = self.cause(DUMMY_SP, ObligationCauseCode::ExprAssignable);
+        let cause = self.cause(DUMMY_SP, ObligationCauseCode::ExprAssignable(None));
         // We don't ever need two-phase here since we throw out the result of the coercion
         let coerce = Coerce::new(self, cause, AllowTwoPhase::No);
         coerce
@@ -1861,7 +1860,7 @@ impl<'tcx, 'exprs, E: AsCoercionSite> CoerceMany<'tcx, 'exprs, E> {
         };
 
         // If this is due to an explicit `return`, suggest adding a return type.
-        if let Some((fn_id, fn_decl, can_suggest)) = fcx.get_fn_decl(parent_id)
+        if let Some((fn_id, fn_decl, can_suggest)) = fcx.tcx.get_fn_decl(parent_id)
             && !due_to_block
         {
             fcx.suggest_missing_return_type(&mut err, fn_decl, expected, found, can_suggest, fn_id);

compiler/rustc_hir_typeck/src/expr.rs

@@ -591,7 +591,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             self.require_type_is_sized_deferred(
                 output,
                 call.map_or(expr.span, |e| e.span),
-                ObligationCauseCode::SizedCallReturnType,
+                ObligationCauseCode::SizedCallReturnType(did),
             );
         }
 
@@ -774,7 +774,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 self.ret_coercion_span.set(Some(expr.span));
             }
             let cause = self.cause(expr.span, ObligationCauseCode::ReturnNoExpression);
-            if let Some((_, fn_decl, _)) = self.get_fn_decl(expr.hir_id) {
+            if let Some((_, fn_decl, _)) = self.tcx.get_fn_decl(expr.hir_id) {
                 coercion.coerce_forced_unit(
                     self,
                     &cause,
@@ -1517,7 +1517,11 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 
         let ty = Ty::new_array_with_const_len(tcx, t, count);
 
-        self.register_wf_obligation(ty.into(), expr.span, ObligationCauseCode::WellFormed(None));
+        self.register_wf_obligation(
+            ty.into(),
+            expr.span,
+            ObligationCauseCode::WellFormed(Some(traits::WellFormedLoc::Expr(expr.hir_id))),
+        );
 
         ty
     }