[WIP] implement explicit deref patterns through `k#deref` #119467

fee1-dead · 2023-12-31T05:19:33Z

Some technical considerations: (feel free to add to the list)

The first commits in this PR are based on Treat k#ident keywords as valid tokens #119351, adding support for the k#ident syntax.
Variants added: ast::PatKind::Deref, hir::PatKind::Deref, thir::PatKind::DerefPattern, mir::TestKind::Deref.
We use Deref for now, but we might want a different trait (DerefPure) later.
In typeck, we deref the expected (input type of the expression) type exactly once for simplicity, and then type check the inner pattern with <expected as Deref>::Target. Doing multiple derefs with a single k#deref isn't supported for now, and we might want to explore how to do implicit/multiple derefs later.
The actual codegen first takes the place being matched (let us call that place), creates a temporary references &place, then calls deref. (place2 = Deref::deref(&place)). The inner patterns then use (*place2) for continued matching. This means: (TODO: add test for types that cannot be moved out)

match vec![1] {
    k#deref [x] => {} // `x` here has type `i32`, not `&i32`
}

We skip generating false edges from or to arms with deref patterns. This behavior should be fixed before this PR actually get merged, since it means that any unreachable arm under deref patterns would not be borrowcked. (see the vec-2.rs test for this) Clarification: skipping false edges are done because deref patterns generate temporaries that are used to create bindings. When false edges are generated for deref patterns the temporaries don't get assigned to since they are assigned to during the tests and not before an arm block starts, which lead to borrowck errors.
The key to the matching algorithm is in sort_candidate, where we replace the original match pair of PatKind::DerefPattern with the inner pattern on the new temporary created by the deref. Note that since sort_candidate can be called on multiple candidates after a test is performed, we need to ensure that the peeling of deref pattern on a match pair only happens once (through is_first), so that the subsequent match arms all do their derefs individually and get tested individually.
The current impl only does Deref as being deliberately minimal. We would want to figure out the binding mode and try doing the appropriate deref in the future.
There is no guarantee that only a single deref occurs. In fact, point 7, through is_first is opposed to this idea. We'd probably want to explore whether is_first is really necessary with more testing.

cc @compiler-errors @BoxyUwU @Nadrieril @matthewjasper @tgross35 @CAD97 (would like to hear from you about the implementation)

rustbot · 2023-12-31T05:19:41Z

r? @petrochenkov

(rustbot has picked a reviewer for you, use r? to override)

rust-log-analyzer · 2023-12-31T05:25:19Z

The job mingw-check failed! Check out the build log: (web) (plain)

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

    Checking same-file v1.0.6
    Checking crossbeam-channel v0.5.8
    Checking term v0.7.0
    Checking color-eyre v0.6.2
error[E0004]: non-exhaustive patterns: `rustc_hir::PatKind::Deref(_)` not covered
    --> src/tools/clippy/clippy_utils/src/hir_utils.rs:959:15
