.project
.settings/
.valgrindrc
+.vscode/
/*-*-*-*/
/*-*-*/
/Makefile
#[inline]
#[unstable(feature = "insert_str",
reason = "recent addition",
- issue = "0")]
+ issue = "35553")]
pub fn insert_str(&mut self, idx: usize, string: &str) {
let len = self.len();
assert!(idx <= len);
})
}
-/// Use the `format!` syntax to write data into a buffer.
+/// Write formatted data into a buffer
///
-/// This macro is typically used with a buffer of `&mut `[`Write`][write].
+/// This macro accepts any value with `write_fmt` method as a writer, a format string, and a list
+/// of arguments to format.
+///
+/// `write_fmt` method usually comes from an implementation of [`std::fmt::Write`][fmt_write] or
+/// [`std::io::Write`][io_write] traits. These are sometimes called 'writers'.
+///
+/// Passed arguments will be formatted according to the specified format string and the resulting
+/// string will be passed to the writer.
///
/// See [`std::fmt`][fmt] for more information on format syntax.
///
+/// Return value is completely dependent on the 'write_fmt' method.
+///
+/// Common return values are: [`Result`][enum_result], [`io::Result`][type_result]
+///
/// [fmt]: ../std/fmt/index.html
-/// [write]: ../std/io/trait.Write.html
+/// [fmt_write]: ../std/fmt/trait.Write.html
+/// [io_write]: ../std/io/trait.Write.html
+/// [enum_result]: ../std/result/enum.Result.html
+/// [type_result]: ../std/io/type.Result.html
///
/// # Examples
///
($dst:expr, $($arg:tt)*) => ($dst.write_fmt(format_args!($($arg)*)))
}
-/// Use the `format!` syntax to write data into a buffer, appending a newline.
-/// On all platforms, the newline is the LINE FEED character (`\n`/`U+000A`)
-/// alone (no additional CARRIAGE RETURN (`\r`/`U+000D`).
+/// Write formatted data into a buffer, with appending a newline.
+///
+/// On all platforms, the newline is the LINE FEED character (`\n`/`U+000A`) alone
+/// (no additional CARRIAGE RETURN (`\r`/`U+000D`).
///
-/// This macro is typically used with a buffer of `&mut `[`Write`][write].
+/// This macro accepts any value with `write_fmt` method as a writer, a format string, and a list
+/// of arguments to format.
+///
+/// `write_fmt` method usually comes from an implementation of [`std::fmt::Write`][fmt_write] or
+/// [`std::io::Write`][io_write] traits. These are sometimes called 'writers'.
+///
+/// Passed arguments will be formatted according to the specified format string and the resulting
+/// string will be passed to the writer.
///
/// See [`std::fmt`][fmt] for more information on format syntax.
///
+/// Return value is completely dependent on the 'write_fmt' method.
+///
+/// Common return values are: [`Result`][enum_result], [`io::Result`][type_result]
+///
/// [fmt]: ../std/fmt/index.html
-/// [write]: ../std/io/trait.Write.html
+/// [fmt_write]: ../std/fmt/trait.Write.html
+/// [io_write]: ../std/io/trait.Write.html
+/// [enum_result]: ../std/result/enum.Result.html
+/// [type_result]: ../std/io/type.Result.html
///
/// # Examples
///
/// ```
/// fn mutate(r: &mut Result<i32, i32>) {
/// match r.as_mut() {
- /// Ok(&mut ref mut v) => *v = 42,
- /// Err(&mut ref mut e) => *e = 0,
+ /// Ok(v) => *v = 42,
+ /// Err(e) => *e = 0,
/// }
/// }
///
match self.unsafe_context.root {
SafeContext => {
// Report an error.
- span_err!(self.tcx.sess, span, E0133,
- "{} requires unsafe function or block",
- description);
+ struct_span_err!(
+ self.tcx.sess, span, E0133,
+ "{} requires unsafe function or block", description)
+ .span_label(span, &format!("unsafe call requires unsafe function or block"))
+ .emit();
}
UnsafeBlock(block_id) => {
// OK, but record this.
let lifetime_j = &lifetimes[j];
if lifetime_i.lifetime.name == lifetime_j.lifetime.name {
- span_err!(self.sess, lifetime_j.lifetime.span, E0263,
- "lifetime name `{}` declared twice in \
- the same scope",
- lifetime_j.lifetime.name);
+ struct_span_err!(self.sess, lifetime_j.lifetime.span, E0263,
+ "lifetime name `{}` declared twice in the same scope",
+ lifetime_j.lifetime.name)
+ .span_label(lifetime_j.lifetime.span,
+ &format!("declared twice"))
+ .span_label(lifetime_i.lifetime.span,
+ &format!("previous declaration here"))
+ .emit();
}
}
let mut err = struct_span_err!(self.sess, span, E0072,
"recursive type `{}` has infinite size",
self.item_path_str(type_def_id));
+ err.span_label(span, &format!("recursive type has infinite size"));
err.help(&format!("insert indirection (e.g., a `Box`, `Rc`, or `&`) \
at some point to make `{}` representable",
self.item_path_str(type_def_id)));
let mut err = match warning_node_id {
Some(_) => None,
None => {
- Some(struct_span_err!(
- self.sess, span, E0038,
- "the trait `{}` cannot be made into an object",
- self.item_path_str(trait_def_id)))
+ let trait_str = self.item_path_str(trait_def_id);
+ let mut db = struct_span_err!(
+ self.sess, span, E0038,
+ "the trait `{}` cannot be made into an object",
+ trait_str);
+ db.span_label(span,
+ &format!("the trait `{}` cannot be made \
+ into an object", trait_str));
+ Some(db)
}
};
lp: &LoanPath<'tcx>,
assign:
&move_data::Assignment) {
- struct_span_err!(
+ let mut err = struct_span_err!(
self.tcx.sess, span, E0384,
"re-assignment of immutable variable `{}`",
- self.loan_path_to_string(lp))
- .span_note(assign.span, "prior assignment occurs here")
- .emit();
+ self.loan_path_to_string(lp));
+ err.span_label(span, &format!("re-assignment of immutable variable"));
+ if span != assign.span {
+ err.span_label(assign.span, &format!("first assignment to `{}`",
+ self.loan_path_to_string(lp)));
+ }
+ err.emit();
}
pub fn span_err(&self, s: Span, m: &str) {
.flat_map(|arm| &arm.0)
.map(|pat| vec![wrap_pat(cx, &pat)])
.collect();
- 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);
+ check_exhaustive(cx, scrut.span, &matrix, source);
},
_ => ()
}
// x @ Foo(..) is legal, but x @ Foo(y) isn't.
if sub.map_or(false, |p| pat_contains_bindings(&p)) {
- span_err!(cx.tcx.sess, p.span, E0007, "cannot bind by-move with sub-bindings");
+ struct_span_err!(cx.tcx.sess, p.span, E0007,
+ "cannot bind by-move with sub-bindings")
+ .span_label(p.span, &format!("binds an already bound by-move value by moving it"))
+ .emit();
} else if has_guard {
- span_err!(cx.tcx.sess, p.span, E0008, "cannot bind by-move into a pattern guard");
+ struct_span_err!(cx.tcx.sess, p.span, E0008,
+ "cannot bind by-move into a pattern guard")
+ .span_label(p.span, &format!("moves value into pattern guard"))
+ .emit();
} else if by_ref_span.is_some() {
let mut err = struct_span_err!(cx.tcx.sess, p.span, E0009,
"cannot bind by-move and by-ref in the same pattern");
if !allow {
self.add(Qualif::NOT_CONST);
if self.mode != Mode::Fn {
- span_err!(self.tcx.sess, self.span, E0017,
- "references in {}s may only refer \
- to immutable values", self.mode);
+ struct_span_err!(self.tcx.sess, self.span, E0017,
+ "references in {}s may only refer \
+ to immutable values", self.mode)
+ .span_label(self.span, &format!("{}s require immutable values",
+ self.mode))
+ .emit();
}
}
} else {
E0130,
"patterns aren't allowed in foreign function \
declarations");
+ err.span_label(span, &format!("pattern not allowed in foreign function"));
if is_recent {
err.span_note(span,
"this is a recent error, see issue #35203 for more details");
struct_span_err!(resolver.session, span, E0432, "{}", msg)
}
ResolutionError::FailedToResolve(msg) => {
- struct_span_err!(resolver.session, span, E0433, "failed to resolve. {}", msg)
+ let mut err = struct_span_err!(resolver.session, span, E0433,
+ "failed to resolve. {}", msg);
+ err.span_label(span, &msg);
+ err
}
ResolutionError::CannotCaptureDynamicEnvironmentInFnItem => {
struct_span_err!(resolver.session,
use rustc::traits::{self, ProjectionMode};
use rustc::ty::error::ExpectedFound;
use rustc::ty::subst::{self, Subst, Substs, VecPerParamSpace};
+use rustc::hir::map::Node;
+use rustc::hir::{ImplItemKind, TraitItem_};
use syntax::ast;
use syntax_pos::Span;
// Compute skolemized form of impl and trait const tys.
let impl_ty = impl_c.ty.subst(tcx, impl_to_skol_substs);
let trait_ty = trait_c.ty.subst(tcx, &trait_to_skol_substs);
- let origin = TypeOrigin::Misc(impl_c_span);
+ let mut origin = TypeOrigin::Misc(impl_c_span);
let err = infcx.commit_if_ok(|_| {
// There is no "body" here, so just pass dummy id.
debug!("checking associated const for compatibility: impl ty {:?}, trait ty {:?}",
impl_ty,
trait_ty);
+
+ // Locate the Span containing just the type of the offending impl
+ if let Some(impl_trait_node) = tcx.map.get_if_local(impl_c.def_id) {
+ if let Node::NodeImplItem(impl_trait_item) = impl_trait_node {
+ if let ImplItemKind::Const(ref ty, _) = impl_trait_item.node {
+ origin = TypeOrigin::Misc(ty.span);
+ }
+ }
+ }
+
let mut diag = struct_span_err!(
tcx.sess, origin.span(), E0326,
"implemented const `{}` has an incompatible type for trait",
trait_c.name
);
+
+ // Add a label to the Span containing just the type of the item
+ if let Some(orig_trait_node) = tcx.map.get_if_local(trait_c.def_id) {
+ if let Node::NodeTraitItem(orig_trait_item) = orig_trait_node {
+ if let TraitItem_::ConstTraitItem(ref ty, _) = orig_trait_item.node {
+ diag.span_label(ty.span, &format!("original trait requirement"));
+ }
+ }
+ }
+
infcx.note_type_err(
&mut diag, origin,
Some(infer::ValuePairs::Types(ExpectedFound {
(0, Vec::new(), tcx.mk_nil())
}
op => {
- span_err!(tcx.sess, it.span, E0092,
- "unrecognized atomic operation function: `{}`", op);
+ struct_span_err!(tcx.sess, it.span, E0092,
+ "unrecognized atomic operation function: `{}`", op)
+ .span_label(it.span, &format!("unrecognized atomic operation"))
+ .emit();
return;
}
};
// Check for duplicate discriminant values
if let Some(i) = disr_vals.iter().position(|&x| x == current_disr_val) {
- let mut err = struct_span_err!(ccx.tcx.sess, v.span, E0081,
- "discriminant value `{}` already exists", disr_vals[i]);
let variant_i_node_id = ccx.tcx.map.as_local_node_id(variants[i].did).unwrap();
- err.span_label(ccx.tcx.map.span(variant_i_node_id),
- &format!("first use of `{}`", disr_vals[i]));
- err.span_label(v.span , &format!("enum already has `{}`", disr_vals[i]));
- err.emit();
+ let variant_i = ccx.tcx.map.expect_variant(variant_i_node_id);
+ let i_span = match variant_i.node.disr_expr {
+ Some(ref expr) => expr.span,
+ None => ccx.tcx.map.span(variant_i_node_id)
+ };
+ let span = match v.node.disr_expr {
+ Some(ref expr) => expr.span,
+ None => v.span
+ };
+ struct_span_err!(ccx.tcx.sess, span, E0081,
+ "discriminant value `{}` already exists", disr_vals[i])
+ .span_label(i_span, &format!("first use of `{}`", disr_vals[i]))
+ .span_label(span , &format!("enum already has `{}`", disr_vals[i]))
+ .emit();
}
disr_vals.push(current_disr_val);
}
for (i, b) in tps_used.iter().enumerate() {
if !*b {
- span_err!(ccx.tcx.sess, tps[i].span, E0091,
+ struct_span_err!(ccx.tcx.sess, tps[i].span, E0091,
"type parameter `{}` is unused",
- tps[i].name);
+ tps[i].name)
+ .span_label(tps[i].span, &format!("unused type parameter"))
+ .emit();
}
}
}
for leaf_ty in ty.walk() {
if let ty::TyParam(p) = leaf_ty.sty {
if p.space == space && p.idx >= index {
- span_err!(ccx.tcx.sess, path.span, E0128,
- "type parameters with a default cannot use \
- forward declared identifiers");
+ struct_span_err!(ccx.tcx.sess, path.span, E0128,
+ "type parameters with a default cannot use \
+ forward declared identifiers")
+ .span_label(path.span, &format!("defaulted type parameters \
+ cannot be forward declared"))
+ .emit();
return ccx.tcx.types.err
}
abi: Abi,
span: Span) {
if decl.variadic && abi != Abi::C {
- span_err!(tcx.sess, span, E0045,
+ let mut err = struct_span_err!(tcx.sess, span, E0045,
"variadic function must have C calling convention");
+ err.span_label(span, &("variadics require C calling conventions").to_string())
+ .emit();
}
}
///
/// extern { fn my_string() -> *const c_char; }
///
-/// fn main() {
-/// unsafe {
-/// let slice = CStr::from_ptr(my_string());
-/// println!("string length: {}", slice.to_bytes().len());
-/// }
+/// unsafe {
+/// let slice = CStr::from_ptr(my_string());
+/// println!("string length: {}", slice.to_bytes().len());
/// }
/// ```
///
/// unsafe { work_with(data.as_ptr()) }
/// }
///
-/// fn main() {
-/// let s = CString::new("data data data data").unwrap();
-/// work(&s);
-/// }
+/// let s = CString::new("data data data data").unwrap();
+/// work(&s);
/// ```
///
/// Converting a foreign C string into a Rust `String`
/// }
/// }
///
-/// fn main() {
-/// println!("string: {}", my_string_safe());
-/// }
+/// println!("string: {}", my_string_safe());
/// ```
#[derive(Hash)]
#[stable(feature = "rust1", since = "1.0.0")]
///
/// extern { fn puts(s: *const c_char); }
///
- /// fn main() {
- /// let to_print = CString::new("Hello!").unwrap();
- /// unsafe {
- /// puts(to_print.as_ptr());
- /// }
+ /// let to_print = CString::new("Hello!").unwrap();
+ /// unsafe {
+ /// puts(to_print.as_ptr());
/// }
/// ```
///
})
}
- /// Returns true iff the address is unnamed.
+ /// Returns true if and only if the address is unnamed.
#[stable(feature = "unix_socket", since = "1.10.0")]
pub fn is_unnamed(&self) -> bool {
if let AddressKind::Unnamed = self.address() {
fn main() {
let x = Some("s".to_string());
match x {
- op_string @ Some(s) => {}, //~ ERROR E0007
- //~| ERROR E0303
+ op_string @ Some(s) => {},
+ //~^ ERROR E0007
+ //~| NOTE binds an already bound by-move value by moving it
+ //~| ERROR E0303
None => {},
}
}
fn main() {
match Some("hi".to_string()) {
- Some(s) if s.len() == 0 => {}, //~ ERROR E0008
+ Some(s) if s.len() == 0 => {},
+ //~^ ERROR E0008
+ //~| NOTE moves value into pattern guard
_ => {},
}
}
const C: i32 = 2;
const CR: &'static mut i32 = &mut C; //~ ERROR E0017
+ //~| NOTE constants require immutable values
//~| ERROR E0017
+ //~| NOTE constants require immutable values
static STATIC_REF: &'static mut i32 = &mut X; //~ ERROR E0017
+ //~| NOTE statics require immutable values
//~| ERROR E0017
+ //~| NOTE statics require immutable values
//~| ERROR E0388
static CONST_REF: &'static mut i32 = &mut C; //~ ERROR E0017
+ //~| NOTE statics require immutable values
//~| ERROR E0017
-
+ //~| NOTE statics require immutable values
fn main() {}
fn foo(&self) -> Self;
}
-fn call_foo(x: Box<Trait>) { //~ ERROR E0038
+fn call_foo(x: Box<Trait>) {
+ //~^ ERROR E0038
+ //~| NOTE the trait `Trait` cannot be made into an object
+ //~| NOTE method `foo` references the `Self` type in its arguments or return type
let y = x.foo();
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-extern "Rust" { fn foo(x: u8, ...); } //~ ERROR E0045
+extern "Rust" { fn foo(x: u8, ...); } //~ ERROR E0045
+ //~| NOTE variadics require C calling conventions
fn main() {
}
// except according to those terms.
struct ListNode { //~ ERROR E0072
+ //~| NOTE recursive type has infinite size
head: u8,
tail: Option<ListNode>,
}
// except according to those terms.
enum Enum {
- P = 3,
- X = 3, //~ ERROR E0081
+ P = 3, //~ NOTE first use of `3isize`
+ X = 3,
+ //~^ ERROR discriminant value `3isize` already exists
+ //~| NOTE enum already has `3isize`
Y = 5
}
// except according to those terms.
type Foo<T> = u32; //~ ERROR E0091
+ //~| NOTE unused type parameter
type Foo2<A, B> = Box<A>; //~ ERROR E0091
+ //~| NOTE unused type parameter
fn main() {
}
#![feature(intrinsics)]
extern "rust-intrinsic" {
fn atomic_foo(); //~ ERROR E0092
-}
+} //~| NOTE unrecognized atomic operation
fn main() {
}
// except according to those terms.
struct Foo<T=U, U=()> { //~ ERROR E0128
+ //~| NOTE defaulted type parameters cannot be forward declared
field1: T,
field2: U,
}
// except according to those terms.
extern {
- fn foo((a, b): (u32, u32)); //~ ERROR E0130
+ fn foo((a, b): (u32, u32));
+ //~^ ERROR E0130
+ //~| NOTE pattern not allowed in foreign function
}
fn main() {
unsafe fn f() { return; }
fn main() {
- f(); //~ ERROR E0133
+ f();
+ //~^ ERROR E0133
+ //~| NOTE unsafe call requires unsafe function or block
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn foo<'a, 'b, 'a>(x: &'a str, y: &'b str) { } //~ ERROR E0263
+fn foo<'a, 'b, 'a>(x: &'a str, y: &'b str) {
+ //~^ ERROR E0263
+ //~| NOTE declared twice
+ //~| NOTE previous declaration here
+}
fn main() {}
target_arch = "aarch64"))]
pub fn main() {
let x: isize;
- x = 1; //~ NOTE prior assignment occurs here
+ x = 1; //~ NOTE first assignment
foo(x);
unsafe {
asm!("mov $1, $0" : "=r"(x) : "r"(5));
//~^ ERROR re-assignment of immutable variable `x`
+ //~| NOTE re-assignment of immutable
//~| NOTE in this expansion of asm!
}
foo(x);
fn test() {
let v: isize;
- v = 1; //~ NOTE prior assignment occurs here
+ v = 1; //~ NOTE first assignment
println!("v={}", v);
v = 2; //~ ERROR re-assignment of immutable variable
+ //~| NOTE re-assignment of immutable
println!("v={}", v);
}
#![feature(associated_consts)]
trait Foo {
- const BAR: u32;
+ const BAR: u32; //~ NOTE original trait requirement
}
struct SignedBar;
impl Foo for SignedBar {
const BAR: i32 = -1;
//~^ ERROR implemented const `BAR` has an incompatible type for trait [E0326]
- //~| expected u32, found i32
+ //~| NOTE expected u32, found i32
}
fn main() {}
let mut map = HashMap::new();
//~^ ERROR E0433
+ //~| NOTE Use of undeclared type or module `HashMap`
for line in input.lines() {
let line = line.unwrap();
enum Foo {
A = 1,
- //~^ NOTE first use
- //~| NOTE first use
- //~| NOTE first use
- B = 1, //~ ERROR discriminant value
- //~^ NOTE enum already
+ //~^ NOTE first use of `1isize`
+ //~| NOTE first use of `1isize`
+ //~| NOTE first use of `1isize`
+ B = 1,
+ //~^ ERROR discriminant value `1isize` already exists
+ //~| NOTE enum already has `1isize`
C = 0,
- D, //~ ERROR discriminant value
- //~^ NOTE enum already
+ D,
+ //~^ ERROR discriminant value `1isize` already exists
+ //~| NOTE enum already has `1isize`
- E = N, //~ ERROR discriminant value
- //~^ NOTE enum already
+ E = N,
+ //~^ ERROR discriminant value `1isize` already exists
+ //~| NOTE enum already has `1isize`
}
// except according to those terms.
pub struct Foo<Bar=Bar>; //~ ERROR E0128
+ //~| NOTE defaulted type parameters cannot be forward declared
pub struct Baz(Foo);
fn main() {}
//~^ ERROR `Array` cannot be made into an object
//~| NOTE the trait cannot require that `Self : Sized`
//~| NOTE requirements on the impl of `std::ops::CoerceUnsized<&Array>`
+ //~| NOTE the trait `Array` cannot be made into an object
as
&Array;
//~^ ERROR `Array` cannot be made into an object
//~| NOTE the trait cannot require that `Self : Sized`
+ //~| NOTE the trait `Array` cannot be made into an object
}
fn main() {}
fn main() {
let _ = &()
as &Map<Key=u32,MapValue=u32>;
- //~^ ERROR the trait `Map` cannot be made into an object
+ //~^ ERROR E0038
//~| NOTE the trait cannot use `Self` as a type parameter
+ //~| NOTE the trait `Map` cannot be made into an object
}
use std::ptr;
fn main() {
- (&ptr::write)(1 as *mut _, 42); //~ ERROR E0133
+ (&ptr::write)(1 as *mut _, 42);
+ //~^ ERROR E0133
+ //~| NOTE unsafe call requires unsafe function or block
}
enum foo { foo_(bar) }
struct bar { x: bar }
//~^ ERROR E0072
+//~| NOTE recursive type has infinite size
fn main() {
}
// too big.
enum Expr { //~ ERROR E0072
+ //~| NOTE recursive type has infinite size
Plus(Expr, Expr),
Literal(i64),
}
// except according to those terms.
struct S { //~ ERROR E0072
+ //~| NOTE recursive type has infinite size
element: Option<S>
}
let v: isize;
loop {
v = 1; //~ ERROR re-assignment of immutable variable
- //~^ NOTE prior assignment occurs here
+ //~^ NOTE re-assignment of immutable variable
v.clone(); // just to prevent liveness warnings
}
}
fn test() {
let v: isize;
- v = 2; //~ NOTE prior assignment occurs here
+ v = 2; //~ NOTE first assignment
v += 1; //~ ERROR re-assignment of immutable variable
+ //~| NOTE re-assignment of immutable
v.clone();
}
// except according to those terms.
fn test() {
- let v: isize = 1; //~ NOTE prior assignment occurs here
+ let v: isize = 1; //~ NOTE first assignment
v.clone();
v = 2; //~ ERROR re-assignment of immutable variable
+ //~| NOTE re-assignment of immutable
v.clone();
}
extern {
fn f1(mut arg: u8); //~ ERROR patterns aren't allowed in foreign function declarations
- //~^ NOTE this is a recent error
+ //~^ NOTE pattern not allowed in foreign function
+ //~| NOTE this is a recent error
fn f2(&arg: u8); //~ ERROR patterns aren't allowed in foreign function declarations
+ //~^ NOTE pattern not allowed in foreign function
fn f3(arg @ _: u8); //~ ERROR patterns aren't allowed in foreign function declarations
- //~^ NOTE this is a recent error
+ //~^ NOTE pattern not allowed in foreign function
+ //~| NOTE this is a recent error
fn g1(arg: u8); // OK
fn g2(_: u8); // OK
// fn g3(u8); // Not yet
fn make_bar<T:Bar>(t: &T) -> &Bar {
//~^ ERROR E0038
//~| NOTE method `bar` has generic type parameters
+ //~| NOTE the trait `Bar` cannot be made into an object
t
}
fn make_bar_explicit<T:Bar>(t: &T) -> &Bar {
//~^ ERROR E0038
- //~^^ NOTE method `bar` has generic type parameters
+ //~| NOTE method `bar` has generic type parameters
+ //~| NOTE the trait `Bar` cannot be made into an object
t as &Bar
}
fn make_bar<T:Bar>(t: &T) -> &Bar {
//~^ ERROR E0038
//~| NOTE method `bar` references the `Self` type in its arguments or return type
+ //~| NOTE the trait `Bar` cannot be made into an object
loop { }
}
fn make_baz<T:Baz>(t: &T) -> &Baz {
//~^ ERROR E0038
//~| NOTE method `bar` references the `Self` type in its arguments or return type
+ //~| NOTE the trait `Baz` cannot be made into an object
t
}
fn make_bar<T:Bar>(t: &T) -> &Bar {
//~^ ERROR E0038
//~| NOTE the trait cannot require that `Self : Sized`
+ //~| NOTE the trait `Bar` cannot be made into an object
t
}
fn make_baz<T:Baz>(t: &T) -> &Baz {
//~^ ERROR E0038
//~| NOTE the trait cannot use `Self` as a type parameter in the supertrait listing
+ //~| NOTE the trait `Baz` cannot be made into an object
t
}
unsafe impl UnsafeTrait for *mut isize {
fn foo(self) {
// Unsafe actions are not made legal by taking place in an unsafe trait:
- *self += 1; //~ ERROR E0133
+ *self += 1;
+ //~^ ERROR E0133
+ //~| NOTE unsafe call requires unsafe function or block
}
}
// except according to those terms.
struct t1 { //~ ERROR E0072
+ //~| NOTE recursive type has infinite size
foo: isize,
foolish: t1
}
!v
}
-const VAL: u32 = dummy(0xFFFF); //~ ERROR E0133
+const VAL: u32 = dummy(0xFFFF);
+//~^ ERROR E0133
+//~| NOTE unsafe call requires unsafe function or block
fn main() {
assert_eq!(VAL, 0xFFFF0000);
--- /dev/null
+// 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.
+
+fn main() {
+ let x: &'static str = "x";
+
+ {
+ let y = "y".to_string();
+ let ref mut x = &*x;
+ *x = &*y;
+ }
+
+ assert_eq!(x, "x");
+}
type Err = ();
fn from_str(s: &str) -> Result<Mode, ()> {
match s {
- "compile-fail" => Ok(CompileFail),
- "parse-fail" => Ok(ParseFail),
- "run-fail" => Ok(RunFail),
- "run-pass" => Ok(RunPass),
- "run-pass-valgrind" => Ok(RunPassValgrind),
- "pretty" => Ok(Pretty),
- "debuginfo-lldb" => Ok(DebugInfoLldb),
- "debuginfo-gdb" => Ok(DebugInfoGdb),
- "codegen" => Ok(Codegen),
- "rustdoc" => Ok(Rustdoc),
- "codegen-units" => Ok(CodegenUnits),
- "incremental" => Ok(Incremental),
- "run-make" => Ok(RunMake),
- "ui" => Ok(Ui),
- "mir-opt" => Ok(MirOpt),
- _ => Err(()),
+ "compile-fail" => Ok(CompileFail),
+ "parse-fail" => Ok(ParseFail),
+ "run-fail" => Ok(RunFail),
+ "run-pass" => Ok(RunPass),
+ "run-pass-valgrind" => Ok(RunPassValgrind),
+ "pretty" => Ok(Pretty),
+ "debuginfo-lldb" => Ok(DebugInfoLldb),
+ "debuginfo-gdb" => Ok(DebugInfoGdb),
+ "codegen" => Ok(Codegen),
+ "rustdoc" => Ok(Rustdoc),
+ "codegen-units" => Ok(CodegenUnits),
+ "incremental" => Ok(Incremental),
+ "run-make" => Ok(RunMake),
+ "ui" => Ok(Ui),
+ "mir-opt" => Ok(MirOpt),
+ _ => Err(()),
}
}
}
impl fmt::Display for Mode {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fmt::Display::fmt(match *self {
- CompileFail => "compile-fail",
- ParseFail => "parse-fail",
- RunFail => "run-fail",
- RunPass => "run-pass",
- RunPassValgrind => "run-pass-valgrind",
- Pretty => "pretty",
- DebugInfoGdb => "debuginfo-gdb",
- DebugInfoLldb => "debuginfo-lldb",
- Codegen => "codegen",
- Rustdoc => "rustdoc",
- CodegenUnits => "codegen-units",
- Incremental => "incremental",
- RunMake => "run-make",
- Ui => "ui",
- MirOpt => "mir-opt",
- }, f)
+ CompileFail => "compile-fail",
+ ParseFail => "parse-fail",
+ RunFail => "run-fail",
+ RunPass => "run-pass",
+ RunPassValgrind => "run-pass-valgrind",
+ Pretty => "pretty",
+ DebugInfoGdb => "debuginfo-gdb",
+ DebugInfoLldb => "debuginfo-lldb",
+ Codegen => "codegen",
+ Rustdoc => "rustdoc",
+ CodegenUnits => "codegen-units",
+ Incremental => "incremental",
+ RunMake => "run-make",
+ Ui => "ui",
+ MirOpt => "mir-opt",
+ },
+ f)
}
}
}
#[derive(PartialEq, Debug)]
-enum WhichLine { ThisLine, FollowPrevious(usize), AdjustBackward(usize) }
+enum WhichLine {
+ ThisLine,
+ FollowPrevious(usize),
+ AdjustBackward(usize),
+}
/// Looks for either "//~| KIND MESSAGE" or "//~^^... KIND MESSAGE"
/// The former is a "follow" that inherits its target from the preceding line;
let tag = match cfg {
Some(rev) => format!("//[{}]~", rev),
- None => format!("//~")
+ None => format!("//~"),
};
rdr.lines()
- .enumerate()
- .filter_map(|(line_num, line)| {
- parse_expected(last_nonfollow_error,
- line_num + 1,
- &line.unwrap(),
- &tag)
- .map(|(which, error)| {
- match which {
- FollowPrevious(_) => {}
- _ => last_nonfollow_error = Some(error.line_num),
- }
- error
- })
- })
- .collect()
+ .enumerate()
+ .filter_map(|(line_num, line)| {
+ parse_expected(last_nonfollow_error, line_num + 1, &line.unwrap(), &tag)
+ .map(|(which, error)| {
+ match which {
+ FollowPrevious(_) => {}
+ _ => last_nonfollow_error = Some(error.line_num),
+ }
+ error
+ })
+ })
+ .collect()
}
fn parse_expected(last_nonfollow_error: Option<usize>,
line: &str,
tag: &str)
-> Option<(WhichLine, Error)> {
- let start = match line.find(tag) { Some(i) => i, None => return None };
+ let start = match line.find(tag) {
+ Some(i) => i,
+ None => return None,
+ };
let (follow, adjusts) = if line[start + tag.len()..].chars().next().unwrap() == '|' {
(true, 0)
} else {
};
let kind_start = start + tag.len() + adjusts + (follow as usize);
let (kind, msg);
- match
- line[kind_start..].split_whitespace()
- .next()
- .expect("Encountered unexpected empty comment")
- .parse::<ErrorKind>()
- {
+ match line[kind_start..]
+ .split_whitespace()
+ .next()
+ .expect("Encountered unexpected empty comment")
+ .parse::<ErrorKind>() {
Ok(k) => {
// If we find `//~ ERROR foo` or something like that:
kind = Some(k);
let letters = line[kind_start..].chars();
msg = letters.skip_while(|c| c.is_whitespace())
- .skip_while(|c| !c.is_whitespace())
- .collect::<String>();
+ .skip_while(|c| !c.is_whitespace())
+ .collect::<String>();
}
Err(_) => {
// Otherwise we found `//~ foo`:
kind = None;
let letters = line[kind_start..].chars();
msg = letters.skip_while(|c| c.is_whitespace())
- .collect::<String>();
+ .collect::<String>();
}
}
let msg = msg.trim().to_owned();
preceding //~^ line.");
(FollowPrevious(line_num), line_num)
} else {
- let which =
- if adjusts > 0 { AdjustBackward(adjusts) } else { ThisLine };
+ let which = if adjusts > 0 {
+ AdjustBackward(adjusts)
+ } else {
+ ThisLine
+ };
let line_num = line_num - adjusts;
(which, line_num)
};
debug!("line={} tag={:?} which={:?} kind={:?} msg={:?}",
- line_num, tag, which, kind, msg);
- Some((which, Error { line_num: line_num,
- kind: kind,
- msg: msg, }))
+ line_num,
+ tag,
+ which,
+ kind,
+ msg);
+ Some((which,
+ Error {
+ line_num: line_num,
+ kind: kind,
+ msg: msg,
+ }))
}
should_fail: false,
};
- iter_header(testfile, None, &mut |ln| {
+ iter_header(testfile,
+ None,
+ &mut |ln| {
props.ignore =
- props.ignore ||
- parse_name_directive(ln, "ignore-test") ||
+ props.ignore || parse_name_directive(ln, "ignore-test") ||
parse_name_directive(ln, &ignore_target(config)) ||
parse_name_directive(ln, &ignore_architecture(config)) ||
parse_name_directive(ln, &ignore_stage(config)) ||
parse_name_directive(ln, &ignore_env(config)) ||
- (config.mode == common::Pretty &&
- parse_name_directive(ln, "ignore-pretty")) ||
+ (config.mode == common::Pretty && parse_name_directive(ln, "ignore-pretty")) ||
(config.target != config.host &&
parse_name_directive(ln, "ignore-cross-compile")) ||
- ignore_gdb(config, ln) ||
- ignore_lldb(config, ln);
+ ignore_gdb(config, ln) || ignore_lldb(config, ln);
- props.should_fail =
- props.should_fail ||
- parse_name_directive(ln, "should-fail");
+ props.should_fail = props.should_fail || parse_name_directive(ln, "should-fail");
});
return props;
format!("ignore-{}", util::get_arch(&config.target))
}
fn ignore_stage(config: &Config) -> String {
- format!("ignore-{}",
- config.stage_id.split('-').next().unwrap())
+ format!("ignore-{}", config.stage_id.split('-').next().unwrap())
}
fn ignore_env(config: &Config) -> String {
- format!("ignore-{}", util::get_env(&config.target).unwrap_or("<unknown>"))
+ format!("ignore-{}",
+ util::get_env(&config.target).unwrap_or("<unknown>"))
}
fn ignore_gdb(config: &Config, line: &str) -> bool {
if config.mode != common::DebugInfoGdb {
if let Some(ref actual_version) = config.gdb_version {
if line.contains("min-gdb-version") {
let min_version = line.trim()
- .split(' ')
- .last()
- .expect("Malformed GDB version directive");
+ .split(' ')
+ .last()
+ .expect("Malformed GDB version directive");
// Ignore if actual version is smaller the minimum required
// version
- gdb_version_to_int(actual_version) <
- gdb_version_to_int(min_version)
+ gdb_version_to_int(actual_version) < gdb_version_to_int(min_version)
} else {
false
}
if let Some(ref actual_version) = config.lldb_version {
if line.contains("min-lldb-version") {
let min_version = line.trim()
- .split(' ')
- .last()
- .expect("Malformed lldb version directive");
+ .split(' ')
+ .last()
+ .expect("Malformed lldb version directive");
// Ignore if actual version is smaller the minimum required
// version
- lldb_version_to_int(actual_version) <
- lldb_version_to_int(min_version)
+ lldb_version_to_int(actual_version) < lldb_version_to_int(min_version)
} else {
false
}
#[derive(Clone, Debug)]
pub struct TestProps {
// Lines that should be expected, in order, on standard out
- pub error_patterns: Vec<String> ,
+ pub error_patterns: Vec<String>,
// Extra flags to pass to the compiler
pub compile_flags: Vec<String>,
// Extra flags to pass when the compiled code is run (such as --bench)
// Other crates that should be compiled (typically from the same
// directory as the test, but for backwards compatibility reasons
// we also check the auxiliary directory)
- pub aux_builds: Vec<String> ,
+ pub aux_builds: Vec<String>,
// Environment settings to use for compiling
- pub rustc_env: Vec<(String,String)> ,
+ pub rustc_env: Vec<(String, String)>,
// Environment settings to use during execution
- pub exec_env: Vec<(String,String)> ,
+ pub exec_env: Vec<(String, String)>,
// Lines to check if they appear in the expected debugger output
- pub check_lines: Vec<String> ,
+ pub check_lines: Vec<String>,
// Build documentation for all specified aux-builds as well
pub build_aux_docs: bool,
// Flag to force a crate to be built with the host architecture
/// tied to a particular revision `foo` (indicated by writing
/// `//[foo]`), then the property is ignored unless `cfg` is
/// `Some("foo")`.
- pub fn load_from(&mut self, testfile: &Path, cfg: Option<&str>) {
- iter_header(testfile, cfg, &mut |ln| {
+ pub fn load_from(&mut self, testfile: &Path, cfg: Option<&str>) {
+ iter_header(testfile,
+ cfg,
+ &mut |ln| {
if let Some(ep) = parse_error_pattern(ln) {
self.error_patterns.push(ep);
}
if let Some(flags) = parse_compile_flags(ln) {
- self.compile_flags.extend(
- flags
- .split_whitespace()
- .map(|s| s.to_owned()));
+ self.compile_flags.extend(flags.split_whitespace()
+ .map(|s| s.to_owned()));
}
if let Some(r) = parse_revisions(ln) {
self.pretty_compare_only = parse_pretty_compare_only(ln);
}
- if let Some(ab) = parse_aux_build(ln) {
+ if let Some(ab) = parse_aux_build(ln) {
self.aux_builds.push(ab);
}
self.rustc_env.push(ee);
}
- if let Some(cl) = parse_check_line(ln) {
+ if let Some(cl) = parse_check_line(ln) {
self.check_lines.push(cl);
}
for key in vec!["RUST_TEST_NOCAPTURE", "RUST_TEST_THREADS"] {
match env::var(key) {
- Ok(val) =>
+ Ok(val) => {
if self.exec_env.iter().find(|&&(ref x, _)| *x == key).is_none() {
self.exec_env.push((key.to_owned(), val))
- },
+ }
+ }
Err(..) => {}
}
}
}
}
-fn iter_header(testfile: &Path,
- cfg: Option<&str>,
- it: &mut FnMut(&str)) {
+fn iter_header(testfile: &Path, cfg: Option<&str>, it: &mut FnMut(&str)) {
if testfile.is_dir() {
- return
+ return;
}
let rdr = BufReader::new(File::open(testfile).unwrap());
for ln in rdr.lines() {
None => false,
};
if matches {
- it(&ln[close_brace+1..]);
+ it(&ln[close_brace + 1..]);
}
} else {
panic!("malformed condition directive: expected `//[foo]`, found `{}`",
fn parse_env(line: &str, name: &str) -> Option<(String, String)> {
parse_name_value_directive(line, name).map(|nv| {
// nv is either FOO or FOO=BAR
- let mut strs: Vec<String> = nv
- .splitn(2, '=')
- .map(str::to_owned)
- .collect();
+ let mut strs: Vec<String> = nv.splitn(2, '=')
+ .map(str::to_owned)
+ .collect();
match strs.len() {
- 1 => (strs.pop().unwrap(), "".to_owned()),
- 2 => {
- let end = strs.pop().unwrap();
- (strs.pop().unwrap(), end)
- }
- n => panic!("Expected 1 or 2 strings, not {}", n)
+ 1 => (strs.pop().unwrap(), "".to_owned()),
+ 2 => {
+ let end = strs.pop().unwrap();
+ (strs.pop().unwrap(), end)
+ }
+ n => panic!("Expected 1 or 2 strings, not {}", n),
}
})
}
line.contains(directive) && !line.contains(&("no-".to_owned() + directive))
}
-pub fn parse_name_value_directive(line: &str, directive: &str)
- -> Option<String> {
+pub fn parse_name_value_directive(line: &str, directive: &str) -> Option<String> {
let keycolon = format!("{}:", directive);
if let Some(colon) = line.find(&keycolon) {
- let value = line[(colon + keycolon.len()) .. line.len()].to_owned();
+ let value = line[(colon + keycolon.len())..line.len()].to_owned();
debug!("{}: {}", directive, value);
Some(value)
} else {
}
pub fn gdb_version_to_int(version_string: &str) -> isize {
- let error_string = format!(
- "Encountered GDB version string with unexpected format: {}",
- version_string);
+ let error_string = format!("Encountered GDB version string with unexpected format: {}",
+ version_string);
let error_string = error_string;
let components: Vec<&str> = version_string.trim().split('.').collect();
}
pub fn lldb_version_to_int(version_string: &str) -> isize {
- let error_string = format!(
- "Encountered LLDB version string with unexpected format: {}",
- version_string);
+ let error_string = format!("Encountered LLDB version string with unexpected format: {}",
+ version_string);
let error_string = error_string;
let major: isize = version_string.parse().ok().expect(&error_string);
return major;
use rustc_serialize::json;
use std::str::FromStr;
use std::path::Path;
-use runtest::{ProcRes};
+use runtest::ProcRes;
// These structs are a subset of the ones found in
// `syntax::json`.
pub fn parse_output(file_name: &str, output: &str, proc_res: &ProcRes) -> Vec<Error> {
output.lines()
- .flat_map(|line| parse_line(file_name, line, output, proc_res))
- .collect()
+ .flat_map(|line| parse_line(file_name, line, output, proc_res))
+ .collect()
}
fn parse_line(file_name: &str, line: &str, output: &str, proc_res: &ProcRes) -> Vec<Error> {
expected_errors
}
Err(error) => {
- proc_res.fatal(Some(&format!(
- "failed to decode compiler output as json: `{}`\noutput: {}\nline: {}",
- error, line, output)));
+ proc_res.fatal(Some(&format!("failed to decode compiler output as json: \
+ `{}`\noutput: {}\nline: {}",
+ error,
+ line,
+ output)));
}
}
} else {
diagnostic: &Diagnostic,
default_spans: &[&DiagnosticSpan],
file_name: &str) {
- let spans_in_this_file: Vec<_> =
- diagnostic.spans.iter()
- .filter(|span| Path::new(&span.file_name) == Path::new(&file_name))
- .collect();
-
- let primary_spans: Vec<_> =
- spans_in_this_file.iter()
- .cloned()
- .filter(|span| span.is_primary)
- .collect();
+ let spans_in_this_file: Vec<_> = diagnostic.spans
+ .iter()
+ .filter(|span| Path::new(&span.file_name) == Path::new(&file_name))
+ .collect();
+
+ let primary_spans: Vec<_> = spans_in_this_file.iter()
+ .cloned()
+ .filter(|span| span.is_primary)
+ .collect();
let primary_spans = if primary_spans.is_empty() {
// subdiagnostics often don't have a span of their own;
// inherit the span from the parent in that case
for span in primary_spans {
let msg = with_code(span, first_line);
let kind = ErrorKind::from_str(&diagnostic.level).ok();
- expected_errors.push(
- Error {
- line_num: span.line_start,
- kind: kind,
- msg: msg,
- }
- );
+ expected_errors.push(Error {
+ line_num: span.line_start,
+ kind: kind,
+ msg: msg,
+ });
}
}
for next_line in message_lines {
for span in primary_spans {
- expected_errors.push(
- Error {
- line_num: span.line_start,
- kind: None,
- msg: with_code(span, next_line),
- }
- );
+ expected_errors.push(Error {
+ line_num: span.line_start,
+ kind: None,
+ msg: with_code(span, next_line),
+ });
}
}
let start_line = primary_spans.iter().map(|s| s.line_start).min().expect("\
every suggestion should have at least one span");
for (index, line) in rendered.lines().enumerate() {
- expected_errors.push(
- Error {
- line_num: start_line + index,
- kind: Some(ErrorKind::Suggestion),
- msg: line.to_string()
- }
- );
+ expected_errors.push(Error {
+ line_num: start_line + index,
+ kind: Some(ErrorKind::Suggestion),
+ msg: line.to_string(),
+ });
}
}
// Add notes for the backtrace
for span in primary_spans {
for frame in &span.expansion {
- push_backtrace(expected_errors,
- frame,
- file_name);
+ push_backtrace(expected_errors, frame, file_name);
}
}
// Add notes for any labels that appear in the message.
for span in spans_in_this_file.iter()
- .filter(|span| span.label.is_some())
- {
+ .filter(|span| span.label.is_some()) {
expected_errors.push(Error {
line_num: span.line_start,
kind: Some(ErrorKind::Note),
- msg: span.label.clone().unwrap()
+ msg: span.label.clone().unwrap(),
});
}
expansion: &DiagnosticSpanMacroExpansion,
file_name: &str) {
if Path::new(&expansion.span.file_name) == Path::new(&file_name) {
- expected_errors.push(
- Error {
- line_num: expansion.span.line_start,
- kind: Some(ErrorKind::Note),
- msg: format!("in this expansion of {}", expansion.macro_decl_name),
- }
- );
+ expected_errors.push(Error {
+ line_num: expansion.span.line_start,
+ kind: Some(ErrorKind::Note),
+ msg: format!("in this expansion of {}", expansion.macro_decl_name),
+ });
}
for previous_expansion in &expansion.span.expansion {
use std::ffi::OsString;
use std::io::prelude::*;
use std::path::PathBuf;
-use std::process::{ExitStatus, Command, Child, Output, Stdio};
+use std::process::{Child, Command, ExitStatus, Output, Stdio};
pub fn dylib_env_var() -> &'static str {
if cfg!(windows) {
// search path for the child.
let var = dylib_env_var();
let mut path = env::split_paths(&env::var_os(var).unwrap_or(OsString::new()))
- .collect::<Vec<_>>();
+ .collect::<Vec<_>>();
if let Some(p) = aux_path {
path.insert(0, PathBuf::from(p))
}
cmd.env(var, newpath);
}
-pub struct Result {pub status: ExitStatus, pub out: String, pub err: String}
+pub struct Result {
+ pub status: ExitStatus,
+ pub out: String,
+ pub err: String,
+}
pub fn run(lib_path: &str,
prog: &str,
aux_path: Option<&str>,
args: &[String],
- env: Vec<(String, String)> ,
- input: Option<String>) -> Option<Result> {
+ env: Vec<(String, String)>,
+ input: Option<String>)
+ -> Option<Result> {
let mut cmd = Command::new(prog);
cmd.args(args)
- .stdin(Stdio::piped())
- .stdout(Stdio::piped())
- .stderr(Stdio::piped());
+ .stdin(Stdio::piped())
+ .stdout(Stdio::piped())
+ .stderr(Stdio::piped());
add_target_env(&mut cmd, lib_path, aux_path);
for (key, val) in env {
cmd.env(&key, &val);
if let Some(input) = input {
process.stdin.as_mut().unwrap().write_all(input.as_bytes()).unwrap();
}
- let Output { status, stdout, stderr } =
- process.wait_with_output().unwrap();
+ let Output { status, stdout, stderr } = process.wait_with_output().unwrap();
Some(Result {
status: status,
out: String::from_utf8(stdout).unwrap(),
- err: String::from_utf8(stderr).unwrap()
+ err: String::from_utf8(stderr).unwrap(),
})
- },
- Err(..) => None
+ }
+ Err(..) => None,
}
}
pub fn run_background(lib_path: &str,
- prog: &str,
- aux_path: Option<&str>,
- args: &[String],
- env: Vec<(String, String)> ,
- input: Option<String>) -> Option<Child> {
+ prog: &str,
+ aux_path: Option<&str>,
+ args: &[String],
+ env: Vec<(String, String)>,
+ input: Option<String>)
+ -> Option<Child> {
let mut cmd = Command::new(prog);
cmd.args(args)
- .stdin(Stdio::piped())
- .stdout(Stdio::piped())
- .stderr(Stdio::piped());
+ .stdin(Stdio::piped())
+ .stdout(Stdio::piped())
+ .stderr(Stdio::piped());
add_target_env(&mut cmd, lib_path, aux_path);
for (key, val) in env {
cmd.env(&key, &val);
}
Some(process)
- },
- Err(..) => None
+ }
+ Err(..) => None,
}
}
let mut mib: [libc::c_int; 2] = [CTL_KERN, KERN_MAXFILESPERPROC];
let mut maxfiles: libc::c_int = 0;
let mut size: libc::size_t = size_of_val(&maxfiles) as libc::size_t;
- if libc::sysctl(&mut mib[0], 2, &mut maxfiles as *mut _ as *mut _, &mut size,
- null_mut(), 0) != 0 {
+ if libc::sysctl(&mut mib[0],
+ 2,
+ &mut maxfiles as *mut _ as *mut _,
+ &mut size,
+ null_mut(),
+ 0) != 0 {
let err = io::Error::last_os_error();
panic!("raise_fd_limit: error calling sysctl: {}", err);
}
// Fetch the current resource limits
- let mut rlim = libc::rlimit{rlim_cur: 0, rlim_max: 0};
+ let mut rlim = libc::rlimit {
+ rlim_cur: 0,
+ rlim_max: 0,
+ };
if libc::getrlimit(libc::RLIMIT_NOFILE, &mut rlim) != 0 {
let err = io::Error::last_os_error();
panic!("raise_fd_limit: error calling getrlimit: {}", err);
pub fn diff_lines(actual: &str, expected: &str) -> Vec<String> {
// mega simplistic diff algorithm that just prints the things added/removed
- zip_all(actual.lines(), expected.lines()).enumerate().filter_map(|(i, (a,e))| {
- match (a, e) {
- (Some(a), Some(e)) => {
- if lines_match(e, a) {
- None
- } else {
- Some(format!("{:3} - |{}|\n + |{}|\n", i, e, a))
+ zip_all(actual.lines(), expected.lines())
+ .enumerate()
+ .filter_map(|(i, (a, e))| {
+ match (a, e) {
+ (Some(a), Some(e)) => {
+ if lines_match(e, a) {
+ None
+ } else {
+ Some(format!("{:3} - |{}|\n + |{}|\n", i, e, a))
+ }
}
- },
- (Some(a), None) => {
- Some(format!("{:3} -\n + |{}|\n", i, a))
- },
- (None, Some(e)) => {
- Some(format!("{:3} - |{}|\n +\n", i, e))
- },
- (None, None) => panic!("Cannot get here")
- }
- }).collect()
+ (Some(a), None) => Some(format!("{:3} -\n + |{}|\n", i, a)),
+ (None, Some(e)) => Some(format!("{:3} - |{}|\n +\n", i, e)),
+ (None, None) => panic!("Cannot get here"),
+ }
+ })
+ .collect()
}
fn lines_match(expected: &str, mut actual: &str) -> bool {
match actual.find(part) {
Some(j) => {
if i == 0 && j != 0 {
- return false
+ return false;
}
actual = &actual[j + part.len()..];
}
- None => {
- return false
- }
+ None => return false,
}
}
actual.is_empty() || expected.ends_with("[..]")
second: I2,
}
-impl<T, I1: Iterator<Item=T>, I2: Iterator<Item=T>> Iterator for ZipAll<I1, I2> {
+impl<T, I1: Iterator<Item = T>, I2: Iterator<Item = T>> Iterator for ZipAll<I1, I2> {
type Item = (Option<T>, Option<T>);
fn next(&mut self) -> Option<(Option<T>, Option<T>)> {
let first = self.first.next();
match (first, second) {
(None, None) => None,
- (a, b) => Some((a, b))
+ (a, b) => Some((a, b)),
}
}
}
-fn zip_all<T, I1: Iterator<Item=T>, I2: Iterator<Item=T>>(a: I1, b: I2) -> ZipAll<I1, I2> {
+fn zip_all<T, I1: Iterator<Item = T>, I2: Iterator<Item = T>>(a: I1, b: I2) -> ZipAll<I1, I2> {
ZipAll {
first: a,
second: b,
use common::Config;
/// Conversion table from triple OS name to Rust SYSNAME
-const OS_TABLE: &'static [(&'static str, &'static str)] = &[
- ("android", "android"),
- ("bitrig", "bitrig"),
- ("darwin", "macos"),
- ("dragonfly", "dragonfly"),
- ("freebsd", "freebsd"),
- ("ios", "ios"),
- ("linux", "linux"),
- ("mingw32", "windows"),
- ("netbsd", "netbsd"),
- ("openbsd", "openbsd"),
- ("win32", "windows"),
- ("windows", "windows"),
- ("solaris", "solaris"),
- ("emscripten", "emscripten"),
-];
+const OS_TABLE: &'static [(&'static str, &'static str)] = &[("android", "android"),
+ ("bitrig", "bitrig"),
+ ("darwin", "macos"),
+ ("dragonfly", "dragonfly"),
+ ("freebsd", "freebsd"),
+ ("ios", "ios"),
+ ("linux", "linux"),
+ ("mingw32", "windows"),
+ ("netbsd", "netbsd"),
+ ("openbsd", "openbsd"),
+ ("win32", "windows"),
+ ("windows", "windows"),
+ ("solaris", "solaris"),
+ ("emscripten", "emscripten")];
-const ARCH_TABLE: &'static [(&'static str, &'static str)] = &[
- ("aarch64", "aarch64"),
- ("amd64", "x86_64"),
- ("arm", "arm"),
- ("arm64", "aarch64"),
- ("hexagon", "hexagon"),
- ("i386", "x86"),
- ("i686", "x86"),
- ("mips", "mips"),
- ("msp430", "msp430"),
- ("powerpc", "powerpc"),
- ("powerpc64", "powerpc64"),
- ("s390x", "systemz"),
- ("sparc", "sparc"),
- ("x86_64", "x86_64"),
- ("xcore", "xcore"),
- ("asmjs", "asmjs"),
-];
+const ARCH_TABLE: &'static [(&'static str, &'static str)] = &[("aarch64", "aarch64"),
+ ("amd64", "x86_64"),
+ ("arm", "arm"),
+ ("arm64", "aarch64"),
+ ("hexagon", "hexagon"),
+ ("i386", "x86"),
+ ("i686", "x86"),
+ ("mips", "mips"),
+ ("msp430", "msp430"),
+ ("powerpc", "powerpc"),
+ ("powerpc64", "powerpc64"),
+ ("s390x", "systemz"),
+ ("sparc", "sparc"),
+ ("x86_64", "x86_64"),
+ ("xcore", "xcore"),
+ ("asmjs", "asmjs")];
pub fn get_os(triple: &str) -> &'static str {
for &(triple_os, os) in OS_TABLE {
if triple.contains(triple_os) {
- return os
+ return os;
}
}
panic!("Cannot determine OS from triple");
pub fn get_arch(triple: &str) -> &'static str {
for &(triple_arch, arch) in ARCH_TABLE {
if triple.contains(triple_arch) {
- return arch
+ return arch;
}
}
panic!("Cannot determine Architecture from triple");
// Windows just uses PATH as the library search path, so we have to
// maintain the current value while adding our own
match env::var(lib_path_env_var()) {
- Ok(curr) => {
- format!("{}{}{}", path, path_div(), curr)
- }
- Err(..) => path.to_owned()
+ Ok(curr) => format!("{}{}{}", path, path_div(), curr),
+ Err(..) => path.to_owned(),
}
}
-pub fn lib_path_env_var() -> &'static str { "PATH" }
-fn path_div() -> &'static str { ";" }
+pub fn lib_path_env_var() -> &'static str {
+ "PATH"
+}
+fn path_div() -> &'static str {
+ ";"
+}
pub fn logv(config: &Config, s: String) {
debug!("{}", s);
- if config.verbose { println!("{}", s); }
+ if config.verbose {
+ println!("{}", s);
+ }
}
projects / rust.git / commitdiff