Add the core logic in old solver and new solver

Author: tiif

compiler/rustc_next_trait_solver/src/solve/mod.rs

@@ -148,6 +148,40 @@ where
         }
     }
 
+    fn compute_unstable_feature_goal(
+        &mut self,
+        param_env: <I as Interner>::ParamEnv,
+        symbol: <I as Interner>::Symbol,
+    ) -> QueryResult<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 self.evaluate_added_goals_and_make_canonical_response(Certainty::Yes);
+                }
+            }
+        }
+
+        if self.cx().features().impl_stability() {
+            // If we are in std/core, and the feature is not enabled through #[unstable_feature_bound(..)]
+            return self.evaluate_added_goals_and_make_canonical_response(Certainty::Maybe(
+                MaybeCause::Ambiguity,
+            ));
+        } else {
+            // Outside of std/core, check if feature is enabled at crate level with #[feature(..)]
+            // or if we are currently in codegen.
+            if self.cx().features().enabled(symbol)
+                || (self.typing_mode() == TypingMode::PostAnalysis)
+            {
+                return self.evaluate_added_goals_and_make_canonical_response(Certainty::Yes);
+            } else {
+                return self.evaluate_added_goals_and_make_canonical_response(Certainty::Maybe(
+                    MaybeCause::Ambiguity,
+                ));
+            }
+        }
+    }
+
     #[instrument(level = "trace", skip(self))]
     fn compute_const_evaluatable_goal(
         &mut self,

compiler/rustc_trait_selection/src/traits/fulfill.rs

@@ -404,6 +404,9 @@ impl<'a, 'tcx> ObligationProcessor for FulfillProcessor<'a, 'tcx> {
                 ty::PredicateKind::AliasRelate(..) => {
                     bug!("AliasRelate is only used by the new solver")
                 }
+                ty::PredicateKind::Clause(ty::ClauseKind::UnstableFeature(_)) => {
+                   unreachable!("unexpected higher ranked `UnstableFeature` goal")
+                }
             },
             Some(pred) => match pred {
                 ty::PredicateKind::Clause(ty::ClauseKind::Trait(data)) => {
@@ -761,6 +764,31 @@ impl<'a, 'tcx> ObligationProcessor for FulfillProcessor<'a, 'tcx> {
                         }
                     }
                 }
+                ty::PredicateKind::Clause(ty::ClauseKind::UnstableFeature(symbol)) => {
+                    // Iterate through all goals in param_env to find the one that has the same symbol.
+                    for pred in obligation.param_env.caller_bounds().iter() {
+                        if let ty::ClauseKind::UnstableFeature(sym) = pred.kind().skip_binder() {
+                            if sym == symbol {
+                                return ProcessResult::Changed(Default::default());
+                            }
+                        }
+                    }
+
+                    if self.selcx.tcx().features().impl_stability() {
+                        // If we are in std/core, and the feature is not enabled through #[unstable_feature_bound(..)].
+                        return ProcessResult::Unchanged;
+                    } else {
+                        // Outside of std/core, check if feature is enabled at crate level with #[feature(..)]
+                        // or if we are currently in codegen.
+                        if self.selcx.tcx().features().enabled(symbol)
+                            || (self.selcx.infcx.typing_mode() == TypingMode::PostAnalysis)
+                        {
+                            return ProcessResult::Changed(Default::default());
+                        } else {
+                            return ProcessResult::Unchanged;
+                        }
+                    }
+                }
             },
         }
     }

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

@@ -838,6 +838,32 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                     }
                 }
 
+                ty::PredicateKind::Clause(ty::ClauseKind::UnstableFeature(symbol)) => {
+                    // Iterate through all goals in param_env to find the one that has the same symbol.
+                    for pred in obligation.param_env.caller_bounds().iter() {
+                        if let ty::ClauseKind::UnstableFeature(sym) = pred.kind().skip_binder() {
+                            if sym == symbol {
+                                return Ok(EvaluatedToOk);
+                            }
+                        }
+                    }
+
+                    if self.tcx().features().impl_stability() {
+                        // If we are in std/core, and the feature is not enabled through #[unstable_feature_bound(..)].
+                        return Ok(EvaluatedToAmbig);
+                    } else {
+                        // Outside of std/core, check if feature is enabled at crate level with #[feature(..)]
+                        // or if we are currently in codegen.
+                        if self.tcx().features().enabled(symbol)
+                            || (self.infcx.typing_mode() == TypingMode::PostAnalysis)
+                        {
+                            return Ok(EvaluatedToOk);
+                        } else {
+                            return Ok(EvaluatedToAmbig);
+                        }
+                    }
+                }
+
                 ty::PredicateKind::Clause(ty::ClauseKind::ConstEvaluatable(uv)) => {
                     match const_evaluatable::is_const_evaluatable(
                         self.infcx,