bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Add warn(unreachable_pub) to rustc_next_trait_solver.

Browse source
This commit is contained in:
Nicholas Nethercote 2024-08-29 15:10:38 +10:00
parent e3062147de
commit 46ea798a94
4 changed files with 37 additions and 26 deletions
Download patch file Download diff file Expand all files Collapse all files

4
compiler/rustc_next_trait_solver/src/lib.rs
View file

@ -4,6 +4,10 @@
//! but were uplifted in the process of making the new trait solver generic. //! but were uplifted in the process of making the new trait solver generic.
//! So if you got to this crate from the old solver, it's totally normal. //! So if you got to this crate from the old solver, it's totally normal.
// tidy-alphabetical-start
#![warn(unreachable_pub)]
// tidy-alphabetical-end
pub mod canonicalizer; pub mod canonicalizer;
pub mod coherence; pub mod coherence;
pub mod delegate; pub mod delegate;

6
compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs
View file

@ -92,7 +92,7 @@ where
#[derive(TypeVisitable_Generic, TypeFoldable_Generic, Lift_Generic)] #[derive(TypeVisitable_Generic, TypeFoldable_Generic, Lift_Generic)]
#[cfg_attr(feature = "nightly", derive(TyDecodable, TyEncodable, HashStable_NoContext))] #[cfg_attr(feature = "nightly", derive(TyDecodable, TyEncodable, HashStable_NoContext))]
// FIXME: This can be made crate-private once `EvalCtxt` also lives in this crate. // FIXME: This can be made crate-private once `EvalCtxt` also lives in this crate.
pub struct NestedGoals<I: Interner> { struct NestedGoals<I: Interner> {
/// These normalizes-to goals are treated specially during the evaluation /// These normalizes-to goals are treated specially during the evaluation
/// loop. In each iteration we take the RHS of the projection, replace it with /// loop. In each iteration we take the RHS of the projection, replace it with
/// a fresh inference variable, and only after evaluating that goal do we /// a fresh inference variable, and only after evaluating that goal do we
@ -109,11 +109,11 @@ pub struct NestedGoals<I: Interner> {
} }
impl<I: Interner> NestedGoals<I> { impl<I: Interner> NestedGoals<I> {
pub fn new() -> Self { fn new() -> Self {
Self { normalizes_to_goals: Vec::new(), goals: Vec::new() } Self { normalizes_to_goals: Vec::new(), goals: Vec::new() }
} }
pub fn is_empty(&self) -> bool { fn is_empty(&self) -> bool {
self.normalizes_to_goals.is_empty() && self.goals.is_empty() self.normalizes_to_goals.is_empty() && self.goals.is_empty()
} }
} }

49
compiler/rustc_next_trait_solver/src/solve/inspect/build.rs
View file

@ -222,13 +222,13 @@ impl<D: SolverDelegate<Interner = I>, I: Interner> ProofTreeBuilder<D> {
self.state.as_deref_mut() self.state.as_deref_mut()
} }
pub fn take_and_enter_probe(&mut self) -> ProofTreeBuilder<D> { pub(crate) fn take_and_enter_probe(&mut self) -> ProofTreeBuilder<D> {
let mut nested = ProofTreeBuilder { state: self.state.take(), _infcx: PhantomData }; let mut nested = ProofTreeBuilder { state: self.state.take(), _infcx: PhantomData };
nested.enter_probe(); nested.enter_probe();
nested nested
} }
pub fn finalize(self) -> Option<inspect::GoalEvaluation<I>> { pub(crate) fn finalize(self) -> Option<inspect::GoalEvaluation<I>> {
match *self.state? { match *self.state? {
DebugSolver::GoalEvaluation(wip_goal_evaluation) => { DebugSolver::GoalEvaluation(wip_goal_evaluation) => {
Some(wip_goal_evaluation.finalize()) Some(wip_goal_evaluation.finalize())
@ -237,22 +237,22 @@ impl<D: SolverDelegate<Interner = I>, I: Interner> ProofTreeBuilder<D> {
} }
} }
pub fn new_maybe_root(generate_proof_tree: GenerateProofTree) -> ProofTreeBuilder<D> { pub(crate) fn new_maybe_root(generate_proof_tree: GenerateProofTree) -> ProofTreeBuilder<D> {
match generate_proof_tree { match generate_proof_tree {
GenerateProofTree::No => ProofTreeBuilder::new_noop(), GenerateProofTree::No => ProofTreeBuilder::new_noop(),
GenerateProofTree::Yes => ProofTreeBuilder::new_root(), GenerateProofTree::Yes => ProofTreeBuilder::new_root(),
} }
} }
pub fn new_root() -> ProofTreeBuilder<D> { fn new_root() -> ProofTreeBuilder<D> {
ProofTreeBuilder::new(DebugSolver::Root) ProofTreeBuilder::new(DebugSolver::Root)
} }
pub fn new_noop() -> ProofTreeBuilder<D> { fn new_noop() -> ProofTreeBuilder<D> {
ProofTreeBuilder { state: None, _infcx: PhantomData } ProofTreeBuilder { state: None, _infcx: PhantomData }
} }
pub fn is_noop(&self) -> bool { pub(crate) fn is_noop(&self) -> bool {
self.state.is_none() self.state.is_none()
} }
@ -272,7 +272,7 @@ impl<D: SolverDelegate<Interner = I>, I: Interner> ProofTreeBuilder<D> {
}) })
} }
pub fn new_canonical_goal_evaluation( pub(crate) fn new_canonical_goal_evaluation(
&mut self, &mut self,
goal: CanonicalInput<I>, goal: CanonicalInput<I>,
) -> ProofTreeBuilder<D> { ) -> ProofTreeBuilder<D> {
@ -284,7 +284,10 @@ impl<D: SolverDelegate<Interner = I>, I: Interner> ProofTreeBuilder<D> {
}) })
} }
pub fn canonical_goal_evaluation(&mut self, canonical_goal_evaluation: ProofTreeBuilder<D>) { pub(crate) fn canonical_goal_evaluation(
&mut self,
canonical_goal_evaluation: ProofTreeBuilder<D>,
) {
if let Some(this) = self.as_mut() { if let Some(this) = self.as_mut() {
match (this, *canonical_goal_evaluation.state.unwrap()) { match (this, *canonical_goal_evaluation.state.unwrap()) {
( (
@ -299,7 +302,7 @@ impl<D: SolverDelegate<Interner = I>, I: Interner> ProofTreeBuilder<D> {
} }
} }
pub fn canonical_goal_evaluation_overflow(&mut self) { pub(crate) fn canonical_goal_evaluation_overflow(&mut self) {
if let Some(this) = self.as_mut() { if let Some(this) = self.as_mut() {
match this { match this {
DebugSolver::CanonicalGoalEvaluation(canonical_goal_evaluation) => { DebugSolver::CanonicalGoalEvaluation(canonical_goal_evaluation) => {
@ -310,7 +313,7 @@ impl<D: SolverDelegate<Interner = I>, I: Interner> ProofTreeBuilder<D> {
} }
} }
pub fn goal_evaluation(&mut self, goal_evaluation: ProofTreeBuilder<D>) { pub(crate) fn goal_evaluation(&mut self, goal_evaluation: ProofTreeBuilder<D>) {
if let Some(this) = self.as_mut() { if let Some(this) = self.as_mut() {
match this { match this {
DebugSolver::Root => *this = *goal_evaluation.state.unwrap(), DebugSolver::Root => *this = *goal_evaluation.state.unwrap(),
@ -322,7 +325,7 @@ impl<D: SolverDelegate<Interner = I>, I: Interner> ProofTreeBuilder<D> {
} }
} }
pub fn new_goal_evaluation_step( pub(crate) fn new_goal_evaluation_step(
&mut self, &mut self,
var_values: ty::CanonicalVarValues<I>, var_values: ty::CanonicalVarValues<I>,
instantiated_goal: QueryInput<I, I::Predicate>, instantiated_goal: QueryInput<I, I::Predicate>,
@ -340,7 +343,7 @@ impl<D: SolverDelegate<Interner = I>, I: Interner> ProofTreeBuilder<D> {
}) })
} }
pub fn goal_evaluation_step(&mut self, goal_evaluation_step: ProofTreeBuilder<D>) { pub(crate) fn goal_evaluation_step(&mut self, goal_evaluation_step: ProofTreeBuilder<D>) {
if let Some(this) = self.as_mut() { if let Some(this) = self.as_mut() {
match (this, *goal_evaluation_step.state.unwrap()) { match (this, *goal_evaluation_step.state.unwrap()) {
( (
@ -354,7 +357,7 @@ impl<D: SolverDelegate<Interner = I>, I: Interner> ProofTreeBuilder<D> {
} }
} }
pub fn add_var_value<T: Into<I::GenericArg>>(&mut self, arg: T) { pub(crate) fn add_var_value<T: Into<I::GenericArg>>(&mut self, arg: T) {
match self.as_mut() { match self.as_mut() {
None => {} None => {}
Some(DebugSolver::CanonicalGoalEvaluationStep(state)) => { Some(DebugSolver::CanonicalGoalEvaluationStep(state)) => {
@ -364,7 +367,7 @@ impl<D: SolverDelegate<Interner = I>, I: Interner> ProofTreeBuilder<D> {
} }
} }
pub fn enter_probe(&mut self) { fn enter_probe(&mut self) {
match self.as_mut() { match self.as_mut() {
None => {} None => {}
Some(DebugSolver::CanonicalGoalEvaluationStep(state)) => { Some(DebugSolver::CanonicalGoalEvaluationStep(state)) => {
@ -381,7 +384,7 @@ impl<D: SolverDelegate<Interner = I>, I: Interner> ProofTreeBuilder<D> {
} }
} }
pub fn probe_kind(&mut self, probe_kind: inspect::ProbeKind<I>) { pub(crate) fn probe_kind(&mut self, probe_kind: inspect::ProbeKind<I>) {
match self.as_mut() { match self.as_mut() {
None => {} None => {}
Some(DebugSolver::CanonicalGoalEvaluationStep(state)) => { Some(DebugSolver::CanonicalGoalEvaluationStep(state)) => {
@ -392,7 +395,11 @@ impl<D: SolverDelegate<Interner = I>, I: Interner> ProofTreeBuilder<D> {
} }
} }
pub fn probe_final_state(&mut self, delegate: &D, max_input_universe: ty::UniverseIndex) { pub(crate) fn probe_final_state(
&mut self,
delegate: &D,
max_input_universe: ty::UniverseIndex,
) {
match self.as_mut() { match self.as_mut() {
None => {} None => {}
Some(DebugSolver::CanonicalGoalEvaluationStep(state)) => { Some(DebugSolver::CanonicalGoalEvaluationStep(state)) => {
@ -409,7 +416,7 @@ impl<D: SolverDelegate<Interner = I>, I: Interner> ProofTreeBuilder<D> {
} }
} }
pub fn add_normalizes_to_goal( pub(crate) fn add_normalizes_to_goal(
&mut self, &mut self,
delegate: &D, delegate: &D,
max_input_universe: ty::UniverseIndex, max_input_universe: ty::UniverseIndex,
@ -423,7 +430,7 @@ impl<D: SolverDelegate<Interner = I>, I: Interner> ProofTreeBuilder<D> {
); );
} }
pub fn add_goal( pub(crate) fn add_goal(
&mut self, &mut self,
delegate: &D, delegate: &D,
max_input_universe: ty::UniverseIndex, max_input_universe: ty::UniverseIndex,
@ -469,7 +476,7 @@ impl<D: SolverDelegate<Interner = I>, I: Interner> ProofTreeBuilder<D> {
} }
} }
pub fn make_canonical_response(&mut self, shallow_certainty: Certainty) { pub(crate) fn make_canonical_response(&mut self, shallow_certainty: Certainty) {
match self.as_mut() { match self.as_mut() {
Some(DebugSolver::CanonicalGoalEvaluationStep(state)) => { Some(DebugSolver::CanonicalGoalEvaluationStep(state)) => {
state state
@ -482,7 +489,7 @@ impl<D: SolverDelegate<Interner = I>, I: Interner> ProofTreeBuilder<D> {
} }
} }
pub fn finish_probe(mut self) -> ProofTreeBuilder<D> { pub(crate) fn finish_probe(mut self) -> ProofTreeBuilder<D> {
match self.as_mut() { match self.as_mut() {
None => {} None => {}
Some(DebugSolver::CanonicalGoalEvaluationStep(state)) => { Some(DebugSolver::CanonicalGoalEvaluationStep(state)) => {
@ -497,7 +504,7 @@ impl<D: SolverDelegate<Interner = I>, I: Interner> ProofTreeBuilder<D> {
self self
} }
pub fn query_result(&mut self, result: QueryResult<I>) { pub(crate) fn query_result(&mut self, result: QueryResult<I>) {
if let Some(this) = self.as_mut() { if let Some(this) = self.as_mut() {
match this { match this {
DebugSolver::CanonicalGoalEvaluation(canonical_goal_evaluation) => { DebugSolver::CanonicalGoalEvaluation(canonical_goal_evaluation) => {

4
compiler/rustc_next_trait_solver/src/solve/normalizes_to/opaque_types.rs
View file

@ -97,7 +97,7 @@ where
/// Checks whether each generic argument is simply a unique generic placeholder. /// Checks whether each generic argument is simply a unique generic placeholder.
/// ///
/// FIXME: Interner argument is needed to constrain the `I` parameter. /// FIXME: Interner argument is needed to constrain the `I` parameter.
pub fn uses_unique_placeholders_ignoring_regions<I: Interner>( fn uses_unique_placeholders_ignoring_regions<I: Interner>(
_cx: I, _cx: I,
args: I::GenericArgs, args: I::GenericArgs,
) -> Result<(), NotUniqueParam<I>> { ) -> Result<(), NotUniqueParam<I>> {
@ -130,7 +130,7 @@ pub fn uses_unique_placeholders_ignoring_regions<I: Interner>(
} }
// FIXME: This should check for dupes and non-params first, then infer vars. // FIXME: This should check for dupes and non-params first, then infer vars.
pub enum NotUniqueParam<I: Interner> { enum NotUniqueParam<I: Interner> {
DuplicateParam(I::GenericArg), DuplicateParam(I::GenericArg),
NotParam(I::GenericArg), NotParam(I::GenericArg),
} }