deduplication logic in trait selection

Author: b-naber

compiler/rustc_trait_selection/src/traits/const_evaluatable.rs

@@ -32,7 +32,7 @@ pub fn is_const_evaluatable<'cx, 'tcx>(
     uv: ty::Unevaluated<'tcx, ()>,
     param_env: ty::ParamEnv<'tcx>,
     span: Span,
-) -> Result<(), NotConstEvaluatable> {
+) -> Result<(), NotConstEvaluatable<'tcx>> {
     debug!("is_const_evaluatable({:?})", uv);
     if infcx.tcx.features().generic_const_exprs {
         let tcx = infcx.tcx;
@@ -174,6 +174,7 @@ pub fn is_const_evaluatable<'cx, 'tcx>(
             Err(NotConstEvaluatable::Error(ErrorReported))
         }
         Err(ErrorHandled::Reported(e)) => Err(NotConstEvaluatable::Error(e)),
+        Err(ErrorHandled::Silent(id)) => Err(NotConstEvaluatable::Silent(id)),
         Ok(_) => Ok(()),
     }
 }

compiler/rustc_trait_selection/src/traits/fulfill.rs

@@ -528,12 +528,14 @@ impl<'a, 'b, 'tcx> FulfillProcessor<'a, 'b, 'tcx> {
                 }
 
                 ty::PredicateKind::ConstEvaluatable(uv) => {
-                    match const_evaluatable::is_const_evaluatable(
+                    let res = const_evaluatable::is_const_evaluatable(
                         self.selcx.infcx(),
                         uv,
-                        obligation.param_env,
+                        obligation.param_env.with_reveal_selection(),
                         obligation.cause.span,
-                    ) {
+                    );
+
+                    match res {
                         Ok(()) => ProcessResult::Changed(vec![]),
                         Err(NotConstEvaluatable::MentionsInfer) => {
                             pending_obligation.stalled_on.clear();
@@ -546,7 +548,8 @@ impl<'a, 'b, 'tcx> FulfillProcessor<'a, 'b, 'tcx> {
                         }
                         Err(
                             e @ NotConstEvaluatable::MentionsParam
-                            | e @ NotConstEvaluatable::Error(_),
+                            | e @ NotConstEvaluatable::Error(_)
+                            | e @ NotConstEvaluatable::Silent(_),
                         ) => ProcessResult::Error(CodeSelectionError(
                             SelectionError::NotConstEvaluatable(e),
                         )),
@@ -625,10 +628,12 @@ impl<'a, 'b, 'tcx> FulfillProcessor<'a, 'b, 'tcx> {
                                 "ConstEquate: const_eval_resolve returned an unexpected error"
                             )
                         }
-                        (Err(ErrorHandled::Silent), _) | (_, Err(ErrorHandled::Silent)) => {
-                            ProcessResult::Error(CodeSelectionError(ConstEvalFailure(
-                                ErrorHandled::Silent,
-                            )))
+                        (Err(ErrorHandled::Silent(id)), _) | (_, Err(ErrorHandled::Silent(id))) => {
+                            ProcessResult::Error(CodeSelectionError(
+                                SelectionError::NotConstEvaluatable(NotConstEvaluatable::Silent(
+                                    id,
+                                )),
+                            ))
                         }
                         (Err(ErrorHandled::TooGeneric), _) | (_, Err(ErrorHandled::TooGeneric)) => {
                             if c1.has_infer_types_or_consts() || c2.has_infer_types_or_consts() {

compiler/rustc_trait_selection/src/traits/mod.rs

@@ -273,6 +273,7 @@ fn do_normalize_predicates<'tcx>(
 
 // FIXME: this is gonna need to be removed ...
 /// Normalizes the parameter environment, reporting errors if they occur.
+#[instrument(skip(tcx), level = "debug")]
 pub fn normalize_param_env_or_error<'tcx>(
     tcx: TyCtxt<'tcx>,
     region_context: DefId,

compiler/rustc_trait_selection/src/traits/project.rs

@@ -26,6 +26,7 @@ use rustc_hir::def_id::DefId;
 use rustc_hir::lang_items::LangItem;
 use rustc_infer::infer::resolve::OpportunisticRegionResolver;
 use rustc_middle::ty::fold::{TypeFoldable, TypeFolder};
+
 use rustc_middle::ty::subst::Subst;
 use rustc_middle::ty::{self, ToPredicate, Ty, TyCtxt};
 use rustc_span::symbol::sym;
@@ -296,7 +297,7 @@ where
 
 pub(crate) fn needs_normalization<'tcx, T: TypeFoldable<'tcx>>(value: &T, reveal: Reveal) -> bool {
     match reveal {
-        Reveal::UserFacing => value
+        Reveal::Selection | Reveal::UserFacing => value
             .has_type_flags(ty::TypeFlags::HAS_TY_PROJECTION | ty::TypeFlags::HAS_CT_PROJECTION),
         Reveal::All => value.has_type_flags(
             ty::TypeFlags::HAS_TY_PROJECTION

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

@@ -675,10 +675,14 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                                 Err(_) => Ok(EvaluatedToErr),
                             }
                         }
-                        (Err(ErrorHandled::Reported(ErrorReported) | ErrorHandled::Silent), _)
-                        | (_, Err(ErrorHandled::Reported(ErrorReported) | ErrorHandled::Silent)) => {
-                            Ok(EvaluatedToErr)
-                        }
+                        (
+                            Err(ErrorHandled::Reported(ErrorReported) | ErrorHandled::Silent(_)),
+                            _,
+                        )
+                        | (
+                            _,
+                            Err(ErrorHandled::Reported(ErrorReported) | ErrorHandled::Silent(_)),
+                        ) => Ok(EvaluatedToErr),
                         (Err(ErrorHandled::Linted), _) | (_, Err(ErrorHandled::Linted)) => {
                             span_bug!(
                                 obligation.cause.span(self.tcx()),
@@ -2659,11 +2663,7 @@ impl<'o, 'tcx> TraitObligationStackList<'o, 'tcx> {
     }
 
     fn depth(&self) -> usize {
-        if let Some(head) = self.head {
-            head.depth
-        } else {
-            0
-        }
+        if let Some(head) = self.head { head.depth } else { 0 }
     }
 }