remove unnecessary code

Author: lcnr

compiler/rustc_hir_analysis/src/check/compare_impl_item.rs

@@ -239,26 +239,21 @@ fn compare_method_predicate_entailment<'tcx>(
     let hybrid_preds = hybrid_preds.into_iter().map(Unnormalized::skip_norm_wip);
     let normalize_cause = traits::ObligationCause::misc(impl_m_span, impl_m_def_id);
     let param_env = ty::ParamEnv::new(tcx.mk_clauses_from_iter(hybrid_preds));
-    // FIXME(-Zhigher-ranked-assumptions): The `hybrid_preds`
+    // NOTE(-Zhigher-ranked-assumptions): The `hybrid_preds`
     // should be well-formed. However, using them may result in
     // region errors as we currently don't track placeholder
     // assumptions.
     //
-    // To avoid being backwards incompatible with the old solver,
-    // we also eagerly normalize the where-bounds in the new solver
-    // here while ignoring region constraints. This means we can then
-    // use where-bounds whose normalization results in placeholder
-    // errors further down without getting any errors.
+    // We eagerly normalize the where-clauses here while ignoring
+    // region constraints This means we can then use where-bounds
+    // whose normalization results in placeholder errors further
+    // down without getting any errors.
     //
-    // It should be sound to do so as the only region errors here
+    // This should be sound to do so as the only region errors here
     // should be due to missing implied bounds.
     //
     // cc trait-system-refactor-initiative/issues/166.
-    let param_env = if tcx.next_trait_solver_globally() {
-        traits::deeply_normalize_param_env_ignoring_regions(tcx, param_env, normalize_cause)
-    } else {
-        traits::normalize_param_env_or_error(tcx, param_env, normalize_cause)
-    };
+    let param_env = traits::normalize_param_env_or_error(tcx, param_env, normalize_cause);
     debug!(caller_bounds=?param_env.caller_bounds());
 
     let infcx = &tcx.infer_ctxt().build(TypingMode::non_body_analysis());

compiler/rustc_trait_selection/src/traits/mod.rs

@@ -31,7 +31,6 @@ use rustc_hir::def::DefKind;
 pub use rustc_infer::traits::*;
 use rustc_macros::TypeVisitable;
 use rustc_middle::query::Providers;
-use rustc_middle::span_bug;
 use rustc_middle::ty::error::{ExpectedFound, TypeError};
 use rustc_middle::ty::{
     self, Clause, GenericArgs, GenericArgsRef, Ty, TyCtxt, TypeFoldable, TypeFolder,
@@ -473,69 +472,6 @@ pub fn normalize_param_env_or_error<'tcx>(
     ty::ParamEnv::new(tcx.mk_clauses(&predicates))
 }
 
-/// Deeply normalize the param env using the next solver ignoring
-/// region errors.
-///
-/// FIXME(-Zhigher-ranked-assumptions): this is a hack to work around
-/// the fact that we don't support placeholder assumptions right now
-/// and is necessary for `compare_method_predicate_entailment`, see the
-/// use of this function for more info. We should remove this once we
-/// have proper support for implied bounds on binders.
-#[instrument(level = "debug", skip(tcx))]
-pub fn deeply_normalize_param_env_ignoring_regions<'tcx>(
-    tcx: TyCtxt<'tcx>,
-    unnormalized_env: ty::ParamEnv<'tcx>,
-    cause: ObligationCause<'tcx>,
-) -> ty::ParamEnv<'tcx> {
-    let predicates: Vec<_> =
-        util::elaborate(tcx, unnormalized_env.caller_bounds().into_iter()).collect();
-
-    debug!("normalize_param_env_or_error: elaborated-predicates={:?}", predicates);
-
-    let elaborated_env = ty::ParamEnv::new(tcx.mk_clauses(&predicates));
-    if !elaborated_env.has_aliases() {
-        return elaborated_env;
-    }
-
-    let span = cause.span;
-    let infcx = tcx
-        .infer_ctxt()
-        .with_next_trait_solver(true)
-        .ignoring_regions()
-        .build(TypingMode::non_body_analysis());
-    let predicates = match crate::solve::deeply_normalize::<_, FulfillmentError<'tcx>>(
-        infcx.at(&cause, elaborated_env),
-        Unnormalized::new_wip(predicates),
-    ) {
-        Ok(predicates) => predicates,
-        Err(errors) => {
-            infcx.err_ctxt().report_fulfillment_errors(errors);
-            // An unnormalized env is better than nothing.
-            debug!("normalize_param_env_or_error: errored resolving predicates");
-            return elaborated_env;
-        }
-    };
-
-    debug!("do_normalize_predicates: normalized predicates = {:?}", predicates);
-    // FIXME(-Zhigher-ranked-assumptions): We're ignoring region errors for now.
-    // There're placeholder constraints `leaking` out.
-    // See the fixme in the enclosing function's docs for more.
-    let _errors = infcx.resolve_regions(cause.body_id, elaborated_env, []);
-
-    let predicates = match infcx.fully_resolve(predicates) {
-        Ok(predicates) => predicates,
-        Err(fixup_err) => {
-            span_bug!(
-                span,
-                "inference variables in normalized parameter environment: {}",
-                fixup_err
-            )
-        }
-    };
-    debug!("normalize_param_env_or_error: final predicates={:?}", predicates);
-    ty::ParamEnv::new(tcx.mk_clauses(&predicates))
-}
-
 #[derive(Debug)]
 pub enum EvaluateConstErr {
     /// The constant being evaluated was either a generic parameter or inference variable, *or*,