Show env normalization differences under two solvers #148939

adwinwhite · 2025-11-14T09:52:04Z

First step for param_env normalization future compat warning. zulip thread

I didn't put the check directly in param_env query because normalize_param_env_or_error has some adjustments on the predicates: elaboration and outlive predicates manipulation. I'd have to replicate these in param_env to compare normalized predicates properly.
The downside of putting the check inside normalize_param_env_or_error is that it's used in more than param_env query. It's also used in compare_impl_item and several other places. I'm not sure if this is desired.

~~I didn't bless tests since the hard error will be changed to lint later.~~
Blessed tests to demonstrate the changes.

And there's one test about const generics I don't know how to fix.
Canonicalizer for the next solver will replace ParamConst with PlaceholderConst, but it still uses the same try_evaluate_const internally and process_obligation doesn't like PlaceholderConst.

r? @lcnr

rustbot · 2025-11-14T09:52:06Z

Some changes occurred to the core trait solver

cc @rust-lang/initiative-trait-system-refactor

rustbot · 2025-11-14T12:30:56Z

This PR was rebased onto a different main commit. Here's a range-diff highlighting what actually changed.

Rebasing is a normal part of keeping PRs up to date, so no action is needed—this note is just to help reviewers.

rust-log-analyzer · 2025-11-14T12:42:28Z

The job aarch64-gnu-llvm-20-1 failed! Check out the build log: (web) (plain enhanced) (plain)

Click to see the possible cause of the failure (guessed by this bot)

[RUSTC-TIMING] build_script_build test:false 0.117
[RUSTC-TIMING] cc test:false 0.701
   Compiling compiler_builtins v0.1.160 (/checkout/library/compiler-builtins/compiler-builtins)