959  |         match pat.kind {
959  |         match pat.kind {
     |               ^^^^^^^^ pattern `rustc_hir::PatKind::Deref(_)` not covered
note: `rustc_hir::PatKind<'_>` defined here
    --> /checkout/compiler/rustc_hir/src/hir.rs:1152:1
     |
     |
1152 | pub enum PatKind<'hir> {
...
...
1193 |     Deref(&'hir Pat<'hir>),
     = note: the matched value is of type `rustc_hir::PatKind<'_>`
     = note: the matched value is of type `rustc_hir::PatKind<'_>`
help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown
     |
1020 ~             PatKind::Never | PatKind::Wild => {},
1021 ~             rustc_hir::PatKind::Deref(_) => todo!(),

    Checking rustc_version v0.4.0
    Checking getopts v0.2.21
    Checking comma v1.0.0
    Checking comma v1.0.0
    Checking bytes v1.4.0
    Checking levenshtein v1.0.5
    Checking ui_test v0.21.2
    Checking tester v0.9.1
error[E0004]: non-exhaustive patterns: `rustc_hir::PatKind::Deref(_)` not covered
     |
1708 |     match pat.kind {
1708 |     match pat.kind {
     |           ^^^^^^^^ pattern `rustc_hir::PatKind::Deref(_)` not covered
note: `rustc_hir::PatKind<'_>` defined here
    --> /checkout/compiler/rustc_hir/src/hir.rs:1152:1
     |
     |
1152 | pub enum PatKind<'hir> {
...
...
1193 |     Deref(&'hir Pat<'hir>),
     = note: the matched value is of type `rustc_hir::PatKind<'_>`
     = note: the matched value is of type `rustc_hir::PatKind<'_>`
help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown
1735 ~         },
1735 ~         },
1736 ~         rustc_hir::PatKind::Deref(_) => todo!(),

For more information about this error, try `rustc --explain E0004`.
error: could not compile `clippy_utils` (lib) due to 2 previous errors
warning: build failed, waiting for other jobs to finish...

petrochenkov · 2023-12-31T15:13:01Z

r? compiler
I'm overloaded with reviews.

petrochenkov · 2023-12-31T15:14:29Z

Also, k#ident is an even worse hack than r#ident.
If context-sensitive keywords don't work in this position, use something like do yeet or builtin #.

fee1-dead · 2024-01-02T16:27:57Z

re k#ident: I will change this soon.

For point number 6, Nadrieril suggested that we do the Deref more than once: one when we do the test, to allow subsequent tests to match on the deref temporary, and do it again when pre-binding, for the false edges to work correctly. This would be unsound if we used Deref, which is a safe trait, but would not be an issue once we switch to using DerefPure.

WaffleLapkin · 2024-01-02T17:41:10Z

@petrochenkov I don't think I agree. k# and r# are basically identical. Moreover k#something is oftentimes used as a placeholder by T-lang when designing stuff, so it's not taken from nowhere (I think they even wanted to use it for actual feature prototypes, although we never went along with it so far...).

I think it should be totally fine as a placeholder here and can't really see any issues...

bors · 2024-01-04T22:45:22Z

☔ The latest upstream changes (presumably #119578) made this pull request unmergeable. Please resolve the merge conflicts.

fee1-dead · 2024-03-15T03:11:18Z

closing in favor of #122222.

…r=compiler-errors deref patterns: bare-bones feature gate and typechecking I am restarting the deref patterns experimentation. This introduces a feature gate under the lang-team [experimental feature](https://github.com/rust-lang/lang-team/blob/master/src/how_to/experiment.md) process, with [`@cramertj` as lang-team liaison](rust-lang/lang-team#88) (it's been a while though, you still ok with this `@cramertj?).` Tracking issue: rust-lang#87121. This is the barest-bones implementation I could think of: - explicit syntax, reusing `box <pat>` because that saves me a ton of work; - use `Deref` as a marker trait (instead of a yet-to-design `DerefPure`); - no support for mutable patterns with `DerefMut` for now; - MIR lowering will come in the next PR. It's the trickiest part. My goal is to let us figure out the MIR lowering part, which might take some work. And hopefully get something working for std types soon. This is in large part salvaged from `@fee1-dead's` rust-lang#119467. r? `@compiler-errors`

…r=compiler-errors deref patterns: bare-bones feature gate and typechecking I am restarting the deref patterns experimentation. This introduces a feature gate under the lang-team [experimental feature](https://github.com/rust-lang/lang-team/blob/master/src/how_to/experiment.md) process, with [``@cramertj`` as lang-team liaison](rust-lang/lang-team#88) (it's been a while though, you still ok with this ``@cramertj?).`` Tracking issue: rust-lang#87121. This is the barest-bones implementation I could think of: - explicit syntax, reusing `box <pat>` because that saves me a ton of work; - use `Deref` as a marker trait (instead of a yet-to-design `DerefPure`); - no support for mutable patterns with `DerefMut` for now; - MIR lowering will come in the next PR. It's the trickiest part. My goal is to let us figure out the MIR lowering part, which might take some work. And hopefully get something working for std types soon. This is in large part salvaged from ``@fee1-dead's`` rust-lang#119467. r? ``@compiler-errors``

…r=compiler-errors deref patterns: bare-bones feature gate and typechecking I am restarting the deref patterns experimentation. This introduces a feature gate under the lang-team [experimental feature](https://github.com/rust-lang/lang-team/blob/master/src/how_to/experiment.md) process, with [```@cramertj``` as lang-team liaison](rust-lang/lang-team#88) (it's been a while though, you still ok with this ```@cramertj?).``` Tracking issue: rust-lang#87121. This is the barest-bones implementation I could think of: - explicit syntax, reusing `box <pat>` because that saves me a ton of work; - use `Deref` as a marker trait (instead of a yet-to-design `DerefPure`); - no support for mutable patterns with `DerefMut` for now; - MIR lowering will come in the next PR. It's the trickiest part. My goal is to let us figure out the MIR lowering part, which might take some work. And hopefully get something working for std types soon. This is in large part salvaged from ```@fee1-dead's``` rust-lang#119467. r? ```@compiler-errors```

…r=compiler-errors deref patterns: bare-bones feature gate and typechecking I am restarting the deref patterns experimentation. This introduces a feature gate under the lang-team [experimental feature](https://github.com/rust-lang/lang-team/blob/master/src/how_to/experiment.md) process, with [````@cramertj```` as lang-team liaison](rust-lang/lang-team#88) (it's been a while though, you still ok with this ````@cramertj?).```` Tracking issue: rust-lang#87121. This is the barest-bones implementation I could think of: - explicit syntax, reusing `box <pat>` because that saves me a ton of work; - use `Deref` as a marker trait (instead of a yet-to-design `DerefPure`); - no support for mutable patterns with `DerefMut` for now; - MIR lowering will come in the next PR. It's the trickiest part. My goal is to let us figure out the MIR lowering part, which might take some work. And hopefully get something working for std types soon. This is in large part salvaged from ````@fee1-dead's```` rust-lang#119467. r? ````@compiler-errors````

Rollup merge of rust-lang#122222 - Nadrieril:deref-pat-feature-gate, r=compiler-errors deref patterns: bare-bones feature gate and typechecking I am restarting the deref patterns experimentation. This introduces a feature gate under the lang-team [experimental feature](https://github.com/rust-lang/lang-team/blob/master/src/how_to/experiment.md) process, with [````@cramertj```` as lang-team liaison](rust-lang/lang-team#88) (it's been a while though, you still ok with this ````@cramertj?).```` Tracking issue: rust-lang#87121. This is the barest-bones implementation I could think of: - explicit syntax, reusing `box <pat>` because that saves me a ton of work; - use `Deref` as a marker trait (instead of a yet-to-design `DerefPure`); - no support for mutable patterns with `DerefMut` for now; - MIR lowering will come in the next PR. It's the trickiest part. My goal is to let us figure out the MIR lowering part, which might take some work. And hopefully get something working for std types soon. This is in large part salvaged from ````@fee1-dead's```` rust-lang#119467. r? ````@compiler-errors````

fee1-dead added 9 commits December 30, 2023 06:41

Treat k#ident keywords as valid tokens

83f35c0

Change token::Ident to use IdentKind

52f3cd5

feature gate

c2de483

parse and handle some cases for deref patterns

54bf204

fix forced keywords symbol

026a9e8

handle more cases, and change to correct handling

05b10f4

Handle deref pattern in mir build

d11e324

fix tests

1a313c3

remove debugging

dc9d011

rustbot assigned petrochenkov Dec 31, 2023

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. T-rustdoc Relevant to the rustdoc team, which will review and decide on the PR/issue. labels Dec 31, 2023

fee1-dead changed the title ~~[WIP] implement deref patterns through k#deref~~ [WIP] implement explicit deref patterns through k#deref Dec 31, 2023

rustbot assigned WaffleLapkin and unassigned petrochenkov Dec 31, 2023

WaffleLapkin added S-waiting-on-author Status: This is awaiting some action (such as code changes or more information) from the author. and removed S-waiting-on-review Status: Awaiting review from the assignee but also interested parties. labels Jan 12, 2024

Nadrieril added the F-deref_patterns `#![feature(deref_patterns)]` label Mar 8, 2024

This was referenced Mar 8, 2024

Tracking issue: deref patterns #87121

Open

deref patterns: bare-bones feature gate and typechecking #122222

Merged

fee1-dead closed this Mar 15, 2024

fee1-dead deleted the derefpat branch March 15, 2024 05:02

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

[WIP] implement explicit deref patterns through `k#deref` #119467

[WIP] implement explicit deref patterns through `k#deref` #119467

fee1-dead commented Dec 31, 2023 •

edited

Loading

rustbot commented Dec 31, 2023

rust-log-analyzer commented Dec 31, 2023

petrochenkov commented Dec 31, 2023

petrochenkov commented Dec 31, 2023 •

edited

Loading

fee1-dead commented Jan 2, 2024

WaffleLapkin commented Jan 2, 2024

bors commented Jan 4, 2024

fee1-dead commented Mar 15, 2024

[WIP] implement explicit deref patterns through k#deref #119467

[WIP] implement explicit deref patterns through k#deref #119467

Conversation

fee1-dead commented Dec 31, 2023 • edited Loading

rustbot commented Dec 31, 2023

rust-log-analyzer commented Dec 31, 2023

petrochenkov commented Dec 31, 2023

petrochenkov commented Dec 31, 2023 • edited Loading

fee1-dead commented Jan 2, 2024

WaffleLapkin commented Jan 2, 2024

bors commented Jan 4, 2024

fee1-dead commented Mar 15, 2024

[WIP] implement explicit deref patterns through `k#deref` #119467

[WIP] implement explicit deref patterns through `k#deref` #119467

fee1-dead commented Dec 31, 2023 •

edited

Loading

petrochenkov commented Dec 31, 2023 •

edited

Loading