rustc: replace TypeContents with two independent properties (is_freeze / needs_drop).
`InteriorUnsafe` / `interior_unsafe` was replaced with a private lang-item `Freeze` auto trait in libcore.
`OwnsDtor` / `needs_drop` was replaced with a specialized traversal that *doesn't* avoid caching results in case of a cycle, as the only cycles left can only occur in erroneous "types with infinite sizes", references and raw pointers not having destructors. Also, `Copy` is now checked at every step of the recursion.
r? @nikomatsakis
impl<'a, T: 'a + fmt::Debug> fmt::Debug for Difference<'a, T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_tuple("Difference")
- .field(&self.clone())
+ .field(&self.a)
+ .field(&self.b)
.finish()
}
}
impl<'a, T: 'a + fmt::Debug> fmt::Debug for SymmetricDifference<'a, T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_tuple("SymmetricDifference")
- .field(&self.clone())
+ .field(&self.a)
+ .field(&self.b)
.finish()
}
}
impl<'a, T: 'a + fmt::Debug> fmt::Debug for Intersection<'a, T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_tuple("Intersection")
- .field(&self.clone())
+ .field(&self.a)
+ .field(&self.b)
.finish()
}
}
impl<'a, T: 'a + fmt::Debug> fmt::Debug for Union<'a, T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_tuple("Union")
- .field(&self.clone())
+ .field(&self.a)
+ .field(&self.b)
.finish()
}
}
impl<E: fmt::Debug> fmt::Debug for Iter<E> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_tuple("Iter")
- .field(&self.clone())
+ .field(&self.index)
+ .field(&self.bits)
.finish()
}
}
impl<'a, T: 'a + fmt::Debug> fmt::Debug for Iter<'a, T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_tuple("Iter")
- .field(&self.clone())
+ .field(&self.len)
.finish()
}
}
impl<'a, T: 'a + fmt::Debug> fmt::Debug for IterMut<'a, T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_tuple("IterMut")
- .field(self.clone())
+ .field(&self.list)
+ .field(&self.len)
.finish()
}
}
impl<T: fmt::Debug> fmt::Debug for IntoIter<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_tuple("IntoIter")
- .field(self.clone())
+ .field(&self.list)
.finish()
}
}
impl<'a, T: 'a + fmt::Debug> fmt::Debug for FrontPlace<'a, T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_tuple("FrontPlace")
- .field(self.clone())
+ .field(&self.list)
.finish()
}
}
impl<'a, T: 'a + fmt::Debug> fmt::Debug for BackPlace<'a, T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_tuple("BackPlace")
- .field(self.clone())
+ .field(&self.list)
.finish()
}
}
let mut v = Vec::new();
let mut w = Vec::new();
+ v.extend(w.clone());
+ assert_eq!(v, &[]);
+
v.extend(0..3);
for i in 0..3 {
w.push(i)
v.extend(w.clone()); // specializes to `append`
assert!(v.iter().eq(w.iter().chain(w.iter())));
+
+ // Zero sized types
+ #[derive(PartialEq, Debug)]
+ struct Foo;
+
+ let mut a = Vec::new();
+ let b = vec![Foo, Foo];
+
+ a.extend(b);
+ assert_eq!(a, &[Foo, Foo]);
+
+ // Double drop
+ let mut count_x = 0;
+ {
+ let mut x = Vec::new();
+ let y = vec![DropCounter { count: &mut count_x }];
+ x.extend(y);
+ }
+ assert_eq!(count_x, 1);
}
#[test]
#[inline]
#[stable(feature = "append", since = "1.4.0")]
pub fn append(&mut self, other: &mut Self) {
- self.reserve(other.len());
- let len = self.len();
- unsafe {
- ptr::copy_nonoverlapping(other.as_ptr(), self.get_unchecked_mut(len), other.len());
- }
-
- self.len += other.len();
unsafe {
+ self.append_elements(other.as_slice() as _);
other.set_len(0);
}
}
+ /// Appends elements to `Self` from other buffer.
+ #[inline]
+ unsafe fn append_elements(&mut self, other: *const [T]) {
+ let count = (*other).len();
+ self.reserve(count);
+ let len = self.len();
+ ptr::copy_nonoverlapping(other as *const T, self.get_unchecked_mut(len), count);
+ self.len += count;
+ }
+
/// Create a draining iterator that removes the specified range in the vector
/// and yields the removed items.
///
vector
}
- fn spec_extend(&mut self, iterator: I) {
+ default fn spec_extend(&mut self, iterator: I) {
// This is the case for a TrustedLen iterator.
let (low, high) = iterator.size_hint();
if let Some(high_value) = high {
vector
}
}
+
+ fn spec_extend(&mut self, mut iterator: IntoIter<T>) {
+ unsafe {
+ self.append_elements(iterator.as_slice() as _);
+ }
+ iterator.ptr = iterator.end;
+ }
}
impl<'a, T: 'a, I> SpecExtend<&'a T, I> for Vec<T>
impl<'a, T: 'a + fmt::Debug> fmt::Debug for Iter<'a, T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_tuple("Iter")
- .field(&self.clone())
+ .field(&self.ring)
+ .field(&self.tail)
+ .field(&self.head)
.finish()
}
}
impl<'a, T: 'a + fmt::Debug> fmt::Debug for IterMut<'a, T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_tuple("IterMut")
- .field(&self.clone())
+ .field(&self.ring)
+ .field(&self.tail)
+ .field(&self.head)
.finish()
}
}
impl<T: fmt::Debug> fmt::Debug for IntoIter<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_tuple("IntoIter")
- .field(&self.clone())
+ .field(&self.inner)
.finish()
}
}
impl<'a, T: 'a + fmt::Debug> fmt::Debug for Drain<'a, T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_tuple("Drain")
- .field(&self.clone())
+ .field(&self.after_tail)
+ .field(&self.after_head)
+ .field(&self.iter)
.finish()
}
}
//! Like many traits, these are often used as bounds for generic functions, to
//! support arguments of multiple types.
//!
-//! - Impl the `As*` traits for reference-to-reference conversions
-//! - Impl the [`Into`] trait when you want to consume the value in the conversion
+//! - Implement the `As*` traits for reference-to-reference conversions
+//! - Implement the [`Into`] trait when you want to consume the value in the conversion
//! - The [`From`] trait is the most flexible, useful for value _and_ reference conversions
//! - The [`TryFrom`] and [`TryInto`] traits behave like [`From`] and [`Into`], but allow for the
//! conversion to fail
//! As a library author, you should prefer implementing [`From<T>`][`From`] or
//! [`TryFrom<T>`][`TryFrom`] rather than [`Into<U>`][`Into`] or [`TryInto<U>`][`TryInto`],
//! as [`From`] and [`TryFrom`] provide greater flexibility and offer
-//! equivalent [`Into`] or [`TryInto`] implementations for free, thanks to a blanket implementation
-//! in the standard library.
+//! equivalent [`Into`] or [`TryInto`] implementations for free, thanks to a
+//! blanket implementation in the standard library.
//!
-//! # Generic impl
+//! # Generic Implementations
//!
//! - [`AsRef`] and [`AsMut`] auto-dereference if the inner type is a reference
//! - [`From`]`<U> for T` implies [`Into`]`<T> for U`
//! - [`TryFrom`]`<U> for T` implies [`TryInto`]`<T> for U`
-//! - [`From`] and [`Into`] are reflexive, which means that all types can `into()`
-//! themselves and `from()` themselves
+//! - [`From`] and [`Into`] are reflexive, which means that all types can
+//! `into` themselves and `from` themselves
//!
//! See each trait for usage examples.
//!
use str::FromStr;
-/// A cheap, reference-to-reference conversion.
+/// A cheap reference-to-reference conversion. Used to convert a value to a
+/// reference value within generic code.
///
-/// `AsRef` is very similar to, but different than, [`Borrow`]. See
-/// [the book][book] for more.
+/// `AsRef` is very similar to, but serves a slightly different purpose than,
+/// [`Borrow`].
+///
+/// `AsRef` is to be used when wishing to convert to a reference of another
+/// type.
+/// `Borrow` is more related to the notion of taking the reference. It is
+/// useful when wishing to abstract over the type of reference
+/// (`&T`, `&mut T`) or allow both the referenced and owned type to be treated
+/// in the same manner.
+///
+/// The key difference between the two traits is the intention:
+///
+/// - Use `AsRef` when goal is to simply convert into a reference
+/// - Use `Borrow` when goal is related to writing code that is agnostic to the
+/// type of borrow and if is reference or value
+///
+/// See [the book][book] for a more detailed comparison.
///
/// [book]: ../../book/borrow-and-asref.html
/// [`Borrow`]: ../../std/borrow/trait.Borrow.html
///
-/// **Note: this trait must not fail**. If the conversion can fail, use a dedicated method which
-/// returns an [`Option<T>`] or a [`Result<T, E>`].
+/// **Note: this trait must not fail**. If the conversion can fail, use a
+/// dedicated method which returns an [`Option<T>`] or a [`Result<T, E>`].
///
/// [`Option<T>`]: ../../std/option/enum.Option.html
/// [`Result<T, E>`]: ../../std/result/enum.Result.html
///
+/// # Generic Implementations
+///
+/// - `AsRef` auto-dereferences if the inner type is a reference or a mutable
+/// reference (e.g.: `foo.as_ref()` will work the same if `foo` has type
+/// `&mut Foo` or `&&mut Foo`)
+///
/// # Examples
///
/// Both [`String`] and `&str` implement `AsRef<str>`:
/// is_hello(s);
/// ```
///
-/// # Generic Impls
-///
-/// - `AsRef` auto-dereferences if the inner type is a reference or a mutable
-/// reference (e.g.: `foo.as_ref()` will work the same if `foo` has type `&mut Foo` or `&&mut Foo`)
-///
#[stable(feature = "rust1", since = "1.0.0")]
pub trait AsRef<T: ?Sized> {
/// Performs the conversion.
/// A cheap, mutable reference-to-mutable reference conversion.
///
-/// **Note: this trait must not fail**. If the conversion can fail, use a dedicated method which
-/// returns an [`Option<T>`] or a [`Result<T, E>`].
+/// This trait is similar to `AsRef` but used for converting between mutable
+/// references.
+///
+/// **Note: this trait must not fail**. If the conversion can fail, use a
+/// dedicated method which returns an [`Option<T>`] or a [`Result<T, E>`].
///
/// [`Option<T>`]: ../../std/option/enum.Option.html
/// [`Result<T, E>`]: ../../std/result/enum.Result.html
///
+/// # Generic Implementations
+///
+/// - `AsMut` auto-dereferences if the inner type is a reference or a mutable
+/// reference (e.g.: `foo.as_ref()` will work the same if `foo` has type
+/// `&mut Foo` or `&&mut Foo`)
+///
/// # Examples
///
/// [`Box<T>`] implements `AsMut<T>`:
/// assert_eq!(*boxed_num, 1);
/// ```
///
-/// # Generic Impls
-///
-/// - `AsMut` auto-dereferences if the inner type is a reference or a mutable
-/// reference (e.g.: `foo.as_ref()` will work the same if `foo` has type `&mut Foo` or `&&mut Foo`)
///
#[stable(feature = "rust1", since = "1.0.0")]
pub trait AsMut<T: ?Sized> {
fn as_mut(&mut self) -> &mut T;
}
-/// A conversion that consumes `self`, which may or may not be expensive.
+/// A conversion that consumes `self`, which may or may not be expensive. The
+/// reciprocal of [`From`][From].
+///
+/// **Note: this trait must not fail**. If the conversion can fail, use
+/// [`TryInto`] or a dedicated method which returns an [`Option<T>`] or a
+/// [`Result<T, E>`].
///
-/// **Note: this trait must not fail**. If the conversion can fail, use [`TryInto`] or a dedicated
-/// method which returns an [`Option<T>`] or a [`Result<T, E>`].
+/// Library authors should not directly implement this trait, but should prefer
+/// implementing the [`From`][From] trait, which offers greater flexibility and
+/// provides an equivalent `Into` implementation for free, thanks to a blanket
+/// implementation in the standard library.
///
-/// Library authors should not directly implement this trait, but should prefer implementing
-/// the [`From`][From] trait, which offers greater flexibility and provides an equivalent `Into`
-/// implementation for free, thanks to a blanket implementation in the standard library.
+/// # Generic Implementations
+///
+/// - [`From<T>`][From]` for U` implies `Into<U> for T`
+/// - [`into`] is reflexive, which means that `Into<T> for T` is implemented
///
/// # Examples
///
/// is_hello(s);
/// ```
///
-/// # Generic Impls
-///
-/// - [`From<T>`][From]` for U` implies `Into<U> for T`
-/// - [`into`] is reflexive, which means that `Into<T> for T` is implemented
-///
/// [`TryInto`]: trait.TryInto.html
/// [`Option<T>`]: ../../std/option/enum.Option.html
/// [`Result<T, E>`]: ../../std/result/enum.Result.html
fn into(self) -> T;
}
-/// Construct `Self` via a conversion.
+/// Simple and safe type conversions in to `Self`. It is the reciprocal of
+/// `Into`.
+///
+/// This trait is useful when performing error handling as described by
+/// [the book][book] and is closely related to the `?` operator.
+///
+/// When constructing a function that is capable of failing the return type
+/// will generally be of the form `Result<T, E>`.
+///
+/// The `From` trait allows for simplification of error handling by providing a
+/// means of returning a single error type that encapsulates numerous possible
+/// erroneous situations.
+///
+/// This trait is not limited to error handling, rather the general case for
+/// this trait would be in any type conversions to have an explicit definition
+/// of how they are performed.
+///
+/// **Note: this trait must not fail**. If the conversion can fail, use
+/// [`TryFrom`] or a dedicated method which returns an [`Option<T>`] or a
+/// [`Result<T, E>`].
///
-/// **Note: this trait must not fail**. If the conversion can fail, use [`TryFrom`] or a dedicated
-/// method which returns an [`Option<T>`] or a [`Result<T, E>`].
+/// # Generic Implementations
+///
+/// - `From<T> for U` implies [`Into<U>`]` for T`
+/// - [`from`] is reflexive, which means that `From<T> for T` is implemented
///
/// # Examples
///
///
/// assert_eq!(string, other_string);
/// ```
-/// # Generic impls
///
-/// - `From<T> for U` implies [`Into<U>`]` for T`
-/// - [`from`] is reflexive, which means that `From<T> for T` is implemented
+/// An example usage for error handling:
+///
+/// ```
+/// use std::io::{self, Read};
+/// use std::num;
+///
+/// enum CliError {
+/// IoError(io::Error),
+/// ParseError(num::ParseIntError),
+/// }
+///
+/// impl From<io::Error> for CliError {
+/// fn from(error: io::Error) -> Self {
+/// CliError::IoError(error)
+/// }
+/// }
+///
+/// impl From<num::ParseIntError> for CliError {
+/// fn from(error: num::ParseIntError) -> Self {
+/// CliError::ParseError(error)
+/// }
+/// }
+///
+/// fn open_and_parse_file(file_name: &str) -> Result<i32, CliError> {
+/// let mut file = std::fs::File::open("test")?;
+/// let mut contents = String::new();
+/// file.read_to_string(&mut contents)?;
+/// let num: i32 = contents.trim().parse()?;
+/// Ok(num)
+/// }
+/// ```
///
/// [`TryFrom`]: trait.TryFrom.html
/// [`Option<T>`]: ../../std/option/enum.Option.html
/// [`String`]: ../../std/string/struct.String.html
/// [`Into<U>`]: trait.Into.html
/// [`from`]: trait.From.html#tymethod.from
+/// [book]: ../../book/error-handling.html
#[stable(feature = "rust1", since = "1.0.0")]
pub trait From<T>: Sized {
/// Performs the conversion.
fn from(T) -> Self;
}
-/// An attempted conversion that consumes `self`, which may or may not be expensive.
+/// An attempted conversion that consumes `self`, which may or may not be
+/// expensive.
///
-/// Library authors should not directly implement this trait, but should prefer implementing
-/// the [`TryFrom`] trait, which offers greater flexibility and provides an equivalent `TryInto`
-/// implementation for free, thanks to a blanket implementation in the standard library.
+/// Library authors should not directly implement this trait, but should prefer
+/// implementing the [`TryFrom`] trait, which offers greater flexibility and
+/// provides an equivalent `TryInto` implementation for free, thanks to a
+/// blanket implementation in the standard library.
///
/// [`TryFrom`]: trait.TryFrom.html
#[unstable(feature = "try_from", issue = "33417")]
// As lifts over &
#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T: ?Sized, U: ?Sized> AsRef<U> for &'a T where T: AsRef<U> {
+impl<'a, T: ?Sized, U: ?Sized> AsRef<U> for &'a T where T: AsRef<U>
+{
fn as_ref(&self) -> &U {
<T as AsRef<U>>::as_ref(*self)
}
// As lifts over &mut
#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T: ?Sized, U: ?Sized> AsRef<U> for &'a mut T where T: AsRef<U> {
+impl<'a, T: ?Sized, U: ?Sized> AsRef<U> for &'a mut T where T: AsRef<U>
+{
fn as_ref(&self) -> &U {
<T as AsRef<U>>::as_ref(*self)
}
// AsMut lifts over &mut
#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T: ?Sized, U: ?Sized> AsMut<U> for &'a mut T where T: AsMut<U> {
+impl<'a, T: ?Sized, U: ?Sized> AsMut<U> for &'a mut T where T: AsMut<U>
+{
fn as_mut(&mut self) -> &mut U {
(*self).as_mut()
}
// From implies Into
#[stable(feature = "rust1", since = "1.0.0")]
-impl<T, U> Into<U> for T where U: From<T> {
+impl<T, U> Into<U> for T where U: From<T>
+{
fn into(self) -> U {
U::from(self)
}
// TryFrom implies TryInto
#[unstable(feature = "try_from", issue = "33417")]
-impl<T, U> TryInto<U> for T where U: TryFrom<T> {
+impl<T, U> TryInto<U> for T where U: TryFrom<T>
+{
type Error = U::Error;
fn try_into(self) -> Result<U, U::Error> {
// FromStr implies TryFrom<&str>
#[unstable(feature = "try_from", issue = "33417")]
-impl<'a, T> TryFrom<&'a str> for T where T: FromStr {
+impl<'a, T> TryFrom<&'a str> for T where T: FromStr
+{
type Error = <T as FromStr>::Err;
fn try_from(s: &'a str) -> Result<T, Self::Error> {
draw_col_separator(buffer, line_offset, width_offset - 2);
+ // Special case when there's only one annotation involved, it is the start of a multiline
+ // span and there's no text at the beginning of the code line. Instead of doing the whole
+ // graph:
+ //
+ // 2 | fn foo() {
+ // | _^
+ // 3 | |
+ // 4 | | }
+ // | |_^ test
+ //
+ // we simplify the output to:
+ //
+ // 2 | / fn foo() {
+ // 3 | |
+ // 4 | | }
+ // | |_^ test
+ if line.annotations.len() == 1 {
+ if let Some(ref ann) = line.annotations.get(0) {
+ if let AnnotationType::MultilineStart(depth) = ann.annotation_type {
+ if source_string[0..ann.start_col].trim() == "" {
+ let style = if ann.is_primary {
+ Style::UnderlinePrimary
+ } else {
+ Style::UnderlineSecondary
+ };
+ buffer.putc(line_offset,
+ width_offset + depth - 1,
+ '/',
+ style);
+ return vec![(depth, style)];
+ }
+ }
+ }
+ }
+
// We want to display like this:
//
// vec.push(vec.pop().unwrap());
for (i, annotation) in annotations.iter().enumerate() {
for (j, next) in annotations.iter().enumerate() {
if overlaps(next, annotation, 0) // This label overlaps with another one and both
- && !annotation.is_line() // take space (they have text and are not
- && !next.is_line() // multiline lines).
- && annotation.has_label()
- && j > i
+ && annotation.has_label() // take space (they have text and are not
+ && j > i // multiline lines).
&& p == 0 // We're currently on the first line, move the label one line down
{
// This annotation needs a new line in the output.
} else {
0
};
- if overlaps(next, annotation, l) // Do not allow two labels to be in the same
+ if (overlaps(next, annotation, l) // Do not allow two labels to be in the same
// line if they overlap including padding, to
// avoid situations like:
//
// | |
// fn_spanx_span
//
- && !annotation.is_line() // Do not add a new line if this annotation
- && !next.is_line() // or the next are vertical line placeholders.
&& annotation.has_label() // Both labels must have some text, otherwise
- && next.has_label() // they are not overlapping.
+ && next.has_label()) // they are not overlapping.
+ // Do not add a new line if this annotation
+ // or the next are vertical line placeholders.
+ || (annotation.takes_space() // If either this or the next annotation is
+ && next.has_label()) // multiline start/end, move it to a new line
+ || (annotation.has_label() // so as not to overlap the orizontal lines.
+ && next.takes_space())
+ || (annotation.takes_space()
+ && next.takes_space())
{
+ // This annotation needs a new line in the output.
p += 1;
break;
}
line_len = p;
}
}
+
if line_len != 0 {
line_len += 1;
}
};
let pos = pos + 1;
- if pos > 1 && annotation.has_label() {
+ if pos > 1 && (annotation.has_label() || annotation.takes_space()) {
for p in line_offset + 1..line_offset + pos + 1 {
buffer.putc(p,
code_offset + annotation.start_col,
// After this we will have:
//
// 2 | fn foo() {
- // | __________ starting here...
+ // | __________
// | |
// | something about `foo`
// 3 |
// 4 | }
- // | _ ...ending here: test
+ // | _ test
for &(pos, annotation) in &annotations_position {
let style = if annotation.is_primary {
Style::LabelPrimary
// After this we will have:
//
// 2 | fn foo() {
- // | ____-_____^ starting here...
+ // | ____-_____^
// | |
// | something about `foo`
// 3 |
// 4 | }
- // | _^ ...ending here: test
+ // | _^ test
for &(_, annotation) in &annotations_position {
let (underline, style) = if annotation.is_primary {
('^', Style::UnderlinePrimary)
start_col: self.start_col,
end_col: self.start_col + 1,
is_primary: self.is_primary,
- label: Some("starting here...".to_owned()),
+ label: None,
annotation_type: AnnotationType::MultilineStart(self.depth)
}
}
start_col: self.end_col - 1,
end_col: self.end_col,
is_primary: self.is_primary,
- label: match self.label {
- Some(ref label) => Some(format!("...ending here: {}", label)),
- None => Some("...ending here".to_owned()),
- },
+ label: self.label.clone(),
annotation_type: AnnotationType::MultilineEnd(self.depth)
}
}
// Each of these corresponds to one part of the following diagram:
//
// x | foo(1 + bar(x,
- // | _________^ starting here... < MultilineStart
- // x | | y), < MultilineLine
- // | |______________^ ...ending here: label < MultilineEnd
+ // | _________^ < MultilineStart
+ // x | | y), < MultilineLine
+ // | |______________^ label < MultilineEnd
// x | z);
/// Annotation marking the first character of a fully shown multiline span
MultilineStart(usize),
false
}
}
+
+ pub fn takes_space(&self) -> bool {
+ // Multiline annotations always have to keep vertical space.
+ match self.annotation_type {
+ AnnotationType::MultilineStart(_) |
+ AnnotationType::MultilineEnd(_) => true,
+ _ => false,
+ }
+ }
}
#[derive(Debug)]
/// spawning process and can itself be constructed using a builder-style
/// interface.
///
+/// There is no implementation of [`Drop`] for child processes,
+/// so if you do not ensure the `Child` has exited then it will continue to
+/// run, even after the `Child` handle to the child process has gone out of
+/// scope.
+///
+/// Calling [`wait`](#method.wait) (or other functions that wrap around it) will make
+/// the parent process wait until the child has actually exited before
+/// continuing.
+///
/// # Examples
///
/// ```should_panic
/// assert!(ecode.success());
/// ```
///
-/// # Note
-///
-/// Take note that there is no implementation of [`Drop`] for child processes,
-/// so if you do not ensure the `Child` has exited then it will continue to
-/// run, even after the `Child` handle to the child process has gone out of
-/// scope.
-///
-/// Calling [`wait`][`wait`] (or other functions that wrap around it) will make
-/// the parent process wait until the child has actually exited before
-/// continuing.
-///
/// [`Command`]: struct.Command.html
/// [`Drop`]: ../../core/ops/trait.Drop.html
/// [`wait`]: #method.wait
--> test.rs:2:10
|
2 | fn foo() {
- | __________^ starting here...
+ | __________^
3 | | }
- | |_^ ...ending here: test
+ | |_^ test
"#);
}
--> test.rs:2:10
|
2 | fn foo() {
- | __________^ starting here...
+ | __________^
3 | |
4 | |
5 | | }
- | |___^ ...ending here: test
+ | |___^ test
"#);
}
--> test.rs:3:3
|
3 | X0 Y0
- | ____^__- starting here...
+ | ____^__-
| | ___|
- | || starting here...
+ | ||
4 | || X1 Y1
5 | || X2 Y2
- | ||____^__- ...ending here: `Y` is a good letter too
+ | ||____^__- `Y` is a good letter too
| |____|
- | ...ending here: `X` is a good letter
+ | `X` is a good letter
"#);
}
--> test.rs:3:3
|
3 | X0 Y0
- | ____^__- starting here...
+ | ____^__-
| | ___|
- | || starting here...
+ | ||
4 | || Y1 X1
- | ||____-__^ ...ending here: `X` is a good letter
+ | ||____-__^ `X` is a good letter
| |_____|
- | ...ending here: `Y` is a good letter too
+ | `Y` is a good letter too
"#);
}
--> test.rs:3:6
|
3 | X0 Y0 Z0
- | ______^ starting here...
+ | ______^
4 | | X1 Y1 Z1
- | |_________- starting here...
+ | |_________-
5 | || X2 Y2 Z2
- | ||____^ ...ending here: `X` is a good letter
+ | ||____^ `X` is a good letter
6 | | X3 Y3 Z3
- | |_____- ...ending here: `Y` is a good letter too
+ | |_____- `Y` is a good letter too
"#);
}
--> test.rs:3:3
|
3 | X0 Y0 Z0
- | _____^__-__- starting here...
+ | _____^__-__-
| | ____|__|
- | || ___| starting here...
- | ||| starting here...
+ | || ___|
+ | |||
4 | ||| X1 Y1 Z1
5 | ||| X2 Y2 Z2
- | |||____^__-__- ...ending here: `Z` label
+ | |||____^__-__- `Z` label
| ||____|__|
- | |____| ...ending here: `Y` is a good letter too
- | ...ending here: `X` is a good letter
+ | |____| `Y` is a good letter too
+ | `X` is a good letter
"#);
}
--> test.rs:3:6
|
3 | X0 Y0 Z0
- | ______^ starting here...
+ | ______^
4 | | X1 Y1 Z1
- | |____^_- starting here...
+ | |____^_-
| ||____|
- | | ...ending here: `X` is a good letter
+ | | `X` is a good letter
5 | | X2 Y2 Z2
- | |____-______- ...ending here: `Y` is a good letter too
+ | |____-______- `Y` is a good letter too
| ____|
- | | starting here...
+ | |
6 | | X3 Y3 Z3
- | |________- ...ending here: `Z`
+ | |________- `Z`
"#);
}
vec![
SpanLabel {
start: Position {
- string: "Y0",
+ string: "X0",
count: 1,
},
end: Position {
],
r#"
error: foo
- --> test.rs:3:6
+ --> test.rs:3:3
|
-3 | X0 Y0 Z0
- | ______^ starting here...
+3 | / X0 Y0 Z0
4 | | X1 Y1 Z1
- | |____^ ...ending here: `X` is a good letter
+ | |____^ `X` is a good letter
5 | X2 Y2 Z2
- | ______- starting here...
+ | ______-
6 | | X3 Y3 Z3
- | |__________- ...ending here: `Y` is a good letter too
+ | |__________- `Y` is a good letter too
"#);
}
--> test.rs:3:6
|
3 | X0 Y0 Z0
- | ______^ starting here...
+ | ______^
4 | | X1 Y1 Z1
- | |____^____- starting here...
+ | |____^____-
| ||____|
- | | ...ending here: `X` is a good letter
+ | | `X` is a good letter
5 | | X2 Y2 Z2
6 | | X3 Y3 Z3
- | |___________- ...ending here: `Y` is a good letter too
+ | |___________- `Y` is a good letter too
"#);
}
--> test.rs:3:6
|
3 | X0 Y0 Z0
- | ______^ starting here...
+ | ______^
4 | | X1 Y1 Z1
- | |____^____- starting here...
+ | |____^____-
| ||____|
- | | ...ending here: `X` is a good letter
+ | | `X` is a good letter
5 | | 1
6 | | 2
7 | | 3
... |
15 | | X2 Y2 Z2
16 | | X3 Y3 Z3
- | |___________- ...ending here: `Y` is a good letter too
+ | |___________- `Y` is a good letter too
"#);
}
--> test.rs:3:6
|
3 | X0 Y0 Z0
- | ______^ starting here...
+ | ______^
4 | | 1
5 | | 2
6 | | 3
7 | | X1 Y1 Z1
- | |_________- starting here...
+ | |_________-
8 | || 4
9 | || 5
10 | || 6
11 | || X2 Y2 Z2
- | ||__________- ...ending here: `Z` is a good letter too
+ | ||__________- `Z` is a good letter too
... |
15 | | 10
16 | | X3 Y3 Z3
- | |_______^ ...ending here: `Y` is a good letter
+ | |_______^ `Y` is a good letter
"#);
}
15 | fn renew<'b: 'a>(self) -> &'b mut [T];
| -------------------------------------- definition of `renew` from trait
...
-19 | fn renew<'b: 'a>(self) -> &'b mut [T] where 'a: 'b {
- | _____^ starting here...
+19 | / fn renew<'b: 'a>(self) -> &'b mut [T] where 'a: 'b {
20 | | //~^ ERROR E0276
21 | | &mut self[..]
22 | | }
- | |_____^ ...ending here: impl has extra requirement `'a: 'b`
+ | |_____^ impl has extra requirement `'a: 'b`
error: aborting due to previous error
19 | fn zip<B, U: Iterator<U>>(self, other: U) -> ZipIterator<Self, U>;
| ------------------------------------------------------------------ definition of `zip` from trait
...
-23 | fn zip<B, U: Iterator<B>>(self, other: U) -> ZipIterator<T, U> {
- | _____^ starting here...
+23 | / fn zip<B, U: Iterator<B>>(self, other: U) -> ZipIterator<T, U> {
24 | | //~^ ERROR E0276
25 | | ZipIterator{a: self, b: other}
26 | | }
- | |_____^ ...ending here: impl has extra requirement `U: Iterator<B>`
+ | |_____^ impl has extra requirement `U: Iterator<B>`
error: aborting due to previous error
--> $DIR/issue-40006.rs:11:9
|
11 | impl X {
- | _________^ starting here...
+ | _________^
12 | | Y
- | |____^ ...ending here: missing `fn`, `type`, or `const`
+ | |____^ missing `fn`, `type`, or `const`
error: missing `fn`, `type`, or `const` for trait-item declaration
--> $DIR/issue-40006.rs:17:10
|
17 | trait X {
- | __________^ starting here...
+ | __________^
18 | | X() {}
- | |____^ ...ending here: missing `fn`, `type`, or `const`
+ | |____^ missing `fn`, `type`, or `const`
error: expected `[`, found `#`
--> $DIR/issue-40006.rs:19:17
--> $DIR/issue-40006.rs:19:21
|
19 | fn xxx() { ### }
- | _____________________^ starting here...
+ | _____________________^
20 | | L = M;
- | |____^ ...ending here: missing `fn`, `type`, or `const`
+ | |____^ missing `fn`, `type`, or `const`
error: missing `fn`, `type`, or `const` for trait-item declaration
--> $DIR/issue-40006.rs:20:11
|
20 | L = M;
- | ___________^ starting here...
+ | ___________^
21 | | Z = { 2 + 3 };
- | |____^ ...ending here: missing `fn`, `type`, or `const`
+ | |____^ missing `fn`, `type`, or `const`
error: expected one of `const`, `extern`, `fn`, `type`, `unsafe`, or `}`, found `;`
--> $DIR/issue-40006.rs:21:18
error[E0569]: requires an `unsafe impl` declaration due to `#[may_dangle]` attribute
--> $DIR/dropck-eyepatch-implies-unsafe-impl.rs:32:1
|
-32 | impl<#[may_dangle] A, B: fmt::Debug> Drop for Pt<A, B> {
- | _^ starting here...
+32 | / impl<#[may_dangle] A, B: fmt::Debug> Drop for Pt<A, B> {
33 | | //~^ ERROR requires an `unsafe impl` declaration due to `#[may_dangle]` attribute
34 | |
35 | | // (unsafe to access self.1 due to #[may_dangle] on A)
36 | | fn drop(&mut self) { println!("drop {} {:?}", self.0, self.2); }
37 | | }
- | |_^ ...ending here
+ | |_^
error[E0569]: requires an `unsafe impl` declaration due to `#[may_dangle]` attribute
--> $DIR/dropck-eyepatch-implies-unsafe-impl.rs:38:1
|
-38 | impl<#[may_dangle] 'a, 'b, B: fmt::Debug> Drop for Pr<'a, 'b, B> {
- | _^ starting here...
+38 | / impl<#[may_dangle] 'a, 'b, B: fmt::Debug> Drop for Pr<'a, 'b, B> {
39 | | //~^ ERROR requires an `unsafe impl` declaration due to `#[may_dangle]` attribute
40 | |
41 | | // (unsafe to access self.1 due to #[may_dangle] on 'a)
42 | | fn drop(&mut self) { println!("drop {} {:?}", self.0, self.2); }
43 | | }
- | |_^ ...ending here
+ | |_^
error: aborting due to 2 previous errors
error: reached the type-length limit while instantiating `<T as Foo><(&(&(&(&(&(&(&(&(&(&(&(&(&(&(&(&(&(&(&(), &()), &(&()...`
--> $DIR/issue-37311.rs:23:5
|
-23 | fn recurse(&self) {
- | _____^ starting here...
+23 | / fn recurse(&self) {
24 | | (self, self).recurse();
25 | | }
- | |_____^ ...ending here
+ | |_____^
|
= note: consider adding a `#![type_length_limit="2097152"]` attribute to your crate
--> $DIR/ex1-return-one-existing-name-if-else.rs:11:44
|
11 | fn foo<'a>(x: &'a i32, y: &i32) -> &'a i32 {
- | ____________________________________________^ starting here...
+ | ____________________________________________^
12 | | if x > y { x } else { y }
13 | | }
- | |_^ ...ending here
+ | |_^
note: ...but the borrowed content is only valid for the anonymous lifetime #1 defined on the body at 11:43
--> $DIR/ex1-return-one-existing-name-if-else.rs:11:44
|
11 | fn foo<'a>(x: &'a i32, y: &i32) -> &'a i32 {
- | ____________________________________________^ starting here...
+ | ____________________________________________^
12 | | if x > y { x } else { y }
13 | | }
- | |_^ ...ending here
+ | |_^
error: aborting due to previous error
--> $DIR/ex2a-push-one-existing-name.rs:15:52
|
15 | fn foo<'a>(x: &mut Vec<Ref<'a, i32>>, y: Ref<i32>) {
- | ____________________________________________________^ starting here...
+ | ____________________________________________________^
16 | | x.push(y);
17 | | }
- | |_^ ...ending here
+ | |_^
note: ...does not necessarily outlive the lifetime 'a as defined on the body at 15:51
--> $DIR/ex2a-push-one-existing-name.rs:15:52
|
15 | fn foo<'a>(x: &mut Vec<Ref<'a, i32>>, y: Ref<i32>) {
- | ____________________________________________________^ starting here...
+ | ____________________________________________________^
16 | | x.push(y);
17 | | }
- | |_^ ...ending here
+ | |_^
error: aborting due to previous error
--> $DIR/ex2b-push-no-existing-names.rs:15:44
|
15 | fn foo(x: &mut Vec<Ref<i32>>, y: Ref<i32>) {
- | ____________________________________________^ starting here...
+ | ____________________________________________^
16 | | x.push(y);
17 | | }
- | |_^ ...ending here
+ | |_^
note: ...does not necessarily outlive the anonymous lifetime #2 defined on the body at 15:43
--> $DIR/ex2b-push-no-existing-names.rs:15:44
|
15 | fn foo(x: &mut Vec<Ref<i32>>, y: Ref<i32>) {
- | ____________________________________________^ starting here...
+ | ____________________________________________^
16 | | x.push(y);
17 | | }
- | |_^ ...ending here
+ | |_^
error: aborting due to previous error
--> $DIR/ex2c-push-inference-variable.rs:15:67
|
15 | fn foo<'a, 'b, 'c>(x: &'a mut Vec<Ref<'b, i32>>, y: Ref<'c, i32>) {
- | ___________________________________________________________________^ starting here...
+ | ___________________________________________________________________^
16 | | let z = Ref { data: y.data };
17 | | x.push(z);
18 | | }
- | |_^ ...ending here
+ | |_^
note: ...so that reference does not outlive borrowed content
--> $DIR/ex2c-push-inference-variable.rs:16:25
|
--> $DIR/ex2c-push-inference-variable.rs:15:67
|
15 | fn foo<'a, 'b, 'c>(x: &'a mut Vec<Ref<'b, i32>>, y: Ref<'c, i32>) {
- | ___________________________________________________________________^ starting here...
+ | ___________________________________________________________________^
16 | | let z = Ref { data: y.data };
17 | | x.push(z);
18 | | }
- | |_^ ...ending here
+ | |_^
note: ...so that expression is assignable (expected Ref<'b, _>, found Ref<'_, _>)
--> $DIR/ex2c-push-inference-variable.rs:17:12
|
--> $DIR/ex2d-push-inference-variable-2.rs:15:67
|
15 | fn foo<'a, 'b, 'c>(x: &'a mut Vec<Ref<'b, i32>>, y: Ref<'c, i32>) {
- | ___________________________________________________________________^ starting here...
+ | ___________________________________________________________________^
16 | | let a: &mut Vec<Ref<i32>> = x;
17 | | let b = Ref { data: y.data };
18 | | a.push(b);
19 | | }
- | |_^ ...ending here
+ | |_^
note: ...so that reference does not outlive borrowed content
--> $DIR/ex2d-push-inference-variable-2.rs:17:25
|
--> $DIR/ex2d-push-inference-variable-2.rs:15:67
|
15 | fn foo<'a, 'b, 'c>(x: &'a mut Vec<Ref<'b, i32>>, y: Ref<'c, i32>) {
- | ___________________________________________________________________^ starting here...
+ | ___________________________________________________________________^
16 | | let a: &mut Vec<Ref<i32>> = x;
17 | | let b = Ref { data: y.data };
18 | | a.push(b);
19 | | }
- | |_^ ...ending here
+ | |_^
note: ...so that expression is assignable (expected &mut std::vec::Vec<Ref<'_, i32>>, found &mut std::vec::Vec<Ref<'b, i32>>)
--> $DIR/ex2d-push-inference-variable-2.rs:16:33
|
--> $DIR/ex2e-push-inference-variable-3.rs:15:67
|
15 | fn foo<'a, 'b, 'c>(x: &'a mut Vec<Ref<'b, i32>>, y: Ref<'c, i32>) {
- | ___________________________________________________________________^ starting here...
+ | ___________________________________________________________________^
16 | | let a: &mut Vec<Ref<i32>> = x;
17 | | let b = Ref { data: y.data };
18 | | Vec::push(a, b);
19 | | }
- | |_^ ...ending here
+ | |_^
note: ...so that reference does not outlive borrowed content
--> $DIR/ex2e-push-inference-variable-3.rs:17:25
|
--> $DIR/ex2e-push-inference-variable-3.rs:15:67
|
15 | fn foo<'a, 'b, 'c>(x: &'a mut Vec<Ref<'b, i32>>, y: Ref<'c, i32>) {
- | ___________________________________________________________________^ starting here...
+ | ___________________________________________________________________^
16 | | let a: &mut Vec<Ref<i32>> = x;
17 | | let b = Ref { data: y.data };
18 | | Vec::push(a, b);
19 | | }
- | |_^ ...ending here
+ | |_^
note: ...so that expression is assignable (expected &mut std::vec::Vec<Ref<'_, i32>>, found &mut std::vec::Vec<Ref<'b, i32>>)
--> $DIR/ex2e-push-inference-variable-3.rs:16:33
|
error[E0308]: mismatched types
--> $DIR/abridged.rs:42:5
|
-42 | X {
- | _____^ starting here...
+42 | / X {
43 | | x: X {
44 | | x: "".to_string(),
45 | | y: 2,
46 | | },
47 | | y: 3,
48 | | }
- | |_____^ ...ending here: expected struct `std::string::String`, found integral variable
+ | |_____^ expected struct `std::string::String`, found integral variable
|
= note: expected type `X<X<_, std::string::String>, std::string::String>`
found type `X<X<_, {integer}>, {integer}>`
error[E0308]: mismatched types
--> $DIR/abridged.rs:52:5
|
-52 | X {
- | _____^ starting here...
+52 | / X {
53 | | x: X {
54 | | x: "".to_string(),
55 | | y: 2,
56 | | },
57 | | y: "".to_string(),
58 | | }
- | |_____^ ...ending here: expected struct `std::string::String`, found integral variable
+ | |_____^ expected struct `std::string::String`, found integral variable
|
= note: expected type `X<X<_, std::string::String>, _>`
found type `X<X<_, {integer}>, _>`
--> $DIR/main.rs:12:18
|
12 | let x: u32 = (
- | __________________^ starting here...
+ | __________________^
13 | | );
- | |_____^ ...ending here: expected u32, found ()
+ | |_____^ expected u32, found ()
|
= note: expected type `u32`
found type `()`
error[E0046]: not all trait items implemented, missing: `CONSTANT`, `Type`, `method`
--> $DIR/m2.rs:20:1
|
-20 | impl m1::X for X {
- | _^ starting here...
+20 | / impl m1::X for X {
21 | | }
- | |_^ ...ending here: missing `CONSTANT`, `Type`, `method` in implementation
+ | |_^ missing `CONSTANT`, `Type`, `method` in implementation
|
= note: `CONSTANT` from trait: `const CONSTANT: u32;`
= note: `Type` from trait: `type Type;`
16 | fn bar(&self);
| -------------- `bar` from trait
...
-22 | impl Foo for FooConstForMethod {
- | _^ starting here...
+22 | / impl Foo for FooConstForMethod {
23 | | //~^ ERROR E0046
24 | | //~| NOTE missing `bar` in implementation
25 | | const bar: u64 = 1;
... |
28 | | const MY_CONST: u32 = 1;
29 | | }
- | |_^ ...ending here: missing `bar` in implementation
+ | |_^ missing `bar` in implementation
error[E0324]: item `MY_CONST` is an associated method, which doesn't match its trait `Foo`
--> $DIR/impl-wrong-item-for-trait.rs:37:5
17 | const MY_CONST: u32;
| -------------------- `MY_CONST` from trait
...
-33 | impl Foo for FooMethodForConst {
- | _^ starting here...
+33 | / impl Foo for FooMethodForConst {
34 | | //~^ ERROR E0046
35 | | //~| NOTE missing `MY_CONST` in implementation
36 | | fn bar(&self) {}
... |
39 | | //~| NOTE does not match trait
40 | | }
- | |_^ ...ending here: missing `MY_CONST` in implementation
+ | |_^ missing `MY_CONST` in implementation
error[E0325]: item `bar` is an associated type, which doesn't match its trait `Foo`
--> $DIR/impl-wrong-item-for-trait.rs:47:5
16 | fn bar(&self);
| -------------- `bar` from trait
...
-44 | impl Foo for FooTypeForMethod {
- | _^ starting here...
+44 | / impl Foo for FooTypeForMethod {
45 | | //~^ ERROR E0046
46 | | //~| NOTE missing `bar` in implementation
47 | | type bar = u64;
... |
50 | | const MY_CONST: u32 = 1;
51 | | }
- | |_^ ...ending here: missing `bar` in implementation
+ | |_^ missing `bar` in implementation
error[E0046]: not all trait items implemented, missing: `fmt`
--> $DIR/impl-wrong-item-for-trait.rs:53:1
|
-53 | impl Debug for FooTypeForMethod {
- | _^ starting here...
+53 | / impl Debug for FooTypeForMethod {
54 | | }
- | |_^ ...ending here: missing `fmt` in implementation
+ | |_^ missing `fmt` in implementation
|
= note: `fmt` from trait: `fn(&Self, &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error>`
error[E0046]: not all trait items implemented, missing: `Item`
--> $DIR/issue-23729.rs:20:9
|
-20 | impl Iterator for Recurrence {
- | _________^ starting here...
+20 | / impl Iterator for Recurrence {
21 | | //~^ ERROR E0046
22 | | //~| NOTE missing `Item` in implementation
23 | | //~| NOTE `Item` from trait: `type Item;`
... |
36 | | }
37 | | }
- | |_________^ ...ending here: missing `Item` in implementation
+ | |_________^ missing `Item` in implementation
|
= note: `Item` from trait: `type Item;`
error[E0046]: not all trait items implemented, missing: `Output`
--> $DIR/issue-23827.rs:36:1
|
-36 | impl<C: Component> FnOnce<(C,)> for Prototype {
- | _^ starting here...
+36 | / impl<C: Component> FnOnce<(C,)> for Prototype {
37 | | //~^ ERROR E0046
38 | | //~| NOTE missing `Output` in implementation
39 | | //~| NOTE `Output` from trait: `type Output;`
... |
42 | | }
43 | | }
- | |_^ ...ending here: missing `Output` in implementation
+ | |_^ missing `Output` in implementation
|
= note: `Output` from trait: `type Output;`
error[E0046]: not all trait items implemented, missing: `Target`
--> $DIR/issue-24356.rs:30:9
|
-30 | impl Deref for Thing {
- | _________^ starting here...
+30 | / impl Deref for Thing {
31 | | //~^ ERROR E0046
32 | | //~| NOTE missing `Target` in implementation
33 | | //~| NOTE `Target` from trait: `type Target;`
34 | | fn deref(&self) -> i8 { self.0 }
35 | | }
- | |_________^ ...ending here: missing `Target` in implementation
+ | |_________^ missing `Target` in implementation
|
= note: `Target` from trait: `type Target;`
note: candidate #1 is defined in an impl for the type `Myisize`
--> $DIR/issue-7575.rs:51:5
|
-51 | fn fff(i: isize) -> isize { //~ NOTE candidate
- | _____^ starting here...
+51 | / fn fff(i: isize) -> isize { //~ NOTE candidate
52 | | i
53 | | }
- | |_____^ ...ending here
+ | |_____^
error: no method named `is_str` found for type `T` in the current scope
--> $DIR/issue-7575.rs:85:7
note: candidate #1 is defined in the trait `ManyImplTrait`
--> $DIR/issue-7575.rs:57:5
|
-57 | fn is_str() -> bool { //~ NOTE candidate
- | _____^ starting here...
+57 | / fn is_str() -> bool { //~ NOTE candidate
58 | | false
59 | | }
- | |_____^ ...ending here
+ | |_____^
= help: to disambiguate the method call, write `ManyImplTrait::is_str(t)` instead
= help: items from traits can only be used if the trait is implemented and in scope; the following trait defines an item `is_str`, perhaps you need to implement it:
= help: candidate #1: `ManyImplTrait`
error: unnecessary `unsafe` block
--> $DIR/lint-unused-unsafe.rs:33:9
|
-33 | unsafe { //~ ERROR: unnecessary `unsafe` block
- | _________^ starting here...
+33 | / unsafe { //~ ERROR: unnecessary `unsafe` block
34 | | unsf()
35 | | }
- | |_________^ ...ending here: unnecessary `unsafe` block
+ | |_________^ unnecessary `unsafe` block
|
note: because it's nested under this `unsafe` block
--> $DIR/lint-unused-unsafe.rs:32:5
|
-32 | unsafe { // don't put the warning here
- | _____^ starting here...
+32 | / unsafe { // don't put the warning here
33 | | unsafe { //~ ERROR: unnecessary `unsafe` block
34 | | unsf()
35 | | }
36 | | }
- | |_____^ ...ending here
+ | |_____^
error: unnecessary `unsafe` block
--> $DIR/lint-unused-unsafe.rs:39:5
|
-39 | unsafe { //~ ERROR: unnecessary `unsafe` block
- | _____^ starting here...
+39 | / unsafe { //~ ERROR: unnecessary `unsafe` block
40 | | unsafe { //~ ERROR: unnecessary `unsafe` block
41 | | unsf()
42 | | }
43 | | }
- | |_____^ ...ending here: unnecessary `unsafe` block
+ | |_____^ unnecessary `unsafe` block
|
note: because it's nested under this `unsafe` fn
--> $DIR/lint-unused-unsafe.rs:38:1
|
-38 | unsafe fn bad7() {
- | _^ starting here...
+38 | / unsafe fn bad7() {
39 | | unsafe { //~ ERROR: unnecessary `unsafe` block
40 | | unsafe { //~ ERROR: unnecessary `unsafe` block
41 | | unsf()
42 | | }
43 | | }
44 | | }
- | |_^ ...ending here
+ | |_^
error: unnecessary `unsafe` block
--> $DIR/lint-unused-unsafe.rs:40:9
|
-40 | unsafe { //~ ERROR: unnecessary `unsafe` block
- | _________^ starting here...
+40 | / unsafe { //~ ERROR: unnecessary `unsafe` block
41 | | unsf()
42 | | }
- | |_________^ ...ending here: unnecessary `unsafe` block
+ | |_________^ unnecessary `unsafe` block
|
note: because it's nested under this `unsafe` fn
--> $DIR/lint-unused-unsafe.rs:38:1
|
-38 | unsafe fn bad7() {
- | _^ starting here...
+38 | / unsafe fn bad7() {
39 | | unsafe { //~ ERROR: unnecessary `unsafe` block
40 | | unsafe { //~ ERROR: unnecessary `unsafe` block
41 | | unsf()
42 | | }
43 | | }
44 | | }
- | |_^ ...ending here
+ | |_^
error: aborting due to 8 previous errors
error[E0072]: recursive type `ListNode` has infinite size
--> $DIR/multiline-span-E0072.rs:12:1
|
-12 | struct
- | _^ starting here...
+12 | / struct
13 | | ListNode
14 | | {
15 | | head: u8,
16 | | tail: Option<ListNode>,
17 | | }
- | |_^ ...ending here: recursive type has infinite size
+ | |_^ recursive type has infinite size
|
= help: insert indirection (e.g., a `Box`, `Rc`, or `&`) at some point to make `ListNode` representable
--> $DIR/multiline-span-simple.rs:23:9
|
23 | foo(1 as u32 +
- | _________^ starting here...
+ | _________^
24 | |
25 | | bar(x,
26 | |
27 | | y),
- | |______________^ ...ending here: the trait `std::ops::Add<()>` is not implemented for `u32`
+ | |______________^ the trait `std::ops::Add<()>` is not implemented for `u32`
|
= note: no implementation for `u32 + ()`
error[E0282]: type annotations needed
--> $DIR/issue-40294.rs:15:1
|
-15 | fn foo<'a,'b,T>(x: &'a T, y: &'b T)
- | _^ starting here...
+15 | / fn foo<'a,'b,T>(x: &'a T, y: &'b T)
16 | | where &'a T : Foo,
17 | | &'b T : Foo
18 | | {
19 | | x.foo();
20 | | y.foo();
21 | | }
- | |_^ ...ending here: cannot infer type for `&'a T`
+ | |_^ cannot infer type for `&'a T`
error: aborting due to previous error
projects / rust.git / commitdiff