From e1e755311a6ae8a3d15dff80851d00a8b2881d82 Mon Sep 17 00:00:00 2001 From: b-naber Date: Mon, 17 Jul 2023 21:58:37 +0000 Subject: [PATCH] add more tests --- .../slice_destructure_fail.rs | 2 - .../slice_destructure_fail.stderr | 25 +------- tests/ui/pattern/issue-76342.rs | 25 -------- tests/ui/pattern/slice-array-infer.rs | 27 ++++++++ .../ui/pattern/slice-patterns-irrefutable.rs | 62 +++++++++++++++++++ .../pattern/slice-patterns-irrefutable.stderr | 14 +++++ 6 files changed, 106 insertions(+), 49 deletions(-) delete mode 100644 tests/ui/pattern/issue-76342.rs create mode 100644 tests/ui/pattern/slice-array-infer.rs create mode 100644 tests/ui/pattern/slice-patterns-irrefutable.rs create mode 100644 tests/ui/pattern/slice-patterns-irrefutable.stderr diff --git a/tests/ui/destructuring-assignment/slice_destructure_fail.rs b/tests/ui/destructuring-assignment/slice_destructure_fail.rs index e36557940ee3d..e5bb50030b915 100644 --- a/tests/ui/destructuring-assignment/slice_destructure_fail.rs +++ b/tests/ui/destructuring-assignment/slice_destructure_fail.rs @@ -3,8 +3,6 @@ fn main() { [a, .., b, ..] = [0, 1]; //~ ERROR `..` can only be used once per slice pattern [a, a, b] = [1, 2]; //~^ ERROR pattern requires 3 elements but array has 2 - //~| ERROR mismatched types [_] = [1, 2]; //~^ ERROR pattern requires 1 element but array has 2 - //~| ERROR mismatched types } diff --git a/tests/ui/destructuring-assignment/slice_destructure_fail.stderr b/tests/ui/destructuring-assignment/slice_destructure_fail.stderr index e42b9695d4da7..acf44ceb184fc 100644 --- a/tests/ui/destructuring-assignment/slice_destructure_fail.stderr +++ b/tests/ui/destructuring-assignment/slice_destructure_fail.stderr @@ -6,37 +6,18 @@ LL | [a, .., b, ..] = [0, 1]; | | | previously used here -error[E0308]: mismatched types - --> $DIR/slice_destructure_fail.rs:4:5 - | -LL | [a, a, b] = [1, 2]; - | ^^^^^^^^^ expected an array with a fixed size of 2 elements, found one with 3 elements - | - = note: expected array `[{integer}; 2]` - found array `[_; 3]` - error[E0527]: pattern requires 3 elements but array has 2 --> $DIR/slice_destructure_fail.rs:4:5 | LL | [a, a, b] = [1, 2]; | ^^^^^^^^^ expected 2 elements -error[E0308]: mismatched types - --> $DIR/slice_destructure_fail.rs:7:5 - | -LL | [_] = [1, 2]; - | ^^^ expected an array with a fixed size of 2 elements, found one with 1 element - | - = note: expected array `[{integer}; 2]` - found array `[_; 1]` - error[E0527]: pattern requires 1 element but array has 2 - --> $DIR/slice_destructure_fail.rs:7:5 + --> $DIR/slice_destructure_fail.rs:6:5 | LL | [_] = [1, 2]; | ^^^ expected 2 elements -error: aborting due to 5 previous errors +error: aborting due to 3 previous errors -Some errors have detailed explanations: E0308, E0527. -For more information about an error, try `rustc --explain E0308`. +For more information about this error, try `rustc --explain E0527`. diff --git a/tests/ui/pattern/issue-76342.rs b/tests/ui/pattern/issue-76342.rs deleted file mode 100644 index e4d3218104e19..0000000000000 --- a/tests/ui/pattern/issue-76342.rs +++ /dev/null @@ -1,25 +0,0 @@ -// check-pass - -// Test that we infer the expected type of a pattern to an array of the given length. - -#![allow(unused_variables)] -struct Zeroes; -impl Into<[usize; 2]> for Zeroes { - fn into(self) -> [usize; 2] { - [0; 2] - } -} -impl Into<[usize; 3]> for Zeroes { - fn into(self) -> [usize; 3] { - [0; 3] - } -} -impl Into<[usize; 4]> for Zeroes { - fn into(self) -> [usize; 4] { - [0; 4] - } -} -fn main() { - let [a, b, c] = Zeroes.into(); - let [d, e, f]: [_; 3] = Zeroes.into(); -} diff --git a/tests/ui/pattern/slice-array-infer.rs b/tests/ui/pattern/slice-array-infer.rs new file mode 100644 index 0000000000000..f94a3dcfe0a6c --- /dev/null +++ b/tests/ui/pattern/slice-array-infer.rs @@ -0,0 +1,27 @@ +// check-pass + +#![allow(unused_variables)] +#![feature(generic_arg_infer)] + +struct Zeroes; +impl Into<&'static [usize; 3]> for Zeroes { + fn into(self) -> &'static [usize; 3] { + &[0; 3] + } +} +impl Into<[usize; 3]> for Zeroes { + fn into(self) -> [usize; 3] { + [0; 3] + } +} +fn main() { + let [a, b, c] = Zeroes.into(); + let [d, e, f] = >::into(Zeroes); + let &[g, h, i] = Zeroes.into(); + let [j, k, l]: [usize; _] = Zeroes.into(); + let [m, n, o]: &[usize; _] = Zeroes.into(); + + // check the binding mode of these patterns: + let _: &[usize] = &[a, b, c, g, h, i, j, k, l]; + let _: &[&usize] = &[d, e, f, m, n, o]; +} diff --git a/tests/ui/pattern/slice-patterns-irrefutable.rs b/tests/ui/pattern/slice-patterns-irrefutable.rs new file mode 100644 index 0000000000000..7be02b44e43d7 --- /dev/null +++ b/tests/ui/pattern/slice-patterns-irrefutable.rs @@ -0,0 +1,62 @@ +// Test that we infer the expected type of a pattern to an array of the given length. + +#![allow(unused_variables)] + +use std::array::TryFromSliceError; +use std::convert::TryInto; + +struct Zeroes; +impl Into<[usize; 2]> for Zeroes { + fn into(self) -> [usize; 2] { + [0; 2] + } +} +impl Into<[usize; 3]> for Zeroes { + fn into(self) -> [usize; 3] { + [0; 3] + } +} +impl Into<[usize; 4]> for Zeroes { + fn into(self) -> [usize; 4] { + [0; 4] + } +} + +fn zeroes_into() { + let [a, b, c] = Zeroes.into(); + let [d, e, f]: [_; 3] = Zeroes.into(); +} + +fn array_try_from(x: &[usize]) -> Result { + let [a, b] = x.try_into()?; + Ok(a + b) +} + +fn default() { + let a: i32; + let b; + [a, b] = Default::default(); +} + +fn test_nested_array() { + let a: [_; 3]; + let b; + //~^ ERROR type annotations needed + [a, b] = Default::default(); +} + +struct Foo([T; 2]); + +impl Default for Foo { + fn default() -> Self { + Foo([Default::default(); 2]) + } +} + +fn field_array() { + let a: i32; + let b; + Foo([a, b]) = Default::default(); +} + +fn main() {} diff --git a/tests/ui/pattern/slice-patterns-irrefutable.stderr b/tests/ui/pattern/slice-patterns-irrefutable.stderr new file mode 100644 index 0000000000000..fac99534f3e23 --- /dev/null +++ b/tests/ui/pattern/slice-patterns-irrefutable.stderr @@ -0,0 +1,14 @@ +error[E0282]: type annotations needed for `[_; 3]` + --> $DIR/slice-patterns-irrefutable.rs:43:9 + | +LL | let b; + | ^ + | +help: consider giving `b` an explicit type, where the placeholders `_` are specified + | +LL | let b: [_; 3]; + | ++++++++ + +error: aborting due to previous error + +For more information about this error, try `rustc --explain E0282`.