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

Auto merge of #35469 - jonathandturner:rollup, r=jonathandturner

Browse Source 
Rollup of 21 pull requests

- Successful merges: #35314, #35355, #35357, #35366, #35394, #35410, #35411, #35413, #35417, #35419, #35421, #35429, #35433, #35434, #35436, #35439, #35443, #35454, #35455, #35467, #35468
- Failed merges: #35395, #35415
This commit is contained in:
bors 2016-08-07 10:52:23 -07:00 committed by GitHub
commit 1744c46e47
67 changed files with 345 additions and 126 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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
}

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,

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();
}
}

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;
}
_ => {

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) => {

21
src/librustc_typeck/coherence/mod.rs
View File

@ -311,18 +311,23 @@ 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,

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;
}
}
_ => ()
}

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/sys/unix/os.rs
View File

@ -37,6 +37,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",

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,

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() {
}

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() {}

7
src/test/compile-fail/issue-23024.rs
View File

@ -18,6 +18,11 @@ 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
//~| NOTE expected 1 type arguments, found 0
//~| ERROR the value of the associated type `Output` (from the trait `std::ops::FnOnce`)
//~| NOTE in this expansion of println!
//~| NOTE in this expansion of println!
//~| NOTE in this expansion of println!
//~| NOTE in this expansion of println!
}

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-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() {}

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
}

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
}