[RUSTC-TIMING] build_script_build test:false 0.324
error: inconsistency during normalizing env `Binder { value: ProjectionPredicate(AliasTerm { args: [F/#4, (B/#3, Alias(Projection, AliasTy { args: [iter::adapters::cloned::Cloned<I/#1>], def_id: DefId(0:9698 ~ core[931f]::iter::traits::iterator::Iterator::Item), .. }))], def_id: DefId(0:4162 ~ core[931f]::ops::function::FnOnce::Output), .. }, Term::Ty(R/#5)), bound_vars: [] }`, old=Binder { value: ProjectionPredicate(AliasTerm { args: [F/#4, (B/#3, ?1t)], def_id: DefId(0:4162 ~ core[931f]::ops::function::FnOnce::Output), .. }, Term::Ty(R/#5)), bound_vars: [] }, next=Some(
           Binder { value: ProjectionPredicate(AliasTerm { args: [F/#4, (B/#3, T/#2)], def_id: DefId(0:4162 ~ core[931f]::ops::function::FnOnce::Output), .. }, Term::Ty(R/#5)), bound_vars: [] },
       )
  --> library/core/src/iter/adapters/cloned.rs:48:5
   |
48 | /     fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
49 | |     where
50 | |         Self: Sized,
51 | |         F: FnMut(B, Self::Item) -> R,
52 | |         R: Try<Output = B>,
   | |___________________________^

error: inconsistency during normalizing env `Binder { value: TraitPredicate(<F as ops::function::FnMut<(B, <iter::adapters::cloned::Cloned<I> as iter::traits::iterator::Iterator>::Item)>>, polarity:Positive), bound_vars: [] }`, old=Binder { value: TraitPredicate(<F as ops::function::FnMut<(B, _)>>, polarity:Positive), bound_vars: [] }, next=Some(
           Binder { value: TraitPredicate(<F as ops::function::FnMut<(B, T)>>, polarity:Positive), bound_vars: [] },
       )
  --> library/core/src/iter/adapters/cloned.rs:48:5
   |
48 | /     fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
49 | |     where
50 | |         Self: Sized,
51 | |         F: FnMut(B, Self::Item) -> R,
52 | |         R: Try<Output = B>,
   | |___________________________^

error: inconsistency during normalizing env `Binder { value: TraitPredicate(<F as ops::function::FnOnce<(B, <iter::adapters::cloned::Cloned<I> as iter::traits::iterator::Iterator>::Item)>>, polarity:Positive), bound_vars: [] }`, old=Binder { value: TraitPredicate(<F as ops::function::FnOnce<(B, _)>>, polarity:Positive), bound_vars: [] }, next=Some(
           Binder { value: TraitPredicate(<F as ops::function::FnOnce<(B, T)>>, polarity:Positive), bound_vars: [] },
       )
  --> library/core/src/iter/adapters/cloned.rs:48:5
   |
48 | /     fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
49 | |     where
50 | |         Self: Sized,
51 | |         F: FnMut(B, Self::Item) -> R,
52 | |         R: Try<Output = B>,
   | |___________________________^

error: inconsistency during normalizing env `Binder { value: ProjectionPredicate(AliasTerm { args: [F/#4, (Acc/#3, Alias(Projection, AliasTy { args: [iter::adapters::cloned::Cloned<I/#1>], def_id: DefId(0:9698 ~ core[931f]::iter::traits::iterator::Iterator::Item), .. }))], def_id: DefId(0:4162 ~ core[931f]::ops::function::FnOnce::Output), .. }, Term::Ty(Acc/#3)), bound_vars: [] }`, old=Binder { value: ProjectionPredicate(AliasTerm { args: [F/#4, (Acc/#3, ?1t)], def_id: DefId(0:4162 ~ core[931f]::ops::function::FnOnce::Output), .. }, Term::Ty(Acc/#3)), bound_vars: [] }, next=Some(
           Binder { value: ProjectionPredicate(AliasTerm { args: [F/#4, (Acc/#3, T/#2)], def_id: DefId(0:4162 ~ core[931f]::ops::function::FnOnce::Output), .. }, Term::Ty(Acc/#3)), bound_vars: [] },
       )
  --> library/core/src/iter/adapters/cloned.rs:57:5
   |
57 | /     fn fold<Acc, F>(self, init: Acc, f: F) -> Acc
58 | |     where
59 | |         F: FnMut(Acc, Self::Item) -> Acc,
   | |_________________________________________^

error: inconsistency during normalizing env `Binder { value: TraitPredicate(<F as ops::function::FnMut<(Acc, <iter::adapters::cloned::Cloned<I> as iter::traits::iterator::Iterator>::Item)>>, polarity:Positive), bound_vars: [] }`, old=Binder { value: TraitPredicate(<F as ops::function::FnMut<(Acc, _)>>, polarity:Positive), bound_vars: [] }, next=Some(
           Binder { value: TraitPredicate(<F as ops::function::FnMut<(Acc, T)>>, polarity:Positive), bound_vars: [] },
       )
  --> library/core/src/iter/adapters/cloned.rs:57:5
   |
57 | /     fn fold<Acc, F>(self, init: Acc, f: F) -> Acc
58 | |     where
59 | |         F: FnMut(Acc, Self::Item) -> Acc,
   | |_________________________________________^

error: inconsistency during normalizing env `Binder { value: TraitPredicate(<F as ops::function::FnOnce<(Acc, <iter::adapters::cloned::Cloned<I> as iter::traits::iterator::Iterator>::Item)>>, polarity:Positive), bound_vars: [] }`, old=Binder { value: TraitPredicate(<F as ops::function::FnOnce<(Acc, _)>>, polarity:Positive), bound_vars: [] }, next=Some(
           Binder { value: TraitPredicate(<F as ops::function::FnOnce<(Acc, T)>>, polarity:Positive), bound_vars: [] },
       )
  --> library/core/src/iter/adapters/cloned.rs:57:5
   |
57 | /     fn fold<Acc, F>(self, init: Acc, f: F) -> Acc
58 | |     where
59 | |         F: FnMut(Acc, Self::Item) -> Acc,
   | |_________________________________________^

error: inconsistency during normalizing env `Binder { value: ProjectionPredicate(AliasTerm { args: [F/#4, (B/#3, Alias(Projection, AliasTy { args: [iter::adapters::cloned::Cloned<I/#1>], def_id: DefId(0:9698 ~ core[931f]::iter::traits::iterator::Iterator::Item), .. }))], def_id: DefId(0:4162 ~ core[931f]::ops::function::FnOnce::Output), .. }, Term::Ty(R/#5)), bound_vars: [] }`, old=Binder { value: ProjectionPredicate(AliasTerm { args: [F/#4, (B/#3, ?1t)], def_id: DefId(0:4162 ~ core[931f]::ops::function::FnOnce::Output), .. }, Term::Ty(R/#5)), bound_vars: [] }, next=Some(
           Binder { value: ProjectionPredicate(AliasTerm { args: [F/#4, (B/#3, T/#2)], def_id: DefId(0:4162 ~ core[931f]::ops::function::FnOnce::Output), .. }, Term::Ty(R/#5)), bound_vars: [] },
       )
  --> library/core/src/iter/adapters/cloned.rs:84:5
   |
84 | /     fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
85 | |     where
86 | |         Self: Sized,
87 | |         F: FnMut(B, Self::Item) -> R,
88 | |         R: Try<Output = B>,
   | |___________________________^

error: inconsistency during normalizing env `Binder { value: TraitPredicate(<F as ops::function::FnMut<(B, <iter::adapters::cloned::Cloned<I> as iter::traits::iterator::Iterator>::Item)>>, polarity:Positive), bound_vars: [] }`, old=Binder { value: TraitPredicate(<F as ops::function::FnMut<(B, _)>>, polarity:Positive), bound_vars: [] }, next=Some(
           Binder { value: TraitPredicate(<F as ops::function::FnMut<(B, T)>>, polarity:Positive), bound_vars: [] },
       )
  --> library/core/src/iter/adapters/cloned.rs:84:5
   |
84 | /     fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
85 | |     where
86 | |         Self: Sized,
87 | |         F: FnMut(B, Self::Item) -> R,
88 | |         R: Try<Output = B>,
   | |___________________________^

error: inconsistency during normalizing env `Binder { value: TraitPredicate(<F as ops::function::FnOnce<(B, <iter::adapters::cloned::Cloned<I> as iter::traits::iterator::Iterator>::Item)>>, polarity:Positive), bound_vars: [] }`, old=Binder { value: TraitPredicate(<F as ops::function::FnOnce<(B, _)>>, polarity:Positive), bound_vars: [] }, next=Some(
           Binder { value: TraitPredicate(<F as ops::function::FnOnce<(B, T)>>, polarity:Positive), bound_vars: [] },
       )
  --> library/core/src/iter/adapters/cloned.rs:84:5
   |
84 | /     fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
85 | |     where
86 | |         Self: Sized,
87 | |         F: FnMut(B, Self::Item) -> R,
88 | |         R: Try<Output = B>,
   | |___________________________^

error: inconsistency during normalizing env `Binder { value: ProjectionPredicate(AliasTerm { args: [F/#4, (Acc/#3, Alias(Projection, AliasTy { args: [iter::adapters::cloned::Cloned<I/#1>], def_id: DefId(0:9698 ~ core[931f]::iter::traits::iterator::Iterator::Item), .. }))], def_id: DefId(0:4162 ~ core[931f]::ops::function::FnOnce::Output), .. }, Term::Ty(Acc/#3)), bound_vars: [] }`, old=Binder { value: ProjectionPredicate(AliasTerm { args: [F/#4, (Acc/#3, ?1t)], def_id: DefId(0:4162 ~ core[931f]::ops::function::FnOnce::Output), .. }, Term::Ty(Acc/#3)), bound_vars: [] }, next=Some(
           Binder { value: ProjectionPredicate(AliasTerm { args: [F/#4, (Acc/#3, T/#2)], def_id: DefId(0:4162 ~ core[931f]::ops::function::FnOnce::Output), .. }, Term::Ty(Acc/#3)), bound_vars: [] },
       )
  --> library/core/src/iter/adapters/cloned.rs:93:5
   |
93 | /     fn rfold<Acc, F>(self, init: Acc, f: F) -> Acc
94 | |     where
95 | |         F: FnMut(Acc, Self::Item) -> Acc,
   | |_________________________________________^

error: inconsistency during normalizing env `Binder { value: TraitPredicate(<F as ops::function::FnMut<(Acc, <iter::adapters::cloned::Cloned<I> as iter::traits::iterator::Iterator>::Item)>>, polarity:Positive), bound_vars: [] }`, old=Binder { value: TraitPredicate(<F as ops::function::FnMut<(Acc, _)>>, polarity:Positive), bound_vars: [] }, next=Some(
           Binder { value: TraitPredicate(<F as ops::function::FnMut<(Acc, T)>>, polarity:Positive), bound_vars: [] },
       )
  --> library/core/src/iter/adapters/cloned.rs:93:5
   |
93 | /     fn rfold<Acc, F>(self, init: Acc, f: F) -> Acc
94 | |     where
95 | |         F: FnMut(Acc, Self::Item) -> Acc,
   | |_________________________________________^

error: inconsistency during normalizing env `Binder { value: TraitPredicate(<F as ops::function::FnOnce<(Acc, <iter::adapters::cloned::Cloned<I> as iter::traits::iterator::Iterator>::Item)>>, polarity:Positive), bound_vars: [] }`, old=Binder { value: TraitPredicate(<F as ops::function::FnOnce<(Acc, _)>>, polarity:Positive), bound_vars: [] }, next=Some(
           Binder { value: TraitPredicate(<F as ops::function::FnOnce<(Acc, T)>>, polarity:Positive), bound_vars: [] },
       )
  --> library/core/src/iter/adapters/cloned.rs:93:5
   |
93 | /     fn rfold<Acc, F>(self, init: Acc, f: F) -> Acc
94 | |     where
95 | |         F: FnMut(Acc, Self::Item) -> Acc,
   | |_________________________________________^

error: inconsistency during normalizing env `Binder { value: ProjectionPredicate(AliasTerm { args: [F/#4, (B/#3, Alias(Projection, AliasTy { args: [iter::adapters::copied::Copied<I/#1>], def_id: DefId(0:9698 ~ core[931f]::iter::traits::iterator::Iterator::Item), .. }))], def_id: DefId(0:4162 ~ core[931f]::ops::function::FnOnce::Output), .. }, Term::Ty(R/#5)), bound_vars: [] }`, old=Binder { value: ProjectionPredicate(AliasTerm { args: [F/#4, (B/#3, ?1t)], def_id: DefId(0:4162 ~ core[931f]::ops::function::FnOnce::Output), .. }, Term::Ty(R/#5)), bound_vars: [] }, next=Some(
           Binder { value: ProjectionPredicate(AliasTerm { args: [F/#4, (B/#3, T/#2)], def_id: DefId(0:4162 ~ core[931f]::ops::function::FnOnce::Output), .. }, Term::Ty(R/#5)), bound_vars: [] },
       )
  --> library/core/src/iter/adapters/copied.rs:68:5
   |
68 | /     fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
69 | |     where
70 | |         Self: Sized,
71 | |         F: FnMut(B, Self::Item) -> R,
72 | |         R: Try<Output = B>,
   | |___________________________^

error: inconsistency during normalizing env `Binder { value: TraitPredicate(<F as ops::function::FnMut<(B, <iter::adapters::copied::Copied<I> as iter::traits::iterator::Iterator>::Item)>>, polarity:Positive), bound_vars: [] }`, old=Binder { value: TraitPredicate(<F as ops::function::FnMut<(B, _)>>, polarity:Positive), bound_vars: [] }, next=Some(
           Binder { value: TraitPredicate(<F as ops::function::FnMut<(B, T)>>, polarity:Positive), bound_vars: [] },
       )
  --> library/core/src/iter/adapters/copied.rs:68:5
   |
68 | /     fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
69 | |     where
70 | |         Self: Sized,
71 | |         F: FnMut(B, Self::Item) -> R,
72 | |         R: Try<Output = B>,
   | |___________________________^

error: inconsistency during normalizing env `Binder { value: TraitPredicate(<F as ops::function::FnOnce<(B, <iter::adapters::copied::Copied<I> as iter::traits::iterator::Iterator>::Item)>>, polarity:Positive), bound_vars: [] }`, old=Binder { value: TraitPredicate(<F as ops::function::FnOnce<(B, _)>>, polarity:Positive), bound_vars: [] }, next=Some(
           Binder { value: TraitPredicate(<F as ops::function::FnOnce<(B, T)>>, polarity:Positive), bound_vars: [] },
       )
  --> library/core/src/iter/adapters/copied.rs:68:5
   |
68 | /     fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
69 | |     where
70 | |         Self: Sized,
71 | |         F: FnMut(B, Self::Item) -> R,
72 | |         R: Try<Output = B>,
   | |___________________________^

error: inconsistency during normalizing env `Binder { value: ProjectionPredicate(AliasTerm { args: [F/#4, (Acc/#3, Alias(Projection, AliasTy { args: [iter::adapters::copied::Copied<I/#1>], def_id: DefId(0:9698 ~ core[931f]::iter::traits::iterator::Iterator::Item), .. }))], def_id: DefId(0:4162 ~ core[931f]::ops::function::FnOnce::Output), .. }, Term::Ty(Acc/#3)), bound_vars: [] }`, old=Binder { value: ProjectionPredicate(AliasTerm { args: [F/#4, (Acc/#3, ?1t)], def_id: DefId(0:4162 ~ core[931f]::ops::function::FnOnce::Output), .. }, Term::Ty(Acc/#3)), bound_vars: [] }, next=Some(
           Binder { value: ProjectionPredicate(AliasTerm { args: [F/#4, (Acc/#3, T/#2)], def_id: DefId(0:4162 ~ core[931f]::ops::function::FnOnce::Output), .. }, Term::Ty(Acc/#3)), bound_vars: [] },
       )
  --> library/core/src/iter/adapters/copied.rs:77:5
   |
77 | /     fn fold<Acc, F>(self, init: Acc, f: F) -> Acc
78 | |     where
79 | |         F: FnMut(Acc, Self::Item) -> Acc,
   | |_________________________________________^

error: inconsistency during normalizing env `Binder { value: TraitPredicate(<F as ops::function::FnMut<(Acc, <iter::adapters::copied::Copied<I> as iter::traits::iterator::Iterator>::Item)>>, polarity:Positive), bound_vars: [] }`, old=Binder { value: TraitPredicate(<F as ops::function::FnMut<(Acc, _)>>, polarity:Positive), bound_vars: [] }, next=Some(
           Binder { value: TraitPredicate(<F as ops::function::FnMut<(Acc, T)>>, polarity:Positive), bound_vars: [] },
       )
  --> library/core/src/iter/adapters/copied.rs:77:5
   |
77 | /     fn fold<Acc, F>(self, init: Acc, f: F) -> Acc
78 | |     where
79 | |         F: FnMut(Acc, Self::Item) -> Acc,
   | |_________________________________________^

error: inconsistency during normalizing env `Binder { value: TraitPredicate(<F as ops::function::FnOnce<(Acc, <iter::adapters::copied::Copied<I> as iter::traits::iterator::Iterator>::Item)>>, polarity:Positive), bound_vars: [] }`, old=Binder { value: TraitPredicate(<F as ops::function::FnOnce<(Acc, _)>>, polarity:Positive), bound_vars: [] }, next=Some(
           Binder { value: TraitPredicate(<F as ops::function::FnOnce<(Acc, T)>>, polarity:Positive), bound_vars: [] },
       )
  --> library/core/src/iter/adapters/copied.rs:77:5
   |
77 | /     fn fold<Acc, F>(self, init: Acc, f: F) -> Acc
78 | |     where
79 | |         F: FnMut(Acc, Self::Item) -> Acc,
   | |_________________________________________^

error: inconsistency during normalizing env `Binder { value: ProjectionPredicate(AliasTerm { args: [F/#4, (B/#3, Alias(Projection, AliasTy { args: [iter::adapters::copied::Copied<I/#1>], def_id: DefId(0:9698 ~ core[931f]::iter::traits::iterator::Iterator::Item), .. }))], def_id: DefId(0:4162 ~ core[931f]::ops::function::FnOnce::Output), .. }, Term::Ty(R/#5)), bound_vars: [] }`, old=Binder { value: ProjectionPredicate(AliasTerm { args: [F/#4, (B/#3, ?1t)], def_id: DefId(0:4162 ~ core[931f]::ops::function::FnOnce::Output), .. }, Term::Ty(R/#5)), bound_vars: [] }, next=Some(
           Binder { value: ProjectionPredicate(AliasTerm { args: [F/#4, (B/#3, T/#2)], def_id: DefId(0:4162 ~ core[931f]::ops::function::FnOnce::Output), .. }, Term::Ty(R/#5)), bound_vars: [] },
       )
   --> library/core/src/iter/adapters/copied.rs:121:5
    |
121 | /     fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
122 | |     where
123 | |         Self: Sized,
124 | |         F: FnMut(B, Self::Item) -> R,
125 | |         R: Try<Output = B>,
    | |___________________________^

error: inconsistency during normalizing env `Binder { value: TraitPredicate(<F as ops::function::FnMut<(B, <iter::adapters::copied::Copied<I> as iter::traits::iterator::Iterator>::Item)>>, polarity:Positive), bound_vars: [] }`, old=Binder { value: TraitPredicate(<F as ops::function::FnMut<(B, _)>>, polarity:Positive), bound_vars: [] }, next=Some(
           Binder { value: TraitPredicate(<F as ops::function::FnMut<(B, T)>>, polarity:Positive), bound_vars: [] },
       )
   --> library/core/src/iter/adapters/copied.rs:121:5
    |
121 | /     fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
122 | |     where
123 | |         Self: Sized,
124 | |         F: FnMut(B, Self::Item) -> R,
125 | |         R: Try<Output = B>,
    | |___________________________^

error: inconsistency during normalizing env `Binder { value: TraitPredicate(<F as ops::function::FnOnce<(B, <iter::adapters::copied::Copied<I> as iter::traits::iterator::Iterator>::Item)>>, polarity:Positive), bound_vars: [] }`, old=Binder { value: TraitPredicate(<F as ops::function::FnOnce<(B, _)>>, polarity:Positive), bound_vars: [] }, next=Some(
           Binder { value: TraitPredicate(<F as ops::function::FnOnce<(B, T)>>, polarity:Positive), bound_vars: [] },
       )
   --> library/core/src/iter/adapters/copied.rs:121:5
    |
121 | /     fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
122 | |     where
123 | |         Self: Sized,
124 | |         F: FnMut(B, Self::Item) -> R,
125 | |         R: Try<Output = B>,
    | |___________________________^

error: inconsistency during normalizing env `Binder { value: ProjectionPredicate(AliasTerm { args: [F/#4, (Acc/#3, Alias(Projection, AliasTy { args: [iter::adapters::copied::Copied<I/#1>], def_id: DefId(0:9698 ~ core[931f]::iter::traits::iterator::Iterator::Item), .. }))], def_id: DefId(0:4162 ~ core[931f]::ops::function::FnOnce::Output), .. }, Term::Ty(Acc/#3)), bound_vars: [] }`, old=Binder { value: ProjectionPredicate(AliasTerm { args: [F/#4, (Acc/#3, ?1t)], def_id: DefId(0:4162 ~ core[931f]::ops::function::FnOnce::Output), .. }, Term::Ty(Acc/#3)), bound_vars: [] }, next=Some(
           Binder { value: ProjectionPredicate(AliasTerm { args: [F/#4, (Acc/#3, T/#2)], def_id: DefId(0:4162 ~ core[931f]::ops::function::FnOnce::Output), .. }, Term::Ty(Acc/#3)), bound_vars: [] },
       )
   --> library/core/src/iter/adapters/copied.rs:130:5
    |
130 | /     fn rfold<Acc, F>(self, init: Acc, f: F) -> Acc
131 | |     where
132 | |         F: FnMut(Acc, Self::Item) -> Acc,
    | |_________________________________________^

error: inconsistency during normalizing env `Binder { value: TraitPredicate(<F as ops::function::FnMut<(Acc, <iter::adapters::copied::Copied<I> as iter::traits::iterator::Iterator>::Item)>>, polarity:Positive), bound_vars: [] }`, old=Binder { value: TraitPredicate(<F as ops::function::FnMut<(Acc, _)>>, polarity:Positive), bound_vars: [] }, next=Some(
           Binder { value: TraitPredicate(<F as ops::function::FnMut<(Acc, T)>>, polarity:Positive), bound_vars: [] },
       )
   --> library/core/src/iter/adapters/copied.rs:130:5
    |
130 | /     fn rfold<Acc, F>(self, init: Acc, f: F) -> Acc
131 | |     where
132 | |         F: FnMut(Acc, Self::Item) -> Acc,
    | |_________________________________________^

error: inconsistency during normalizing env `Binder { value: TraitPredicate(<F as ops::function::FnOnce<(Acc, <iter::adapters::copied::Copied<I> as iter::traits::iterator::Iterator>::Item)>>, polarity:Positive), bound_vars: [] }`, old=Binder { value: TraitPredicate(<F as ops::function::FnOnce<(Acc, _)>>, polarity:Positive), bound_vars: [] }, next=Some(
           Binder { value: TraitPredicate(<F as ops::function::FnOnce<(Acc, T)>>, polarity:Positive), bound_vars: [] },
       )
   --> library/core/src/iter/adapters/copied.rs:130:5
    |
130 | /     fn rfold<Acc, F>(self, init: Acc, f: F) -> Acc
131 | |     where
132 | |         F: FnMut(Acc, Self::Item) -> Acc,
    | |_________________________________________^

error: inconsistency during normalizing env `Binder { value: ProjectionPredicate(AliasTerm { args: [Fold/#4, (Acc/#3, Alias(Projection, AliasTy { args: [iter::adapters::filter_map::FilterMap<I/#1, F/#2>], def_id: DefId(0:9698 ~ core[931f]::iter::traits::iterator::Iterator::Item), .. }))], def_id: DefId(0:4162 ~ core[931f]::ops::function::FnOnce::Output), .. }, Term::Ty(R/#5)), bound_vars: [] }`, old=Binder { value: ProjectionPredicate(AliasTerm { args: [Fold/#4, (Acc/#3, ?0t)], def_id: DefId(0:4162 ~ core[931f]::ops::function::FnOnce::Output), .. }, Term::Ty(R/#5)), bound_vars: [] }, next=Some(
           Binder { value: ProjectionPredicate(AliasTerm { args: [Fold/#4, (Acc/#3, B/#0)], def_id: DefId(0:4162 ~ core[931f]::ops::function::FnOnce::Output), .. }, Term::Ty(R/#5)), bound_vars: [] },
       )
   --> library/core/src/iter/adapters/filter_map.rs:132:5
    |
132 | /     fn try_fold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R
133 | |     where
134 | |         Self: Sized,
135 | |         Fold: FnMut(Acc, Self::Item) -> R,
136 | |         R: Try<Output = Acc>,
    | |_____________________________^

error: inconsistency during normalizing env `Binder { value: TraitPredicate(<Fold as ops::function::FnMut<(Acc, <iter::adapters::filter_map::FilterMap<I, F> as iter::traits::iterator::Iterator>::Item)>>, polarity:Positive), bound_vars: [] }`, old=Binder { value: TraitPredicate(<Fold as ops::function::FnMut<(Acc, _)>>, polarity:Positive), bound_vars: [] }, next=Some(
           Binder { value: TraitPredicate(<Fold as ops::function::FnMut<(Acc, B)>>, polarity:Positive), bound_vars: [] },
       )
   --> library/core/src/iter/adapters/filter_map.rs:132:5
    |
132 | /     fn try_fold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R
133 | |     where
134 | |         Self: Sized,
135 | |         Fold: FnMut(Acc, Self::Item) -> R,
136 | |         R: Try<Output = Acc>,
    | |_____________________________^

error: inconsistency during normalizing env `Binder { value: TraitPredicate(<Fold as ops::function::FnOnce<(Acc, <iter::adapters::filter_map::FilterMap<I, F> as iter::traits::iterator::Iterator>::Item)>>, polarity:Positive), bound_vars: [] }`, old=Binder { value: TraitPredicate(<Fold as ops::function::FnOnce<(Acc, _)>>, polarity:Positive), bound_vars: [] }, next=Some(
           Binder { value: TraitPredicate(<Fold as ops::function::FnOnce<(Acc, B)>>, polarity:Positive), bound_vars: [] },
       )
   --> library/core/src/iter/adapters/filter_map.rs:132:5
    |
132 | /     fn try_fold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R
133 | |     where
134 | |         Self: Sized,
135 | |         Fold: FnMut(Acc, Self::Item) -> R,
136 | |         R: Try<Output = Acc>,
    | |_____________________________^

error: inconsistency during normalizing env `Binder { value: ProjectionPredicate(AliasTerm { args: [Fold/#4, (Acc/#3, Alias(Projection, AliasTy { args: [iter::adapters::filter_map::FilterMap<I/#1, F/#2>], def_id: DefId(0:9698 ~ core[931f]::iter::traits::iterator::Iterator::Item), .. }))], def_id: DefId(0:4162 ~ core[931f]::ops::function::FnOnce::Output), .. }, Term::Ty(Acc/#3)), bound_vars: [] }`, old=Binder { value: ProjectionPredicate(AliasTerm { args: [Fold/#4, (Acc/#3, ?0t)], def_id: DefId(0:4162 ~ core[931f]::ops::function::FnOnce::Output), .. }, Term::Ty(Acc/#3)), bound_vars: [] }, next=Some(
           Binder { value: ProjectionPredicate(AliasTerm { args: [Fold/#4, (Acc/#3, B/#0)], def_id: DefId(0:4162 ~ core[931f]::ops::function::FnOnce::Output), .. }, Term::Ty(Acc/#3)), bound_vars: [] },
       )
   --> library/core/src/iter/adapters/filter_map.rs:142:5
    |
142 | /     fn fold<Acc, Fold>(self, init: Acc, fold: Fold) -> Acc
143 | |     where
144 | |         Fold: FnMut(Acc, Self::Item) -> Acc,
    | |____________________________________________^

error: inconsistency during normalizing env `Binder { value: TraitPredicate(<Fold as ops::function::FnMut<(Acc, <iter::adapters::filter_map::FilterMap<I, F> as iter::traits::iterator::Iterator>::Item)>>, polarity:Positive), bound_vars: [] }`, old=Binder { value: TraitPredicate(<Fold as ops::function::FnMut<(Acc, _)>>, polarity:Positive), bound_vars: [] }, next=Some(
           Binder { value: TraitPredicate(<Fold as ops::function::FnMut<(Acc, B)>>, polarity:Positive), bound_vars: [] },
       )
   --> library/core/src/iter/adapters/filter_map.rs:142:5
    |
142 | /     fn fold<Acc, Fold>(self, init: Acc, fold: Fold) -> Acc
143 | |     where
144 | |         Fold: FnMut(Acc, Self::Item) -> Acc,
    | |____________________________________________^

error: inconsistency during normalizing env `Binder { value: TraitPredicate(<Fold as ops::function::FnOnce<(Acc, <iter::adapters::filter_map::FilterMap<I, F> as iter::traits::iterator::Iterator>::Item)>>, polarity:Positive), bound_vars: [] }`, old=Binder { value: TraitPredicate(<Fold as ops::function::FnOnce<(Acc, _)>>, polarity:Positive), bound_vars: [] }, next=Some(
           Binder { value: TraitPredicate(<Fold as ops::function::FnOnce<(Acc, B)>>, polarity:Positive), bound_vars: [] },
       )
   --> library/core/src/iter/adapters/filter_map.rs:142:5
    |
142 | /     fn fold<Acc, Fold>(self, init: Acc, fold: Fold) -> Acc
143 | |     where
144 | |         Fold: FnMut(Acc, Self::Item) -> Acc,
    | |____________________________________________^

error: inconsistency during normalizing env `Binder { value: ProjectionPredicate(AliasTerm { args: [Fold/#4, (Acc/#3, Alias(Projection, AliasTy { args: [iter::adapters::filter_map::FilterMap<I/#1, F/#2>], def_id: DefId(0:9698 ~ core[931f]::iter::traits::iterator::Iterator::Item), .. }))], def_id: DefId(0:4162 ~ core[931f]::ops::function::FnOnce::Output), .. }, Term::Ty(R/#5)), bound_vars: [] }`, old=Binder { value: ProjectionPredicate(AliasTerm { args: [Fold/#4, (Acc/#3, ?0t)], def_id: DefId(0:4162 ~ core[931f]::ops::function::FnOnce::Output), .. }, Term::Ty(R/#5)), bound_vars: [] }, next=Some(
           Binder { value: ProjectionPredicate(AliasTerm { args: [Fold/#4, (Acc/#3, B/#0)], def_id: DefId(0:4162 ~ core[931f]::ops::function::FnOnce::Output), .. }, Term::Ty(R/#5)), bound_vars: [] },
       )
   --> library/core/src/iter/adapters/filter_map.rs:171:5
    |
171 | /     fn try_rfold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R
172 | |     where
173 | |         Self: Sized,
174 | |         Fold: FnMut(Acc, Self::Item) -> R,
175 | |         R: Try<Output = Acc>,
    | |_____________________________^

error: inconsistency during normalizing env `Binder { value: TraitPredicate(<Fold as ops::function::FnMut<(Acc, <iter::adapters::filter_map::FilterMap<I, F> as iter::traits::iterator::Iterator>::Item)>>, polarity:Positive), bound_vars: [] }`, old=Binder { value: TraitPredicate(<Fold as ops::function::FnMut<(Acc, _)>>, polarity:Positive), bound_vars: [] }, next=Some(
           Binder { value: TraitPredicate(<Fold as ops::function::FnMut<(Acc, B)>>, polarity:Positive), bound_vars: [] },
       )
   --> library/core/src/iter/adapters/filter_map.rs:171:5
    |
171 | /     fn try_rfold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R
172 | |     where
173 | |         Self: Sized,
174 | |         Fold: FnMut(Acc, Self::Item) -> R,
175 | |         R: Try<Output = Acc>,
    | |_____________________________^

error: inconsistency during normalizing env `Binder { value: TraitPredicate(<Fold as ops::function::FnOnce<(Acc, <iter::adapters::filter_map::FilterMap<I, F> as iter::traits::iterator::Iterator>::Item)>>, polarity:Positive), bound_vars: [] }`, old=Binder { value: TraitPredicate(<Fold as ops::function::FnOnce<(Acc, _)>>, polarity:Positive), bound_vars: [] }, next=Some(
           Binder { value: TraitPredicate(<Fold as ops::function::FnOnce<(Acc, B)>>, polarity:Positive), bound_vars: [] },
       )
   --> library/core/src/iter/adapters/filter_map.rs:171:5
    |
171 | /     fn try_rfold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R
172 | |     where
173 | |         Self: Sized,
174 | |         Fold: FnMut(Acc, Self::Item) -> R,
175 | |         R: Try<Output = Acc>,
    | |_____________________________^

error: inconsistency during normalizing env `Binder { value: ProjectionPredicate(AliasTerm { args: [Fold/#4, (Acc/#3, Alias(Projection, AliasTy { args: [iter::adapters::filter_map::FilterMap<I/#1, F/#2>], def_id: DefId(0:9698 ~ core[931f]::iter::traits::iterator::Iterator::Item), .. }))], def_id: DefId(0:4162 ~ core[931f]::ops::function::FnOnce::Output), .. }, Term::Ty(Acc/#3)), bound_vars: [] }`, old=Binder { value: ProjectionPredicate(AliasTerm { args: [Fold/#4, (Acc/#3, ?0t)], def_id: DefId(0:4162 ~ core[931f]::ops::function::FnOnce::Output), .. }, Term::Ty(Acc/#3)), bound_vars: [] }, next=Some(
           Binder { value: ProjectionPredicate(AliasTerm { args: [Fold/#4, (Acc/#3, B/#0)], def_id: DefId(0:4162 ~ core[931f]::ops::function::FnOnce::Output), .. }, Term::Ty(Acc/#3)), bound_vars: [] },
       )
   --> library/core/src/iter/adapters/filter_map.rs:181:5
    |
181 | /     fn rfold<Acc, Fold>(self, init: Acc, fold: Fold) -> Acc
182 | |     where
183 | |         Fold: FnMut(Acc, Self::Item) -> Acc,
    | |____________________________________________^

error: inconsistency during normalizing env `Binder { value: TraitPredicate(<Fold as ops::function::FnMut<(Acc, <iter::adapters::filter_map::FilterMap<I, F> as iter::traits::iterator::Iterator>::Item)>>, polarity:Positive), bound_vars: [] }`, old=Binder { value: TraitPredicate(<Fold as ops::function::FnMut<(Acc, _)>>, polarity:Positive), bound_vars: [] }, next=Some(
           Binder { value: TraitPredicate(<Fold as ops::function::FnMut<(Acc, B)>>, polarity:Positive), bound_vars: [] },
       )
   --> library/core/src/iter/adapters/filter_map.rs:181:5
    |
181 | /     fn rfold<Acc, Fold>(self, init: Acc, fold: Fold) -> Acc
182 | |     where
183 | |         Fold: FnMut(Acc, Self::Item) -> Acc,
    | |____________________________________________^

error: inconsistency during normalizing env `Binder { value: TraitPredicate(<Fold as ops::function::FnOnce<(Acc, <iter::adapters::filter_map::FilterMap<I, F> as iter::traits::iterator::Iterator>::Item)>>, polarity:Positive), bound_vars: [] }`, old=Binder { value: TraitPredicate(<Fold as ops::function::FnOnce<(Acc, _)>>, polarity:Positive), bound_vars: [] }, next=Some(
           Binder { value: TraitPredicate(<Fold as ops::function::FnOnce<(Acc, B)>>, polarity:Positive), bound_vars: [] },
       )
   --> library/core/src/iter/adapters/filter_map.rs:181:5
    |
181 | /     fn rfold<Acc, Fold>(self, init: Acc, fold: Fold) -> Acc
182 | |     where
183 | |         Fold: FnMut(Acc, Self::Item) -> Acc,
    | |____________________________________________^

error: inconsistency during normalizing env `Binder { value: ProjectionPredicate(AliasTerm { args: [Fold/#3, (Acc/#2, Alias(Projection, AliasTy { args: [iter::adapters::flatten::Flatten<I/#0>], def_id: DefId(0:9698 ~ core[931f]::iter::traits::iterator::Iterator::Item), .. }))], def_id: DefId(0:4162 ~ core[931f]::ops::function::FnOnce::Output), .. }, Term::Ty(R/#4)), bound_vars: [] }`, old=Binder { value: ProjectionPredicate(AliasTerm { args: [Fold/#3, (Acc/#2, ?3t)], def_id: DefId(0:4162 ~ core[931f]::ops::function::FnOnce::Output), .. }, Term::Ty(R/#4)), bound_vars: [] }, next=Some(
           Binder { value: ProjectionPredicate(AliasTerm { args: [Fold/#3, (Acc/#2, Alias(Projection, AliasTy { args: [U/#1], def_id: DefId(0:9698 ~ core[931f]::iter::traits::iterator::Iterator::Item), .. }))], def_id: DefId(0:4162 ~ core[931f]::ops::function::FnOnce::Output), .. }, Term::Ty(R/#4)), bound_vars: [] },
       )
   --> library/core/src/iter/adapters/flatten.rs:235:5
    |
235 | /     fn try_fold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R
236 | |     where
237 | |         Self: Sized,
238 | |         Fold: FnMut(Acc, Self::Item) -> R,
239 | |         R: Try<Output = Acc>,
    | |_____________________________^

error: inconsistency during normalizing env `Binder { value: TraitPredicate(<Fold as ops::function::FnMut<(Acc, <iter::adapters::flatten::Flatten<I> as iter::traits::iterator::Iterator>::Item)>>, polarity:Positive), bound_vars: [] }`, old=Binder { value: TraitPredicate(<Fold as ops::function::FnMut<(Acc, _)>>, polarity:Positive), bound_vars: [] }, next=Some(
           Binder { value: TraitPredicate(<Fold as ops::function::FnMut<(Acc, <U as iter::traits::iterator::Iterator>::Item)>>, polarity:Positive), bound_vars: [] },
       )
   --> library/core/src/iter/adapters/flatten.rs:235:5
    |
235 | /     fn try_fold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R
236 | |     where
237 | |         Self: Sized,
238 | |         Fold: FnMut(Acc, Self::Item) -> R,
239 | |         R: Try<Output = Acc>,
    | |_____________________________^

error: inconsistency during normalizing env `Binder { value: TraitPredicate(<Fold as ops::function::FnOnce<(Acc, <iter::adapters::flatten::Flatten<I> as iter::traits::iterator::Iterator>::Item)>>, polarity:Positive), bound_vars: [] }`, old=Binder { value: TraitPredicate(<Fold as ops::function::FnOnce<(Acc, _)>>, polarity:Positive), bound_vars: [] }, next=Some(
           Binder { value: TraitPredicate(<Fold as ops::function::FnOnce<(Acc, <U as iter::traits::iterator::Iterator>::Item)>>, polarity:Positive), bound_vars: [] },
       )
   --> library/core/src/iter/adapters/flatten.rs:235:5
    |
235 | /     fn try_fold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R
236 | |     where
237 | |         Self: Sized,
238 | |         Fold: FnMut(Acc, Self::Item) -> R,
239 | |         R: Try<Output = Acc>,
    | |_____________________________^

error: inconsistency during normalizing env `Binder { value: ProjectionPredicate(AliasTerm { args: [Fold/#3, (Acc/#2, Alias(Projection, AliasTy { args: [iter::adapters::flatten::Flatten<I/#0>], def_id: DefId(0:9698 ~ core[931f]::iter::traits::iterator::Iterator::Item), .. }))], def_id: DefId(0:4162 ~ core[931f]::ops::function::FnOnce::Output), .. }, Term::Ty(Acc/#2)), bound_vars: [] }`, old=Binder { value: ProjectionPredicate(AliasTerm { args: [Fold/#3, (Acc/#2, ?3t)], def_id: DefId(0:4162 ~ core[931f]::ops::function::FnOnce::Output), .. }, Term::Ty(Acc/#2)), bound_vars: [] }, next=Some(
           Binder { value: ProjectionPredicate(AliasTerm { args: [Fold/#3, (Acc/#2, Alias(Projection, AliasTy { args: [U/#1], def_id: DefId(0:9698 ~ core[931f]::iter::traits::iterator::Iterator::Item), .. }))], def_id: DefId(0:4162 ~ core[931f]::ops::function::FnOnce::Output), .. }, Term::Ty(Acc/#2)), bound_vars: [] },
       )
   --> library/core/src/iter/adapters/flatten.rs:245:5
    |
245 | /     fn fold<Acc, Fold>(self, init: Acc, fold: Fold) -> Acc
246 | |     where
247 | |         Fold: FnMut(Acc, Self::Item) -> Acc,
    | |____________________________________________^

error: inconsistency during normalizing env `Binder { value: TraitPredicate(<Fold as ops::function::FnMut<(Acc, <iter::adapters::flatten::Flatten<I> as iter::traits::iterator::Iterator>::Item)>>, polarity:Positive), bound_vars: [] }`, old=Binder { value: TraitPredicate(<Fold as ops::function::FnMut<(Acc, _)>>, polarity:Positive), bound_vars: [] }, next=Some(
           Binder { value: TraitPredicate(<Fold as ops::function::FnMut<(Acc, <U as iter::traits::iterator::Iterator>::Item)>>, polarity:Positive), bound_vars: [] },
       )
   --> library/core/src/iter/adapters/flatten.rs:245:5
    |
245 | /     fn fold<Acc, Fold>(self, init: Acc, fold: Fold) -> Acc
246 | |     where
247 | |         Fold: FnMut(Acc, Self::Item) -> Acc,
    | |____________________________________________^

error: inconsistency during normalizing env `Binder { value: TraitPredicate(<Fold as ops::function::FnOnce<(Acc, <iter::adapters::flatten::Flatten<I> as iter::traits::iterator::Iterator>::Item)>>, polarity:Positive), bound_vars: [] }`, old=Binder { value: TraitPredicate(<Fold as ops::function::FnOnce<(Acc, _)>>, polarity:Positive), bound_vars: [] }, next=Some(
           Binder { value: TraitPredicate(<Fold as ops::function::FnOnce<(Acc, <U as iter::traits::iterator::Iterator>::Item)>>, polarity:Positive), bound_vars: [] },
       )
   --> library/core/src/iter/adapters/flatten.rs:245:5
    |
245 | /     fn fold<Acc, Fold>(self, init: Acc, fold: Fold) -> Acc
246 | |     where
247 | |         Fold: FnMut(Acc, Self::Item) -> Acc,
    | |____________________________________________^

error: inconsistency during normalizing env `Binder { value: ProjectionPredicate(AliasTerm { args: [Fold/#3, (Acc/#2, Alias(Projection, AliasTy { args: [iter::adapters::flatten::Flatten<I/#0>], def_id: DefId(0:9698 ~ core[931f]::iter::traits::iterator::Iterator::Item), .. }))], def_id: DefId(0:4162 ~ core[931f]::ops::function::FnOnce::Output), .. }, Term::Ty(R/#4)), bound_vars: [] }`, old=Binder { value: ProjectionPredicate(AliasTerm { args: [Fold/#3, (Acc/#2, ?3t)], def_id: DefId(0:4162 ~ core[931f]::ops::function::FnOnce::Output), .. }, Term::Ty(R/#4)), bound_vars: [] }, next=Some(
           Binder { value: ProjectionPredicate(AliasTerm { args: [Fold/#3, (Acc/#2, Alias(Projection, AliasTy { args: [U/#1], def_id: DefId(0:9698 ~ core[931f]::iter::traits::iterator::Iterator::Item), .. }))], def_id: DefId(0:4162 ~ core[931f]::ops::function::FnOnce::Output), .. }, Term::Ty(R/#4)), bound_vars: [] },
       )
   --> library/core/src/iter/adapters/flatten.rs:280:5
    |
280 | /     fn try_rfold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R
281 | |     where
282 | |         Self: Sized,
283 | |         Fold: FnMut(Acc, Self::Item) -> R,
284 | |         R: Try<Output = Acc>,
    | |_____________________________^

error: inconsistency during normalizing env `Binder { value: TraitPredicate(<Fold as ops::function::FnMut<(Acc, <iter::adapters::flatten::Flatten<I> as iter::traits::iterator::Iterator>::Item)>>, polarity:Positive), bound_vars: [] }`, old=Binder { value: TraitPredicate(<Fold as ops::function::FnMut<(Acc, _)>>, polarity:Positive), bound_vars: [] }, next=Some(
           Binder { value: TraitPredicate(<Fold as ops::function::FnMut<(Acc, <U as iter::traits::iterator::Iterator>::Item)>>, polarity:Positive), bound_vars: [] },
       )
   --> library/core/src/iter/adapters/flatten.rs:280:5
    |
280 | /     fn try_rfold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R
281 | |     where
282 | |         Self: Sized,
283 | |         Fold: FnMut(Acc, Self::Item) -> R,
284 | |         R: Try<Output = Acc>,
    | |_____________________________^

error: inconsistency during normalizing env `Binder { value: TraitPredicate(<Fold as ops::function::FnOnce<(Acc, <iter::adapters::flatten::Flatten<I> as iter::traits::iterator::Iterator>::Item)>>, polarity:Positive), bound_vars: [] }`, old=Binder { value: TraitPredicate(<Fold as ops::function::FnOnce<(Acc, _)>>, polarity:Positive), bound_vars: [] }, next=Some(
           Binder { value: TraitPredicate(<Fold as ops::function::FnOnce<(Acc, <U as iter::traits::iterator::Iterator>::Item)>>, polarity:Positive), bound_vars: [] },
       )
   --> library/core/src/iter/adapters/flatten.rs:280:5
    |
280 | /     fn try_rfold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R
281 | |     where
282 | |         Self: Sized,
283 | |         Fold: FnMut(Acc, Self::Item) -> R,
284 | |         R: Try<Output = Acc>,

lcnr · 2025-11-14T16:34:53Z

compiler/rustc_trait_selection/src/solve/normalize.rs

+        // FIXME: `generic_const_exprs` causes query cycle problem. Same as the old solver.
+        if !ct.has_aliases() || infcx.tcx.features().generic_const_exprs() {


hmm, disable the lint if generic_const_exprs is enabled instead

rustbot added S-waiting-on-review Status: Awaiting review from the assignee but also interested parties. T-compiler Relevant to the compiler team, which will review and decide on the PR/issue. WG-trait-system-refactor The Rustc Trait System Refactor Initiative (-Znext-solver) labels Nov 14, 2025

rustbot assigned lcnr Nov 14, 2025

This comment has been minimized.

Sign in to view

adwinwhite added 2 commits November 14, 2025 20:06

show env normalization differences under two solvers

d3094bb

bless tests

4408f14

adwinwhite force-pushed the env_normalization_fcw branch from 5cd4303 to 4408f14 Compare November 14, 2025 12:30

lcnr reviewed Nov 14, 2025

View reviewed changes

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

Show env normalization differences under two solvers #148939

Show env normalization differences under two solvers #148939

adwinwhite commented Nov 14, 2025 •

edited

Loading

Uh oh!

rustbot commented Nov 14, 2025

Uh oh!

This comment has been minimized.

rustbot commented Nov 14, 2025

Uh oh!

rust-log-analyzer commented Nov 14, 2025

Uh oh!

lcnr Nov 14, 2025

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

4 participants

		// FIXME: `generic_const_exprs` causes query cycle problem. Same as the old solver.
		if !ct.has_aliases() \|\| infcx.tcx.features().generic_const_exprs() {

Show env normalization differences under two solvers #148939

Are you sure you want to change the base?

Show env normalization differences under two solvers #148939

Conversation

adwinwhite commented Nov 14, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

rustbot commented Nov 14, 2025

Uh oh!

This comment has been minimized.

rustbot commented Nov 14, 2025

Uh oh!

rust-log-analyzer commented Nov 14, 2025

Uh oh!

lcnr Nov 14, 2025

Choose a reason for hiding this comment

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

4 participants

adwinwhite commented Nov 14, 2025 •

edited

Loading