OpenE2K/rust
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Auto merge of #51319 - Mark-Simulacrum:rollup, r=Mark-Simulacrum

Browse Source 
Rollup of 6 pull requests

Successful merges:

 - #51143 (Specify that packed types must derive, not implement, Copy)
 - #51226 (Make Layout's align a NonZeroUsize)
 - #51297 (Fix run button style)
 - #51306 (impl Default for &mut str)
 - #51312 (Clarify the difference between get_mut and into_mut for OccupiedEntry)
 - #51313 (use type name in E0599 enum variant suggestion)

Failed merges:
This commit is contained in:
bors 2018-06-03 03:13:43 +00:00
commit 3575be60ea
14 changed files with 99 additions and 57 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
src/liballoc/btree/map.rs
View File

@ -2369,6 +2369,11 @@ impl<'a, K: Ord, V> OccupiedEntry<'a, K, V> {
/// Gets a mutable reference to the value in the entry. /// Gets a mutable reference to the value in the entry.
/// ///
/// If you need a reference to the `OccupiedEntry` which may outlive the
/// destruction of the `Entry` value, see [`into_mut`].
///
/// [`into_mut`]: #method.into_mut
///
/// # Examples /// # Examples
/// ///
/// ``` /// ```
@ -2380,9 +2385,13 @@ impl<'a, K: Ord, V> OccupiedEntry<'a, K, V> {
/// ///
/// assert_eq!(map["poneyland"], 12); /// assert_eq!(map["poneyland"], 12);
/// if let Entry::Occupied(mut o) = map.entry("poneyland") { /// if let Entry::Occupied(mut o) = map.entry("poneyland") {
/// *o.get_mut() += 10; /// *o.get_mut() += 10;
/// assert_eq!(*o.get(), 22);
///
/// // We can use the same Entry multiple times.
/// *o.get_mut() += 2;
/// } /// }
/// assert_eq!(map["poneyland"], 22); /// assert_eq!(map["poneyland"], 24);
/// ``` /// ```
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
pub fn get_mut(&mut self) -> &mut V { pub fn get_mut(&mut self) -> &mut V {
@ -2391,6 +2400,10 @@ impl<'a, K: Ord, V> OccupiedEntry<'a, K, V> {
/// Converts the entry into a mutable reference to its value. /// Converts the entry into a mutable reference to its value.
/// ///
/// If you need multiple references to the `OccupiedEntry`, see [`get_mut`].
///
/// [`get_mut`]: #method.get_mut
///
/// # Examples /// # Examples
/// ///
/// ``` /// ```

1
src/liballoc/tests/str.rs
View File

@ -1326,6 +1326,7 @@ fn test_str_default() {
t::<&str>(); t::<&str>();
t::<String>(); t::<String>();
t::<&mut str>();
} }
#[test] #[test]

80
src/libcore/alloc.rs
View File

@ -20,6 +20,7 @@ use fmt;
use mem; use mem;
use usize; use usize;
use ptr::{self, NonNull}; use ptr::{self, NonNull};
use num::NonZeroUsize;
extern { extern {
/// An opaque, unsized type. Used for pointers to allocated memory. /// An opaque, unsized type. Used for pointers to allocated memory.
@ -66,7 +67,7 @@ fn size_align<T>() -> (usize, usize) {
#[derive(Copy, Clone, Debug, PartialEq, Eq)] #[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub struct Layout { pub struct Layout {
// size of the requested block of memory, measured in bytes. // size of the requested block of memory, measured in bytes.
size: usize, size_: usize,
// alignment of the requested block of memory, measured in bytes. // alignment of the requested block of memory, measured in bytes.
// we ensure that this is always a power-of-two, because API's // we ensure that this is always a power-of-two, because API's
@ -75,17 +76,12 @@ pub struct Layout {
// //
// (However, we do not analogously require `align >= sizeof(void*)`, // (However, we do not analogously require `align >= sizeof(void*)`,
// even though that is *also* a requirement of `posix_memalign`.) // even though that is *also* a requirement of `posix_memalign`.)
align: usize, align_: NonZeroUsize,
} }
// FIXME: audit default implementations for overflow errors,
// (potentially switching to overflowing_add and
// overflowing_mul as necessary).
impl Layout { impl Layout {
/// Constructs a `Layout` from a given `size` and `align`, /// Constructs a `Layout` from a given `size` and `align`,
/// or returns `None` if either of the following conditions /// or returns `LayoutErr` if either of the following conditions
/// are not met: /// are not met:
/// ///
/// * `align` must be a power of two, /// * `align` must be a power of two,
@ -126,23 +122,23 @@ impl Layout {
/// ///
/// # Safety /// # Safety
/// ///
/// This function is unsafe as it does not verify that `align` is /// This function is unsafe as it does not verify the preconditions from
/// a power-of-two nor `size` aligned to `align` fits within the /// [`Layout::from_size_align`](#method.from_size_align).
/// address space (i.e. the `Layout::from_size_align` preconditions).
#[inline] #[inline]
pub unsafe fn from_size_align_unchecked(size: usize, align: usize) -> Self { pub unsafe fn from_size_align_unchecked(size: usize, align: usize) -> Self {
Layout { size: size, align: align } Layout { size_: size, align_: NonZeroUsize::new_unchecked(align) }
} }
/// The minimum size in bytes for a memory block of this layout. /// The minimum size in bytes for a memory block of this layout.
#[inline] #[inline]
pub fn size(&self) -> usize { self.size } pub fn size(&self) -> usize { self.size_ }
/// The minimum byte alignment for a memory block of this layout. /// The minimum byte alignment for a memory block of this layout.
#[inline] #[inline]
pub fn align(&self) -> usize { self.align } pub fn align(&self) -> usize { self.align_.get() }
/// Constructs a `Layout` suitable for holding a value of type `T`. /// Constructs a `Layout` suitable for holding a value of type `T`.
#[inline]
pub fn new<T>() -> Self { pub fn new<T>() -> Self {
let (size, align) = size_align::<T>(); let (size, align) = size_align::<T>();
// Note that the align is guaranteed by rustc to be a power of two and // Note that the align is guaranteed by rustc to be a power of two and
@ -158,6 +154,7 @@ impl Layout {
/// Produces layout describing a record that could be used to /// Produces layout describing a record that could be used to
/// allocate backing structure for `T` (which could be a trait /// allocate backing structure for `T` (which could be a trait
/// or other unsized type like a slice). /// or other unsized type like a slice).
#[inline]
pub fn for_value<T: ?Sized>(t: &T) -> Self { pub fn for_value<T: ?Sized>(t: &T) -> Self {
let (size, align) = (mem::size_of_val(t), mem::align_of_val(t)); let (size, align) = (mem::size_of_val(t), mem::align_of_val(t));
// See rationale in `new` for why this us using an unsafe variant below // See rationale in `new` for why this us using an unsafe variant below
@ -181,18 +178,19 @@ impl Layout {
/// ///
/// # Panics /// # Panics
/// ///
/// Panics if the combination of `self.size` and the given `align` /// Panics if the combination of `self.size()` and the given `align`
/// violates the conditions listed in `from_size_align`. /// violates the conditions listed in
/// [`Layout::from_size_align`](#method.from_size_align).
#[inline] #[inline]
pub fn align_to(&self, align: usize) -> Self { pub fn align_to(&self, align: usize) -> Self {
Layout::from_size_align(self.size, cmp::max(self.align, align)).unwrap() Layout::from_size_align(self.size(), cmp::max(self.align(), align)).unwrap()
} }
/// Returns the amount of padding we must insert after `self` /// Returns the amount of padding we must insert after `self`
/// to ensure that the following address will satisfy `align` /// to ensure that the following address will satisfy `align`
/// (measured in bytes). /// (measured in bytes).
/// ///
/// E.g. if `self.size` is 9, then `self.padding_needed_for(4)` /// E.g. if `self.size()` is 9, then `self.padding_needed_for(4)`
/// returns 3, because that is the minimum number of bytes of /// returns 3, because that is the minimum number of bytes of
/// padding required to get a 4-aligned address (assuming that the /// padding required to get a 4-aligned address (assuming that the
/// corresponding memory block starts at a 4-aligned address). /// corresponding memory block starts at a 4-aligned address).
@ -203,7 +201,7 @@ impl Layout {
/// Note that the utility of the returned value requires `align` /// Note that the utility of the returned value requires `align`
/// to be less than or equal to the alignment of the starting /// to be less than or equal to the alignment of the starting
/// address for the whole allocated block of memory. One way to /// address for the whole allocated block of memory. One way to
/// satisfy this constraint is to ensure `align <= self.align`. /// satisfy this constraint is to ensure `align <= self.align()`.
#[inline] #[inline]
pub fn padding_needed_for(&self, align: usize) -> usize { pub fn padding_needed_for(&self, align: usize) -> usize {
let len = self.size(); let len = self.size();
@ -227,7 +225,8 @@ impl Layout {
// size and padding overflow in the above manner should cause // size and padding overflow in the above manner should cause
// the allocator to yield an error anyway.) // the allocator to yield an error anyway.)
let len_rounded_up = len.wrapping_add(align).wrapping_sub(1) & !align.wrapping_sub(1); let len_rounded_up = len.wrapping_add(align).wrapping_sub(1)
& !align.wrapping_sub(1);
return len_rounded_up.wrapping_sub(len); return len_rounded_up.wrapping_sub(len);
} }
@ -238,14 +237,19 @@ impl Layout {
/// layout of the array and `offs` is the distance between the start /// layout of the array and `offs` is the distance between the start
/// of each element in the array. /// of each element in the array.
/// ///
/// On arithmetic overflow, returns `None`. /// On arithmetic overflow, returns `LayoutErr`.
#[inline] #[inline]
pub fn repeat(&self, n: usize) -> Result<(Self, usize), LayoutErr> { pub fn repeat(&self, n: usize) -> Result<(Self, usize), LayoutErr> {
let padded_size = self.size.checked_add(self.padding_needed_for(self.align)) let padded_size = self.size().checked_add(self.padding_needed_for(self.align()))
.ok_or(LayoutErr { private: () })?; .ok_or(LayoutErr { private: () })?;
let alloc_size = padded_size.checked_mul(n) let alloc_size = padded_size.checked_mul(n)
.ok_or(LayoutErr { private: () })?; .ok_or(LayoutErr { private: () })?;
Ok((Layout::from_size_align(alloc_size, self.align)?, padded_size))
unsafe {
// self.align is already known to be valid and alloc_size has been
// padded already.
Ok((Layout::from_size_align_unchecked(alloc_size, self.align()), padded_size))
}
} }
/// Creates a layout describing the record for `self` followed by /// Creates a layout describing the record for `self` followed by
@ -258,16 +262,15 @@ impl Layout {
/// start of the `next` embedded within the concatenated record /// start of the `next` embedded within the concatenated record
/// (assuming that the record itself starts at offset 0). /// (assuming that the record itself starts at offset 0).
/// ///
/// On arithmetic overflow, returns `None`. /// On arithmetic overflow, returns `LayoutErr`.
#[inline]
pub fn extend(&self, next: Self) -> Result<(Self, usize), LayoutErr> { pub fn extend(&self, next: Self) -> Result<(Self, usize), LayoutErr> {
let new_align = cmp::max(self.align, next.align); let new_align = cmp::max(self.align(), next.align());
let realigned = Layout::from_size_align(self.size, new_align)?; let pad = self.padding_needed_for(next.align());
let pad = realigned.padding_needed_for(next.align); let offset = self.size().checked_add(pad)
let offset = self.size.checked_add(pad)
.ok_or(LayoutErr { private: () })?; .ok_or(LayoutErr { private: () })?;
let new_size = offset.checked_add(next.size) let new_size = offset.checked_add(next.size())
.ok_or(LayoutErr { private: () })?; .ok_or(LayoutErr { private: () })?;
let layout = Layout::from_size_align(new_size, new_align)?; let layout = Layout::from_size_align(new_size, new_align)?;
@ -285,10 +288,11 @@ impl Layout {
/// guaranteed that all elements in the array will be properly /// guaranteed that all elements in the array will be properly
/// aligned. /// aligned.
/// ///
/// On arithmetic overflow, returns `None`. /// On arithmetic overflow, returns `LayoutErr`.
#[inline]
pub fn repeat_packed(&self, n: usize) -> Result<Self, LayoutErr> { pub fn repeat_packed(&self, n: usize) -> Result<Self, LayoutErr> {
let size = self.size().checked_mul(n).ok_or(LayoutErr { private: () })?; let size = self.size().checked_mul(n).ok_or(LayoutErr { private: () })?;
Layout::from_size_align(size, self.align) Layout::from_size_align(size, self.align())
} }
/// Creates a layout describing the record for `self` followed by /// Creates a layout describing the record for `self` followed by
@ -305,17 +309,19 @@ impl Layout {
/// signature out of convenience in matching the signature of /// signature out of convenience in matching the signature of
/// `extend`.) /// `extend`.)
/// ///
/// On arithmetic overflow, returns `None`. /// On arithmetic overflow, returns `LayoutErr`.
#[inline]
pub fn extend_packed(&self, next: Self) -> Result<(Self, usize), LayoutErr> { pub fn extend_packed(&self, next: Self) -> Result<(Self, usize), LayoutErr> {
let new_size = self.size().checked_add(next.size()) let new_size = self.size().checked_add(next.size())
.ok_or(LayoutErr { private: () })?; .ok_or(LayoutErr { private: () })?;
let layout = Layout::from_size_align(new_size, self.align)?; let layout = Layout::from_size_align(new_size, self.align())?;
Ok((layout, self.size())) Ok((layout, self.size()))
} }
/// Creates a layout describing the record for a `[T; n]`. /// Creates a layout describing the record for a `[T; n]`.
/// ///
/// On arithmetic overflow, returns `None`. /// On arithmetic overflow, returns `LayoutErr`.
#[inline]
pub fn array<T>(n: usize) -> Result<Self, LayoutErr> { pub fn array<T>(n: usize) -> Result<Self, LayoutErr> {
Layout::new::<T>() Layout::new::<T>()
.repeat(n) .repeat(n)
@ -842,7 +848,7 @@ pub unsafe trait Alloc {
layout: Layout, layout: Layout,
new_size: usize) -> Result<(), CannotReallocInPlace> { new_size: usize) -> Result<(), CannotReallocInPlace> {
let _ = ptr; // this default implementation doesn't care about the actual address. let _ = ptr; // this default implementation doesn't care about the actual address.
debug_assert!(new_size >= layout.size); debug_assert!(new_size >= layout.size());
let (_l, u) = self.usable_size(&layout); let (_l, u) = self.usable_size(&layout);
// _l <= layout.size() [guaranteed by usable_size()] // _l <= layout.size() [guaranteed by usable_size()]
// layout.size() <= new_layout.size() [required by this method] // layout.size() <= new_layout.size() [required by this method]
@ -897,7 +903,7 @@ pub unsafe trait Alloc {
layout: Layout, layout: Layout,
new_size: usize) -> Result<(), CannotReallocInPlace> { new_size: usize) -> Result<(), CannotReallocInPlace> {
let _ = ptr; // this default implementation doesn't care about the actual address. let _ = ptr; // this default implementation doesn't care about the actual address.
debug_assert!(new_size <= layout.size); debug_assert!(new_size <= layout.size());
let (l, _u) = self.usable_size(&layout); let (l, _u) = self.usable_size(&layout);
// layout.size() <= _u [guaranteed by usable_size()] // layout.size() <= _u [guaranteed by usable_size()]
// new_layout.size() <= layout.size() [required by this method] // new_layout.size() <= layout.size() [required by this method]

6
src/libcore/str/mod.rs
View File

@ -3875,6 +3875,12 @@ impl<'a> Default for &'a str {
fn default() -> &'a str { "" } fn default() -> &'a str { "" }
} }
#[stable(feature = "default_mut_str", since = "1.28.0")]
impl<'a> Default for &'a mut str {
/// Creates an empty mutable str
fn default() -> &'a mut str { unsafe { from_utf8_unchecked_mut(&mut []) } }
}
/// An iterator over the non-whitespace substrings of a string, /// An iterator over the non-whitespace substrings of a string,
/// separated by any amount of whitespace. /// separated by any amount of whitespace.
/// ///

4
src/librustc_mir/transform/check_unsafety.rs
View File

@ -362,8 +362,8 @@ fn unsafe_derive_on_repr_packed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: D
format!("#[derive] can't be used on a #[repr(packed)] struct with \ format!("#[derive] can't be used on a #[repr(packed)] struct with \
type parameters (error E0133)") type parameters (error E0133)")
} else { } else {
format!("#[derive] can't be used on a non-Copy #[repr(packed)] struct \ format!("#[derive] can't be used on a #[repr(packed)] struct that \
(error E0133)") does not derive Copy (error E0133)")
}; };
tcx.lint_node(SAFE_PACKED_BORROWS, tcx.lint_node(SAFE_PACKED_BORROWS,
lint_node_id, lint_node_id,

12
src/librustc_typeck/check/method/suggest.rs
View File

@ -195,7 +195,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
let ty_string = self.ty_to_string(actual); let ty_string = self.ty_to_string(actual);
let is_method = mode == Mode::MethodCall; let is_method = mode == Mode::MethodCall;
let mut suggestion = None; let mut suggestion = None;
let type_str = if is_method { let item_kind = if is_method {
"method" "method"
} else if actual.is_enum() { } else if actual.is_enum() {
if let TyAdt(ref adt_def, _) = actual.sty { if let TyAdt(ref adt_def, _) = actual.sty {
@ -235,7 +235,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
span, span,
E0689, E0689,
"can't call {} `{}` on ambiguous numeric type `{}`", "can't call {} `{}` on ambiguous numeric type `{}`",
type_str, item_kind,
item_name, item_name,
ty_string ty_string
); );
@ -284,12 +284,12 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
span, span,
E0599, E0599,
"no {} named `{}` found for type `{}` in the current scope", "no {} named `{}` found for type `{}` in the current scope",
type_str, item_kind,
item_name, item_name,
ty_string ty_string
); );
if let Some(suggestion) = suggestion { if let Some(suggestion) = suggestion {
err.note(&format!("did you mean `{}::{}`?", type_str, suggestion)); err.note(&format!("did you mean `{}::{}`?", ty_string, suggestion));
} }
err err
} }
@ -301,7 +301,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
if let Some(full_sp) = tcx.hir.span_if_local(def.did) { if let Some(full_sp) = tcx.hir.span_if_local(def.did) {
let def_sp = tcx.sess.codemap().def_span(full_sp); let def_sp = tcx.sess.codemap().def_span(full_sp);
err.span_label(def_sp, format!("{} `{}` not found {}", err.span_label(def_sp, format!("{} `{}` not found {}",
type_str, item_kind,
item_name, item_name,
if def.is_enum() && !is_method { if def.is_enum() && !is_method {
"here" "here"
@ -355,7 +355,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
} }
} }
} else { } else {
err.span_label(span, format!("{} not found in `{}`", type_str, ty_string)); err.span_label(span, format!("{} not found in `{}`", item_kind, ty_string));
} }
if self.is_fn_ty(&rcvr_ty, span) { if self.is_fn_ty(&rcvr_ty, span) {

3
src/librustdoc/html/static/rustdoc.css
View File

@ -561,7 +561,8 @@ a {
content: '\2002\00a7\2002'; content: '\2002\00a7\2002';
} }
.docblock a:not(.srclink):hover, .docblock-short a:not(.srclink):hover, .stability a { .docblock a:not(.srclink):not(.test-arrow):hover,
.docblock-short a:not(.srclink):not(.test-arrow):hover, .stability a {
text-decoration: underline; text-decoration: underline;
} }

3
src/librustdoc/html/static/themes/dark.css
View File

@ -163,7 +163,8 @@ a {
color: #ddd; color: #ddd;
} }
.docblock a:not(.srclink), .docblock-short a:not(.srclink), .stability a { .docblock a:not(.srclink):not(.test-arrow), .docblock-short a:not(.srclink):not(.test-arrow),
.stability a {
color: #D2991D; color: #D2991D;
} }

3
src/librustdoc/html/static/themes/light.css
View File

@ -163,7 +163,8 @@ a {
color: #000; color: #000;
} }
.docblock a:not(.srclink), .docblock-short a:not(.srclink), .stability a { .docblock a:not(.srclink):not(.test-arrow), .docblock-short a:not(.srclink):not(.test-arrow),
.stability a {
color: #3873AD; color: #3873AD;
} }

17
src/libstd/collections/hash/map.rs
View File

@ -2250,6 +2250,11 @@ impl<'a, K, V> OccupiedEntry<'a, K, V> {
/// Gets a mutable reference to the value in the entry. /// Gets a mutable reference to the value in the entry.
/// ///
/// If you need a reference to the `OccupiedEntry` which may outlive the
/// destruction of the `Entry` value, see [`into_mut`].
///
/// [`into_mut`]: #method.into_mut
///
/// # Examples /// # Examples
/// ///
/// ``` /// ```
@ -2261,10 +2266,14 @@ impl<'a, K, V> OccupiedEntry<'a, K, V> {
/// ///
/// assert_eq!(map["poneyland"], 12); /// assert_eq!(map["poneyland"], 12);
/// if let Entry::Occupied(mut o) = map.entry("poneyland") { /// if let Entry::Occupied(mut o) = map.entry("poneyland") {
/// *o.get_mut() += 10; /// *o.get_mut() += 10;
/// assert_eq!(*o.get(), 22);
///
/// // We can use the same Entry multiple times.
/// *o.get_mut() += 2;
/// } /// }
/// ///
/// assert_eq!(map["poneyland"], 22); /// assert_eq!(map["poneyland"], 24);
/// ``` /// ```
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
pub fn get_mut(&mut self) -> &mut V { pub fn get_mut(&mut self) -> &mut V {
@ -2274,6 +2283,10 @@ impl<'a, K, V> OccupiedEntry<'a, K, V> {
/// Converts the OccupiedEntry into a mutable reference to the value in the entry /// Converts the OccupiedEntry into a mutable reference to the value in the entry
/// with a lifetime bound to the map itself. /// with a lifetime bound to the map itself.
/// ///
/// If you need multiple references to the `OccupiedEntry`, see [`get_mut`].
///
/// [`get_mut`]: #method.get_mut
///
/// # Examples /// # Examples
/// ///
/// ``` /// ```

2
src/test/ui/deriving-with-repr-packed.rs
View File

@ -33,7 +33,7 @@ pub struct Bar(u32, u32, u32);
struct Y(usize); struct Y(usize);
#[derive(PartialEq)] #[derive(PartialEq)]
//~^ ERROR #[derive] can't be used on a non-Copy #[repr(packed)] //~^ ERROR #[derive] can't be used
//~| hard error //~| hard error
#[repr(packed)] #[repr(packed)]
struct X(Y); struct X(Y);

4
src/test/ui/deriving-with-repr-packed.stderr
View File

@ -21,7 +21,7 @@ LL | #[derive(Copy, Clone, PartialEq, Eq)]
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= note: for more information, see issue #46043 <https://github.com/rust-lang/rust/issues/46043> = note: for more information, see issue #46043 <https://github.com/rust-lang/rust/issues/46043>
error: #[derive] can't be used on a non-Copy #[repr(packed)] struct (error E0133) error: #[derive] can't be used on a #[repr(packed)] struct that does not derive Copy (error E0133)
--> $DIR/deriving-with-repr-packed.rs:26:10 --> $DIR/deriving-with-repr-packed.rs:26:10
| |
LL | #[derive(PartialEq, Eq)] LL | #[derive(PartialEq, Eq)]
@ -30,7 +30,7 @@ LL | #[derive(PartialEq, Eq)]
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= note: for more information, see issue #46043 <https://github.com/rust-lang/rust/issues/46043> = note: for more information, see issue #46043 <https://github.com/rust-lang/rust/issues/46043>
error: #[derive] can't be used on a non-Copy #[repr(packed)] struct (error E0133) error: #[derive] can't be used on a #[repr(packed)] struct that does not derive Copy (error E0133)
--> $DIR/deriving-with-repr-packed.rs:35:10 --> $DIR/deriving-with-repr-packed.rs:35:10
| |
LL | #[derive(PartialEq)] LL | #[derive(PartialEq)]

2
src/test/ui/issue-23217.stderr
View File

@ -6,7 +6,7 @@ LL | pub enum SomeEnum {
LL | B = SomeEnum::A, LL | B = SomeEnum::A,
| ^^^^^^^^^^^ variant not found in `SomeEnum` | ^^^^^^^^^^^ variant not found in `SomeEnum`
| |
= note: did you mean `variant::B`? = note: did you mean `SomeEnum::B`?
error: aborting due to previous error error: aborting due to previous error

2
src/test/ui/issue-28971.stderr
View File

@ -7,7 +7,7 @@ LL | enum Foo {
LL | Foo::Baz(..) => (), LL | Foo::Baz(..) => (),
| ^^^^^^^^^^^^ variant not found in `Foo` | ^^^^^^^^^^^^ variant not found in `Foo`
| |
= note: did you mean `variant::Bar`? = note: did you mean `Foo::Bar`?
error: aborting due to previous error error: aborting due to previous error