Represent trait constness as a distinct predicate #131985
Merged
Conversation
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
rustbot
added
S-waiting-on-review
|
Some changes occurred in src/tools/clippy cc @rust-lang/clippy Some changes occurred in src/librustdoc/clean/types.rs cc @camelid This PR changes Stable MIR cc @oli-obk, @celinval, @ouz-a Some changes occurred in match checking cc @Nadrieril changes to the core type system changes to the core type system Some changes occurred in match lowering cc @Nadrieril HIR ty lowering was modified cc @fmease |
This comment has been minimized.
This comment has been minimized.
compiler-errors
force-pushed
the
const-pred
branch
from
127ab2c to
1139e91
Compare
This comment has been minimized.
This comment has been minimized.
compiler-errors
force-pushed
the
const-pred
branch
from
1139e91 to
efc40e1
Compare
|
☔ The latest upstream changes (presumably #131980) made this pull request unmergeable. Please resolve the merge conflicts. |
compiler-errors
force-pushed
the
const-pred
branch
from
efc40e1 to
a2df5ea
Compare
fee1-dead
reviewed
Oct 21, 2024
compiler-errors
commented
Oct 21, 2024
| predicates: tcx.arena.alloc_from_iter(bounds.clauses(tcx).map(|(clause, span)| { | ||
| ( | ||
| clause.kind().map_bound(|clause| match clause { | ||
| ty::ClauseKind::HostEffect(ty::HostEffectPredicate { |
There was a problem hiding this comment.
It kinda sucks that for the sake of not rewriting all of the code, we end up collecting a list of HostEffect(T: Trait, Maybe) then stripping away everything but the trait ref when actually in the const condition query lol
I don't see how functions like lower_poly_trait_ref could easily be made to be generic over their output, tho.
| QueryResult, | ||
| }; | ||
|
|
||
| impl<D, I> assembly::GoalKind<D> for ty::HostEffectPredicate<I> |
There was a problem hiding this comment.
beware that the only thing that is not yet implemented is ~const in item bounds. Not because I couldn't do it, but mostly because I didn't want to complicate the new trait solver implementation yet.
So this code doesn't work yet:
#![feature(const_trait_impl, effects)]
#[const_trait]
trait Bar {}
#[const_trait]
trait Foo {
type Bar: ~const Bar;
}
const fn needs_const_bar<T: ~const Bar>() {}
const fn test<T: ~const Foo>() {
needs_const_bar::<T::Bar>();
}We just need to change the item bound candidate assembly to also have a callback for assembling "custom" item bounds, tho.
compiler/rustc_ty_utils/src/ty.rs
Outdated
| @@ -150,6 +150,13 @@ fn param_env(tcx: TyCtxt<'_>, def_id: DefId) -> ty::ParamEnv<'_> { | |||
| }); | |||
| } | |||
|
|
|||
| predicates.extend( | |||
There was a problem hiding this comment.
Here we extend the param-env with the ~const bounds of the item, so that we can type check it with those assumptions.
| @@ -690,6 +689,9 @@ impl<'tcx> Stable<'tcx> for ty::ClauseKind<'tcx> { | |||
| ClauseKind::ConstEvaluatable(const_) => { | |||
| stable_mir::ty::ClauseKind::ConstEvaluatable(const_.stable(tables)) | |||
| } | |||
| ClauseKind::HostEffect(..) => { | |||
| todo!() | |||
There was a problem hiding this comment.
I'll leave this unimplemented currently, at least until we get consensus that this is something we want :D
|
☔ The latest upstream changes (presumably #131988) made this pull request unmergeable. Please resolve the merge conflicts. |
compiler-errors
force-pushed
the
const-pred
branch
from
516ed74 to
884e04e
Compare
rustbot
added
A-testsuite
|
Preemptively assigning to @lcnr or @fee1-dead; please re- or un-assign as desired. I believe from an earlier conversation that lcnr said they'd be interested in reviewing if fee1-dead can't get to it, though please speak up if I misunderstood :3 |
compiler-errors
force-pushed
the
const-pred
branch
from
884e04e to
1eb7baa
Compare
This comment has been minimized.
This comment has been minimized.
compiler-errors
force-pushed
the
const-pred
branch
from
1eb7baa to
41e4c4e
Compare
|
☔ The latest upstream changes (presumably #132020) made this pull request unmergeable. Please resolve the merge conflicts. |
lcnr
reviewed
Oct 22, 2024
bors
added
S-waiting-on-bors
|
The job Click to see the possible cause of the failure (guessed by this bot) |
|
@bors retry |
|
|
☀️ Test successful - checks-actions |
This was referenced Oct 24, 2024
|
Finished benchmarking commit (1d4a767): comparison URL. Overall result: ❌✅ regressions and improvements - please read the text belowOur benchmarks found a performance regression caused by this PR. Next Steps:
@rustbot label: +perf-regression Instruction countThis is the most reliable metric that we have; it was used to determine the overall result at the top of this comment. However, even this metric can sometimes exhibit noise.
Max RSS (memory usage)Results (primary -1.1%, secondary -2.1%)This is a less reliable metric that may be of interest but was not used to determine the overall result at the top of this comment.
CyclesResults (secondary -3.1%)This is a less reliable metric that may be of interest but was not used to determine the overall result at the top of this comment.
Binary sizeResults (primary 0.1%, secondary 0.1%)This is a less reliable metric that may be of interest but was not used to determine the overall result at the top of this comment.
Bootstrap: 780.742s -> 785.158s (0.57%) |
|
The small @rustbot label: +perf-regression-triaged |
rustbot
added
the
perf-regression-triaged
14 tasks
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
cc @rust-lang/project-const-traits
r? @ghost for now
Also mirrored everything that is written below on this hackmd here: https://hackmd.io/@compiler-errors/r12zoixg1l
Tl;dr:
I'm putting this up both as a request for comments and a vibe-check, but also as a legitimate implementation that I'd like to see land (though no rush of course on that last part).
Background
Early days
Once upon a time, we represented trait constness in the param-env and in
TraitPredicate. This was very difficult to implement correctly; it had bugs and was also incomplete; I don't think this was anyone's fault though, it was just the limit of experimental knowledge we had at that point.Dealing with
~constwithin predicates themselves meant dealing with constness all throughout the trait solver. This was difficult to keep track of, and afaict was not handled well with all the corners of candidate assembly.Specifically, we had to (in various places) remap constness according to the param-env constness:
rust/compiler/rustc_trait_selection/src/traits/select/mod.rs
Line 1498 in 574b64a
This was annoying and manual and also error prone.
Beginning of the effects desugaring
Later on, #113210 reimplemented a new desugaring for const traits via a
<const HOST: bool>predicate. This essentially "reified" the const checking and separated it from any of the remapping or separate tracking in param-envs. For example, if I was in a const-if-const environment, but I wanted to call a trait that was non-const, this reification would turn the constness mismatch into a simple type mismatch of the effect parameter.While this was a monumental step towards straightening out const trait checking in the trait system, it had its own issues, since that meant that the constness of a trait (or any item within it, like an associated type) was early-bound. This essentially meant that
<T as Trait>::Assocwas distinct from<T as ~const Trait>::Assoc, which was bad.Associated-type bound based effects desugaring
After this, #120639 implemented a new effects desugaring. This used an associated type to more clearly represent the fact that the constness is not an input parameter of a trait, but a property that could be computed of a impl. The write-up linked in that PR explains it better than I could.
However, I feel like it really reached the limits of what can comfortably be expressed in terms of associated type and trait calculus. Also,
<const HOST: bool>remains a synthetic const parameter, which is observable in nested items like RPITs and closures, and comes with tons of its own hacks in the astconv and middle layer.For example, there are pieces of unintuitive code that are needed to represent semantics like elaboration, and eventually will be needed to make error reporting intuitive, and hopefully in the future assist us in implementing built-in traits (eventually we'll want something like
~const Fntrait bounds!).elaboration hack:
rust/compiler/rustc_type_ir/src/elaborate.rs
Lines 133 to 195 in 8069f8d
trait bound remapping hack for diagnostics:
rust/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
Lines 2370 to 2413 in 8069f8d
I want to be clear that I don't think this is a issue of implementation quality or anything like that; I think it's simply a very clear sign that we're using types and traits in a way that they're not fundamentally supposed to be used, especially given that constness deserves to be represented as a first-class concept.
What now?
This PR implements a new desugaring for const traits. Specifically, it introduces a
HostEffectpredicate to represent the obligation an impl is const, rather than using associated type bounds and the compat trait that exists for effects today.HostEffectpredicateA
HostEffectclause has two parts -- theTraitRefwe're trying to prove, and aHostPolarity::{Maybe, Const}.HostPolarity::Constcorresponds toT: const Traitbounds, which must always be proven as const, and which can be written in any context. These are lowered directly into the predicates of an item, since they're not "context-specific".On the other hand,
HostPolarity::Maybecorresponds toT: ~const Traitbounds which must only exist in a conditionally-const context like a method in a#[const_trait], or aconst fnfree function. We do not lower these immediately into the predicates of an item; instead, we collect them into a new query called theconst_conditions. These are the set of trait refs that we need to prove have const implementations for an item to be const.Notably, they're represented as bare (poly) trait refs because they are meant to be paired back together with a
HostPolaritywhen they're being registered in typeck (see next section).For example, given:
foo's const conditions would containT: A, but notT: B. On the flip side, foo's predicates (predicates_of) query would containHostEffect(T: B, HostPolarity::Const)but notHostEffect(T: A, HostPolarity::Maybe)since we don't need to prove that predicate in a non-const environment (and it's not even the right predicate to prove in an unconditionally const environment).Type checking const bodies
When type checking bodies in HIR, when we encounter a call expression, we additionally register the callee item's const conditions with the
HostPolarityfrom the body we're typechecking (Constfor unconditionally const things likeconst/staticitems, andMaybefor conditionally const things like const fns; and we don't registerHostPolaritypredicates for non-const bodies).When type-checking a conditionally const body, we augment its param-env with
HostEffect(..., Maybe)predicates.Checking that const impls are WF
We extend the logic in
compare_method_predicate_entailmentto also check the const-conditions of the impl method, to make sure that we error for:We also extend the WF check for impls to register the const conditions of the trait that is being implemented. This is to make sure we error for:
Proving a
HostEffectpredicateWe have several ways of proving a
HostEffectpredicate:HostEffectpredicate from the param-env~constwhere clauses).Later I expect that we will add more built-in implementations for things like
Fn.What next?
After this PR, I'd like to split out the work more so it can proceed in parallel and probably amongst others that are not me.
HostEffectgoal for places in HIR typeck that correspond to call terminators, like autoderef.HostEffectrules for traits likeFn.So what?
This ends up being super convenient basically everywhere in the compiler. Due to the design of the new trait solver, we end up having an almost parallel structure to the existing trait and projection predicates for assembling
HostEffectpredicates; adding new candidates and especially new built-in implementations is now basically trivial, and it's quite straightforward to understand the confirmation logic for these predicates.Same with diagnostics reporting; since we have predicates which represent the obligation to prove an impl is const, we can simplify and make these diagnostics richer without having to write a ton of logic to intercept and rewrite the existing
Compattrait errors.Finally, it gives us a much more straightforward path for supporting the const effect on the old trait solver. I'm personally quite passionate about getting const trait support into the hands of users without having to wait until the new solver lands1, so I think after this PR lands we can begin to gauge how difficult it would be to implement constness in the old trait solver too. This PR will not do this yet.
Footnotes
Though this is not a prerequisite or by any means the only justification for this PR. ↩