Limit the use of `PlaceCtxt`

2024-01-30T16:06:30+00:00

Make `PatternColumn` generic in `Cx`

2024-01-30T15:57:44+00:00

Stop using derivative in rustc_pattern_analysis

2024-01-27T12:21:01+00:00

Rollup merge of #118803 - Nadrieril:min-exhaustive-patterns, r=compiler-errors

2024-01-26T05:36:36+00:00

Add the `min_exhaustive_patterns` feature gate ## Motivation Pattern-matching on empty types is tricky around unsafe code. For that reason, current stable rust conservatively requires arms for empty types in all but the simplest case. It has long been the intention to allow omitting empty arms when it's safe to do so. The [`exhaustive_patterns`](https://github.com/rust-lang/rust/issues/51085) feature allows the omission of all empty arms, but hasn't been stabilized because that was deemed dangerous around unsafe code. ## Proposal This feature aims to stabilize an uncontroversial subset of exhaustive_patterns. Namely: when `min_exhaustive_patterns` is enabled and the data we're matching on is guaranteed to be valid by rust's operational semantics, then we allow empty arms to be omitted. E.g.: ```rust let x: Result = foo(); match x { // ok Ok(y) => ..., } let Ok(y) = x; // ok ``` If the place is not guaranteed to hold valid data (namely ptr dereferences, ref dereferences (conservatively) and union field accesses), then we keep stable behavior i.e. we (usually) require arms for the empty cases. ```rust unsafe { let ptr: *const Result = ...; match *ptr { Ok(x) => { ... } Err(_) => { ... } // still required } } let foo: Result = ...; match foo { Ok(x) => { ... } Err(&_) => { ... } // still required because of the dereference } unsafe { let ptr: *const ! = ...; match *ptr {} // already allowed on stable } ``` Note that we conservatively consider that a valid reference can point to invalid data, hence we don't allow arms of type `&!` and similar cases to be omitted. This could eventually change depending on [opsem decisions](https://github.com/rust-lang/unsafe-code-guidelines/issues/413). Whenever opsem is undecided on a case, we conservatively keep today's stable behavior. I proposed this behavior in the [`never_patterns`](https://github.com/rust-lang/rust/issues/118155) feature gate but it makes sense on its own and could be stabilized more quickly. The two proposals nicely complement each other. ## Unresolved Questions Part of the question is whether this requires an RFC. I'd argue this doesn't need one since there is no design question beyond the intent to omit unreachable patterns, but I'm aware the problem can be framed in ways that require design (I'm thinking of the [original never patterns proposal](https://smallcultfollowing.com/babysteps/blog/2018/08/13/never-patterns-exhaustive-matching-and-uninhabited-types-oh-my/), which would frame this behavior as "auto-nevering" happening). EDIT: I initially proposed a future-compatibility lint as part of this feature, I don't anymore.

Rollup merge of #120318 - Nadrieril:share-debug-impl, r=compiler-errors

2024-01-25T07:39:45+00:00

pattern_analysis: Reuse most of the `DeconstructedPat` `Debug` impl The `DeconstructedPat: Debug` is best-effort because we'd need `tcx` to get things like field names etc. Since rust-analyzer has a similar constraint, this PR moves most the impl to be shared between the two. While I was at it I also fixed a nit in the `IntRange: Debug` impl. r? `@compiler-errors`

Implement feature gate logic

2024-01-24T23:12:32+00:00

Most of the `DeconstructedPat` `Debug` impl is reusable

2024-01-24T19:04:33+00:00

Let `ctor_sub_tys` return any Iterator they want

2024-01-24T15:55:26+00:00

Since we always clone and allocate the types somewhere else ourselves, no need to ask for `Cx` to do the allocation.

Rename `TyCtxt::emit_spanned_lint` as `TyCtxt::emit_node_span_lint`.

2024-01-22T21:09:05+00:00

Remove Ty: Copy bound

2024-01-20T14:22:14+00:00

rust/compiler/rustc_pattern_analysis/src/rustc.rs, branch 1.77.2