-
Notifications
You must be signed in to change notification settings - Fork 12.7k
New issue
Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.
By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.
Already on GitHub? Sign in to your account
Improve opaque type higher-ranked region error message under NLL #92306
Conversation
r? @davidtwco (rust-highfive has picked a reviewer for you, use r? to override) |
--> $DIR/opaque-hrtb.rs:12:13 | ||
| | ||
LL | fn foo() -> impl for<'a> MyTrait<&'a str> { | ||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `MyTrait` is not general enough |
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
This span isn't great, but it's the same one that we get without #![feature(nll)]
. I'll probably work on improving it in a follow-up PR.
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
Most such spans will get better with my lazy TAIT PR
@bors try @rust-timer queue |
Awaiting bors try build completion. @rustbot label: +S-waiting-on-perf |
⌛ Trying commit 1bd8e29ed18ad76b00d71d3d51b1d5a94888e6d4 with merge 9cb40efda24c4b68d6c59a8e3d6d294ac2f86e67... |
☀️ Try build successful - checks-actions |
Queued 9cb40efda24c4b68d6c59a8e3d6d294ac2f86e67 with parent f8abed9, future comparison URL. |
Finished benchmarking commit (9cb40efda24c4b68d6c59a8e3d6d294ac2f86e67): comparison url. Summary: This change led to moderate relevant regressions 😿 in compiler performance.
If you disagree with this performance assessment, please file an issue in rust-lang/rustc-perf. Benchmarking this pull request likely means that it is perf-sensitive, so we're automatically marking it as not fit for rolling up. While you can manually mark this PR as fit for rollup, we strongly recommend not doing so since this PR led to changes in compiler perf. Next Steps: If you can justify the regressions found in this try perf run, please indicate this with @bors rollup=never |
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
This is really cool and may make some things easier for me actually
r? @oli-obk |
☔ The latest upstream changes (presumably #92844) made this pull request unmergeable. Please resolve the merge conflicts. |
d264b14
to
d2871e9
Compare
☔ The latest upstream changes (presumably #92007) made this pull request unmergeable. Please resolve the merge conflicts. |
d2871e9
to
880d8e2
Compare
@bors try @rust-timer queue |
Awaiting bors try build completion. @rustbot label: +S-waiting-on-perf |
⌛ Trying commit 880d8e2a06157563f1fe47fb5125a96e7037fced with merge 0fd10de714ecd9c91b80fb63c4fffd13e1f68f56... |
Currently, any higher-ranked region errors involving opaque types fall back to a generic "higher-ranked subtype error" message when run under NLL. This PR adds better error message handling for this case, giving us the same kinds of error messages that we currently get without NLL: ``` error: implementation of `MyTrait` is not general enough --> $DIR/opaque-hrtb.rs:12:13 | LL | fn foo() -> impl for<'a> MyTrait<&'a str> { | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `MyTrait` is not general enough | = note: `impl MyTrait<&'2 str>` must implement `MyTrait<&'1 str>`, for any lifetime `'1`... = note: ...but it actually implements `MyTrait<&'2 str>`, for some specific lifetime `'2` error: aborting due to previous error ``` To accomplish this, several different refactoring needed to be made: * We now have a dedicated `InstantiateOpaqueType` struct which implements `TypeOp`. This is used to invoke `instantiate_opaque_types` during MIR type checking. * `TypeOp` is refactored to pass around a `MirBorrowckCtxt`, which is needed to report opaque type region errors. * We no longer assume that all `TypeOp`s correspond to canonicalized queries. This allows us to properly handle opaque type instantiation (which does not occur in a query) as a `TypeOp`. A new `ErrorInfo` associated type is used to determine what additional information is used during higher-ranked region error handling. * The body of `try_extract_error_from_fulfill_cx` has been moved out to a new function `try_extract_error_from_region_constraints`. This allows us to re-use the same error reporting code between canonicalized queries (which can extract region constraints directly from a fresh `InferCtxt`) and opaque type handling (which needs to take region constraints from the pre-existing `InferCtxt` that we use throughout MIR borrow checking).
880d8e2
to
48a48fd
Compare
@bors r=oli-obk |
📌 Commit 48a48fd has been approved by |
⌛ Testing commit 48a48fd with merge 27ee5ca00e0d78f12757b37a3a8592495491c1f2... |
The job Click to see the possible cause of the failure (guessed by this bot)
|
💔 Test failed - checks-actions |
☀️ Test successful - checks-actions |
Finished benchmarking commit (1f0a968): comparison url. Summary: This benchmark run did not return any relevant results. If you disagree with this performance assessment, please file an issue in rust-lang/rustc-perf. @rustbot label: -perf-regression |
Revert lazy TAIT PR Revert rust-lang#92306 (sorry `@Aaron1011,` will include your changes in the fix PR) Revert rust-lang#93783 Revert rust-lang#92007 fixes rust-lang#93788 fixes rust-lang#93794 fixes rust-lang#93821 fixes rust-lang#93831 fixes rust-lang#93841
Revert lazy TAIT PR Revert rust-lang/rust#92306 (sorry `@Aaron1011,` will include your changes in the fix PR) Revert rust-lang/rust#93783 Revert rust-lang/rust#92007 fixes rust-lang/rust#93788 fixes rust-lang/rust#93794 fixes rust-lang/rust#93821 fixes rust-lang/rust#93831 fixes rust-lang/rust#93841
…sakis Lazy type-alias-impl-trait take two ### user visible change 1: RPIT inference from recursive call sites Lazy TAIT has an insta-stable change. The following snippet now compiles, because opaque types can now have their hidden type set from wherever the opaque type is mentioned. ```rust fn bar(b: bool) -> impl std::fmt::Debug { if b { return 42 } let x: u32 = bar(false); // this errors on stable 99 } ``` The return type of `bar` stays opaque, you can't do `bar(false) + 42`, you need to actually mention the hidden type. ### user visible change 2: divergence between RPIT and TAIT in return statements Note that `return` statements and the trailing return expression are special with RPIT (but not TAIT). So ```rust #![feature(type_alias_impl_trait)] type Foo = impl std::fmt::Debug; fn foo(b: bool) -> Foo { if b { return vec![42]; } std::iter::empty().collect() //~ ERROR `Foo` cannot be built from an iterator } fn bar(b: bool) -> impl std::fmt::Debug { if b { return vec![42] } std::iter::empty().collect() // Works, magic (accidentally stabilized, not intended) } ``` But when we are working with the return value of a recursive call, the behavior of RPIT and TAIT is the same: ```rust type Foo = impl std::fmt::Debug; fn foo(b: bool) -> Foo { if b { return vec![]; } let mut x = foo(false); x = std::iter::empty().collect(); //~ ERROR `Foo` cannot be built from an iterator vec![] } fn bar(b: bool) -> impl std::fmt::Debug { if b { return vec![]; } let mut x = bar(false); x = std::iter::empty().collect(); //~ ERROR `impl Debug` cannot be built from an iterator vec![] } ``` ### user visible change 3: TAIT does not merge types across branches In contrast to RPIT, TAIT does not merge types across branches, so the following does not compile. ```rust type Foo = impl std::fmt::Debug; fn foo(b: bool) -> Foo { if b { vec![42_i32] } else { std::iter::empty().collect() //~^ ERROR `Foo` cannot be built from an iterator over elements of type `_` } } ``` It is easy to support, but we should make an explicit decision to include the additional complexity in the implementation (it's not much, see a721052457cf513487fb4266e3ade65c29b272d2 which needs to be reverted to enable this). ### PR formalities previous attempt: rust-lang#92007 This PR also includes rust-lang#92306 and rust-lang#93783, as they were reverted along with rust-lang#92007 in rust-lang#93893 fixes rust-lang#93411 fixes rust-lang#88236 fixes rust-lang#89312 fixes rust-lang#87340 fixes rust-lang#86800 fixes rust-lang#86719 fixes rust-lang#84073 fixes rust-lang#83919 fixes rust-lang#82139 fixes rust-lang#77987 fixes rust-lang#74282 fixes rust-lang#67830 fixes rust-lang#62742 fixes rust-lang#54895
Currently, any higher-ranked region errors involving opaque types
fall back to a generic "higher-ranked subtype error" message when
run under NLL. This PR adds better error message handling for this
case, giving us the same kinds of error messages that we currently
get without NLL:
To accomplish this, several different refactoring needed to be made:
InstantiateOpaqueType
struct whichimplements
TypeOp
. This is used to invokeinstantiate_opaque_types
during MIR type checking.
TypeOp
is refactored to pass around aMirBorrowckCtxt
, which isneeded to report opaque type region errors.
TypeOp
s correspond to canonicalizedqueries. This allows us to properly handle opaque type instantiation
(which does not occur in a query) as a
TypeOp
.A new
ErrorInfo
associated type is used to determine whatadditional information is used during higher-ranked region error
handling.
try_extract_error_from_fulfill_cx
has been moved out to a new function
try_extract_error_from_region_constraints
.This allows us to re-use the same error reporting code between
canonicalized queries (which can extract region constraints directly
from a fresh
InferCtxt
) and opaque type handling (which needs to takeregion constraints from the pre-existing
InferCtxt
that we usethroughout MIR borrow checking).