summary refs log tree commit diff
path: root/tests/ui/pattern
AgeCommit message (Collapse)AuthorLines
2023-11-08Auto merge of #116930 - RalfJung:raw-ptr-match, r=davidtwcobors-14/+94
patterns: reject raw pointers that are not just integers Matching against `0 as *const i32` is fine, matching against `&42 as *const i32` is not. This extends the existing check against function pointers and wide pointers: we now uniformly reject all these pointer types during valtree construction, and then later lint because of that. See [here](https://github.com/rust-lang/rust/pull/116930#issuecomment-1784654073) for some more explanation and context. Also fixes https://github.com/rust-lang/rust/issues/116929. Cc `@oli-obk` `@lcnr`
2023-11-03Tweak spans for "adt defined here" noteNadrieril-136/+150
2023-11-02Always do all the pattern checksNadrieril-4/+22
2023-11-02Add regression test for pattern checksNadrieril-0/+72
2023-11-02Tweak diagnostic for consistencyNadrieril-57/+109
2023-11-01Auto merge of #117289 - estebank:issue-72298, r=cjgillotbors-0/+94
Account for `ref` and `mut` in the wrong place for pattern ident renaming If the user writes `S { ref field: name }` instead of `S { field: ref name }`, we suggest the correct code. Fix #72298.
2023-10-30Account for `ref` and `mut` in the wrong place for pattern ident renamingEsteban Küber-0/+94
If the user writes `S { ref field: name }` instead of `S { field: ref name }`, we suggest the correct code. Fix #72298.
2023-10-28make pointer_structural_match warn-by-defaultRalf Jung-14/+94
2023-10-27Match usize/isize exhaustivelyNadrieril-243/+194
2023-10-27Add testsNadrieril-14/+80
2023-10-27Lint overlapping ranges as a separate passNadrieril-15/+58
2023-10-16Fix inline const pattern unsafety checking in THIRMatthew Jasper-14/+31
THIR unsafety checking was getting a cycle of function unsafety checking -> building THIR for the function -> evaluating pattern inline constants in the function -> building MIR for the inline constant -> checking unsafety of functions (so that THIR can be stolen) This is fixed by not stealing THIR when generating MIR but instead when unsafety checking. This leaves an issue with pattern inline constants not being unsafety checked because they are evaluated away when generating THIR. To fix that we now represent inline constants in THIR patterns and visit them in THIR unsafety checking.
2023-10-15use `PatKind::error` when an ADT const value has violationbohan-0/+18
2023-10-14Skip most of check_match checks in the presence of `PatKind::Error`Nadrieril-34/+9
2023-10-12Auto merge of #116391 - Nadrieril:constructorset, r=cjgillotbors-0/+61
exhaustiveness: Rework constructor splitting `SplitWildcard` was pretty opaque. I replaced it with a more legible abstraction: `ConstructorSet` represents the set of constructors for patterns of a given type. This clarifies responsibilities: `ConstructorSet` handles one clear task, and diagnostic-related shenanigans can be done separately. I'm quite excited, I had has this in mind for years but could never quite introduce it. This opens up possibilities, including type-specific optimisations (like using a `FxHashSet` to collect enum variants, which had been [hackily attempted some years ago](https://github.com/rust-lang/rust/pull/76918)), my one-pass rewrite (https://github.com/rust-lang/rust/pull/116042), and future librarification.
2023-10-11Avoid emitting the non_exhaustive error if other errors already occurredOli Scherer-47/+9
2023-10-11Prevent spurious `unreachable pattern` lintsOli Scherer-143/+71
Means you'll get more `non-exhaustive` patterns
2023-10-06Auto merge of #114811 - estebank:impl-ambiguity, r=wesleywiserbors-0/+3
Show more information when multiple `impl`s apply - When there are `impl`s without type params, show only those (to avoid showing overly generic `impl`s). ``` error[E0283]: type annotations needed --> $DIR/multiple-impl-apply.rs:34:9 | LL | let y = x.into(); | ^ ---- type must be known at this point | note: multiple `impl`s satisfying `_: From<Baz>` found --> $DIR/multiple-impl-apply.rs:14:1 | LL | impl From<Baz> for Bar { | ^^^^^^^^^^^^^^^^^^^^^^ ... LL | impl From<Baz> for Foo { | ^^^^^^^^^^^^^^^^^^^^^^ = note: required for `Baz` to implement `Into<_>` help: consider giving `y` an explicit type | LL | let y: /* Type */ = x.into(); | ++++++++++++ ``` - Lower the importance of `T: Sized`, `T: WellFormed` and coercion errors, to prioritize more relevant errors. The pre-existing deduplication logic deals with hiding redundant errors better that way, and we show errors with more metadata that is useful to the user. - Show `<SelfTy as Trait>::assoc_fn` suggestion in more cases. ``` error[E0790]: cannot call associated function on trait without specifying the corresponding `impl` type --> $DIR/cross-return-site-inference.rs:38:16 | LL | return Err(From::from("foo")); | ^^^^^^^^^^ cannot call associated function of trait | help: use a fully-qualified path to a specific available implementation | LL | return Err(</* self type */ as From>::from("foo")); | +++++++++++++++++++ + ``` Fix #88284.
2023-10-05Add a note to duplicate diagnosticsAlex Macleod-0/+4
2023-10-05Fix handling slices of empty typesNadrieril-0/+61
2023-10-04Reorder fullfillment errors to keep more interesting ones firstEsteban Küber-0/+3
In `report_fullfillment_errors` push back `T: Sized`, `T: WellFormed` and coercion errors to the end of the list. The pre-existing deduplication logic eliminates redundant errors better that way, keeping the resulting output with fewer errors than before, while also having more detail.
2023-10-01Evaluate float consts eagerlyNadrieril-15/+77
2023-09-21adjust how closure/generator types and rvalues are printedRalf Jung-2/+2
2023-09-07fixes #114896surechen-0/+18
2023-09-03Improve clarity of diagnostic message on non-exhaustive matchesSebastian Toh-5/+5
2023-08-28Add note when matching on nested non-exhaustive enumsSebastian Toh-0/+42
2023-08-28Add note that str cannot be matched exhaustivelySebastian Toh-0/+31
2023-08-21Add note when matching on tuples/ADTs containing non-exhaustive typesSebastian Toh-0/+245
2023-07-28address reviewb-naber-1/+13
2023-07-17add more testsb-naber-25/+103
2023-07-17address reviewb-naber-3/+8
2023-07-17add test for nested patternb-naber-0/+15
2023-07-17add tests for refutable patternsb-naber-5/+172
2023-07-17add test, bless testsb-naber-0/+16
2023-07-01add regression testEric Mark Martin-0/+38
2023-06-28add comment backEric Mark Martin-1/+2
2023-06-28add note for non-exhaustive matches with guardsEric Mark Martin-24/+55
2023-06-24Revert "Structurally resolve correctly in check_pat_lit"Michael Goulet-0/+15
This reverts commit 54fb5a48b968b3a329ceeb57226d9ac60f983f04.
2023-05-31Only rewrite valtree-constants to patterns and keep other constants opaqueOli Scherer-2/+2
2023-05-29Rollup merge of #111558 - c410-f3r:t3st3ss, r=WaffleLapkinMatthias Krüger-0/+35
Move tests r? `@petrochenkov`
2023-05-25Add NOTE annotations.Camille GILLOT-75/+141
2023-05-25Add inter-crate test.Camille GILLOT-40/+75
2023-05-24Move testsCaio-0/+35
2023-05-21Rename `drop_ref` lint to `dropping_references`Urgau-3/+3
2023-05-21Rename `drop_copy` lint to `dropping_copy_types`Urgau-2/+2
2023-05-16Auto merge of #105750 - oli-obk:valtrees, r=lcnrbors-40/+53
Always fall back to PartialEq when a constant in a pattern is not recursively structural-eq Right now we destructure the constant as far as we can, but with this PR we just don't take it apart anymore. This is preparatory work for moving to always using valtrees, as these will just do a single conversion of the constant to a valtree at the start, and if that fails, fall back to `PartialEq`. This removes a few cases where we emitted the `unreachable pattern` lint, because we stop looking into the constant deeply enough to detect that a constant is already covered by another pattern. Previous work: https://github.com/rust-lang/rust/pull/70743 This is groundwork towards fixing https://github.com/rust-lang/rust/issues/83085 and https://github.com/rust-lang/rust/issues/105047
2023-05-16Rollup merge of #111428 - bvanjoi:fix-109250, r=NilstriebNilstrieb-6/+9
refactor(resolve): clean up the early error return caused by non-call closes https://github.com/rust-lang/rust/issues/109250 It seems no bad happened, r? ``@Nilstrieb``
2023-05-15Always fall back to PartialEq when a constant in a pattern is not ↵Oli Scherer-40/+53
recursively structural-eq
2023-05-10Adjust tests for new drop and forget lintsUrgau-0/+9
2023-05-10refactor(resolve): clean up the early error return caused by non-callbohan-6/+9
generated by cgit-pink 1.4.1-3-g733a5 (git 2.37.1) at 2026-03-01 03:53:24 +0000