user0/rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge branch 'master' of github.com:theypsilon/rust

Browse source
This commit is contained in:
José manuel Barroso Galindo 2016-08-10 00:35:16 +07:00
commit 71a34d728b
84 changed files with 689 additions and 191 deletions
Download patch file Download diff file Expand all files Collapse all files

8
src/libcollections/slice.rs
View file

@ -973,8 +973,8 @@ impl<T> [T] {
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn binary_search_by<F>(&self, f: F) -> Result<usize, usize>
where F: FnMut(&T) -> Ordering
pub fn binary_search_by<'a, F>(&'a self, f: F) -> Result<usize, usize>
where F: FnMut(&'a T) -> Ordering
{
core_slice::SliceExt::binary_search_by(self, f)
}
@ -1009,8 +1009,8 @@ impl<T> [T] {
/// ```
#[stable(feature = "slice_binary_search_by_key", since = "1.10.0")]
#[inline]
pub fn binary_search_by_key<B, F>(&self, b: &B, f: F) -> Result<usize, usize>
where F: FnMut(&T) -> B,
pub fn binary_search_by_key<'a, B, F>(&'a self, b: &B, f: F) -> Result<usize, usize>
where F: FnMut(&'a T) -> B,
B: Ord
{
core_slice::SliceExt::binary_search_by_key(self, b, f)

21
src/libcollections/string.rs
View file

@ -1874,6 +1874,27 @@ impl<'a> From<String> for Cow<'a, str> {
}
}
#[stable(feature = "cow_str_from_iter", since = "1.12.0")]
impl<'a> FromIterator<char> for Cow<'a, str> {
fn from_iter<I: IntoIterator<Item = char>>(it: I) -> Cow<'a, str> {
Cow::Owned(FromIterator::from_iter(it))
}
}
#[stable(feature = "cow_str_from_iter", since = "1.12.0")]
impl<'a, 'b> FromIterator<&'b str> for Cow<'a, str> {
fn from_iter<I: IntoIterator<Item = &'b str>>(it: I) -> Cow<'a, str> {
Cow::Owned(FromIterator::from_iter(it))
}
}
#[stable(feature = "cow_str_from_iter", since = "1.12.0")]
impl<'a> FromIterator<String> for Cow<'a, str> {
fn from_iter<I: IntoIterator<Item = String>>(it: I) -> Cow<'a, str> {
Cow::Owned(FromIterator::from_iter(it))
}
}
#[stable(feature = "rust1", since = "1.0.0")]
impl Into<Vec<u8>> for String {
fn into(self) -> Vec<u8> {

125
src/libcore/cell.rs
View file

@ -147,10 +147,13 @@
use clone::Clone;
use cmp::{PartialEq, Eq, PartialOrd, Ord, Ordering};
use default::Default;
use marker::{Copy, Send, Sync, Sized, Unsize};
use fmt::{self, Debug, Display};
use marker::{Copy, PhantomData, Send, Sync, Sized, Unsize};
use ops::{Deref, DerefMut, Drop, FnOnce, CoerceUnsized};
use option::Option;
use option::Option::{None, Some};
use result::Result;
use result::Result::{Ok, Err};
/// A mutable memory location that admits only `Copy` data.
///
@ -347,6 +350,46 @@ pub enum BorrowState {
Unused,
}
/// An error returned by [`RefCell::try_borrow`](struct.RefCell.html#method.try_borrow).
#[unstable(feature = "try_borrow", issue = "35070")]
pub struct BorrowError<'a, T: 'a + ?Sized> {
marker: PhantomData<&'a RefCell<T>>,
}
#[unstable(feature = "try_borrow", issue = "35070")]
impl<'a, T: ?Sized> Debug for BorrowError<'a, T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_struct("BorrowError").finish()
}
}
#[unstable(feature = "try_borrow", issue = "35070")]
impl<'a, T: ?Sized> Display for BorrowError<'a, T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
Display::fmt("already mutably borrowed", f)
}
}
/// An error returned by [`RefCell::try_borrow_mut`](struct.RefCell.html#method.try_borrow_mut).
#[unstable(feature = "try_borrow", issue = "35070")]
pub struct BorrowMutError<'a, T: 'a + ?Sized> {
marker: PhantomData<&'a RefCell<T>>,
}
#[unstable(feature = "try_borrow", issue = "35070")]
impl<'a, T: ?Sized> Debug for BorrowMutError<'a, T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_struct("BorrowMutError").finish()
}
}
#[unstable(feature = "try_borrow", issue = "35070")]
impl<'a, T: ?Sized> Display for BorrowMutError<'a, T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
Display::fmt("already borrowed", f)
}
}
// Values [1, MAX-1] represent the number of `Ref` active
// (will not outgrow its range since `usize` is the size of the address space)
type BorrowFlag = usize;
@ -432,7 +475,8 @@ impl<T: ?Sized> RefCell<T> {
///
/// # Panics
///
/// Panics if the value is currently mutably borrowed.
/// Panics if the value is currently mutably borrowed. For a non-panicking variant, use
/// [`try_borrow`](#method.try_borrow).
///
/// # Examples
///
@ -463,12 +507,45 @@ impl<T: ?Sized> RefCell<T> {
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn borrow(&self) -> Ref<T> {
self.try_borrow().expect("already mutably borrowed")
}
/// Immutably borrows the wrapped value, returning an error if the value is currently mutably
/// borrowed.
///
/// The borrow lasts until the returned `Ref` exits scope. Multiple immutable borrows can be
/// taken out at the same time.
///
/// This is the non-panicking variant of [`borrow`](#method.borrow).
///
/// # Examples
///
/// ```
/// #![feature(try_borrow)]
///
/// use std::cell::RefCell;
///
/// let c = RefCell::new(5);
///
/// {
/// let m = c.borrow_mut();
/// assert!(c.try_borrow().is_err());
/// }
///
/// {
/// let m = c.borrow();
/// assert!(c.try_borrow().is_ok());
/// }
/// ```
#[unstable(feature = "try_borrow", issue = "35070")]
#[inline]
pub fn try_borrow(&self) -> Result<Ref<T>, BorrowError<T>> {
match BorrowRef::new(&self.borrow) {
Some(b) => Ref {
Some(b) => Ok(Ref {
value: unsafe { &*self.value.get() },
borrow: b,
},
None => panic!("RefCell<T> already mutably borrowed"),
}),
None => Err(BorrowError { marker: PhantomData }),
}
}
@ -479,7 +556,8 @@ impl<T: ?Sized> RefCell<T> {
///
/// # Panics
///
/// Panics if the value is currently borrowed.
/// Panics if the value is currently borrowed. For a non-panicking variant, use
/// [`try_borrow_mut`](#method.try_borrow_mut).
///
/// # Examples
///
@ -511,12 +589,41 @@ impl<T: ?Sized> RefCell<T> {
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn borrow_mut(&self) -> RefMut<T> {
self.try_borrow_mut().expect("already borrowed")
}
/// Mutably borrows the wrapped value, returning an error if the value is currently borrowed.
///
/// The borrow lasts until the returned `RefMut` exits scope. The value cannot be borrowed
/// while this borrow is active.
///
/// This is the non-panicking variant of [`borrow_mut`](#method.borrow_mut).
///
/// # Examples
///
/// ```
/// #![feature(try_borrow)]
///
/// use std::cell::RefCell;
///
/// let c = RefCell::new(5);
///
/// {
/// let m = c.borrow();
/// assert!(c.try_borrow_mut().is_err());
/// }
///
/// assert!(c.try_borrow_mut().is_ok());
/// ```
#[unstable(feature = "try_borrow", issue = "35070")]
#[inline]
pub fn try_borrow_mut(&self) -> Result<RefMut<T>, BorrowMutError<T>> {
match BorrowRefMut::new(&self.borrow) {
Some(b) => RefMut {
Some(b) => Ok(RefMut {
value: unsafe { &mut *self.value.get() },
borrow: b,
},
None => panic!("RefCell<T> already borrowed"),
}),
None => Err(BorrowMutError { marker: PhantomData }),
}
}

2
src/libcore/iter/traits.rs
View file

@ -548,7 +548,7 @@ pub trait ExactSizeIterator: Iterator {
/// assert_eq!(one_element.next(), None);
/// ```
#[inline]
#[unstable(feature = "exact_size_is_empty", issue = "0")]
#[unstable(feature = "exact_size_is_empty", issue = "35428")]
fn is_empty(&self) -> bool {
self.len() == 0
}

16
src/libcore/slice.rs
View file

@ -105,11 +105,11 @@ pub trait SliceExt {
fn binary_search(&self, x: &Self::Item) -> Result<usize, usize>
where Self::Item: Ord;
#[stable(feature = "core", since = "1.6.0")]
fn binary_search_by<F>(&self, f: F) -> Result<usize, usize>
where F: FnMut(&Self::Item) -> Ordering;
fn binary_search_by<'a, F>(&'a self, f: F) -> Result<usize, usize>
where F: FnMut(&'a Self::Item) -> Ordering;
#[stable(feature = "slice_binary_search_by_key", since = "1.10.0")]
fn binary_search_by_key<B, F>(&self, b: &B, f: F) -> Result<usize, usize>
where F: FnMut(&Self::Item) -> B,
fn binary_search_by_key<'a, B, F>(&'a self, b: &B, f: F) -> Result<usize, usize>
where F: FnMut(&'a Self::Item) -> B,
B: Ord;
#[stable(feature = "core", since = "1.6.0")]
fn len(&self) -> usize;
@ -301,8 +301,8 @@ impl<T> SliceExt for [T] {
self as *const [T] as *const T
}
fn binary_search_by<F>(&self, mut f: F) -> Result<usize, usize> where
F: FnMut(&T) -> Ordering
fn binary_search_by<'a, F>(&'a self, mut f: F) -> Result<usize, usize>
where F: FnMut(&'a T) -> Ordering
{
let mut base = 0usize;
let mut s = self;
@ -514,8 +514,8 @@ impl<T> SliceExt for [T] {
}
#[inline]
fn binary_search_by_key<B, F>(&self, b: &B, mut f: F) -> Result<usize, usize>
where F: FnMut(&Self::Item) -> B,
fn binary_search_by_key<'a, B, F>(&'a self, b: &B, mut f: F) -> Result<usize, usize>
where F: FnMut(&'a Self::Item) -> B,
B: Ord
{
self.binary_search_by(|k| f(k).cmp(b))

10
src/librustc/traits/error_reporting.rs
View file

@ -870,10 +870,12 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
fn need_type_info(&self, span: Span, ty: Ty<'tcx>) {
span_err!(self.tcx.sess, span, E0282,
"unable to infer enough type information about `{}`; \
type annotations or generic parameter binding required",
ty);
let mut err = struct_span_err!(self.tcx.sess, span, E0282,
"unable to infer enough type information about `{}`",
ty);
err.note("type annotations or generic parameter binding required");
err.span_label(span, &format!("cannot infer type for `{}`", ty));
err.emit()
}
fn note_obligation_cause<T>(&self,

7
src/librustc_const_eval/check_match.rs
View file

@ -235,7 +235,12 @@ fn check_expr(cx: &mut MatchCheckCtxt, ex: &hir::Expr) {
.flat_map(|arm| &arm.0)
.map(|pat| vec![wrap_pat(cx, &pat)])
.collect();
check_exhaustive(cx, ex.span, &matrix, source);
let match_span = Span {
lo: ex.span.lo,
hi: scrut.span.hi,
expn_id: ex.span.expn_id
};
check_exhaustive(cx, match_span, &matrix, source);
},
_ => ()
}

6
src/librustc_mir/transform/qualify_consts.rs
View file

@ -686,8 +686,10 @@ impl<'a, 'tcx> Visitor<'tcx> for Qualifier<'a, 'tcx, 'tcx> {
Rvalue::Box(_) => {
self.add(Qualif::NOT_CONST);
if self.mode != Mode::Fn {
span_err!(self.tcx.sess, self.span, E0010,
"allocations are not allowed in {}s", self.mode);
struct_span_err!(self.tcx.sess, self.span, E0010,
"allocations are not allowed in {}s", self.mode)
.span_label(self.span, &format!("allocation not allowed in {}s", self.mode))
.emit();
}
}

6
src/librustc_resolve/lib.rs
View file

@ -3375,7 +3375,11 @@ impl<'a> Resolver<'a> {
(true, _) | (_, true) => struct_span_err!(self.session, span, E0260, "{}", msg),
_ => match (old_binding.is_import(), binding.is_import()) {
(false, false) => struct_span_err!(self.session, span, E0428, "{}", msg),
(true, true) => struct_span_err!(self.session, span, E0252, "{}", msg),
(true, true) => {
let mut e = struct_span_err!(self.session, span, E0252, "{}", msg);
e.span_label(span, &format!("already imported"));
e
},
_ => {
let mut e = struct_span_err!(self.session, span, E0255, "{}", msg);
e.span_label(span, &format!("`{}` was already imported", name));

46
src/librustc_typeck/astconv.rs
View file

@ -1215,10 +1215,12 @@ impl<'o, 'gcx: 'tcx, 'tcx> AstConv<'gcx, 'tcx>+'o {
type_str: &str,
trait_str: &str,
name: &str) {
span_err!(self.tcx().sess, span, E0223,
"ambiguous associated type; specify the type using the syntax \
`<{} as {}>::{}`",
type_str, trait_str, name);
struct_span_err!(self.tcx().sess, span, E0223, "ambiguous associated type")
.span_label(span, &format!("ambiguous associated type"))
.note(&format!("specify the type using the syntax `<{} as {}>::{}`",
type_str, trait_str, name))
.emit();
}
// Search for a bound on a type parameter which includes the associated item
@ -2095,8 +2097,11 @@ impl<'o, 'gcx: 'tcx, 'tcx> AstConv<'gcx, 'tcx>+'o {
if !trait_bounds.is_empty() {
let b = &trait_bounds[0];
span_err!(self.tcx().sess, b.trait_ref.path.span, E0225,
"only the builtin traits can be used as closure or object bounds");
let span = b.trait_ref.path.span;
struct_span_err!(self.tcx().sess, span, E0225,
"only the builtin traits can be used as closure or object bounds")
.span_label(span, &format!("non-builtin trait used as bounds"))
.emit();
}
let region_bound =
@ -2255,20 +2260,27 @@ fn check_type_argument_count(tcx: TyCtxt, span: Span, supplied: usize,
} else {
"expected"
};
span_err!(tcx.sess, span, E0243,
"wrong number of type arguments: {} {}, found {}",
expected, required, supplied);
struct_span_err!(tcx.sess, span, E0243, "wrong number of type arguments")
.span_label(
span,
&format!("{} {} type arguments, found {}", expected, required, supplied)
)
.emit();
} else if supplied > accepted {
let expected = if required < accepted {
"expected at most"
let expected = if required == 0 {
"expected no".to_string()
} else if required < accepted {
format!("expected at most {}", accepted)
} else {
"expected"
format!("expected {}", accepted)
};
span_err!(tcx.sess, span, E0244,
"wrong number of type arguments: {} {}, found {}",
expected,
accepted,
supplied);
struct_span_err!(tcx.sess, span, E0244, "wrong number of type arguments")
.span_label(
span,
&format!("{} type arguments, found {}", expected, supplied)
)
.emit();
}
}

21
src/librustc_typeck/check/_match.rs
View file

@ -93,13 +93,12 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
end.span
};
// Note: spacing here is intentional, we want a space before "start" and "end".
span_err!(tcx.sess, span, E0029,
"only char and numeric types are allowed in range patterns\n \
start type: {}\n end type: {}",
self.ty_to_string(lhs_ty),
self.ty_to_string(rhs_ty)
);
struct_span_err!(tcx.sess, span, E0029,
"only char and numeric types are allowed in range patterns")
.span_label(span, &format!("ranges require char or numeric types"))
.note(&format!("start type: {}", self.ty_to_string(lhs_ty)))
.note(&format!("end type: {}", self.ty_to_string(rhs_ty)))
.emit();
return;
}
@ -700,9 +699,11 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
for field in variant.fields
.iter()
.filter(|field| !used_fields.contains_key(&field.name)) {
span_err!(tcx.sess, span, E0027,
"pattern does not mention field `{}`",
field.name);
struct_span_err!(tcx.sess, span, E0027,
"pattern does not mention field `{}`",
field.name)
.span_label(span, &format!("missing field `{}`", field.name))
.emit();
}
}
}

4
src/librustc_typeck/check/callee.rs
View file

@ -28,7 +28,9 @@ use rustc::hir;
/// method that is called)
pub fn check_legal_trait_for_method_call(ccx: &CrateCtxt, span: Span, trait_id: DefId) {
if ccx.tcx.lang_items.drop_trait() == Some(trait_id) {
span_err!(ccx.tcx.sess, span, E0040, "explicit use of destructor method");
struct_span_err!(ccx.tcx.sess, span, E0040, "explicit use of destructor method")
.span_label(span, &format!("call to destructor method"))
.emit();
}
}

18
src/librustc_typeck/check/compare_method.rs
View file

@ -59,19 +59,33 @@ pub fn compare_impl_method<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>,
(&ty::ExplicitSelfCategory::Static,
&ty::ExplicitSelfCategory::Static) => {}
(&ty::ExplicitSelfCategory::Static, _) => {
span_err!(tcx.sess, impl_m_span, E0185,
let mut err = struct_span_err!(tcx.sess, impl_m_span, E0185,
"method `{}` has a `{}` declaration in the impl, \
but not in the trait",
trait_m.name,
impl_m.explicit_self);
err.span_label(impl_m_span, &format!("`{}` used in impl",
impl_m.explicit_self));
if let Some(span) = tcx.map.span_if_local(trait_m.def_id) {
err.span_label(span, &format!("trait declared without `{}`",
impl_m.explicit_self));
}
err.emit();
return;
}
(_, &ty::ExplicitSelfCategory::Static) => {
span_err!(tcx.sess, impl_m_span, E0186,
let mut err = struct_span_err!(tcx.sess, impl_m_span, E0186,
"method `{}` has a `{}` declaration in the trait, \
but not in the impl",
trait_m.name,
trait_m.explicit_self);
err.span_label(impl_m_span, &format!("expected `{}` in impl",
trait_m.explicit_self));
if let Some(span) = tcx.map.span_if_local(trait_m.def_id) {
err.span_label(span, & format!("`{}` used in trait",
trait_m.explicit_self));
}
err.emit();
return;
}
_ => {

44
src/librustc_typeck/check/method/suggest.rs
View file

@ -162,26 +162,34 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
},
rcvr_ty);
// If the item has the name of a field, give a help note
if let (&ty::TyStruct(def, substs), Some(expr)) = (&rcvr_ty.sty, rcvr_expr) {
if let Some(field) = def.struct_variant().find_field_named(item_name) {
let expr_string = match tcx.sess.codemap().span_to_snippet(expr.span) {
Ok(expr_string) => expr_string,
_ => "s".into() // Default to a generic placeholder for the
// expression when we can't generate a string
// snippet
};
// If the method name is the name of a field with a function or closure type,
// give a helping note that it has to be called as (x.f)(...).
if let Some(expr) = rcvr_expr {
for (ty, _) in self.autoderef(span, rcvr_ty) {
if let ty::TyStruct(def, substs) = ty.sty {
if let Some(field) = def.struct_variant().find_field_named(item_name) {
let snippet = tcx.sess.codemap().span_to_snippet(expr.span);
let expr_string = match snippet {
Ok(expr_string) => expr_string,
_ => "s".into() // Default to a generic placeholder for the
// expression when we can't generate a
// string snippet
};
let field_ty = field.ty(tcx, substs);
let field_ty = field.ty(tcx, substs);
if self.is_fn_ty(&field_ty, span) {
err.span_note(span,
&format!("use `({0}.{1})(...)` if you meant to call \
the function stored in the `{1}` field",
expr_string, item_name));
} else {
err.span_note(span, &format!("did you mean to write `{0}.{1}`?",
expr_string, item_name));
if self.is_fn_ty(&field_ty, span) {
err.span_note(span, &format!(
"use `({0}.{1})(...)` if you meant to call the function \
stored in the `{1}` field",
expr_string, item_name));
} else {
err.span_note(span, &format!(
"did you mean to write `{0}.{1}`?",
expr_string, item_name));
}
break;
}
}
}
}

7
src/librustc_typeck/check/mod.rs
View file

@ -1136,11 +1136,16 @@ fn check_impl_items_against_trait<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>,
}
if !missing_items.is_empty() {
span_err!(tcx.sess, impl_span, E0046,
struct_span_err!(tcx.sess, impl_span, E0046,
"not all trait items implemented, missing: `{}`",
missing_items.iter()
.map(|name| name.to_string())
.collect::<Vec<_>>().join("`, `"))
.span_label(impl_span, &format!("missing `{}` in implementation",
missing_items.iter()
.map(|name| name.to_string())
.collect::<Vec<_>>().join("`, `"))
).emit();
}
if !invalidated_items.is_empty() {

14
src/librustc_typeck/check/writeback.rs
View file

@ -441,13 +441,19 @@ impl<'cx, 'gcx, 'tcx> Resolver<'cx, 'gcx, 'tcx> {
if !self.tcx.sess.has_errors() {
match self.reason {
ResolvingExpr(span) => {
span_err!(self.tcx.sess, span, E0101,
"cannot determine a type for this expression: {}", e);
struct_span_err!(
self.tcx.sess, span, E0101,
"cannot determine a type for this expression: {}", e)
.span_label(span, &format!("cannot resolve type of expression"))
.emit();
}
ResolvingLocal(span) => {
span_err!(self.tcx.sess, span, E0102,
"cannot determine a type for this local variable: {}", e);
struct_span_err!(
self.tcx.sess, span, E0102,
"cannot determine a type for this local variable: {}", e)
.span_label(span, &format!("cannot resolve type of variable"))
.emit();
}
ResolvingPattern(span) => {

36
src/librustc_typeck/coherence/mod.rs
View file

@ -311,24 +311,36 @@ impl<'a, 'gcx, 'tcx> CoherenceChecker<'a, 'gcx, 'tcx> {
match param_env.can_type_implement_copy(tcx, self_type, span) {
Ok(()) => {}
Err(CopyImplementationError::InfrigingField(name)) => {
span_err!(tcx.sess, span, E0204,
"the trait `Copy` may not be \
implemented for this type; field \
`{}` does not implement `Copy`",
name)
struct_span_err!(tcx.sess, span, E0204,
"the trait `Copy` may not be implemented for \
this type")
.span_label(span, &format!(
"field `{}` does not implement `Copy`", name)
)
.emit()
}
Err(CopyImplementationError::InfrigingVariant(name)) => {
span_err!(tcx.sess, span, E0205,
struct_span_err!(tcx.sess, span, E0205,
"the trait `Copy` may not be \
implemented for this type; variant \
implemented for this type")
.span_label(span, &format!("variant \
`{}` does not implement `Copy`",
name)
name))
.emit()
}
Err(CopyImplementationError::NotAnAdt) => {
span_err!(tcx.sess, span, E0206,
"the trait `Copy` may not be implemented \
for this type; type is not a structure or \
enumeration")
let item = tcx.map.expect_item(impl_node_id);
let span = if let ItemImpl(_, _, _, _, ref ty, _) = item.node {
ty.span
} else {
span
};
struct_span_err!(tcx.sess, span, E0206,
"the trait `Copy` may not be implemented for this type")
.span_label(span, &format!("type is not a structure or enumeration"))
.emit();
}
Err(CopyImplementationError::HasDestructor) => {
span_err!(tcx.sess, span, E0184,

30
src/librustc_typeck/coherence/orphan.rs
View file

@ -33,10 +33,12 @@ struct OrphanChecker<'cx, 'tcx:'cx> {
impl<'cx, 'tcx> OrphanChecker<'cx, 'tcx> {
fn check_def_id(&self, item: &hir::Item, def_id: DefId) {
if def_id.krate != LOCAL_CRATE {
span_err!(self.tcx.sess, item.span, E0116,
struct_span_err!(self.tcx.sess, item.span, E0116,
"cannot define inherent `impl` for a type outside of the \
crate where the type is defined; define and implement \
a trait or new type instead");
crate where the type is defined")
.span_label(item.span, &format!("impl for type defined outside of crate."))
.span_note(item.span, &format!("define and implement a trait or new type instead"))
.emit();
}
}
@ -66,7 +68,7 @@ impl<'cx, 'tcx> OrphanChecker<'cx, 'tcx> {
fn check_item(&self, item: &hir::Item) {
let def_id = self.tcx.map.local_def_id(item.id);
match item.node {
hir::ItemImpl(_, _, _, None, _, _) => {
hir::ItemImpl(_, _, _, None, ref ty, _) => {
// For inherent impls, self type must be a nominal type
// defined in this crate.
debug!("coherence2::orphan check: inherent impl {}",
@ -209,11 +211,11 @@ impl<'cx, 'tcx> OrphanChecker<'cx, 'tcx> {
return;
}
_ => {
struct_span_err!(self.tcx.sess, item.span, E0118,
struct_span_err!(self.tcx.sess, ty.span, E0118,
"no base type found for inherent implementation")
.span_help(item.span,
"either implement a trait on it or create a newtype to wrap it \
instead")
.span_label(ty.span, &format!("impl requires a base type"))
.note(&format!("either implement a trait on it or create a newtype \
to wrap it instead"))
.emit();
return;
}
@ -228,12 +230,14 @@ impl<'cx, 'tcx> OrphanChecker<'cx, 'tcx> {
match traits::orphan_check(self.tcx, def_id) {
Ok(()) => { }
Err(traits::OrphanCheckErr::NoLocalInputType) => {
span_err!(
struct_span_err!(
self.tcx.sess, item.span, E0117,
"the impl does not reference any \
types defined in this crate; \
only traits defined in the current crate can be \
implemented for arbitrary types");
"only traits defined in the current crate can be \
implemented for arbitrary types")
.span_label(item.span, &format!("impl doesn't use types inside crate"))
.note(&format!("the impl does not reference any \
types defined in this crate"))
.emit();
return;
}
Err(traits::OrphanCheckErr::UncoveredTy(param_ty)) => {

16
src/librustc_typeck/collect.rs
View file

@ -367,8 +367,13 @@ impl<'a, 'tcx> AstConv<'tcx, 'tcx> for ItemCtxt<'a, 'tcx> {
_substs: Option<&mut Substs<'tcx>>,
_space: Option<ParamSpace>,
span: Span) -> Ty<'tcx> {
span_err!(self.tcx().sess, span, E0121,
"the type placeholder `_` is not allowed within types on item signatures");
struct_span_err!(
self.tcx().sess,
span,
E0121,
"the type placeholder `_` is not allowed within types on item signatures"
).span_label(span, &format!("not allowed in type signatures"))
.emit();
self.tcx().types.err
}
@ -770,9 +775,10 @@ fn convert_item(ccx: &CrateCtxt, it: &hir::Item) {
let mut err = struct_span_err!(tcx.sess, impl_item.span, E0201,
"duplicate definitions with name `{}`:",
impl_item.name);
span_note!(&mut err, *entry.get(),
"previous definition of `{}` here",
impl_item.name);
err.span_label(*entry.get(),
&format!("previous definition of `{}` here",
impl_item.name));
err.span_label(impl_item.span, &format!("duplicate definition"));
err.emit();
}
Vacant(entry) => {

14
src/librustc_typeck/lib.rs
View file

@ -211,11 +211,15 @@ fn check_main_fn_ty(ccx: &CrateCtxt,
match tcx.map.find(main_id) {
Some(hir_map::NodeItem(it)) => {
match it.node {
hir::ItemFn(_, _, _, _, ref ps, _)
if ps.is_parameterized() => {
span_err!(ccx.tcx.sess, main_span, E0131,
"main function is not allowed to have type parameters");
return;
hir::ItemFn(_, _, _, _, ref generics, _) => {
if let Some(gen_span) = generics.span() {
struct_span_err!(ccx.tcx.sess, gen_span, E0131,
"main function is not allowed to have type parameters")
.span_label(gen_span,
&format!("main cannot have type parameters"))
.emit();
return;
}
}
_ => ()
}

15
src/libstd/error.rs
View file

@ -49,6 +49,7 @@
use any::TypeId;
use boxed::Box;
use cell;
use char;
use fmt::{self, Debug, Display};
use marker::{Send, Sync, Reflect};
@ -289,6 +290,20 @@ impl Error for fmt::Error {
}
}
#[unstable(feature = "try_borrow", issue = "35070")]
impl<'a, T: ?Sized + Reflect> Error for cell::BorrowError<'a, T> {
fn description(&self) -> &str {
"already mutably borrowed"
}
}
#[unstable(feature = "try_borrow", issue = "35070")]
impl<'a, T: ?Sized + Reflect> Error for cell::BorrowMutError<'a, T> {
fn description(&self) -> &str {
"already borrowed"
}
}
// copied from any.rs
impl Error + 'static {
/// Returns true if the boxed type is the same as `T`

9
src/libstd/ffi/c_str.rs
View file

@ -373,6 +373,15 @@ impl NulError {
/// Consumes this error, returning the underlying vector of bytes which
/// generated the error in the first place.
///
/// # Examples
///
/// ```
/// use std::ffi::CString;
///
/// let nul_error = CString::new("foo\0bar").unwrap_err();
/// assert_eq!(nul_error.into_vec(), b"foo\0bar");
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
pub fn into_vec(self) -> Vec<u8> { self.1 }
}

1
src/libstd/lib.rs
View file

@ -269,6 +269,7 @@
#![feature(str_utf16)]
#![feature(test, rustc_private)]
#![feature(thread_local)]
#![feature(try_borrow)]
#![feature(try_from)]
#![feature(unboxed_closures)]
#![feature(unicode)]

14
src/libstd/sys/unix/os.rs
View file

@ -21,6 +21,7 @@ use fmt;
use io;
use iter;
use libc::{self, c_int, c_char, c_void};
use marker::PhantomData;
use mem;
use memchr;
use path::{self, PathBuf};
@ -37,6 +38,7 @@ static ENV_LOCK: Mutex = Mutex::new();
extern {
#[cfg(not(target_os = "dragonfly"))]
#[cfg_attr(any(target_os = "linux", target_os = "emscripten"),
link_name = "__errno_location")]
#[cfg_attr(any(target_os = "bitrig",
@ -304,7 +306,7 @@ pub fn current_exe() -> io::Result<PathBuf> {
pub struct Args {
iter: vec::IntoIter<OsString>,
_dont_send_or_sync_me: *mut (),
_dont_send_or_sync_me: PhantomData<*mut ()>,
}
impl Iterator for Args {
@ -342,7 +344,7 @@ pub fn args() -> Args {
};
Args {
iter: vec.into_iter(),
_dont_send_or_sync_me: ptr::null_mut(),
_dont_send_or_sync_me: PhantomData,
}
}
@ -399,7 +401,7 @@ pub fn args() -> Args {
}
}
Args { iter: res.into_iter(), _dont_send_or_sync_me: ptr::null_mut() }
Args { iter: res.into_iter(), _dont_send_or_sync_me: PhantomData }
}
#[cfg(any(target_os = "linux",
@ -418,12 +420,12 @@ pub fn args() -> Args {
let v: Vec<OsString> = bytes.into_iter().map(|v| {
OsStringExt::from_vec(v)
}).collect();
Args { iter: v.into_iter(), _dont_send_or_sync_me: ptr::null_mut() }
Args { iter: v.into_iter(), _dont_send_or_sync_me: PhantomData }
}
pub struct Env {
iter: vec::IntoIter<(OsString, OsString)>,
_dont_send_or_sync_me: *mut (),
_dont_send_or_sync_me: PhantomData<*mut ()>,
}
impl Iterator for Env {
@ -464,7 +466,7 @@ pub fn env() -> Env {
}
let ret = Env {
iter: result.into_iter(),
_dont_send_or_sync_me: ptr::null_mut(),
_dont_send_or_sync_me: PhantomData,
};
ENV_LOCK.unlock();
return ret

1
src/test/compile-fail/E0010.rs
View file

@ -11,5 +11,6 @@
#![feature(box_syntax)]
const CON : Box<i32> = box 0; //~ ERROR E0010
//~| NOTE allocation not allowed in
fn main() {}

4
src/test/compile-fail/E0027.rs
View file

@ -17,6 +17,8 @@ fn main() {
let d = Dog { name: "Rusty".to_string(), age: 8 };
match d {
Dog { age: x } => {} //~ ERROR E0027
Dog { age: x } => {}
//~^ ERROR pattern does not mention field `name`
//~| NOTE missing field `name`
}
}

6
src/test/compile-fail/E0029.rs
View file

@ -12,7 +12,11 @@ fn main() {
let s = "hoho";
match s {
"hello" ... "world" => {} //~ ERROR E0029
"hello" ... "world" => {}
//~^ ERROR only char and numeric types are allowed in range patterns
//~| NOTE ranges require char or numeric types
//~| NOTE start type: &'static str
//~| NOTE end type: &'static str
_ => {}
}
}

4
src/test/compile-fail/E0040.rs
View file

@ -20,5 +20,7 @@ impl Drop for Foo {
fn main() {
let mut x = Foo { x: -7 };
x.drop(); //~ ERROR E0040
x.drop();
//~^ ERROR E0040
//~| NOTE call to destructor method
}

4
src/test/compile-fail/E0046.rs
View file

@ -14,7 +14,9 @@ trait Foo {
struct Bar;
impl Foo for Bar {} //~ ERROR E0046
impl Foo for Bar {}
//~^ ERROR E0046
//~| NOTE missing `foo` in implementation
fn main() {
}

4
src/test/compile-fail/E0101.rs
View file

@ -9,5 +9,7 @@
// except according to those terms.
fn main() {
let x = |_| {}; //~ ERROR E0101
let x = |_| {};
//~^ ERROR E0101
//~| NOTE cannot resolve type of expression
}

4
src/test/compile-fail/E0102.rs
View file

@ -9,5 +9,7 @@
// except according to those terms.
fn main() {
let x = []; //~ ERROR E0102
let x = [];
//~^ ERROR E0102
//~| NOTE cannot resolve type of variable
}

5
src/test/compile-fail/E0116.rs
View file

@ -8,7 +8,10 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
impl Vec<u8> {} //~ ERROR E0116
impl Vec<u8> {}
//~^ ERROR E0116
//~| NOTE impl for type defined outside of crate.
//~| NOTE define and implement a trait or new type instead
fn main() {
}

2
src/test/compile-fail/E0117.rs
View file

@ -9,6 +9,8 @@
// except according to those terms.
impl Drop for u32 {} //~ ERROR E0117
//~^ NOTE impl doesn't use types inside crate
//~| NOTE the impl does not reference any types defined in this crate
fn main() {
}

2
src/test/compile-fail/E0118.rs
View file

@ -9,6 +9,8 @@
// except according to those terms.
impl (u8, u8) { //~ ERROR E0118
//~^ NOTE impl requires a base type
//~| NOTE either implement a trait on it or create a newtype to wrap it instead
fn get_state(&self) -> String {
String::new()
}

4
src/test/compile-fail/E0131.rs
View file

@ -8,5 +8,7 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
fn main<T>() { //~ ERROR E0131
fn main<T>() {
//~^ ERROR E0131
//~| NOTE main cannot have type parameters
}

3
src/test/compile-fail/E0185.rs
View file

@ -9,13 +9,14 @@
// except according to those terms.
trait Foo {
fn foo();
fn foo(); //~ trait declared without `&self`
}
struct Bar;
impl Foo for Bar {
fn foo(&self) {} //~ ERROR E0185
//~^ `&self` used in impl
}
fn main() {

3
src/test/compile-fail/E0186.rs
View file

@ -9,13 +9,14 @@
// except according to those terms.
trait Foo {
fn foo(&self);
fn foo(&self); //~ `&self` used in trait
}
struct Bar;
impl Foo for Bar {
fn foo() {} //~ ERROR E0186
//~^ expected `&self` in impl
}
fn main() {

9
src/test/compile-fail/E0204.rs
View file

@ -12,9 +12,14 @@ struct Foo {
foo: Vec<u32>,
}
impl Copy for Foo { } //~ ERROR E0204
impl Copy for Foo { }
//~^ ERROR E0204
//~| NOTE field `foo` does not implement `Copy`
#[derive(Copy)] //~ ERROR E0204
#[derive(Copy)]
//~^ ERROR E0204
//~| NOTE field `ty` does not implement `Copy`
//~| NOTE in this expansion of #[derive(Copy)]
struct Foo2<'a> {
ty: &'a mut bool,
}

9
src/test/compile-fail/E0205.rs
View file

@ -13,9 +13,14 @@ enum Foo {
Baz,
}
impl Copy for Foo { } //~ ERROR E0205
impl Copy for Foo { }
//~^ ERROR E0205
//~| NOTE variant `Bar` does not implement `Copy`
#[derive(Copy)] //~ ERROR E0205
#[derive(Copy)]
//~^ ERROR E0205
//~| NOTE variant `Bar` does not implement `Copy`
//~| NOTE in this expansion of #[derive(Copy)]
enum Foo2<'a> {
Bar(&'a mut bool),
Baz,

12
src/test/compile-fail/E0206.rs
View file

@ -10,13 +10,19 @@
type Foo = i32;
impl Copy for Foo { } //~ ERROR E0206
//~^ ERROR E0117
impl Copy for Foo { }
//~^ ERROR the trait `Copy` may not be implemented for this type
//~| NOTE type is not a structure or enumeration
//~| ERROR only traits defined in the current crate can be implemented for arbitrary types
//~| NOTE impl doesn't use types inside crate
//~| NOTE the impl does not reference any types defined in this crate
#[derive(Copy, Clone)]
struct Bar;
impl Copy for &'static Bar { } //~ ERROR E0206
impl Copy for &'static Bar { }
//~^ ERROR the trait `Copy` may not be implemented for this type
//~| NOTE type is not a structure or enumeration
fn main() {
}

5
src/test/compile-fail/E0223.rs
View file

@ -11,5 +11,8 @@
trait MyTrait { type X; }
fn main() {
let foo: MyTrait::X; //~ ERROR E0223
let foo: MyTrait::X;
//~^ ERROR ambiguous associated type
//~| NOTE ambiguous associated type
//~| NOTE specify the type using the syntax `<Type as MyTrait>::X`
}

4
src/test/compile-fail/E0225.rs
View file

@ -9,5 +9,7 @@
// except according to those terms.
fn main() {
let _: Box<std::io::Read + std::io::Write>; //~ ERROR E0225
let _: Box<std::io::Read + std::io::Write>;
//~^ ERROR only the builtin traits can be used as closure or object bounds [E0225]
//~| NOTE non-builtin trait used as bounds
}

4
src/test/compile-fail/E0243.rs
View file

@ -9,7 +9,9 @@
// except according to those terms.
struct Foo<T> { x: T }
struct Bar { x: Foo } //~ ERROR E0243
struct Bar { x: Foo }
//~^ ERROR E0243
//~| NOTE expected 1 type arguments, found 0
fn main() {
}

5
src/test/compile-fail/E0244.rs
View file

@ -9,7 +9,10 @@
// except according to those terms.
struct Foo { x: bool }
struct Bar<S, T> { x: Foo<S, T> } //~ ERROR E0244
struct Bar<S, T> { x: Foo<S, T> }
//~^ ERROR E0244
//~| NOTE expected no type arguments, found 2
fn main() {
}

6
src/test/compile-fail/associated-types-in-ambiguous-context.rs
View file

@ -15,15 +15,21 @@ trait Get {
fn get<T:Get,U:Get>(x: T, y: U) -> Get::Value {}
//~^ ERROR ambiguous associated type
//~| NOTE ambiguous associated type
//~| NOTE specify the type using the syntax `<Type as Get>::Value`
trait Grab {
type Value;
fn grab(&self) -> Grab::Value;
//~^ ERROR ambiguous associated type
//~| NOTE ambiguous associated type
//~| NOTE specify the type using the syntax `<Type as Grab>::Value`
}
type X = std::ops::Deref::Target;
//~^ ERROR ambiguous associated type
//~| NOTE ambiguous associated type
//~| NOTE specify the type using the syntax `<Type as std::ops::Deref>::Target`
fn main() {
}

27
src/test/compile-fail/coherence-impls-copy.rs
View file

@ -27,23 +27,34 @@ impl Clone for TestE { fn clone(&self) -> Self { *self } }
impl Copy for MyType {}
impl Copy for &'static mut MyType {}
//~^ ERROR E0206
//~^ ERROR the trait `Copy` may not be implemented for this type
//~| NOTE type is not a structure or enumeration
impl Clone for MyType { fn clone(&self) -> Self { *self } }
impl Copy for (MyType, MyType) {}
//~^ ERROR E0206
//~| ERROR E0117
//~^ ERROR the trait `Copy` may not be implemented for this type
//~| NOTE type is not a structure or enumeration
//~| ERROR only traits defined in the current crate can be implemented for arbitrary types
//~| NOTE impl doesn't use types inside crate
//~| NOTE the impl does not reference any types defined in this crate
impl Copy for &'static NotSync {}
//~^ ERROR E0206
//~^ ERROR the trait `Copy` may not be implemented for this type
//~| NOTE type is not a structure or enumeration
impl Copy for [MyType] {}
//~^ ERROR E0206
//~| ERROR E0117
//~^ ERROR the trait `Copy` may not be implemented for this type
//~| NOTE type is not a structure or enumeration
//~| ERROR only traits defined in the current crate can be implemented for arbitrary types
//~| NOTE impl doesn't use types inside crate
//~| NOTE the impl does not reference any types defined in this crate
impl Copy for &'static [NotSync] {}
//~^ ERROR E0206
//~| ERROR E0117
//~^ ERROR the trait `Copy` may not be implemented for this type
//~| NOTE type is not a structure or enumeration
//~| ERROR only traits defined in the current crate can be implemented for arbitrary types
//~| NOTE impl doesn't use types inside crate
//~| NOTE the impl does not reference any types defined in this crate
fn main() {
}

3
src/test/compile-fail/double-import.rs
View file

@ -7,8 +7,6 @@
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
#![feature(no_core)]
#![no_core]
// This tests that conflicting imports shows both `use` lines
// when reporting the error.
@ -23,5 +21,6 @@ mod sub2 {
use sub1::foo; //~ NOTE previous import of `foo` here
use sub2::foo; //~ ERROR a value named `foo` has already been imported in this module [E0252]
//~| NOTE already imported
fn main() {}

4
src/test/compile-fail/generic-type-less-params-with-defaults.rs
View file

@ -16,5 +16,7 @@ struct Vec<T, A = Heap>(
marker::PhantomData<(T,A)>);
fn main() {
let _: Vec; //~ ERROR wrong number of type arguments: expected at least 1, found 0
let _: Vec;
//~^ ERROR E0243
//~| NOTE expected at least 1 type arguments, found 0
}

3
src/test/compile-fail/generic-type-more-params-with-defaults.rs
View file

@ -17,5 +17,6 @@ struct Vec<T, A = Heap>(
fn main() {
let _: Vec<isize, Heap, bool>;
//~^ ERROR wrong number of type arguments: expected at most 2, found 3
//~^ ERROR E0244
//~| NOTE expected at most 2 type arguments, found 3
}

4
src/test/compile-fail/impl-duplicate-methods.rs
View file

@ -12,7 +12,9 @@ struct Foo;
impl Foo {
fn orange(&self) {} //~ NOTE previous definition of `orange` here
fn orange(&self) {} //~ ERROR duplicate definitions with name `orange`
fn orange(&self) {}
//~^ ERROR duplicate definition
//~| NOTE duplicate definition
}
fn main() {}

3
src/test/compile-fail/impl-wrong-item-for-trait.rs
View file

@ -21,6 +21,7 @@ pub struct FooConstForMethod;
impl Foo for FooConstForMethod {
//~^ ERROR E0046
//~| NOTE missing `bar` in implementation
const bar: u64 = 1;
//~^ ERROR E0323
//~| NOTE does not match trait
@ -31,6 +32,7 @@ pub struct FooMethodForConst;
impl Foo for FooMethodForConst {
//~^ ERROR E0046
//~| NOTE missing `MY_CONST` in implementation
fn bar(&self) {}
fn MY_CONST() {}
//~^ ERROR E0324
@ -41,6 +43,7 @@ pub struct FooTypeForMethod;
impl Foo for FooTypeForMethod {
//~^ ERROR E0046
//~| NOTE missing `bar` in implementation
type bar = u64;
//~^ ERROR E0325
//~| NOTE does not match trait

4
src/test/compile-fail/issue-12187-1.rs
View file

@ -14,5 +14,7 @@ fn new<T>() -> &'static T {
fn main() {
let &v = new();
//~^ ERROR type annotations or generic parameter binding required
//~^ ERROR unable to infer enough type information about `_` [E0282]
//~| NOTE cannot infer type for `_`
//~| NOTE type annotations or generic parameter binding
}

4
src/test/compile-fail/issue-12187-2.rs
View file

@ -14,5 +14,7 @@ fn new<'r, T>() -> &'r T {
fn main() {
let &v = new();
//~^ ERROR type annotations or generic parameter binding required
//~^ ERROR unable to infer enough type information about `_` [E0282]
//~| NOTE cannot infer type for `_`
//~| NOTE type annotations or generic parameter binding
}

4
src/test/compile-fail/issue-14092.rs
View file

@ -8,6 +8,8 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
fn fn1(0: Box) {} //~ ERROR: wrong number of type arguments: expected 1, found 0
fn fn1(0: Box) {}
//~^ ERROR E0243
//~| NOTE expected 1 type arguments, found 0
fn main() {}

2
src/test/compile-fail/issue-23024.rs
View file

@ -18,6 +18,6 @@ fn main()
vfnfer.push(box h);
println!("{:?}",(vfnfer[0] as Fn)(3));
//~^ ERROR the precise format of `Fn`-family traits'
//~| ERROR wrong number of type arguments: expected 1, found 0
//~| ERROR E0243
//~| ERROR the value of the associated type `Output` (from the trait `std::ops::FnOnce`)
}

2
src/test/compile-fail/issue-23041.rs
View file

@ -14,4 +14,6 @@ fn main()
fn bar(x:i32) ->i32 { 3*x };
let b:Box<Any> = Box::new(bar as fn(_)->_);
b.downcast_ref::<fn(_)->_>(); //~ ERROR E0282
//~| NOTE cannot infer type for `_`
//~| NOTE type annotations or generic parameter binding required
}

3
src/test/compile-fail/issue-23729.rs
View file

@ -18,7 +18,8 @@ fn main() {
}
impl Iterator for Recurrence {
//~^ ERROR not all trait items implemented, missing: `Item` [E0046]
//~^ ERROR E0046
//~| NOTE missing `Item` in implementation
#[inline]
fn next(&mut self) -> Option<u64> {
if self.pos < 2 {

3
src/test/compile-fail/issue-23827.rs
View file

@ -34,7 +34,8 @@ impl<C: Component> FnMut<(C,)> for Prototype {
}
impl<C: Component> FnOnce<(C,)> for Prototype {
//~^ ERROR not all trait items implemented, missing: `Output` [E0046]
//~^ ERROR E0046
//~| NOTE missing `Output` in implementation
extern "rust-call" fn call_once(self, (comp,): (C,)) -> Prototype {
Fn::call(&self, (comp,))
}

3
src/test/compile-fail/issue-24356.rs
View file

@ -28,7 +28,8 @@ fn main() {
// Causes ICE
impl Deref for Thing {
//~^ ERROR not all trait items implemented, missing: `Target` [E0046]
//~^ ERROR E0046
//~| NOTE missing `Target` in implementation
fn deref(&self) -> i8 { self.0 }
}

2
src/test/compile-fail/issue-26886.rs
View file

@ -11,7 +11,9 @@
use std::sync::{self, Arc}; //~ NOTE previous import
//~^ NOTE previous import
use std::sync::Arc; //~ ERROR a type named
//~| NOTE already imported
use std::sync; //~ ERROR a module named
//~| NOTE already imported
fn main() {
}

2
src/test/compile-fail/issue-27340.rs
View file

@ -10,7 +10,7 @@
struct Foo;
#[derive(Copy, Clone)]
//~^ ERROR the trait `Copy` may not be implemented for this type; field `0` does not implement
//~^ ERROR the trait `Copy` may not be implemented for this type
struct Bar(Foo);
fn main() {}

46
src/test/compile-fail/issue-33784.rs Normal file
View file

@ -0,0 +1,46 @@
// Copyright 2016 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
use std::ops::Deref;
struct Obj<F> where F: FnMut() -> u32 {
fn_ptr: fn() -> (),
closure: F,
}
struct C {
c_fn_ptr: fn() -> (),
}
struct D(C);
impl Deref for D {
type Target = C;
fn deref(&self) -> &C {
&self.0
}
}
fn empty() {}
fn main() {
let o = Obj { fn_ptr: empty, closure: || 42 };
let p = &o;
p.closure(); //~ ERROR no method named `closure` found
//~^ NOTE use `(p.closure)(...)` if you meant to call the function stored in the `closure` field
let q = &p;
q.fn_ptr(); //~ ERROR no method named `fn_ptr` found
//~^ NOTE use `(q.fn_ptr)(...)` if you meant to call the function stored in the `fn_ptr` field
let r = D(C { c_fn_ptr: empty });
let s = &r;
s.c_fn_ptr(); //~ ERROR no method named `c_fn_ptr` found
//~^ NOTE use `(s.c_fn_ptr)(...)` if you meant to call the function stored in the `c_fn_ptr`
}

4
src/test/compile-fail/issue-34209.rs
View file

@ -15,7 +15,9 @@ enum S {
fn bug(l: S) {
match l {
S::B{ } => { },
//~^ ERROR ambiguous associated type; specify the type using the syntax `<S as Trait>::B`
//~^ ERROR ambiguous associated type
//~| NOTE ambiguous associated type
//~| NOTE specify the type using the syntax `<S as Trait>::B`
}
}

2
src/test/compile-fail/issue-5062.rs
View file

@ -9,4 +9,4 @@
// except according to those terms.
fn main() { format!("{:?}", None); }
//~^ ERROR type annotations or generic parameter binding required
//~^ ERROR unable to infer enough type information about `_` [E0282]

2
src/test/compile-fail/issue-6458-2.rs
View file

@ -11,5 +11,5 @@
fn main() {
// Unconstrained type:
format!("{:?}", None);
//~^ ERROR type annotations or generic parameter binding required
//~^ ERROR unable to infer enough type information about `_` [E0282]
}

4
src/test/compile-fail/issue-6458-3.rs
View file

@ -12,5 +12,7 @@ use std::mem;
fn main() {
mem::transmute(0);
//~^ ERROR type annotations or generic parameter binding required
//~^ ERROR unable to infer enough type information about `_` [E0282]
//~| NOTE cannot infer type for `_`
//~| NOTE type annotations or generic parameter binding
}

4
src/test/compile-fail/issue-6458-4.rs
View file

@ -10,7 +10,9 @@
fn foo(b: bool) -> Result<bool,String> {
Err("bar".to_string());
//~^ ERROR type annotations or generic parameter binding required
//~^ ERROR unable to infer enough type information about `_` [E0282]
//~| NOTE cannot infer type for `_`
//~| NOTE type annotations or generic parameter binding
}
fn main() {

4
src/test/compile-fail/issue-6458.rs
View file

@ -17,7 +17,9 @@ pub fn foo<State>(_: TypeWithState<State>) {}
pub fn bar() {
foo(TypeWithState(marker::PhantomData));
//~^ ERROR type annotations or generic parameter binding required
//~^ ERROR unable to infer enough type information about `_` [E0282]
//~| NOTE cannot infer type for `_`
//~| NOTE type annotations or generic parameter binding
}
fn main() {

4
src/test/compile-fail/issue-7813.rs
View file

@ -10,5 +10,7 @@
fn main() {
let v = &[];
let it = v.iter(); //~ ERROR type annotations or generic parameter binding required
let it = v.iter(); //~ ERROR unable to infer enough type information about `_` [E0282]
//~| NOTE cannot infer type for `_`
//~| NOTE type annotations or generic parameter binding
}

2
src/test/compile-fail/method-ambig-one-trait-unknown-int-type.rs
View file

@ -32,7 +32,7 @@ impl foo for Vec<isize> {
fn m1() {
// we couldn't infer the type of the vector just based on calling foo()...
let mut x = Vec::new();
//~^ ERROR type annotations or generic parameter binding required
//~^ ERROR unable to infer enough type information about `_` [E0282]
x.foo();
}

8
src/test/compile-fail/qualified-path-params-2.rs
View file

@ -25,7 +25,11 @@ impl S {
fn f<T>() {}
}
type A = <S as Tr>::A::f<u8>; //~ ERROR type parameters are not allowed on this type
//~^ ERROR ambiguous associated type; specify the type using the syntax `<<S as Tr>::A as Trait>::f`
type A = <S as Tr>::A::f<u8>;
//~^ ERROR type parameters are not allowed on this type
//~| NOTE type parameter not allowed
//~| ERROR ambiguous associated type
//~| NOTE ambiguous associated type
//~| NOTE specify the type using the syntax `<<S as Tr>::A as Trait>::f`
fn main() {}

8
src/test/compile-fail/self-impl.rs
View file

@ -31,9 +31,13 @@ impl SuperFoo for Bar {
impl Bar {
fn f() {
let _: <Self>::Baz = true;
//~^ERROR: ambiguous associated type; specify the type using the syntax `<Bar as Trait>::Baz`
//~^ ERROR ambiguous associated type
//~| NOTE ambiguous associated type
//~| NOTE specify the type using the syntax `<Bar as Trait>::Baz`
let _: Self::Baz = true;
//~^ERROR: ambiguous associated type; specify the type using the syntax `<Bar as Trait>::Baz`
//~^ ERROR ambiguous associated type
//~| NOTE ambiguous associated type
//~| NOTE specify the type using the syntax `<Bar as Trait>::Baz`
}
}

4
src/test/compile-fail/traits-multidispatch-convert-ambig-dest.rs
View file

@ -34,7 +34,9 @@ where T : Convert<U>
fn a() {
test(22, std::default::Default::default());
//~^ ERROR type annotations or generic parameter binding required
//~^ ERROR unable to infer enough type information about `_` [E0282]
//~| NOTE cannot infer type for `_`
//~| NOTE type annotations or generic parameter binding
}
fn main() {}

17
src/test/compile-fail/typeck-builtin-bound-type-parameters.rs
View file

@ -9,20 +9,27 @@
// except according to those terms.
fn foo1<T:Copy<U>, U>(x: T) {}
//~^ ERROR: wrong number of type arguments: expected 0, found 1
//~^ ERROR E0244
//~| NOTE expected no type arguments, found 1
trait Trait: Copy<Send> {}
//~^ ERROR: wrong number of type arguments: expected 0, found 1
//~^ ERROR E0244
//~| NOTE expected no type arguments, found 1
struct MyStruct1<T: Copy<T>>;
//~^ ERROR wrong number of type arguments: expected 0, found 1
//~^ ERROR E0244
//~| NOTE expected no type arguments, found 1
struct MyStruct2<'a, T: Copy<'a>>;
//~^ ERROR: wrong number of lifetime parameters: expected 0, found 1
//~| NOTE unexpected lifetime parameter
fn foo2<'a, T:Copy<'a, U>, U>(x: T) {}
//~^ ERROR: wrong number of type arguments: expected 0, found 1
//~^^ ERROR: wrong number of lifetime parameters: expected 0, found 1
//~^ ERROR E0244
//~| NOTE expected no type arguments, found 1
//~| ERROR: wrong number of lifetime parameters: expected 0, found 1
//~| NOTE unexpected lifetime parameter
fn main() {
}

34
src/test/compile-fail/typeck_type_placeholder_item.rs
View file

@ -13,107 +13,141 @@
fn test() -> _ { 5 }
//~^ ERROR the type placeholder `_` is not allowed within types on item signatures
//~| NOTE not allowed in type signatures
fn test2() -> (_, _) { (5, 5) }
//~^ ERROR the type placeholder `_` is not allowed within types on item signatures
//~^^ ERROR the type placeholder `_` is not allowed within types on item signatures
//~| NOTE not allowed in type signatures
//~| NOTE not allowed in type signatures
static TEST3: _ = "test";
//~^ ERROR the type placeholder `_` is not allowed within types on item signatures
//~| NOTE not allowed in type signatures
static TEST4: _ = 145;
//~^ ERROR the type placeholder `_` is not allowed within types on item signatures
//~| NOTE not allowed in type signatures
static TEST5: (_, _) = (1, 2);
//~^ ERROR the type placeholder `_` is not allowed within types on item signatures
//~^^ ERROR the type placeholder `_` is not allowed within types on item signatures
//~| NOTE not allowed in type signatures
//~| NOTE not allowed in type signatures
fn test6(_: _) { }
//~^ ERROR the type placeholder `_` is not allowed within types on item signatures
//~| NOTE not allowed in type signatures
fn test7(x: _) { let _x: usize = x; }
//~^ ERROR the type placeholder `_` is not allowed within types on item signatures
//~| NOTE not allowed in type signatures
fn test8(_f: fn() -> _) { }
//~^ ERROR the type placeholder `_` is not allowed within types on item signatures
//~| NOTE not allowed in type signatures
struct Test9;
impl Test9 {
fn test9(&self) -> _ { () }
//~^ ERROR the type placeholder `_` is not allowed within types on item signatures
//~| NOTE not allowed in type signatures
fn test10(&self, _x : _) { }
//~^ ERROR the type placeholder `_` is not allowed within types on item signatures
//~| NOTE not allowed in type signatures
}
impl Clone for Test9 {
fn clone(&self) -> _ { Test9 }
//~^ ERROR the type placeholder `_` is not allowed within types on item signatures
//~| NOTE not allowed in type signatures
fn clone_from(&mut self, other: _) { *self = Test9; }
//~^ ERROR the type placeholder `_` is not allowed within types on item signatures
//~| NOTE not allowed in type signatures
}
struct Test10 {
a: _,
//~^ ERROR the type placeholder `_` is not allowed within types on item signatures
//~| NOTE not allowed in type signatures
b: (_, _),
//~^ ERROR the type placeholder `_` is not allowed within types on item signatures
//~^^ ERROR the type placeholder `_` is not allowed within types on item signatures
//~| NOTE not allowed in type signatures
//~| NOTE not allowed in type signatures
}
pub fn main() {
fn fn_test() -> _ { 5 }
//~^ ERROR the type placeholder `_` is not allowed within types on item signatures
//~| NOTE not allowed in type signatures
fn fn_test2() -> (_, _) { (5, 5) }
//~^ ERROR the type placeholder `_` is not allowed within types on item signatures
//~^^ ERROR the type placeholder `_` is not allowed within types on item signatures
//~| NOTE not allowed in type signatures
//~| NOTE not allowed in type signatures
static FN_TEST3: _ = "test";
//~^ ERROR the type placeholder `_` is not allowed within types on item signatures
//~| NOTE not allowed in type signatures
static FN_TEST4: _ = 145;
//~^ ERROR the type placeholder `_` is not allowed within types on item signatures
//~| NOTE not allowed in type signatures
static FN_TEST5: (_, _) = (1, 2);
//~^ ERROR the type placeholder `_` is not allowed within types on item signatures
//~^^ ERROR the type placeholder `_` is not allowed within types on item signatures
//~| NOTE not allowed in type signatures
//~| NOTE not allowed in type signatures
fn fn_test6(_: _) { }
//~^ ERROR the type placeholder `_` is not allowed within types on item signatures
//~| NOTE not allowed in type signatures
fn fn_test7(x: _) { let _x: usize = x; }
//~^ ERROR the type placeholder `_` is not allowed within types on item signatures
//~| NOTE not allowed in type signatures
fn fn_test8(_f: fn() -> _) { }
//~^ ERROR the type placeholder `_` is not allowed within types on item signatures
//~| NOTE not allowed in type signatures
struct FnTest9;
impl FnTest9 {
fn fn_test9(&self) -> _ { () }
//~^ ERROR the type placeholder `_` is not allowed within types on item signatures
//~| NOTE not allowed in type signatures
fn fn_test10(&self, _x : _) { }
//~^ ERROR the type placeholder `_` is not allowed within types on item signatures
//~| NOTE not allowed in type signatures
}
impl Clone for FnTest9 {
fn clone(&self) -> _ { FnTest9 }
//~^ ERROR the type placeholder `_` is not allowed within types on item signatures
//~| NOTE not allowed in type signatures
fn clone_from(&mut self, other: _) { *self = FnTest9; }
//~^ ERROR the type placeholder `_` is not allowed within types on item signatures
//~| NOTE not allowed in type signatures
}
struct FnTest10 {
a: _,
//~^ ERROR the type placeholder `_` is not allowed within types on item signatures
//~| NOTE not allowed in type signatures
b: (_, _),
//~^ ERROR the type placeholder `_` is not allowed within types on item signatures
//~^^ ERROR the type placeholder `_` is not allowed within types on item signatures
//~| NOTE not allowed in type signatures
//~| NOTE not allowed in type signatures
}
}

3
src/test/compile-fail/typeck_type_placeholder_lifetime_1.rs
View file

@ -17,5 +17,6 @@ struct Foo<'a, T:'a> {
pub fn main() {
let c: Foo<_, _> = Foo { r: &5 };
//~^ ERROR wrong number of type arguments: expected 1, found 2
//~^ ERROR E0244
//~| NOTE expected 1 type arguments, found 2
}

3
src/test/compile-fail/typeck_type_placeholder_lifetime_2.rs
View file

@ -17,5 +17,6 @@ struct Foo<'a, T:'a> {
pub fn main() {
let c: Foo<_, usize> = Foo { r: &5 };
//~^ ERROR wrong number of type arguments: expected 1, found 2
//~^ ERROR E0244
//~| NOTE expected 1 type arguments, found 2
}

3
src/test/compile-fail/unboxed-closure-sugar-wrong-trait.rs
View file

@ -13,7 +13,8 @@
trait Trait {}
fn f<F:Trait(isize) -> isize>(x: F) {}
//~^ ERROR wrong number of type arguments: expected 0, found 1
//~^ ERROR E0244
//~| NOTE expected no type arguments, found 1
//~| ERROR associated type `Output` not found
fn main() {}

4
src/test/compile-fail/unconstrained-none.rs
View file

@ -11,5 +11,7 @@
// Issue #5062
fn main() {
None; //~ ERROR type annotations or generic parameter binding required
None; //~ ERROR unable to infer enough type information about `_` [E0282]
//~| NOTE cannot infer type for `_`
//~| NOTE type annotations or generic parameter binding
}

4
src/test/compile-fail/unconstrained-ref.rs
View file

@ -13,5 +13,7 @@ struct S<'a, T:'a> {
}
fn main() {
S { o: &None }; //~ ERROR type annotations or generic parameter binding required
S { o: &None }; //~ ERROR unable to infer enough type information about `_` [E0282]
//~| NOTE cannot infer type for `_`
//~| NOTE type annotations or generic parameter binding
}

3
src/test/compile-fail/use-mod.rs
View file

@ -15,7 +15,8 @@ use foo::bar::{
Bar,
self
//~^ NOTE another `self` import appears here
//~^^ ERROR a module named `bar` has already been imported in this module
//~| ERROR a module named `bar` has already been imported in this module
//~| NOTE already imported
};
use {self};

4
src/test/compile-fail/vector-no-ann.rs
View file

@ -11,5 +11,7 @@
fn main() {
let _foo = Vec::new();
//~^ ERROR type annotations or generic parameter binding required
//~^ ERROR unable to infer enough type information about `_` [E0282]
//~| NOTE cannot infer type for `_`
//~| NOTE type annotations or generic parameter binding
}

21
src/test/run-pass/issue-20847.rs Normal file
View file

@ -0,0 +1,21 @@
// Copyright 2016 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
#![feature(fn_traits)]
use std::ops::Fn;
fn say(x: u32, y: u32) {
println!("{} {}", x, y);
}
fn main() {
Fn::call(&say, (1, 2));
}

29
src/test/run-pass/slice_binary_search.rs Normal file
View file

@ -0,0 +1,29 @@
// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
// Test binary_search_by_key lifetime. Issue #34683
#[derive(Debug)]
struct Assignment {
topic: String,
partition: i32,
}
fn main() {
let xs = vec![
Assignment { topic: "abc".into(), partition: 1 },
Assignment { topic: "def".into(), partition: 2 },
Assignment { topic: "ghi".into(), partition: 3 },
];
let key: &str = "def";
let r = xs.binary_search_by_key(&key, |e| &e.topic);
assert_eq!(Ok(1), r.map(|i| i));
}