squiid/rust
1
0
Fork 0
Code Issues Pull requests Projects Activity

Auto merge of #65368 - Centril:rollup-lb7fe48, r=Centril

Browse source 
Rollup of 13 pull requests

Successful merges:

 - #65039 (Document missing deny by default lints)
 - #65069 (Implement Clone::clone_from for VecDeque)
 - #65165 (Improve docs on some char boolean methods)
 - #65248 (Suggest `if let` on `let` refutable binding)
 - #65250 (resolve: fix error title regarding private constructors)
 - #65295 (Move diagnostics code out of the critical path)
 - #65320 (Report `CONST_ERR` lint in external macros)
 - #65327 (replace the hand-written binary search with the library one)
 - #65339 (do not reference LLVM for our concurrency memory model)
 - #65357 (syntax: simplify maybe_annotate_with_ascription)
 - #65358 (simplify maybe_stage_features)
 - #65359 (simplify integer_lit)
 - #65360 (mbe: reduce panictry! uses.)

Failed merges:

r? @ghost
This commit is contained in:
bors 2019-10-13 11:36:52 +00:00
commit aa2ae564d3
37 changed files with 761 additions and 377 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

25
src/doc/rustc/src/lints/listing/deny-by-default.md
View file

@ -222,3 +222,28 @@ error: invalid `crate_type` value
| ^^^^^^^^^^^^^^^^^^^^
|
```
## const-err
This lint detects expressions that will always panic at runtime and would be an
error in a `const` context.
```rust,ignore
let _ = [0; 4][4];
```
This will produce:
```text
error: index out of bounds: the len is 4 but the index is 4
--> src/lib.rs:1:9
|
1 | let _ = [0; 4][4];
| ^^^^^^^^^
|
```
## order-dependent-trait-objects
This lint detects a trait coherency violation that would allow creating two
trait impls for the same dynamic trait object involving marker traits.

101
src/liballoc/collections/vec_deque.rs
View file

@ -10,8 +10,8 @@
use core::array::LengthAtMost32;
use core::cmp::{self, Ordering};
use core::fmt;
use core::iter::{repeat_with, FromIterator, FusedIterator};
use core::mem;
use core::iter::{once, repeat_with, FromIterator, FusedIterator};
use core::mem::{self, replace};
use core::ops::Bound::{Excluded, Included, Unbounded};
use core::ops::{Index, IndexMut, RangeBounds, Try};
use core::ptr::{self, NonNull};
@ -57,11 +57,88 @@ pub struct VecDeque<T> {
buf: RawVec<T>,
}
/// PairSlices pairs up equal length slice parts of two deques
///
/// For example, given deques "A" and "B" with the following division into slices:
///
/// A: [0 1 2] [3 4 5]
/// B: [a b] [c d e]
///
/// It produces the following sequence of matching slices:
///
/// ([0 1], [a b])
/// ([2], [c])
/// ([3 4], [d e])
///
/// and the uneven remainder of either A or B is skipped.
struct PairSlices<'a, 'b, T> {
a0: &'a mut [T],
a1: &'a mut [T],
b0: &'b [T],
b1: &'b [T],
}
impl<'a, 'b, T> PairSlices<'a, 'b, T> {
fn from(to: &'a mut VecDeque<T>, from: &'b VecDeque<T>) -> Self {
let (a0, a1) = to.as_mut_slices();
let (b0, b1) = from.as_slices();
PairSlices { a0, a1, b0, b1 }
}
fn has_remainder(&self) -> bool {
!self.b0.is_empty()
}
fn remainder(self) -> impl Iterator<Item=&'b [T]> {
once(self.b0).chain(once(self.b1))
}
}
impl<'a, 'b, T> Iterator for PairSlices<'a, 'b, T>
{
type Item = (&'a mut [T], &'b [T]);
fn next(&mut self) -> Option<Self::Item> {
// Get next part length
let part = cmp::min(self.a0.len(), self.b0.len());
if part == 0 {
return None;
}
let (p0, p1) = replace(&mut self.a0, &mut []).split_at_mut(part);
let (q0, q1) = self.b0.split_at(part);
// Move a1 into a0, if it's empty (and b1, b0 the same way).
self.a0 = p1;
self.b0 = q1;
if self.a0.is_empty() {
self.a0 = replace(&mut self.a1, &mut []);
}
if self.b0.is_empty() {
self.b0 = replace(&mut self.b1, &[]);
}
Some((p0, q0))
}
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<T: Clone> Clone for VecDeque<T> {
fn clone(&self) -> VecDeque<T> {
self.iter().cloned().collect()
}
fn clone_from(&mut self, other: &Self) {
self.truncate(other.len());
let mut iter = PairSlices::from(self, other);
while let Some((dst, src)) = iter.next() {
dst.clone_from_slice(&src);
}
if iter.has_remainder() {
for remainder in iter.remainder() {
self.extend(remainder.iter().cloned());
}
}
}
}
#[stable(feature = "rust1", since = "1.0.0")]
@ -2209,6 +2286,16 @@ impl<'a, T> Iterator for Iter<'a, T> {
final_res
}
fn nth(&mut self, n: usize) -> Option<Self::Item> {
if n >= count(self.tail, self.head, self.ring.len()) {
self.tail = self.head;
None
} else {
self.tail = wrap_index(self.tail.wrapping_add(n), self.ring.len());
self.next()
}
}
#[inline]
fn last(mut self) -> Option<&'a T> {
self.next_back()
@ -2327,6 +2414,16 @@ impl<'a, T> Iterator for IterMut<'a, T> {
back.iter_mut().fold(accum, &mut f)
}
fn nth(&mut self, n: usize) -> Option<Self::Item> {
if n >= count(self.tail, self.head, self.ring.len()) {
self.tail = self.head;
None
} else {
self.tail = wrap_index(self.tail.wrapping_add(n), self.ring.len());
self.next()
}
}
#[inline]
fn last(mut self) -> Option<&'a mut T> {
self.next_back()

23
src/liballoc/collections/vec_deque/tests.rs
View file

@ -361,6 +361,29 @@ fn test_vec_from_vecdeque() {
}
}
#[test]
fn test_clone_from() {
let m = vec![1; 8];
let n = vec![2; 12];
for pfv in 0..8 {
for pfu in 0..8 {
for longer in 0..2 {
let (vr, ur) = if longer == 0 { (&m, &n) } else { (&n, &m) };
let mut v = VecDeque::from(vr.clone());
for _ in 0..pfv {
v.push_front(1);
}
let mut u = VecDeque::from(ur.clone());
for _ in 0..pfu {
u.push_front(2);
}
v.clone_from(&u);
assert_eq!(&v, &u);
}
}
}
}
#[test]
fn issue_53529() {
use crate::boxed::Box;

172
src/libcore/char/methods.rs
View file

@ -116,9 +116,9 @@ impl char {
// the code is split up here to improve execution speed for cases where
// the `radix` is constant and 10 or smaller
let val = if radix <= 10 {
let val = if radix <= 10 {
match self {
'0' ..= '9' => self as u32 - '0' as u32,
'0'..='9' => self as u32 - '0' as u32,
_ => return None,
}
} else {
@ -130,8 +130,11 @@ impl char {
}
};
if val < radix { Some(val) }
else { None }
if val < radix {
Some(val)
} else {
None
}
}
/// Returns an iterator that yields the hexadecimal Unicode escape of a
@ -303,8 +306,8 @@ impl char {
'\r' => EscapeDefaultState::Backslash('r'),
'\n' => EscapeDefaultState::Backslash('n'),
'\\' | '\'' | '"' => EscapeDefaultState::Backslash(self),
'\x20' ..= '\x7e' => EscapeDefaultState::Char(self),
_ => EscapeDefaultState::Unicode(self.escape_unicode())
'\x20'..='\x7e' => EscapeDefaultState::Char(self),
_ => EscapeDefaultState::Unicode(self.escape_unicode()),
};
EscapeDefault { state: init_state }
}
@ -436,30 +439,31 @@ impl char {
pub fn encode_utf8(self, dst: &mut [u8]) -> &mut str {
let code = self as u32;
unsafe {
let len =
if code < MAX_ONE_B && !dst.is_empty() {
let len = if code < MAX_ONE_B && !dst.is_empty() {
*dst.get_unchecked_mut(0) = code as u8;
1
} else if code < MAX_TWO_B && dst.len() >= 2 {
*dst.get_unchecked_mut(0) = (code >> 6 & 0x1F) as u8 | TAG_TWO_B;
*dst.get_unchecked_mut(1) = (code & 0x3F) as u8 | TAG_CONT;
2
} else if code < MAX_THREE_B && dst.len() >= 3 {
} else if code < MAX_THREE_B && dst.len() >= 3 {
*dst.get_unchecked_mut(0) = (code >> 12 & 0x0F) as u8 | TAG_THREE_B;
*dst.get_unchecked_mut(1) = (code >> 6 & 0x3F) as u8 | TAG_CONT;
*dst.get_unchecked_mut(1) = (code >> 6 & 0x3F) as u8 | TAG_CONT;
*dst.get_unchecked_mut(2) = (code & 0x3F) as u8 | TAG_CONT;
3
} else if dst.len() >= 4 {
*dst.get_unchecked_mut(0) = (code >> 18 & 0x07) as u8 | TAG_FOUR_B;
*dst.get_unchecked_mut(1) = (code >> 12 & 0x3F) as u8 | TAG_CONT;
*dst.get_unchecked_mut(2) = (code >> 6 & 0x3F) as u8 | TAG_CONT;
*dst.get_unchecked_mut(2) = (code >> 6 & 0x3F) as u8 | TAG_CONT;
*dst.get_unchecked_mut(3) = (code & 0x3F) as u8 | TAG_CONT;
4
} else {
panic!("encode_utf8: need {} bytes to encode U+{:X}, but the buffer has {}",
panic!(
"encode_utf8: need {} bytes to encode U+{:X}, but the buffer has {}",
from_u32_unchecked(code).len_utf8(),
code,
dst.len())
dst.len(),
)
};
from_utf8_unchecked_mut(dst.get_unchecked_mut(..len))
}
@ -515,15 +519,24 @@ impl char {
*dst.get_unchecked_mut(1) = 0xDC00 | ((code as u16) & 0x3FF);
slice::from_raw_parts_mut(dst.as_mut_ptr(), 2)
} else {
panic!("encode_utf16: need {} units to encode U+{:X}, but the buffer has {}",
panic!(
"encode_utf16: need {} units to encode U+{:X}, but the buffer has {}",
from_u32_unchecked(code).len_utf16(),
code,
dst.len())
dst.len(),
)
}
}
}
/// Returns `true` if this `char` is an alphabetic code point, and false if not.
/// Returns `true` if this `char` has the `Alphabetic` property.
///
/// `Alphabetic` is described in Chapter 4 (Character Properties) of the [Unicode Standard] and
/// specified in the [Unicode Character Database][ucd] [`DerivedCoreProperties.txt`].
///
/// [Unicode Standard]: https://www.unicode.org/versions/latest/
/// [ucd]: https://www.unicode.org/reports/tr44/
/// [`DerivedCoreProperties.txt`]: https://www.unicode.org/Public/UCD/latest/ucd/DerivedCoreProperties.txt
///
/// # Examples
///
@ -547,10 +560,14 @@ impl char {
}
}
/// Returns `true` if this `char` is lowercase.
/// Returns `true` if this `char` has the `Lowercase` property.
///
/// 'Lowercase' is defined according to the terms of the Unicode Derived Core
/// Property `Lowercase`.
/// `Lowercase` is described in Chapter 4 (Character Properties) of the [Unicode Standard] and
/// specified in the [Unicode Character Database][ucd] [`DerivedCoreProperties.txt`].
///
/// [Unicode Standard]: https://www.unicode.org/versions/latest/
/// [ucd]: https://www.unicode.org/reports/tr44/
/// [`DerivedCoreProperties.txt`]: https://www.unicode.org/Public/UCD/latest/ucd/DerivedCoreProperties.txt
///
/// # Examples
///
@ -575,10 +592,14 @@ impl char {
}
}
/// Returns `true` if this `char` is uppercase.
/// Returns `true` if this `char` has the `Uppercase` property.
///
/// 'Uppercase' is defined according to the terms of the Unicode Derived Core
/// Property `Uppercase`.
/// `Uppercase` is described in Chapter 4 (Character Properties) of the [Unicode Standard] and
/// specified in the [Unicode Character Database][ucd] [`DerivedCoreProperties.txt`].
///
/// [Unicode Standard]: https://www.unicode.org/versions/latest/
/// [ucd]: https://www.unicode.org/reports/tr44/
/// [`DerivedCoreProperties.txt`]: https://www.unicode.org/Public/UCD/latest/ucd/DerivedCoreProperties.txt
///
/// # Examples
///
@ -603,10 +624,12 @@ impl char {
}
}
/// Returns `true` if this `char` is whitespace.
/// Returns `true` if this `char` has the `White_Space` property.
///
/// 'Whitespace' is defined according to the terms of the Unicode Derived Core
/// Property `White_Space`.
/// `White_Space` is specified in the [Unicode Character Database][ucd] [`PropList.txt`].
///
/// [ucd]: https://www.unicode.org/reports/tr44/
/// [`PropList.txt`]: https://www.unicode.org/Public/UCD/latest/ucd/PropList.txt
///
/// # Examples
///
@ -630,10 +653,10 @@ impl char {
}
}
/// Returns `true` if this `char` is alphanumeric.
/// Returns `true` if this `char` satisfies either [`is_alphabetic()`] or [`is_numeric()`].
///
/// 'Alphanumeric'-ness is defined in terms of the Unicode General Categories
/// `Nd`, `Nl`, `No` and the Derived Core Property `Alphabetic`.
/// [`is_alphabetic()`]: #method.is_alphabetic
/// [`is_numeric()`]: #method.is_numeric
///
/// # Examples
///
@ -655,10 +678,15 @@ impl char {
self.is_alphabetic() || self.is_numeric()
}
/// Returns `true` if this `char` is a control code point.
/// Returns `true` if this `char` has the general category for control codes.
///
/// 'Control code point' is defined in terms of the Unicode General
/// Category `Cc`.
/// Control codes (code points with the general category of `Cc`) are described in Chapter 4
/// (Character Properties) of the [Unicode Standard] and specified in the [Unicode Character
/// Database][ucd] [`UnicodeData.txt`].
///
/// [Unicode Standard]: https://www.unicode.org/versions/latest/
/// [ucd]: https://www.unicode.org/reports/tr44/
/// [`UnicodeData.txt`]: https://www.unicode.org/Public/UCD/latest/ucd/UnicodeData.txt
///
/// # Examples
///
@ -675,19 +703,29 @@ impl char {
general_category::Cc(self)
}
/// Returns `true` if this `char` is an extended grapheme character.
/// Returns `true` if this `char` has the `Grapheme_Extend` property.
///
/// 'Extended grapheme character' is defined in terms of the Unicode Shaping and Rendering
/// Category `Grapheme_Extend`.
/// `Grapheme_Extend` is described in [Unicode Standard Annex #29 (Unicode Text
/// Segmentation)][uax29] and specified in the [Unicode Character Database][ucd]
/// [`DerivedCoreProperties.txt`].
///
/// [uax29]: https://www.unicode.org/reports/tr29/
/// [ucd]: https://www.unicode.org/reports/tr44/
/// [`DerivedCoreProperties.txt`]: https://www.unicode.org/Public/UCD/latest/ucd/DerivedCoreProperties.txt
#[inline]
pub(crate) fn is_grapheme_extended(self) -> bool {
derived_property::Grapheme_Extend(self)
}
/// Returns `true` if this `char` is numeric.
/// Returns `true` if this `char` has one of the general categories for numbers.
///
/// 'Numeric'-ness is defined in terms of the Unicode General Categories
/// `Nd`, `Nl`, `No`.
/// The general categories for numbers (`Nd` for decimal digits, `Nl` for letter-like numeric
/// characters, and `No` for other numeric characters) are specified in the [Unicode Character
/// Database][ucd] [`UnicodeData.txt`].
///
/// [Unicode Standard]: https://www.unicode.org/versions/latest/
/// [ucd]: https://www.unicode.org/reports/tr44/
/// [`UnicodeData.txt`]: https://www.unicode.org/Public/UCD/latest/ucd/UnicodeData.txt
///
/// # Examples
///
@ -713,25 +751,29 @@ impl char {
}
}
/// Returns an iterator that yields the lowercase equivalent of a `char`
/// as one or more `char`s.
/// Returns an iterator that yields the lowercase mapping of this `char` as one or more
/// `char`s.
///
/// If a character does not have a lowercase equivalent, the same character
/// will be returned back by the iterator.
/// If this `char` does not have a lowercase mapping, the iterator yields the same `char`.
///
/// This performs complex unconditional mappings with no tailoring: it maps
/// one Unicode character to its lowercase equivalent according to the
/// [Unicode database] and the additional complex mappings
/// [`SpecialCasing.txt`]. Conditional mappings (based on context or
/// language) are not considered here.
/// If this `char` has a one-to-one lowercase mapping given by the [Unicode Character
/// Database][ucd] [`UnicodeData.txt`], the iterator yields that `char`.
///
/// For a full reference, see [here][reference].
/// [ucd]: https://www.unicode.org/reports/tr44/
/// [`UnicodeData.txt`]: https://www.unicode.org/Public/UCD/latest/ucd/UnicodeData.txt
///
/// [Unicode database]: ftp://ftp.unicode.org/Public/UNIDATA/UnicodeData.txt
/// If this `char` requires special considerations (e.g. multiple `char`s) the iterator yields
/// the `char`(s) given by [`SpecialCasing.txt`].
///
/// [`SpecialCasing.txt`]: ftp://ftp.unicode.org/Public/UNIDATA/SpecialCasing.txt
/// [`SpecialCasing.txt`]: https://www.unicode.org/Public/UCD/latest/ucd/SpecialCasing.txt
///
/// [reference]: http://www.unicode.org/versions/Unicode7.0.0/ch03.pdf#G33992
/// This operation performs an unconditional mapping without tailoring. That is, the conversion
/// is independent of context and language.
///
/// In the [Unicode Standard], Chapter 4 (Character Properties) discusses case mapping in
/// general and Chapter 3 (Conformance) discusses the default algorithm for case conversion.
///
/// [Unicode Standard]: https://www.unicode.org/versions/latest/
///
/// # Examples
///
@ -774,25 +816,29 @@ impl char {
ToLowercase(CaseMappingIter::new(conversions::to_lower(self)))
}
/// Returns an iterator that yields the uppercase equivalent of a `char`
/// as one or more `char`s.
/// Returns an iterator that yields the uppercase mapping of this `char` as one or more
/// `char`s.
///
/// If a character does not have an uppercase equivalent, the same character
/// will be returned back by the iterator.
/// If this `char` does not have a uppercase mapping, the iterator yields the same `char`.
///
/// This performs complex unconditional mappings with no tailoring: it maps
/// one Unicode character to its uppercase equivalent according to the
/// [Unicode database] and the additional complex mappings
/// [`SpecialCasing.txt`]. Conditional mappings (based on context or
/// language) are not considered here.
/// If this `char` has a one-to-one uppercase mapping given by the [Unicode Character
/// Database][ucd] [`UnicodeData.txt`], the iterator yields that `char`.
///
/// For a full reference, see [here][reference].
/// [ucd]: https://www.unicode.org/reports/tr44/
/// [`UnicodeData.txt`]: https://www.unicode.org/Public/UCD/latest/ucd/UnicodeData.txt
///
/// [Unicode database]: ftp://ftp.unicode.org/Public/UNIDATA/UnicodeData.txt
/// If this `char` requires special considerations (e.g. multiple `char`s) the iterator yields
/// the `char`(s) given by [`SpecialCasing.txt`].
///
/// [`SpecialCasing.txt`]: ftp://ftp.unicode.org/Public/UNIDATA/SpecialCasing.txt
/// [`SpecialCasing.txt`]: https://www.unicode.org/Public/UCD/latest/ucd/SpecialCasing.txt
///
/// [reference]: http://www.unicode.org/versions/Unicode7.0.0/ch03.pdf#G33992
/// This operation performs an unconditional mapping without tailoring. That is, the conversion
/// is independent of context and language.
///
/// In the [Unicode Standard], Chapter 4 (Character Properties) discusses case mapping in
/// general and Chapter 3 (Conformance) discusses the default algorithm for case conversion.
///
/// [Unicode Standard]: https://www.unicode.org/versions/latest/
///
/// # Examples
///

52
src/libcore/sync/atomic.rs
View file

@ -18,11 +18,11 @@
//!
//! Each method takes an [`Ordering`] which represents the strength of
//! the memory barrier for that operation. These orderings are the
//! same as [LLVM atomic orderings][1]. For more information see the [nomicon][2].
//! same as the [C++20 atomic orderings][1]. For more information see the [nomicon][2].
//!
//! [`Ordering`]: enum.Ordering.html
//!
//! [1]: https://llvm.org/docs/LangRef.html#memory-model-for-concurrent-operations
//! [1]: https://en.cppreference.com/w/cpp/atomic/memory_order
//! [2]: ../../../nomicon/atomics.html
//!
//! Atomic variables are safe to share between threads (they implement [`Sync`])
@ -217,8 +217,8 @@ unsafe impl<T> Sync for AtomicPtr<T> {}
/// operations synchronize other memory while additionally preserving a total order of such
/// operations across all threads.
///
/// Rust's memory orderings are [the same as
/// LLVM's](https://llvm.org/docs/LangRef.html#memory-model-for-concurrent-operations).
/// Rust's memory orderings are [the same as those of
/// C++20](https://en.cppreference.com/w/cpp/atomic/memory_order).
///
/// For more information see the [nomicon].
///
@ -231,9 +231,9 @@ unsafe impl<T> Sync for AtomicPtr<T> {}
pub enum Ordering {
/// No ordering constraints, only atomic operations.
///
/// Corresponds to LLVM's [`Monotonic`] ordering.
/// Corresponds to [`memory_order_relaxed`] in C++20.
///
/// [`Monotonic`]: https://llvm.org/docs/Atomics.html#monotonic
/// [`memory_order_relaxed`]: https://en.cppreference.com/w/cpp/atomic/memory_order#Relaxed_ordering
#[stable(feature = "rust1", since = "1.0.0")]
Relaxed,
/// When coupled with a store, all previous operations become ordered
@ -246,11 +246,12 @@ pub enum Ordering {
///
/// This ordering is only applicable for operations that can perform a store.
///
/// Corresponds to LLVM's [`Release`] ordering.
/// Corresponds to [`memory_order_release`] in C++20.
///
/// [`Release`]: https://llvm.org/docs/Atomics.html#release
/// [`Acquire`]: https://llvm.org/docs/Atomics.html#acquire
/// [`Relaxed`]: https://llvm.org/docs/Atomics.html#monotonic
/// [`Release`]: #variant.Release
/// [`Acquire`]: #variant.Acquire
/// [`Relaxed`]: #variant.Relaxed
/// [`memory_order_release`]: https://en.cppreference.com/w/cpp/atomic/memory_order#Release-Acquire_ordering
#[stable(feature = "rust1", since = "1.0.0")]
Release,
/// When coupled with a load, if the loaded value was written by a store operation with
@ -263,11 +264,12 @@ pub enum Ordering {
///
/// This ordering is only applicable for operations that can perform a load.
///
/// Corresponds to LLVM's [`Acquire`] ordering.
/// Corresponds to [`memory_order_acquire`] in C++20.
///
/// [`Acquire`]: https://llvm.org/docs/Atomics.html#acquire
/// [`Release`]: https://llvm.org/docs/Atomics.html#release
/// [`Relaxed`]: https://llvm.org/docs/Atomics.html#monotonic
/// [`Acquire`]: #variant.Acquire
/// [`Release`]: #variant.Release
/// [`Relaxed`]: #variant.Relaxed
/// [`memory_order_acquire`]: https://en.cppreference.com/w/cpp/atomic/memory_order#Release-Acquire_ordering
#[stable(feature = "rust1", since = "1.0.0")]
Acquire,
/// Has the effects of both [`Acquire`] and [`Release`] together:
@ -275,28 +277,28 @@ pub enum Ordering {
///
/// Notice that in the case of `compare_and_swap`, it is possible that the operation ends up
/// not performing any store and hence it has just [`Acquire`] ordering. However,
/// [`AcqRel`][`AcquireRelease`] will never perform [`Relaxed`] accesses.
/// `AcqRel` will never perform [`Relaxed`] accesses.
///
/// This ordering is only applicable for operations that combine both loads and stores.
///
/// Corresponds to LLVM's [`AcquireRelease`] ordering.
/// Corresponds to [`memory_order_acq_rel`] in C++20.
///
/// [`AcquireRelease`]: https://llvm.org/docs/Atomics.html#acquirerelease
/// [`Acquire`]: https://llvm.org/docs/Atomics.html#acquire
/// [`Release`]: https://llvm.org/docs/Atomics.html#release
/// [`Relaxed`]: https://llvm.org/docs/Atomics.html#monotonic
/// [`memory_order_acq_rel`]: https://en.cppreference.com/w/cpp/atomic/memory_order#Release-Acquire_ordering
/// [`Acquire`]: #variant.Acquire
/// [`Release`]: #variant.Release
/// [`Relaxed`]: #variant.Relaxed
#[stable(feature = "rust1", since = "1.0.0")]
AcqRel,
/// Like [`Acquire`]/[`Release`]/[`AcqRel`] (for load, store, and load-with-store
/// operations, respectively) with the additional guarantee that all threads see all
/// sequentially consistent operations in the same order.
///
/// Corresponds to LLVM's [`SequentiallyConsistent`] ordering.
/// Corresponds to [`memory_order_seq_cst`] in C++20.
///
/// [`SequentiallyConsistent`]: https://llvm.org/docs/Atomics.html#sequentiallyconsistent
/// [`Acquire`]: https://llvm.org/docs/Atomics.html#acquire
/// [`Release`]: https://llvm.org/docs/Atomics.html#release
/// [`AcqRel`]: https://llvm.org/docs/Atomics.html#acquirerelease
/// [`memory_order_seq_cst`]: https://en.cppreference.com/w/cpp/atomic/memory_order#Sequentially-consistent_ordering
/// [`Acquire`]: #variant.Acquire
/// [`Release`]: #variant.Release
/// [`AcqRel`]: #variant.AcqRel
#[stable(feature = "rust1", since = "1.0.0")]
SeqCst,
}

3
src/librustc/lint/builtin.rs
View file

@ -21,7 +21,8 @@ declare_lint! {
declare_lint! {
pub CONST_ERR,
Deny,
"constant evaluation detected erroneous expression"
"constant evaluation detected erroneous expression",
report_in_external_macro: true
}
declare_lint! {

36
src/librustc_mir/hair/pattern/check_match.rs
View file

@ -62,12 +62,13 @@ impl<'tcx> Visitor<'tcx> for MatchVisitor<'_, 'tcx> {
fn visit_local(&mut self, loc: &'tcx hir::Local) {
intravisit::walk_local(self, loc);
self.check_irrefutable(&loc.pat, match loc.source {
hir::LocalSource::Normal => "local binding",
hir::LocalSource::ForLoopDesugar => "`for` loop binding",
hir::LocalSource::AsyncFn => "async fn binding",
hir::LocalSource::AwaitDesugar => "`await` future binding",
});
let (msg, sp) = match loc.source {
hir::LocalSource::Normal => ("local binding", Some(loc.span)),
hir::LocalSource::ForLoopDesugar => ("`for` loop binding", None),
hir::LocalSource::AsyncFn => ("async fn binding", None),
hir::LocalSource::AwaitDesugar => ("`await` future binding", None),
};
self.check_irrefutable(&loc.pat, msg, sp);
// Check legality of move bindings and `@` patterns.
self.check_patterns(false, &loc.pat);
@ -77,7 +78,7 @@ impl<'tcx> Visitor<'tcx> for MatchVisitor<'_, 'tcx> {
intravisit::walk_body(self, body);
for param in &body.params {
self.check_irrefutable(&param.pat, "function argument");
self.check_irrefutable(&param.pat, "function argument", None);
self.check_patterns(false, &param.pat);
}
}
@ -242,7 +243,7 @@ impl<'tcx> MatchVisitor<'_, 'tcx> {
})
}
fn check_irrefutable(&self, pat: &'tcx Pat, origin: &str) {
fn check_irrefutable(&self, pat: &'tcx Pat, origin: &str, sp: Option<Span>) {
let module = self.tcx.hir().get_module_parent(pat.hir_id);
MatchCheckCtxt::create_and_enter(self.tcx, self.param_env, module, |ref mut cx| {
let mut patcx = PatCtxt::new(self.tcx,
@ -266,18 +267,35 @@ impl<'tcx> MatchVisitor<'_, 'tcx> {
"refutable pattern in {}: {} not covered",
origin, joined_patterns
);
match &pat.kind {
let suggest_if_let = match &pat.kind {
hir::PatKind::Path(hir::QPath::Resolved(None, path))
if path.segments.len() == 1 && path.segments[0].args.is_none() =>
{
const_not_var(&mut err, cx.tcx, pat, path);
false
}
_ => {
err.span_label(
pat.span,
pattern_not_covered_label(&witnesses, &joined_patterns),
);
true
}
};
if let (Some(span), true) = (sp, suggest_if_let) {
err.note("`let` bindings require an \"irrefutable pattern\", like a `struct` or \
an `enum` with only one variant");
if let Ok(snippet) = self.tcx.sess.source_map().span_to_snippet(span) {
err.span_suggestion(
span,
"you might want to use `if let` to ignore the variant that isn't matched",
format!("if {} {{ /* */ }}", &snippet[..snippet.len() - 1]),
Applicability::HasPlaceholders,
);
}
err.note("for more information, visit \
https://doc.rust-lang.org/book/ch18-02-refutability.html");
}
adt_defined_here(cx, &mut err, pattern_ty, &witnesses);

34
src/librustc_resolve/lib.rs
View file

@ -2378,26 +2378,38 @@ impl<'a> Resolver<'a> {
let mut reported_spans = FxHashSet::default();
for &PrivacyError(dedup_span, ident, binding) in &self.privacy_errors {
if reported_spans.insert(dedup_span) {
let mut err = struct_span_err!(
self.session,
ident.span,
E0603,
"{} `{}` is private",
binding.res().descr(),
ident.name,
);
if let NameBindingKind::Res(
let session = &self.session;
let mk_struct_span_error = |is_constructor| {
struct_span_err!(
session,
ident.span,
E0603,
"{}{} `{}` is private",
binding.res().descr(),
if is_constructor { " constructor"} else { "" },
ident.name,
)
};
let mut err = if let NameBindingKind::Res(
Res::Def(DefKind::Ctor(CtorOf::Struct, CtorKind::Fn), ctor_def_id), _
) = binding.kind {
let def_id = (&*self).parent(ctor_def_id).expect("no parent for a constructor");
if let Some(fields) = self.field_names.get(&def_id) {
let mut err = mk_struct_span_error(true);
let first_field = fields.first().expect("empty field list in the map");
err.span_label(
fields.iter().fold(first_field.span, |acc, field| acc.to(field.span)),
"a tuple struct constructor is private if any of its fields is private",
"a constructor is private if any of the fields is private",
);
err
} else {
mk_struct_span_error(false)
}
}
} else {
mk_struct_span_error(false)
};
err.emit();
}
}

41
src/librustc_typeck/check/method/mod.rs
View file

@ -213,27 +213,28 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
segment,
);
let mut needs_mut = false;
if let ty::Ref(region, t_type, mutability) = self_ty.kind {
let trait_type = self.tcx.mk_ref(region, ty::TypeAndMut {
ty: t_type,
mutbl: mutability.invert(),
});
match self.lookup_probe(
span,
segment.ident,
trait_type,
call_expr,
ProbeScope::TraitsInScope
) {
Ok(ref new_pick) if *new_pick != pick => {
needs_mut = true;
}
_ => {}
}
}
if result.illegal_sized_bound {
let mut needs_mut = false;
if let ty::Ref(region, t_type, mutability) = self_ty.kind {
let trait_type = self.tcx.mk_ref(region, ty::TypeAndMut {
ty: t_type,
mutbl: mutability.invert(),
});
// We probe again to see if there might be a borrow mutability discrepancy.
match self.lookup_probe(
span,
segment.ident,
trait_type,
call_expr,
ProbeScope::TraitsInScope
) {
Ok(ref new_pick) if *new_pick != pick => {
needs_mut = true;
}
_ => {}
}
}
// We probe again, taking all traits into account (not only those in scope).
let candidates = match self.lookup_probe(
span,

52
src/libsyntax/ext/mbe/macro_parser.rs
View file

@ -76,7 +76,7 @@ use TokenTreeOrTokenTreeSlice::*;
use crate::ast::{Ident, Name};
use crate::ext::mbe::{self, TokenTree};
use crate::parse::{Directory, ParseSess};
use crate::parse::{Directory, ParseSess, PResult};
use crate::parse::parser::{Parser, PathStyle};
use crate::parse::token::{self, DocComment, Nonterminal, Token};
use crate::print::pprust;
@ -893,26 +893,30 @@ fn parse_nt(p: &mut Parser<'_>, sp: Span, name: Symbol) -> Nonterminal {
}
// check at the beginning and the parser checks after each bump
p.process_potential_macro_variable();
match name {
sym::item => match panictry!(p.parse_item()) {
match parse_nt_inner(p, sp, name) {
Ok(nt) => nt,
Err(mut err) => {
err.emit();
FatalError.raise();
}
}
}
fn parse_nt_inner<'a>(p: &mut Parser<'a>, sp: Span, name: Symbol) -> PResult<'a, Nonterminal> {
Ok(match name {
sym::item => match p.parse_item()? {
Some(i) => token::NtItem(i),
None => {
p.fatal("expected an item keyword").emit();
FatalError.raise();
}
None => return Err(p.fatal("expected an item keyword")),
},
sym::block => token::NtBlock(panictry!(p.parse_block())),
sym::stmt => match panictry!(p.parse_stmt()) {
sym::block => token::NtBlock(p.parse_block()?),
sym::stmt => match p.parse_stmt()? {
Some(s) => token::NtStmt(s),
None => {
p.fatal("expected a statement").emit();
FatalError.raise();
}
None => return Err(p.fatal("expected a statement")),
},
sym::pat => token::NtPat(panictry!(p.parse_pat(None))),
sym::expr => token::NtExpr(panictry!(p.parse_expr())),
sym::literal => token::NtLiteral(panictry!(p.parse_literal_maybe_minus())),
sym::ty => token::NtTy(panictry!(p.parse_ty())),
sym::pat => token::NtPat(p.parse_pat(None)?),
sym::expr => token::NtExpr(p.parse_expr()?),
sym::literal => token::NtLiteral(p.parse_literal_maybe_minus()?),
sym::ty => token::NtTy(p.parse_ty()?),
// this could be handled like a token, since it is one
sym::ident => if let Some((name, is_raw)) = get_macro_name(&p.token) {
let span = p.token.span;
@ -920,21 +924,19 @@ fn parse_nt(p: &mut Parser<'_>, sp: Span, name: Symbol) -> Nonterminal {
token::NtIdent(Ident::new(name, span), is_raw)
} else {
let token_str = pprust::token_to_string(&p.token);
p.fatal(&format!("expected ident, found {}", &token_str)).emit();
FatalError.raise()
return Err(p.fatal(&format!("expected ident, found {}", &token_str)));
}
sym::path => token::NtPath(panictry!(p.parse_path(PathStyle::Type))),
sym::meta => token::NtMeta(panictry!(p.parse_attr_item())),
sym::vis => token::NtVis(panictry!(p.parse_visibility(true))),
sym::path => token::NtPath(p.parse_path(PathStyle::Type)?),
sym::meta => token::NtMeta(p.parse_attr_item()?),
sym::vis => token::NtVis(p.parse_visibility(true)?),
sym::lifetime => if p.check_lifetime() {
token::NtLifetime(p.expect_lifetime().ident)
} else {
let token_str = pprust::token_to_string(&p.token);
p.fatal(&format!("expected a lifetime, found `{}`", &token_str)).emit();
FatalError.raise();
return Err(p.fatal(&format!("expected a lifetime, found `{}`", &token_str)));
}
// this is not supposed to happen, since it has been checked
// when compiling the macro.
_ => p.span_bug(sp, "invalid fragment specifier"),
}
})
}

22
src/libsyntax/feature_gate/check.rs
View file

@ -855,25 +855,19 @@ impl UnstableFeatures {
pub fn is_nightly_build(&self) -> bool {
match *self {
UnstableFeatures::Allow | UnstableFeatures::Cheat => true,
_ => false,
UnstableFeatures::Disallow => false,
}
}
}
fn maybe_stage_features(span_handler: &Handler, krate: &ast::Crate, unstable: UnstableFeatures) {
let allow_features = match unstable {
UnstableFeatures::Allow => true,
UnstableFeatures::Disallow => false,
UnstableFeatures::Cheat => true
};
if !allow_features {
for attr in &krate.attrs {
if attr.check_name(sym::feature) {
let release_channel = option_env!("CFG_RELEASE_CHANNEL").unwrap_or("(unknown)");
span_err!(span_handler, attr.span, E0554,
"`#![feature]` may not be used on the {} release channel",
release_channel);
}
if !unstable.is_nightly_build() {
for attr in krate.attrs.iter().filter(|attr| attr.check_name(sym::feature)) {
span_err!(
span_handler, attr.span, E0554,
"`#![feature]` may not be used on the {} release channel",
option_env!("CFG_RELEASE_CHANNEL").unwrap_or("(unknown)")
);
}
}
}

