Make may_use_unstable_feature a free function

Author: tiif

compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs

@@ -21,6 +21,7 @@ use crate::coherence;
 use crate::delegate::SolverDelegate;
 use crate::placeholder::BoundVarReplacer;
 use crate::solve::inspect::{self, ProofTreeBuilder};
+use crate::solve::ty::may_use_unstable_feature;
 use crate::solve::search_graph::SearchGraph;
 use crate::solve::{
     CanonicalInput, Certainty, FIXPOINT_STEP_LIMIT, Goal, GoalEvaluation, GoalEvaluationKind,
@@ -1186,7 +1187,7 @@ where
         param_env: I::ParamEnv,
         symbol: I::Symbol,
     ) -> bool {
-        self.delegate.may_use_unstable_feature(param_env, symbol)
+        may_use_unstable_feature(&**self.delegate, param_env, symbol)
     }
 }
 

compiler/rustc_trait_selection/src/traits/fulfill.rs

@@ -12,7 +12,7 @@ use rustc_middle::bug;
 use rustc_middle::ty::abstract_const::NotConstEvaluatable;
 use rustc_middle::ty::error::{ExpectedFound, TypeError};
 use rustc_middle::ty::{self, Binder, Const, GenericArgsRef, TypeVisitableExt, TypingMode};
-use rustc_type_ir::InferCtxtLike;
+use rustc_type_ir::may_use_unstable_feature;
 use thin_vec::{ThinVec, thin_vec};
 use tracing::{debug, debug_span, instrument};
 
@@ -772,8 +772,7 @@ impl<'a, 'tcx> ObligationProcessor for FulfillProcessor<'a, 'tcx> {
                     }
                 }
                 ty::PredicateKind::Clause(ty::ClauseKind::UnstableFeature(symbol)) => {
-                    #[allow(rustc::usage_of_type_ir_traits)]
-                    if self.selcx.infcx.may_use_unstable_feature(obligation.param_env, symbol) {
+                    if may_use_unstable_feature(self.selcx.infcx, obligation.param_env, symbol) {
                         ProcessResult::Changed(Default::default())
                     } else {
                         ProcessResult::Unchanged

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

@@ -31,7 +31,7 @@ use rustc_middle::ty::{
     TypeFoldable, TypeVisitableExt, TypingMode, Upcast, elaborate,
 };
 use rustc_span::{Symbol, sym};
-use rustc_type_ir::InferCtxtLike;
+use rustc_type_ir::may_use_unstable_feature;
 use tracing::{debug, instrument, trace};
 
 use self::EvaluationResult::*;
@@ -834,8 +834,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                 }
 
                 ty::PredicateKind::Clause(ty::ClauseKind::UnstableFeature(symbol)) => {
-                    #[allow(rustc::usage_of_type_ir_traits)]
-                    if self.infcx.may_use_unstable_feature(obligation.param_env, symbol) {
+                    if may_use_unstable_feature(self.infcx, obligation.param_env, symbol) {
                         Ok(EvaluatedToOk)
                     } else {
                         Ok(EvaluatedToAmbig)

compiler/rustc_type_ir/src/infer_ctxt.rs

@@ -285,42 +285,46 @@ pub trait InferCtxtLike: Sized {
 
     fn reset_opaque_types(&self);
 
-    fn may_use_unstable_feature(
-        &self,
-        param_env: <Self::Interner as Interner>::ParamEnv,
-        symbol: <Self::Interner as Interner>::Symbol,
-    ) -> bool {
-        // Iterate through all goals in param_env to find the one that has the same symbol.
-        for pred in param_env.caller_bounds().iter() {
-            if let ty::ClauseKind::UnstableFeature(sym) = pred.kind().skip_binder() {
-                if sym == symbol {
-                    return true;
-                }
+}
+
+
+pub fn may_use_unstable_feature<'a, I: Interner, Infcx>(
+    infcx: &'a Infcx,
+    param_env: I::ParamEnv,
+    symbol: I::Symbol,
+) -> bool 
+where Infcx: InferCtxtLike<Interner = I>
+{
+    // Iterate through all goals in param_env to find the one that has the same symbol.
+    for pred in param_env.caller_bounds().iter() {
+        if let ty::ClauseKind::UnstableFeature(sym) = pred.kind().skip_binder() {
+            if sym == symbol {
+                return true;
             }
         }
+    }
 
-        // During codegen we must assume that all feature bounds hold as we may be
-        // monomorphizing a body from an upstream crate which had an unstable feature
-        // enabled that we do not.
-        //
-        // Coherence should already report overlap errors involving unstable impls
-        // as the affected code would otherwise break when stabilizing this feature.
-        // It is also easily possible to accidentally cause unsoundness this way as
-        // we have to always enable unstable impls during codegen.
-        //
-        // Return ambiguity can also prevent people from writing code which depends on inference guidance
-        // that might no longer work after the impl is stabilised,
-        // tests/ui/unstable-feature_bound/unstable_impl_coherence_inherence.rs is one of the example.
-        //
-        // Note: `feature_bound_holds_in_crate` does not consider a feature to be enabled
-        // if we are in std/core even if there is a corresponding `feature` attribute on the crate.
-
-        if (self.typing_mode() == TypingMode::PostAnalysis)
-            || self.cx().features().feature_bound_holds_in_crate(symbol)
-        {
-            return true;
-        } else {
-            return false;
-        }
+    // During codegen we must assume that all feature bounds hold as we may be
+    // monomorphizing a body from an upstream crate which had an unstable feature
+    // enabled that we do not.
+    //
+    // Coherence should already report overlap errors involving unstable impls
+    // as the affected code would otherwise break when stabilizing this feature.
+    // It is also easily possible to accidentally cause unsoundness this way as
+    // we have to always enable unstable impls during codegen.
+    //
+    // Return ambiguity can also prevent people from writing code which depends on inference guidance
+    // that might no longer work after the impl is stabilised,
+    // tests/ui/unstable-feature_bound/unstable_impl_coherence_inherence.rs is one of the example.
+    //
+    // Note: `feature_bound_holds_in_crate` does not consider a feature to be enabled
+    // if we are in std/core even if there is a corresponding `feature` attribute on the crate.
+
+    if (infcx.typing_mode() == TypingMode::PostAnalysis)
+        || infcx.cx().features().feature_bound_holds_in_crate(symbol)
+    {
+        return true;
+    } else {
+        return false;
     }
 }