use std::env;
use std::ffi::OsString;
-use std::io;
-use std::io::prelude::*;
use std::str::FromStr;
use std::path::PathBuf;
use std::process::{Command, ExitStatus};
}
if verbose > 1 {
- writeln!(&mut io::stderr(), "rustc command: {:?}", cmd).unwrap();
+ eprintln!("rustc command: {:?}", cmd);
}
// Actually run the compiler!
errors::Level::Note);
}
- writeln!(io::stderr(), "{}", str::from_utf8(&data.lock().unwrap()).unwrap()).unwrap();
+ eprintln!("{}", str::from_utf8(&data.lock().unwrap()).unwrap());
}
exit_on_err();
use std::fs::File;
use std::io::prelude::*;
-use std::io;
use std::path::Path;
use std::str;
use html::markdown::{Markdown, RenderType};
let result = File::open(file_path)
.and_then(|mut f| f.read_to_end(&mut contents));
if let Err(e) = result {
- let _ = writeln!(&mut io::stderr(),
- "error reading `{}`: {}",
- file_path.display(), e);
+ eprintln!("error reading `{}`: {}", file_path.display(), e);
return Err(LoadStringError::ReadFail);
}
match str::from_utf8(&contents) {
Ok(s) => Ok(s.to_string()),
Err(_) => {
- let _ = writeln!(&mut io::stderr(),
- "error reading `{}`: not UTF-8",
- file_path.display());
+ eprintln!("error reading `{}`: not UTF-8", file_path.display());
Err(LoadStringError::BadUtf8)
}
}
use std::default::Default;
use std::fs::File;
use std::io::prelude::*;
-use std::io;
use std::path::{PathBuf, Path};
use getopts;
let mut out = match File::create(&output) {
Err(e) => {
- let _ = writeln!(&mut io::stderr(),
- "rustdoc: {}: {}",
- output.display(), e);
+ eprintln!("rustdoc: {}: {}", output.display(), e);
return 4;
}
Ok(f) => f
let (metadata, text) = extract_leading_metadata(&input_str);
if metadata.is_empty() {
- let _ = writeln!(
- &mut io::stderr(),
- "rustdoc: invalid markdown file: no initial lines starting with `# ` or `%`"
- );
+ eprintln!("rustdoc: invalid markdown file: no initial lines starting with `# ` or `%`");
return 5;
}
let title = metadata[0];
match err {
Err(e) => {
- let _ = writeln!(&mut io::stderr(),
- "rustdoc: cannot write to `{}`: {}",
- output.display(), e);
+ eprintln!("rustdoc: cannot write to `{}`: {}", output.display(), e);
6
}
Ok(_) => 0
found = entry.remove_item(&test).is_some();
}
if !found {
- let _ = writeln!(&mut io::stderr(),
- "WARNING: {} Code block is not currently run as a test, but will \
- in future versions of rustdoc. Please ensure this code block is \
- a runnable test, or use the `ignore` directive.",
- name);
+ eprintln!("WARNING: {} Code block is not currently run as a test, but will \
+ in future versions of rustdoc. Please ensure this code block is \
+ a runnable test, or use the `ignore` directive.",
+ name);
return
}
}
/// function and compute the exit code from its return value:
///
/// ```
-/// use std::io::{self, Write};
-///
/// fn run_app() -> Result<(), ()> {
/// // Application logic here
/// Ok(())
/// ::std::process::exit(match run_app() {
/// Ok(_) => 0,
/// Err(err) => {
-/// writeln!(io::stderr(), "error: {:?}", err).unwrap();
+/// eprintln!("error: {:?}", err);
/// 1
/// }
/// });
// error-pattern:panic 1
// error-pattern:drop 2
-use std::io::{self, Write};
struct Droppable(u32);
impl Drop for Droppable {
if self.0 == 1 {
panic!("panic 1");
} else {
- write!(io::stderr(), "drop {}", self.0);
+ eprint!("drop {}", self.0);
}
}
}
// except according to those terms.
// error-pattern:drop 1
// error-pattern:drop 2
-use std::io::{self, Write};
/// Structure which will not allow to be dropped twice.
impl<'a> Drop for Droppable<'a> {
fn drop(&mut self) {
if *self.0 {
- writeln!(io::stderr(), "{} dropped twice", self.1);
+ eprintln!("{} dropped twice", self.1);
::std::process::exit(1);
}
- writeln!(io::stderr(), "drop {}", self.1);
+ eprintln!("drop {}", self.1);
*self.0 = true;
}
}
// except according to those terms.
// error-pattern:drop 1
-use std::io::{self, Write};
/// Structure which will not allow to be dropped twice.
impl<'a> Drop for Droppable<'a> {
fn drop(&mut self) {
if *self.0 {
- writeln!(io::stderr(), "{} dropped twice", self.1);
+ eprintln!("{} dropped twice", self.1);
::std::process::exit(1);
}
- writeln!(io::stderr(), "drop {}", self.1);
+ eprintln!("drop {}", self.1);
*self.0 = true;
}
}
// error-pattern:drop 3
// error-pattern:drop 2
// error-pattern:drop 1
-use std::io::{self, Write};
/// Structure which will not allow to be dropped twice.
impl<'a> Drop for Droppable<'a> {
fn drop(&mut self) {
if *self.0 {
- writeln!(io::stderr(), "{} dropped twice", self.1);
+ eprintln!("{} dropped twice", self.1);
::std::process::exit(1);
}
- writeln!(io::stderr(), "drop {}", self.1);
+ eprintln!("drop {}", self.1);
*self.0 = true;
}
}
// error-pattern:0 dropped
// error-pattern:exit
-use std::io::{self, Write};
-
struct Droppable(u8);
impl Drop for Droppable {
fn drop(&mut self) {
- write!(io::stderr(), "{} dropped\n", self.0);
+ eprintln!("{} dropped", self.0);
}
}
fn converging_fn() {
- write!(io::stderr(), "converging_fn called\n");
+ eprintln!("converging_fn called");
}
fn mir(d: Droppable) {
// error-pattern:dropped
// error-pattern:exit
-use std::io::{self, Write};
-
struct Droppable;
impl Drop for Droppable {
fn drop(&mut self) {
- write!(io::stderr(), "dropped\n");
+ eprintln!("dropped");
}
}
// return value of this function is copied into the return slot
fn complex() -> u64 {
- write!(io::stderr(), "complex called\n");
+ eprintln!("complex called");
42
}
// error-pattern:diverging_fn called
// error-pattern:0 dropped
-use std::io::{self, Write};
-
struct Droppable(u8);
impl Drop for Droppable {
fn drop(&mut self) {
- write!(io::stderr(), "{} dropped", self.0);
+ eprintln!("{} dropped", self.0);
}
}
#![feature(panic_handler)]
use std::panic;
-use std::io::{self, Write};
fn main() {
panic::set_hook(Box::new(|i| {
- write!(io::stderr(), "greetings from the panic handler");
+ eprint!("greetings from the panic handler");
}));
panic!("foobar");
}
#![feature(panic_handler)]
use std::panic;
-use std::io::{self, Write};
fn main() {
panic::set_hook(Box::new(|i| {
- write!(io::stderr(), "greetings from the panic handler");
+ eprint!("greetings from the panic handler");
}));
panic::take_hook();
panic!("foobar");
// ignore-pretty issue #37195
// ignore-emscripten spawning processes is not supported
-use std::io;
-use std::io::prelude::*;
use std::env;
#[path = "backtrace-debuginfo-aux.rs"] mod aux;
let args: Vec<String> = env::args().collect();
if args.len() >= 2 {
let case = args[1].parse().unwrap();
- writeln!(&mut io::stderr(), "test case {}", case).unwrap();
+ eprintln!("test case {}", case);
outer(case, pos!());
println!("done.");
} else {
macro_rules! tidy_error {
($bad:expr, $fmt:expr, $($arg:tt)*) => ({
- use std::io::Write;
*$bad = true;
- write!(::std::io::stderr(), "tidy error: ").expect("could not write to stderr");
- writeln!(::std::io::stderr(), $fmt, $($arg)*).expect("could not write to stderr");
+ eprint!("tidy error: ");
+ eprintln!($fmt, $($arg)*);
});
}
use std::process;
use std::path::PathBuf;
use std::env;
-use std::io::{self, Write};
fn main() {
let path = env::args_os().skip(1).next().expect("need an argument");
}
if bad {
- writeln!(io::stderr(), "some tidy checks failed").expect("could not write to stderr");
+ eprintln!("some tidy checks failed");
process::exit(1);
}
}
projects / rust.git / commitdiff