Add the core logic in both old solver and new solver

Author: tiif

compiler/rustc_next_trait_solver/src/solve/mod.rs

@@ -148,6 +148,37 @@ 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);
+                }
+            }
+        }
+
+        // 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.
+        //
+        // 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.cx().features().feature_bound_holds_in_crate(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)) => {
@@ -767,6 +770,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());
+                            }
+                        }
+                    }
+
+                    // 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.
+                    //
+                    // Note: we don't 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.selcx.tcx().features().staged_api()
+                        && 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

@@ -844,6 +844,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);
+                            }
+                        }
+                    }
+
+                    // 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.
+                    //
+                    // Note: we don't 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.tcx().features().staged_api()
+                        && 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,