1
src/libsyntax/lib.rs
View file

@ -17,6 +17,7 @@
#![feature(proc_macro_internals)]
#![feature(proc_macro_span)]
#![feature(try_trait)]
#![feature(slice_patterns)]
#![feature(unicode_internals)]
#![recursion_limit="256"]

22
src/libsyntax/parse/diagnostics.rs
View file

@ -2,7 +2,7 @@ use crate::ast::{
self, Param, BinOpKind, BindingMode, BlockCheckMode, Expr, ExprKind, Ident, Item, ItemKind,
Mutability, Pat, PatKind, PathSegment, QSelf, Ty, TyKind, VariantData,
};
use crate::feature_gate::{feature_err, UnstableFeatures};
use crate::feature_gate::feature_err;
use crate::parse::{SeqSep, PResult, Parser, ParseSess};
use crate::parse::parser::{BlockMode, PathStyle, SemiColonMode, TokenType, TokenExpectType};
use crate::parse::token::{self, TokenKind};
@ -387,14 +387,17 @@ impl<'a> Parser<'a> {
let next_pos = sm.lookup_char_pos(self.token.span.lo());
let op_pos = sm.lookup_char_pos(sp.hi());
let allow_unstable = self.sess.unstable_features.is_nightly_build();
if likely_path {
err.span_suggestion(
sp,
"maybe write a path separator here",
"::".to_string(),
match self.sess.unstable_features {
UnstableFeatures::Disallow => Applicability::MachineApplicable,
_ => Applicability::MaybeIncorrect,
if allow_unstable {
Applicability::MaybeIncorrect
} else {
Applicability::MachineApplicable
},
);
} else if op_pos.line != next_pos.line && maybe_expected_semicolon {
@ -404,14 +407,13 @@ impl<'a> Parser<'a> {
";".to_string(),
Applicability::MaybeIncorrect,
);
} else if let UnstableFeatures::Disallow = self.sess.unstable_features {
err.span_label(sp, "tried to parse a type due to this");
} else {
} else if allow_unstable {
err.span_label(sp, "tried to parse a type due to this type ascription");
}
if let UnstableFeatures::Disallow = self.sess.unstable_features {
// Give extra information about type ascription only if it's a nightly compiler.
} else {
err.span_label(sp, "tried to parse a type due to this");
}
if allow_unstable {
// Give extra information about type ascription only if it's a nightly compiler.
err.note("`#![feature(type_ascription)]` lets you annotate an expression with a \
type: `<expr>: <type>`");
err.note("for more information, see \

15
src/libsyntax/parse/literal.rs
View file

@ -426,15 +426,12 @@ fn integer_lit(symbol: Symbol, suffix: Option<Symbol>) -> Result<LitKind, LitErr
let symbol = strip_underscores(symbol);
let s = symbol.as_str();
let mut base = 10;
if s.len() > 1 && s.as_bytes()[0] == b'0' {
match s.as_bytes()[1] {
b'x' => base = 16,
b'o' => base = 8,
b'b' => base = 2,
_ => {}
}
}
let base = match s.as_bytes() {
[b'0', b'x', ..] => 16,
[b'0', b'o', ..] => 8,
[b'0', b'b', ..] => 2,
_ => 10,
};
let ty = match suffix {
Some(suf) => match suf {

21
src/libsyntax/source_map.rs
View file

@ -878,25 +878,8 @@ impl SourceMap {
// Returns the index of the `SourceFile` (in `self.files`) that contains `pos`.
pub fn lookup_source_file_idx(&self, pos: BytePos) -> usize {
let files = self.files.borrow();
let files = &files.source_files;
let count = files.len();
// Binary search for the `SourceFile`.
let mut a = 0;
let mut b = count;
while b - a > 1 {
let m = (a + b) / 2;
if files[m].start_pos > pos {
b = m;
} else {
a = m;
}
}
assert!(a < count, "position {} does not resolve to a source location", pos.to_usize());
return a;
self.files.borrow().source_files.binary_search_by_key(&pos, |key| key.start_pos)
.unwrap_or_else(|p| p - 1)
}
pub fn count_lines(&self) -> usize {

14
src/test/ui/consts/auxiliary/external_macro.rs Normal file
View file

@ -0,0 +1,14 @@
#![feature(allow_internal_unstable)]
// Macro to help ensure CONST_ERR lint errors
// are not silenced in external macros.
// https://github.com/rust-lang/rust/issues/65300
#[macro_export]
#[allow_internal_unstable(type_ascription)]
macro_rules! static_assert {
($test:expr) => {
#[allow(dead_code)]
const _: () = [()][!($test: bool) as usize];
}
}

13
src/test/ui/consts/const-external-macro-const-err.rs Normal file
View file

@ -0,0 +1,13 @@
// edition:2018
// aux-build:external_macro.rs
// Ensure that CONST_ERR lint errors
// are not silenced in external macros.
// https://github.com/rust-lang/rust/issues/65300
extern crate external_macro;
use external_macro::static_assert;
fn main() {
static_assert!(2 + 2 == 5); //~ ERROR
}

11
src/test/ui/consts/const-external-macro-const-err.stderr Normal file
View file

@ -0,0 +1,11 @@
error: any use of this value will cause an error
--> $DIR/const-external-macro-const-err.rs:12:5
|
LL | static_assert!(2 + 2 == 5);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^ index out of bounds: the len is 1 but the index is 1
|
= note: `#[deny(const_err)]` on by default
= note: this error originates in a macro outside of the current crate (in Nightly builds, run with -Z external-macro-backtrace for more info)
error: aborting due to previous error

7
src/test/ui/consts/const-match-check.eval1.stderr
View file

@ -3,6 +3,13 @@ error[E0005]: refutable pattern in local binding: `std::i32::MIN..=-1i32` and `1
|
LL | A = { let 0 = 0; 0 },
| ^ patterns `std::i32::MIN..=-1i32` and `1i32..=std::i32::MAX` not covered
|
= note: `let` bindings require an "irrefutable pattern", like a `struct` or an `enum` with only one variant
= note: for more information, visit https://doc.rust-lang.org/book/ch18-02-refutability.html
help: you might want to use `if let` to ignore the variant that isn't matched
|
LL | A = { if let 0 = 0 { /* */ } 0 },
| ^^^^^^^^^^^^^^^^^^^^^^
error: aborting due to previous error

7
src/test/ui/consts/const-match-check.eval2.stderr
View file

@ -3,6 +3,13 @@ error[E0005]: refutable pattern in local binding: `std::i32::MIN..=-1i32` and `1
|
LL | let x: [i32; { let 0 = 0; 0 }] = [];
| ^ patterns `std::i32::MIN..=-1i32` and `1i32..=std::i32::MAX` not covered
|
= note: `let` bindings require an "irrefutable pattern", like a `struct` or an `enum` with only one variant
= note: for more information, visit https://doc.rust-lang.org/book/ch18-02-refutability.html
help: you might want to use `if let` to ignore the variant that isn't matched
|
LL | let x: [i32; { if let 0 = 0 { /* */ } 0 }] = [];
| ^^^^^^^^^^^^^^^^^^^^^^
error: aborting due to previous error

28
src/test/ui/consts/const-match-check.matchck.stderr
View file

@ -3,24 +3,52 @@ error[E0005]: refutable pattern in local binding: `std::i32::MIN..=-1i32` and `1
|
LL | const X: i32 = { let 0 = 0; 0 };
| ^ patterns `std::i32::MIN..=-1i32` and `1i32..=std::i32::MAX` not covered
|
= note: `let` bindings require an "irrefutable pattern", like a `struct` or an `enum` with only one variant
= note: for more information, visit https://doc.rust-lang.org/book/ch18-02-refutability.html
help: you might want to use `if let` to ignore the variant that isn't matched
|
LL | const X: i32 = { if let 0 = 0 { /* */ } 0 };
| ^^^^^^^^^^^^^^^^^^^^^^
error[E0005]: refutable pattern in local binding: `std::i32::MIN..=-1i32` and `1i32..=std::i32::MAX` not covered
--> $DIR/const-match-check.rs:8:23
|
LL | static Y: i32 = { let 0 = 0; 0 };
| ^ patterns `std::i32::MIN..=-1i32` and `1i32..=std::i32::MAX` not covered
|
= note: `let` bindings require an "irrefutable pattern", like a `struct` or an `enum` with only one variant
= note: for more information, visit https://doc.rust-lang.org/book/ch18-02-refutability.html
help: you might want to use `if let` to ignore the variant that isn't matched
|
LL | static Y: i32 = { if let 0 = 0 { /* */ } 0 };
| ^^^^^^^^^^^^^^^^^^^^^^
error[E0005]: refutable pattern in local binding: `std::i32::MIN..=-1i32` and `1i32..=std::i32::MAX` not covered
--> $DIR/const-match-check.rs:13:26
|
LL | const X: i32 = { let 0 = 0; 0 };
| ^ patterns `std::i32::MIN..=-1i32` and `1i32..=std::i32::MAX` not covered
|
= note: `let` bindings require an "irrefutable pattern", like a `struct` or an `enum` with only one variant
= note: for more information, visit https://doc.rust-lang.org/book/ch18-02-refutability.html
help: you might want to use `if let` to ignore the variant that isn't matched
|
LL | const X: i32 = { if let 0 = 0 { /* */ } 0 };
| ^^^^^^^^^^^^^^^^^^^^^^
error[E0005]: refutable pattern in local binding: `std::i32::MIN..=-1i32` and `1i32..=std::i32::MAX` not covered
--> $DIR/const-match-check.rs:19:26
|
LL | const X: i32 = { let 0 = 0; 0 };
| ^ patterns `std::i32::MIN..=-1i32` and `1i32..=std::i32::MAX` not covered
|
= note: `let` bindings require an "irrefutable pattern", like a `struct` or an `enum` with only one variant
= note: for more information, visit https://doc.rust-lang.org/book/ch18-02-refutability.html
help: you might want to use `if let` to ignore the variant that isn't matched
|
LL | const X: i32 = { if let 0 = 0 { /* */ } 0 };
| ^^^^^^^^^^^^^^^^^^^^^^
error: aborting due to 4 previous errors

7
src/test/ui/empty/empty-never-array.stderr
View file

@ -11,6 +11,13 @@ LL | | }
...
LL | let Helper::U(u) = Helper::T(t, []);
| ^^^^^^^^^^^^ pattern `T(_, _)` not covered
|
= note: `let` bindings require an "irrefutable pattern", like a `struct` or an `enum` with only one variant
= note: for more information, visit https://doc.rust-lang.org/book/ch18-02-refutability.html
help: you might want to use `if let` to ignore the variant that isn't matched
|
LL | if let Helper::U(u) = Helper::T(t, []) { /* */ }
|
error[E0381]: use of possibly-uninitialized variable: `u`
--> $DIR/empty-never-array.rs:12:5

7
src/test/ui/error-codes/E0005.stderr
View file

@ -3,6 +3,13 @@ error[E0005]: refutable pattern in local binding: `None` not covered
|
LL | let Some(y) = x;
| ^^^^^^^ pattern `None` not covered
|
= note: `let` bindings require an "irrefutable pattern", like a `struct` or an `enum` with only one variant
= note: for more information, visit https://doc.rust-lang.org/book/ch18-02-refutability.html
help: you might want to use `if let` to ignore the variant that isn't matched
|
LL | if let Some(y) = x { /* */ }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: aborting due to previous error

16
src/test/ui/feature-gates/feature-gate-exhaustive-patterns.nll.stderr Normal file
View file

@ -0,0 +1,16 @@
error[E0005]: refutable pattern in local binding: `Err(_)` not covered
--> $DIR/feature-gate-exhaustive-patterns.rs:7:9
|
LL | let Ok(_x) = foo();
| ^^^^^^ pattern `Err(_)` not covered
|
= note: `let` bindings require an "irrefutable pattern", like a `struct` or an `enum` with only one variant
= note: for more information, visit https://doc.rust-lang.org/book/ch18-02-refutability.html
help: you might want to use `if let` to ignore the variant that isn't matched
|
LL | if let Ok(_x) = foo() { /* */ }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: aborting due to previous error
For more information about this error, try `rustc --explain E0005`.

7
src/test/ui/feature-gates/feature-gate-exhaustive-patterns.stderr
View file

@ -3,6 +3,13 @@ error[E0005]: refutable pattern in local binding: `Err(_)` not covered
|
LL | let Ok(_x) = foo();
| ^^^^^^ pattern `Err(_)` not covered
|
= note: `let` bindings require an "irrefutable pattern", like a `struct` or an `enum` with only one variant
= note: for more information, visit https://doc.rust-lang.org/book/ch18-02-refutability.html
help: you might want to use `if let` to ignore the variant that isn't matched
|
LL | if let Ok(_x) = foo() { /* */ }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: aborting due to previous error

7
src/test/ui/issues/issue-31561.stderr
View file

@ -12,6 +12,13 @@ LL | | }
...
LL | let Thing::Foo(y) = Thing::Foo(1);
| ^^^^^^^^^^^^^ patterns `Bar` and `Baz` not covered
|
= note: `let` bindings require an "irrefutable pattern", like a `struct` or an `enum` with only one variant
= note: for more information, visit https://doc.rust-lang.org/book/ch18-02-refutability.html
help: you might want to use `if let` to ignore the variant that isn't matched
|
LL | if let Thing::Foo(y) = Thing::Foo(1) { /* */ }
|
error: aborting due to previous error

28
src/test/ui/match/non-exhaustive-defined-here.stderr
View file

@ -41,6 +41,13 @@ LL | | }
...
LL | let E::A = e;
| ^^^^ patterns `B` and `C` not covered
|
= note: `let` bindings require an "irrefutable pattern", like a `struct` or an `enum` with only one variant
= note: for more information, visit https://doc.rust-lang.org/book/ch18-02-refutability.html
help: you might want to use `if let` to ignore the variant that isn't matched
|
LL | if let E::A = e { /* */ }
| ^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0004]: non-exhaustive patterns: `&B` and `&C` not covered
--> $DIR/non-exhaustive-defined-here.rs:40:11
@ -85,6 +92,13 @@ LL | | }
...
LL | let E::A = e;
| ^^^^ patterns `&B` and `&C` not covered
|
= note: `let` bindings require an "irrefutable pattern", like a `struct` or an `enum` with only one variant
= note: for more information, visit https://doc.rust-lang.org/book/ch18-02-refutability.html
help: you might want to use `if let` to ignore the variant that isn't matched
|
LL | if let E::A = e { /* */ }
| ^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0004]: non-exhaustive patterns: `&&mut &B` and `&&mut &C` not covered
--> $DIR/non-exhaustive-defined-here.rs:48:11
@ -129,6 +143,13 @@ LL | | }
...
LL | let E::A = e;
| ^^^^ patterns `&&mut &B` and `&&mut &C` not covered
|
= note: `let` bindings require an "irrefutable pattern", like a `struct` or an `enum` with only one variant
= note: for more information, visit https://doc.rust-lang.org/book/ch18-02-refutability.html
help: you might want to use `if let` to ignore the variant that isn't matched
|
LL | if let E::A = e { /* */ }
|
error[E0004]: non-exhaustive patterns: `None` not covered
--> $DIR/non-exhaustive-defined-here.rs:65:11
@ -163,6 +184,13 @@ LL | | }
...
LL | let Opt::Some(ref _x) = e;
| ^^^^^^^^^^^^^^^^^ pattern `None` not covered
|
= note: `let` bindings require an "irrefutable pattern", like a `struct` or an `enum` with only one variant
= note: for more information, visit https://doc.rust-lang.org/book/ch18-02-refutability.html
help: you might want to use `if let` to ignore the variant that isn't matched
|
LL | if let Opt::Some(ref _x) = e { /* */ }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: aborting due to 8 previous errors

96
src/test/ui/privacy/privacy5.rs
View file

@ -48,31 +48,31 @@ mod a {
}
fn this_crate() {
let a = a::A(()); //~ ERROR tuple struct `A` is private
let b = a::B(2); //~ ERROR tuple struct `B` is private
let c = a::C(2, 3); //~ ERROR tuple struct `C` is private
let a = a::A(()); //~ ERROR tuple struct constructor `A` is private
let b = a::B(2); //~ ERROR tuple struct constructor `B` is private
let c = a::C(2, 3); //~ ERROR tuple struct constructor `C` is private
let d = a::D(4);
let a::A(()) = a; //~ ERROR tuple struct `A` is private
let a::A(_) = a; //~ ERROR tuple struct `A` is private
match a { a::A(()) => {} } //~ ERROR tuple struct `A` is private
match a { a::A(_) => {} } //~ ERROR tuple struct `A` is private
let a::A(()) = a; //~ ERROR tuple struct constructor `A` is private
let a::A(_) = a; //~ ERROR tuple struct constructor `A` is private
match a { a::A(()) => {} } //~ ERROR tuple struct constructor `A` is private
match a { a::A(_) => {} } //~ ERROR tuple struct constructor `A` is private
let a::B(_) = b; //~ ERROR tuple struct `B` is private
let a::B(_b) = b; //~ ERROR tuple struct `B` is private
match b { a::B(_) => {} } //~ ERROR tuple struct `B` is private
match b { a::B(_b) => {} } //~ ERROR tuple struct `B` is private
match b { a::B(1) => {} a::B(_) => {} } //~ ERROR tuple struct `B` is private
//~^ ERROR tuple struct `B` is private
let a::B(_) = b; //~ ERROR tuple struct constructor `B` is private
let a::B(_b) = b; //~ ERROR tuple struct constructor `B` is private
match b { a::B(_) => {} } //~ ERROR tuple struct constructor `B` is private
match b { a::B(_b) => {} } //~ ERROR tuple struct constructor `B` is private
match b { a::B(1) => {} a::B(_) => {} } //~ ERROR tuple struct constructor `B` is private
//~^ ERROR tuple struct constructor `B` is private
let a::C(_, _) = c; //~ ERROR tuple struct `C` is private
let a::C(_a, _) = c; //~ ERROR tuple struct `C` is private
let a::C(_, _b) = c; //~ ERROR tuple struct `C` is private
let a::C(_a, _b) = c; //~ ERROR tuple struct `C` is private
match c { a::C(_, _) => {} } //~ ERROR tuple struct `C` is private
match c { a::C(_a, _) => {} } //~ ERROR tuple struct `C` is private
match c { a::C(_, _b) => {} } //~ ERROR tuple struct `C` is private
match c { a::C(_a, _b) => {} } //~ ERROR tuple struct `C` is private
let a::C(_, _) = c; //~ ERROR tuple struct constructor `C` is private
let a::C(_a, _) = c; //~ ERROR tuple struct constructor `C` is private
let a::C(_, _b) = c; //~ ERROR tuple struct constructor `C` is private
let a::C(_a, _b) = c; //~ ERROR tuple struct constructor `C` is private
match c { a::C(_, _) => {} } //~ ERROR tuple struct constructor `C` is private
match c { a::C(_a, _) => {} } //~ ERROR tuple struct constructor `C` is private
match c { a::C(_, _b) => {} } //~ ERROR tuple struct constructor `C` is private
match c { a::C(_a, _b) => {} } //~ ERROR tuple struct constructor `C` is private
let a::D(_) = d;
let a::D(_d) = d;
@ -80,38 +80,38 @@ fn this_crate() {
match d { a::D(_d) => {} }
match d { a::D(1) => {} a::D(_) => {} }
let a2 = a::A; //~ ERROR tuple struct `A` is private
let b2 = a::B; //~ ERROR tuple struct `B` is private
let c2 = a::C; //~ ERROR tuple struct `C` is private
let a2 = a::A; //~ ERROR tuple struct constructor `A` is private
let b2 = a::B; //~ ERROR tuple struct constructor `B` is private
let c2 = a::C; //~ ERROR tuple struct constructor `C` is private
let d2 = a::D;
}
fn xcrate() {
let a = other::A(()); //~ ERROR tuple struct `A` is private
let b = other::B(2); //~ ERROR tuple struct `B` is private
let c = other::C(2, 3); //~ ERROR tuple struct `C` is private
let a = other::A(()); //~ ERROR tuple struct constructor `A` is private
let b = other::B(2); //~ ERROR tuple struct constructor `B` is private
let c = other::C(2, 3); //~ ERROR tuple struct constructor `C` is private
let d = other::D(4);
let other::A(()) = a; //~ ERROR tuple struct `A` is private
let other::A(_) = a; //~ ERROR tuple struct `A` is private
match a { other::A(()) => {} } //~ ERROR tuple struct `A` is private
match a { other::A(_) => {} } //~ ERROR tuple struct `A` is private
let other::A(()) = a; //~ ERROR tuple struct constructor `A` is private
let other::A(_) = a; //~ ERROR tuple struct constructor `A` is private
match a { other::A(()) => {} } //~ ERROR tuple struct constructor `A` is private
match a { other::A(_) => {} } //~ ERROR tuple struct constructor `A` is private
let other::B(_) = b; //~ ERROR tuple struct `B` is private
let other::B(_b) = b; //~ ERROR tuple struct `B` is private
match b { other::B(_) => {} } //~ ERROR tuple struct `B` is private
match b { other::B(_b) => {} } //~ ERROR tuple struct `B` is private
match b { other::B(1) => {} other::B(_) => {} } //~ ERROR tuple struct `B` is private
//~^ ERROR tuple struct `B` is private
let other::B(_) = b; //~ ERROR tuple struct constructor `B` is private
let other::B(_b) = b; //~ ERROR tuple struct constructor `B` is private
match b { other::B(_) => {} } //~ ERROR tuple struct constructor `B` is private
match b { other::B(_b) => {} } //~ ERROR tuple struct constructor `B` is private
match b { other::B(1) => {}//~ ERROR tuple struct constructor `B` is private
other::B(_) => {} } //~ ERROR tuple struct constructor `B` is private
let other::C(_, _) = c; //~ ERROR tuple struct `C` is private
let other::C(_a, _) = c; //~ ERROR tuple struct `C` is private
let other::C(_, _b) = c; //~ ERROR tuple struct `C` is private
let other::C(_a, _b) = c; //~ ERROR tuple struct `C` is private
match c { other::C(_, _) => {} } //~ ERROR tuple struct `C` is private
match c { other::C(_a, _) => {} } //~ ERROR tuple struct `C` is private
match c { other::C(_, _b) => {} } //~ ERROR tuple struct `C` is private
match c { other::C(_a, _b) => {} } //~ ERROR tuple struct `C` is private
let other::C(_, _) = c; //~ ERROR tuple struct constructor `C` is private
let other::C(_a, _) = c; //~ ERROR tuple struct constructor `C` is private
let other::C(_, _b) = c; //~ ERROR tuple struct constructor `C` is private
let other::C(_a, _b) = c; //~ ERROR tuple struct constructor `C` is private
match c { other::C(_, _) => {} } //~ ERROR tuple struct constructor `C` is private
match c { other::C(_a, _) => {} } //~ ERROR tuple struct constructor `C` is private
match c { other::C(_, _b) => {} } //~ ERROR tuple struct constructor `C` is private
match c { other::C(_a, _b) => {} } //~ ERROR tuple struct constructor `C` is private
let other::D(_) = d;
let other::D(_d) = d;
@ -119,9 +119,9 @@ fn xcrate() {
match d { other::D(_d) => {} }
match d { other::D(1) => {} other::D(_) => {} }
let a2 = other::A; //~ ERROR tuple struct `A` is private
let b2 = other::B; //~ ERROR tuple struct `B` is private
let c2 = other::C; //~ ERROR tuple struct `C` is private
let a2 = other::A; //~ ERROR tuple struct constructor `A` is private
let b2 = other::B; //~ ERROR tuple struct constructor `B` is private
let c2 = other::C; //~ ERROR tuple struct constructor `C` is private
let d2 = other::D;
}

200
src/test/ui/privacy/privacy5.stderr
View file

@ -1,220 +1,220 @@
error[E0603]: tuple struct `A` is private
error[E0603]: tuple struct constructor `A` is private
--> $DIR/privacy5.rs:51:16
|
LL | pub struct A(());
| -- a tuple struct constructor is private if any of its fields is private
| -- a constructor is private if any of the fields is private
...
LL | let a = a::A(());
| ^
error[E0603]: tuple struct `B` is private
error[E0603]: tuple struct constructor `B` is private
--> $DIR/privacy5.rs:52:16
|
LL | pub struct B(isize);
| ----- a tuple struct constructor is private if any of its fields is private
| ----- a constructor is private if any of the fields is private
...
LL | let b = a::B(2);
| ^
error[E0603]: tuple struct `C` is private
error[E0603]: tuple struct constructor `C` is private
--> $DIR/privacy5.rs:53:16
|
LL | pub struct C(pub isize, isize);
| ---------------- a tuple struct constructor is private if any of its fields is private
| ---------------- a constructor is private if any of the fields is private
...
LL | let c = a::C(2, 3);
| ^
error[E0603]: tuple struct `A` is private
error[E0603]: tuple struct constructor `A` is private
--> $DIR/privacy5.rs:56:12
|
LL | pub struct A(());
| -- a tuple struct constructor is private if any of its fields is private
| -- a constructor is private if any of the fields is private
...
LL | let a::A(()) = a;
| ^
error[E0603]: tuple struct `A` is private
error[E0603]: tuple struct constructor `A` is private
--> $DIR/privacy5.rs:57:12
|
LL | pub struct A(());
| -- a tuple struct constructor is private if any of its fields is private
| -- a constructor is private if any of the fields is private
...
LL | let a::A(_) = a;
| ^
error[E0603]: tuple struct `A` is private
error[E0603]: tuple struct constructor `A` is private
--> $DIR/privacy5.rs:58:18
|
LL | pub struct A(());
| -- a tuple struct constructor is private if any of its fields is private
| -- a constructor is private if any of the fields is private
...
LL | match a { a::A(()) => {} }
| ^
error[E0603]: tuple struct `A` is private
error[E0603]: tuple struct constructor `A` is private
--> $DIR/privacy5.rs:59:18
|
LL | pub struct A(());
| -- a tuple struct constructor is private if any of its fields is private
| -- a constructor is private if any of the fields is private
...
LL | match a { a::A(_) => {} }
| ^
error[E0603]: tuple struct `B` is private
error[E0603]: tuple struct constructor `B` is private
--> $DIR/privacy5.rs:61:12
|
LL | pub struct B(isize);
| ----- a tuple struct constructor is private if any of its fields is private
| ----- a constructor is private if any of the fields is private
...
LL | let a::B(_) = b;
| ^
error[E0603]: tuple struct `B` is private
error[E0603]: tuple struct constructor `B` is private
--> $DIR/privacy5.rs:62:12
|
LL | pub struct B(isize);
| ----- a tuple struct constructor is private if any of its fields is private
| ----- a constructor is private if any of the fields is private
...
LL | let a::B(_b) = b;
| ^
error[E0603]: tuple struct `B` is private
error[E0603]: tuple struct constructor `B` is private
--> $DIR/privacy5.rs:63:18
|
LL | pub struct B(isize);
| ----- a tuple struct constructor is private if any of its fields is private
| ----- a constructor is private if any of the fields is private
...
LL | match b { a::B(_) => {} }
| ^
error[E0603]: tuple struct `B` is private
error[E0603]: tuple struct constructor `B` is private
--> $DIR/privacy5.rs:64:18
|
LL | pub struct B(isize);
| ----- a tuple struct constructor is private if any of its fields is private
| ----- a constructor is private if any of the fields is private
...
LL | match b { a::B(_b) => {} }
| ^
error[E0603]: tuple struct `B` is private
error[E0603]: tuple struct constructor `B` is private
--> $DIR/privacy5.rs:65:18
|
LL | pub struct B(isize);
| ----- a tuple struct constructor is private if any of its fields is private
| ----- a constructor is private if any of the fields is private
...
LL | match b { a::B(1) => {} a::B(_) => {} }
| ^
error[E0603]: tuple struct `B` is private
error[E0603]: tuple struct constructor `B` is private
--> $DIR/privacy5.rs:65:32
|
LL | pub struct B(isize);
| ----- a tuple struct constructor is private if any of its fields is private
| ----- a constructor is private if any of the fields is private
...
LL | match b { a::B(1) => {} a::B(_) => {} }
| ^
error[E0603]: tuple struct `C` is private
error[E0603]: tuple struct constructor `C` is private
--> $DIR/privacy5.rs:68:12
|
LL | pub struct C(pub isize, isize);
| ---------------- a tuple struct constructor is private if any of its fields is private
| ---------------- a constructor is private if any of the fields is private
...
LL | let a::C(_, _) = c;
| ^
error[E0603]: tuple struct `C` is private
error[E0603]: tuple struct constructor `C` is private
--> $DIR/privacy5.rs:69:12
|
LL | pub struct C(pub isize, isize);
| ---------------- a tuple struct constructor is private if any of its fields is private
| ---------------- a constructor is private if any of the fields is private
...
LL | let a::C(_a, _) = c;
| ^
error[E0603]: tuple struct `C` is private
error[E0603]: tuple struct constructor `C` is private
--> $DIR/privacy5.rs:70:12
|
LL | pub struct C(pub isize, isize);
| ---------------- a tuple struct constructor is private if any of its fields is private
| ---------------- a constructor is private if any of the fields is private
...
LL | let a::C(_, _b) = c;
| ^
error[E0603]: tuple struct `C` is private
error[E0603]: tuple struct constructor `C` is private
--> $DIR/privacy5.rs:71:12
|
LL | pub struct C(pub isize, isize);
| ---------------- a tuple struct constructor is private if any of its fields is private
| ---------------- a constructor is private if any of the fields is private
...
LL | let a::C(_a, _b) = c;
| ^
error[E0603]: tuple struct `C` is private
error[E0603]: tuple struct constructor `C` is private
--> $DIR/privacy5.rs:72:18
|
LL | pub struct C(pub isize, isize);
| ---------------- a tuple struct constructor is private if any of its fields is private
| ---------------- a constructor is private if any of the fields is private
...
LL | match c { a::C(_, _) => {} }
| ^
error[E0603]: tuple struct `C` is private
error[E0603]: tuple struct constructor `C` is private
--> $DIR/privacy5.rs:73:18
|
LL | pub struct C(pub isize, isize);
| ---------------- a tuple struct constructor is private if any of its fields is private
| ---------------- a constructor is private if any of the fields is private
...
LL | match c { a::C(_a, _) => {} }
| ^
error[E0603]: tuple struct `C` is private
error[E0603]: tuple struct constructor `C` is private
--> $DIR/privacy5.rs:74:18
|
LL | pub struct C(pub isize, isize);
| ---------------- a tuple struct constructor is private if any of its fields is private
| ---------------- a constructor is private if any of the fields is private
...
LL | match c { a::C(_, _b) => {} }
| ^
error[E0603]: tuple struct `C` is private
error[E0603]: tuple struct constructor `C` is private
--> $DIR/privacy5.rs:75:18
|
LL | pub struct C(pub isize, isize);
| ---------------- a tuple struct constructor is private if any of its fields is private
| ---------------- a constructor is private if any of the fields is private
...
LL | match c { a::C(_a, _b) => {} }
| ^
error[E0603]: tuple struct `A` is private
error[E0603]: tuple struct constructor `A` is private
--> $DIR/privacy5.rs:83:17
|
LL | pub struct A(());
| -- a tuple struct constructor is private if any of its fields is private
| -- a constructor is private if any of the fields is private
...
LL | let a2 = a::A;
| ^
error[E0603]: tuple struct `B` is private
error[E0603]: tuple struct constructor `B` is private
--> $DIR/privacy5.rs:84:17
|
LL | pub struct B(isize);
| ----- a tuple struct constructor is private if any of its fields is private
| ----- a constructor is private if any of the fields is private
...
LL | let b2 = a::B;
| ^
error[E0603]: tuple struct `C` is private
error[E0603]: tuple struct constructor `C` is private
--> $DIR/privacy5.rs:85:17
|
LL | pub struct C(pub isize, isize);
| ---------------- a tuple struct constructor is private if any of its fields is private
| ---------------- a constructor is private if any of the fields is private
...
LL | let c2 = a::C;
| ^
error[E0603]: tuple struct `A` is private
error[E0603]: tuple struct constructor `A` is private
--> $DIR/privacy5.rs:90:20
|
LL | let a = other::A(());
@ -223,9 +223,9 @@ LL | let a = other::A(());
::: $DIR/auxiliary/privacy_tuple_struct.rs:1:14
|
LL | pub struct A(());
| -- a tuple struct constructor is private if any of its fields is private
| -- a constructor is private if any of the fields is private
error[E0603]: tuple struct `B` is private
error[E0603]: tuple struct constructor `B` is private
--> $DIR/privacy5.rs:91:20
|
LL | let b = other::B(2);
@ -234,9 +234,9 @@ LL | let b = other::B(2);
::: $DIR/auxiliary/privacy_tuple_struct.rs:2:14
|
LL | pub struct B(isize);
| ----- a tuple struct constructor is private if any of its fields is private
| ----- a constructor is private if any of the fields is private
error[E0603]: tuple struct `C` is private
error[E0603]: tuple struct constructor `C` is private
--> $DIR/privacy5.rs:92:20
|
LL | let c = other::C(2, 3);
@ -245,9 +245,9 @@ LL | let c = other::C(2, 3);
::: $DIR/auxiliary/privacy_tuple_struct.rs:3:14
|
LL | pub struct C(pub isize, isize);
| ---------------- a tuple struct constructor is private if any of its fields is private
| ---------------- a constructor is private if any of the fields is private
error[E0603]: tuple struct `A` is private
error[E0603]: tuple struct constructor `A` is private
--> $DIR/privacy5.rs:95:16
|
LL | let other::A(()) = a;
@ -256,9 +256,9 @@ LL | let other::A(()) = a;
::: $DIR/auxiliary/privacy_tuple_struct.rs:1:14
|
LL | pub struct A(());
| -- a tuple struct constructor is private if any of its fields is private
| -- a constructor is private if any of the fields is private
error[E0603]: tuple struct `A` is private
error[E0603]: tuple struct constructor `A` is private
--> $DIR/privacy5.rs:96:16
|
LL | let other::A(_) = a;
@ -267,9 +267,9 @@ LL | let other::A(_) = a;
::: $DIR/auxiliary/privacy_tuple_struct.rs:1:14
|
LL | pub struct A(());
| -- a tuple struct constructor is private if any of its fields is private
| -- a constructor is private if any of the fields is private
error[E0603]: tuple struct `A` is private
error[E0603]: tuple struct constructor `A` is private
--> $DIR/privacy5.rs:97:22
|
LL | match a { other::A(()) => {} }
@ -278,9 +278,9 @@ LL | match a { other::A(()) => {} }
::: $DIR/auxiliary/privacy_tuple_struct.rs:1:14
|
LL | pub struct A(());
| -- a tuple struct constructor is private if any of its fields is private
| -- a constructor is private if any of the fields is private
error[E0603]: tuple struct `A` is private
error[E0603]: tuple struct constructor `A` is private
--> $DIR/privacy5.rs:98:22
|
LL | match a { other::A(_) => {} }
@ -289,9 +289,9 @@ LL | match a { other::A(_) => {} }
::: $DIR/auxiliary/privacy_tuple_struct.rs:1:14
|
LL | pub struct A(());
| -- a tuple struct constructor is private if any of its fields is private
| -- a constructor is private if any of the fields is private
error[E0603]: tuple struct `B` is private
error[E0603]: tuple struct constructor `B` is private
--> $DIR/privacy5.rs:100:16
|
LL | let other::B(_) = b;
@ -300,9 +300,9 @@ LL | let other::B(_) = b;
::: $DIR/auxiliary/privacy_tuple_struct.rs:2:14
|
LL | pub struct B(isize);
| ----- a tuple struct constructor is private if any of its fields is private
| ----- a constructor is private if any of the fields is private
error[E0603]: tuple struct `B` is private
error[E0603]: tuple struct constructor `B` is private
--> $DIR/privacy5.rs:101:16
|
LL | let other::B(_b) = b;
@ -311,9 +311,9 @@ LL | let other::B(_b) = b;
::: $DIR/auxiliary/privacy_tuple_struct.rs:2:14
|
LL | pub struct B(isize);
| ----- a tuple struct constructor is private if any of its fields is private
| ----- a constructor is private if any of the fields is private
error[E0603]: tuple struct `B` is private
error[E0603]: tuple struct constructor `B` is private
--> $DIR/privacy5.rs:102:22
|
LL | match b { other::B(_) => {} }
@ -322,9 +322,9 @@ LL | match b { other::B(_) => {} }
::: $DIR/auxiliary/privacy_tuple_struct.rs:2:14
|
LL | pub struct B(isize);
| ----- a tuple struct constructor is private if any of its fields is private
| ----- a constructor is private if any of the fields is private
error[E0603]: tuple struct `B` is private
error[E0603]: tuple struct constructor `B` is private
--> $DIR/privacy5.rs:103:22
|
LL | match b { other::B(_b) => {} }
@ -333,31 +333,31 @@ LL | match b { other::B(_b) => {} }
::: $DIR/auxiliary/privacy_tuple_struct.rs:2:14
|
LL | pub struct B(isize);
| ----- a tuple struct constructor is private if any of its fields is private
| ----- a constructor is private if any of the fields is private
error[E0603]: tuple struct `B` is private
error[E0603]: tuple struct constructor `B` is private
--> $DIR/privacy5.rs:104:22
|
LL | match b { other::B(1) => {} other::B(_) => {} }
LL | match b { other::B(1) => {}
| ^
|
::: $DIR/auxiliary/privacy_tuple_struct.rs:2:14
|
LL | pub struct B(isize);
| ----- a tuple struct constructor is private if any of its fields is private
| ----- a constructor is private if any of the fields is private
error[E0603]: tuple struct `B` is private
--> $DIR/privacy5.rs:104:40
error[E0603]: tuple struct constructor `B` is private
--> $DIR/privacy5.rs:105:16
|
LL | match b { other::B(1) => {} other::B(_) => {} }
| ^
LL | other::B(_) => {} }
| ^
|
::: $DIR/auxiliary/privacy_tuple_struct.rs:2:14
|
LL | pub struct B(isize);
| ----- a tuple struct constructor is private if any of its fields is private
| ----- a constructor is private if any of the fields is private
error[E0603]: tuple struct `C` is private
error[E0603]: tuple struct constructor `C` is private
--> $DIR/privacy5.rs:107:16
|
LL | let other::C(_, _) = c;
@ -366,9 +366,9 @@ LL | let other::C(_, _) = c;
::: $DIR/auxiliary/privacy_tuple_struct.rs:3:14
|
LL | pub struct C(pub isize, isize);
| ---------------- a tuple struct constructor is private if any of its fields is private
| ---------------- a constructor is private if any of the fields is private
error[E0603]: tuple struct `C` is private
error[E0603]: tuple struct constructor `C` is private
--> $DIR/privacy5.rs:108:16
|
LL | let other::C(_a, _) = c;
@ -377,9 +377,9 @@ LL | let other::C(_a, _) = c;
::: $DIR/auxiliary/privacy_tuple_struct.rs:3:14
|
LL | pub struct C(pub isize, isize);
| ---------------- a tuple struct constructor is private if any of its fields is private
| ---------------- a constructor is private if any of the fields is private
error[E0603]: tuple struct `C` is private
error[E0603]: tuple struct constructor `C` is private
--> $DIR/privacy5.rs:109:16
|
LL | let other::C(_, _b) = c;
@ -388,9 +388,9 @@ LL | let other::C(_, _b) = c;
::: $DIR/auxiliary/privacy_tuple_struct.rs:3:14
|
LL | pub struct C(pub isize, isize);
| ---------------- a tuple struct constructor is private if any of its fields is private
| ---------------- a constructor is private if any of the fields is private
error[E0603]: tuple struct `C` is private
error[E0603]: tuple struct constructor `C` is private
--> $DIR/privacy5.rs:110:16
|
LL | let other::C(_a, _b) = c;
@ -399,9 +399,9 @@ LL | let other::C(_a, _b) = c;
::: $DIR/auxiliary/privacy_tuple_struct.rs:3:14
|
LL | pub struct C(pub isize, isize);
| ---------------- a tuple struct constructor is private if any of its fields is private
| ---------------- a constructor is private if any of the fields is private
error[E0603]: tuple struct `C` is private
error[E0603]: tuple struct constructor `C` is private
--> $DIR/privacy5.rs:111:22
|
LL | match c { other::C(_, _) => {} }
@ -410,9 +410,9 @@ LL | match c { other::C(_, _) => {} }
::: $DIR/auxiliary/privacy_tuple_struct.rs:3:14
|
LL | pub struct C(pub isize, isize);
| ---------------- a tuple struct constructor is private if any of its fields is private
| ---------------- a constructor is private if any of the fields is private
error[E0603]: tuple struct `C` is private
error[E0603]: tuple struct constructor `C` is private
--> $DIR/privacy5.rs:112:22
|
LL | match c { other::C(_a, _) => {} }
@ -421,9 +421,9 @@ LL | match c { other::C(_a, _) => {} }
::: $DIR/auxiliary/privacy_tuple_struct.rs:3:14
|
LL | pub struct C(pub isize, isize);
| ---------------- a tuple struct constructor is private if any of its fields is private
| ---------------- a constructor is private if any of the fields is private
error[E0603]: tuple struct `C` is private
error[E0603]: tuple struct constructor `C` is private
--> $DIR/privacy5.rs:113:22
|
LL | match c { other::C(_, _b) => {} }
@ -432,9 +432,9 @@ LL | match c { other::C(_, _b) => {} }
::: $DIR/auxiliary/privacy_tuple_struct.rs:3:14
|
LL | pub struct C(pub isize, isize);
| ---------------- a tuple struct constructor is private if any of its fields is private
| ---------------- a constructor is private if any of the fields is private
error[E0603]: tuple struct `C` is private
error[E0603]: tuple struct constructor `C` is private
--> $DIR/privacy5.rs:114:22
|
LL | match c { other::C(_a, _b) => {} }
@ -443,9 +443,9 @@ LL | match c { other::C(_a, _b) => {} }
::: $DIR/auxiliary/privacy_tuple_struct.rs:3:14
|
LL | pub struct C(pub isize, isize);
| ---------------- a tuple struct constructor is private if any of its fields is private
| ---------------- a constructor is private if any of the fields is private
error[E0603]: tuple struct `A` is private
error[E0603]: tuple struct constructor `A` is private
--> $DIR/privacy5.rs:122:21
|
LL | let a2 = other::A;
@ -454,9 +454,9 @@ LL | let a2 = other::A;
::: $DIR/auxiliary/privacy_tuple_struct.rs:1:14
|
LL | pub struct A(());
| -- a tuple struct constructor is private if any of its fields is private
| -- a constructor is private if any of the fields is private
error[E0603]: tuple struct `B` is private
error[E0603]: tuple struct constructor `B` is private
--> $DIR/privacy5.rs:123:21
|
LL | let b2 = other::B;
@ -465,9 +465,9 @@ LL | let b2 = other::B;
::: $DIR/auxiliary/privacy_tuple_struct.rs:2:14
|
LL | pub struct B(isize);
| ----- a tuple struct constructor is private if any of its fields is private
| ----- a constructor is private if any of the fields is private
error[E0603]: tuple struct `C` is private
error[E0603]: tuple struct constructor `C` is private
--> $DIR/privacy5.rs:124:21
|
LL | let c2 = other::C;
@ -476,7 +476,7 @@ LL | let c2 = other::C;
::: $DIR/auxiliary/privacy_tuple_struct.rs:3:14
|
LL | pub struct C(pub isize, isize);
| ---------------- a tuple struct constructor is private if any of its fields is private
| ---------------- a constructor is private if any of the fields is private
error: aborting due to 48 previous errors

7
src/test/ui/recursion/recursive-types-are-not-uninhabited.stderr
View file

@ -3,6 +3,13 @@ error[E0005]: refutable pattern in local binding: `Err(_)` not covered
|
LL | let Ok(x) = res;
| ^^^^^ pattern `Err(_)` not covered
|
= note: `let` bindings require an "irrefutable pattern", like a `struct` or an `enum` with only one variant
= note: for more information, visit https://doc.rust-lang.org/book/ch18-02-refutability.html
help: you might want to use `if let` to ignore the variant that isn't matched
|
LL | if let Ok(x) = res { /* */ }
|
error[E0381]: use of possibly-uninitialized variable: `x`
--> $DIR/recursive-types-are-not-uninhabited.rs:8:5

7
src/test/ui/refutable-pattern-errors.stderr
View file

@ -9,6 +9,13 @@ error[E0005]: refutable pattern in local binding: `(std::i32::MIN..=0i32, _)` an
|
LL | let (1, (Some(1), 2..=3)) = (1, (None, 2));
| ^^^^^^^^^^^^^^^^^^^^^ patterns `(std::i32::MIN..=0i32, _)` and `(2i32..=std::i32::MAX, _)` not covered
|
= note: `let` bindings require an "irrefutable pattern", like a `struct` or an `enum` with only one variant
= note: for more information, visit https://doc.rust-lang.org/book/ch18-02-refutability.html
help: you might want to use `if let` to ignore the variant that isn't matched
|
LL | if let (1, (Some(1), 2..=3)) = (1, (None, 2)) { /* */ }
|
error: aborting due to 2 previous errors

12
src/test/ui/resolve/privacy-struct-ctor.rs
View file

@ -16,7 +16,7 @@ mod m {
fn f() {
n::Z;
//~^ ERROR tuple struct `Z` is private
//~^ ERROR tuple struct constructor `Z` is private
Z;
//~^ ERROR expected value, found struct `Z`
}
@ -27,21 +27,21 @@ use m::S2; // OK, only the type is imported
fn main() {
m::S;
//~^ ERROR tuple struct `S` is private
//~^ ERROR tuple struct constructor `S` is private
let _: S = m::S(2);
//~^ ERROR tuple struct `S` is private
//~^ ERROR tuple struct constructor `S` is private
S;
//~^ ERROR expected value, found struct `S`
m::n::Z;
//~^ ERROR tuple struct `Z` is private
//~^ ERROR tuple struct constructor `Z` is private
S2;
//~^ ERROR expected value, found struct `S2`
xcrate::m::S;
//~^ ERROR tuple struct `S` is private
//~^ ERROR tuple struct constructor `S` is private
xcrate::S;
//~^ ERROR expected value, found struct `xcrate::S`
xcrate::m::n::Z;
//~^ ERROR tuple struct `Z` is private
//~^ ERROR tuple struct constructor `Z` is private
}

24
src/test/ui/resolve/privacy-struct-ctor.stderr
View file

@ -34,43 +34,43 @@ help: possible better candidate is found in another module, you can import it in
LL | use m::S;
|
error[E0603]: tuple struct `Z` is private
error[E0603]: tuple struct constructor `Z` is private
--> $DIR/privacy-struct-ctor.rs:18:12
|
LL | pub(in m) struct Z(pub(in m::n) u8);
| --------------- a tuple struct constructor is private if any of its fields is private
| --------------- a constructor is private if any of the fields is private
...
LL | n::Z;
| ^
error[E0603]: tuple struct `S` is private
error[E0603]: tuple struct constructor `S` is private
--> $DIR/privacy-struct-ctor.rs:29:8
|
LL | pub struct S(u8);
| -- a tuple struct constructor is private if any of its fields is private
| -- a constructor is private if any of the fields is private
...
LL | m::S;
| ^
error[E0603]: tuple struct `S` is private
error[E0603]: tuple struct constructor `S` is private
--> $DIR/privacy-struct-ctor.rs:31:19
|
LL | pub struct S(u8);
| -- a tuple struct constructor is private if any of its fields is private
| -- a constructor is private if any of the fields is private
...
LL | let _: S = m::S(2);
| ^
error[E0603]: tuple struct `Z` is private
error[E0603]: tuple struct constructor `Z` is private
--> $DIR/privacy-struct-ctor.rs:35:11
|
LL | pub(in m) struct Z(pub(in m::n) u8);
| --------------- a tuple struct constructor is private if any of its fields is private
| --------------- a constructor is private if any of the fields is private
...
LL | m::n::Z;
| ^
error[E0603]: tuple struct `S` is private
error[E0603]: tuple struct constructor `S` is private
--> $DIR/privacy-struct-ctor.rs:41:16
|
LL | xcrate::m::S;
@ -79,9 +79,9 @@ LL | xcrate::m::S;
::: $DIR/auxiliary/privacy-struct-ctor.rs:2:18
|
LL | pub struct S(u8);
| -- a tuple struct constructor is private if any of its fields is private
| -- a constructor is private if any of the fields is private
error[E0603]: tuple struct `Z` is private
error[E0603]: tuple struct constructor `Z` is private
--> $DIR/privacy-struct-ctor.rs:45:19
|
LL | xcrate::m::n::Z;
@ -90,7 +90,7 @@ LL | xcrate::m::n::Z;
::: $DIR/auxiliary/privacy-struct-ctor.rs:5:28
|
LL | pub(in m) struct Z(pub(in m::n) u8);
| --------------- a tuple struct constructor is private if any of its fields is private
| --------------- a constructor is private if any of the fields is private
error: aborting due to 10 previous errors

2
src/test/ui/rfc-2008-non-exhaustive/struct.rs
View file

@ -21,7 +21,7 @@ fn main() {
//~^ ERROR expected function, found struct `TupleStruct` [E0423]
let ts_explicit = structs::TupleStruct(640, 480);
//~^ ERROR tuple struct `TupleStruct` is private [E0603]
//~^ ERROR tuple struct constructor `TupleStruct` is private [E0603]
let TupleStruct { 0: first_field, 1: second_field } = ts;
//~^ ERROR `..` required with struct marked as non-exhaustive

4
src/test/ui/rfc-2008-non-exhaustive/struct.stderr
View file

@ -10,7 +10,7 @@ error[E0423]: expected value, found struct `UnitStruct`
LL | let us = UnitStruct;
| ^^^^^^^^^^ constructor is not visible here due to private fields
error[E0603]: tuple struct `TupleStruct` is private
error[E0603]: tuple struct constructor `TupleStruct` is private
--> $DIR/struct.rs:23:32
|
LL | let ts_explicit = structs::TupleStruct(640, 480);
@ -19,7 +19,7 @@ LL | let ts_explicit = structs::TupleStruct(640, 480);
::: $DIR/auxiliary/structs.rs:13:24
|
LL | pub struct TupleStruct(pub u16, pub u16);
| ---------------- a tuple struct constructor is private if any of its fields is private
| ---------------- a constructor is private if any of the fields is private
error[E0603]: unit struct `UnitStruct` is private
--> $DIR/struct.rs:32:32

7
src/test/ui/uninhabited/uninhabited-irrefutable.stderr
View file

@ -12,6 +12,13 @@ LL | | }
...
LL | let Foo::D(_y) = x;
| ^^^^^^^^^^ pattern `A(_)` not covered
|
= note: `let` bindings require an "irrefutable pattern", like a `struct` or an `enum` with only one variant
= note: for more information, visit https://doc.rust-lang.org/book/ch18-02-refutability.html
help: you might want to use `if let` to ignore the variant that isn't matched
|
LL | if let Foo::D(_y) = x { /* */ }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: aborting due to previous error

7
src/test/ui/uninhabited/uninhabited-matches-feature-gated.stderr
View file

@ -51,6 +51,13 @@ error[E0005]: refutable pattern in local binding: `Err(_)` not covered
|
LL | let Ok(x) = x;
| ^^^^^ pattern `Err(_)` not covered
|
= note: `let` bindings require an "irrefutable pattern", like a `struct` or an `enum` with only one variant
= note: for more information, visit https://doc.rust-lang.org/book/ch18-02-refutability.html
help: you might want to use `if let` to ignore the variant that isn't matched
|
LL | if let Ok(x) = x { /* */ }
|
error: aborting due to 7 previous errors