bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Mass rename if_ok! to try!

Browse source 
This "bubble up an error" macro was originally named if_ok! in order to get it
landed, but after the fact it was discovered that this name is not exactly
desirable.

The name `if_ok!` isn't immediately clear that is has much to do with error
handling, and it doesn't look fantastic in all contexts (if if_ok!(...) {}). In
general, the agreed opinion about `if_ok!` is that is came in as subpar.

The name `try!` is more invocative of error handling, it's shorter by 2 letters,
and it looks fitting in almost all circumstances. One concern about the word
`try!` is that it's too invocative of exceptions, but the belief is that this
will be overcome with documentation and examples.

Close #12037
This commit is contained in:
Alex Crichton 2014-02-19 10:07:49 -08:00
parent 06e1281198
commit 7bb498bd7a
32 changed files with 1222 additions and 1226 deletions
Download patch file Download diff file Expand all files Collapse all files

104
src/libextra/json.rs
View file

@ -246,7 +246,7 @@ use serialize::Encodable;
use serialize; use serialize;
use collections::TreeMap; use collections::TreeMap;
macro_rules! if_ok( ($e:expr) => ( macro_rules! try( ($e:expr) => (
match $e { Ok(e) => e, Err(e) => { self.error = Err(e); return } } match $e { Ok(e) => e, Err(e) => { self.error = Err(e); return } }
) ) ) )
@ -342,7 +342,7 @@ impl<'a> Encoder<'a> {
} }
impl<'a> serialize::Encoder for Encoder<'a> { impl<'a> serialize::Encoder for Encoder<'a> {
fn emit_nil(&mut self) { if_ok!(write!(self.wr, "null")) } fn emit_nil(&mut self) { try!(write!(self.wr, "null")) }
fn emit_uint(&mut self, v: uint) { self.emit_f64(v as f64); } fn emit_uint(&mut self, v: uint) { self.emit_f64(v as f64); }
fn emit_u64(&mut self, v: u64) { self.emit_f64(v as f64); } fn emit_u64(&mut self, v: u64) { self.emit_f64(v as f64); }
@ -358,20 +358,20 @@ impl<'a> serialize::Encoder for Encoder<'a> {
fn emit_bool(&mut self, v: bool) { fn emit_bool(&mut self, v: bool) {
if v { if v {
if_ok!(write!(self.wr, "true")); try!(write!(self.wr, "true"));
} else { } else {
if_ok!(write!(self.wr, "false")); try!(write!(self.wr, "false"));
} }
} }
fn emit_f64(&mut self, v: f64) { fn emit_f64(&mut self, v: f64) {
if_ok!(write!(self.wr, "{}", f64::to_str_digits(v, 6u))) try!(write!(self.wr, "{}", f64::to_str_digits(v, 6u)))
} }
fn emit_f32(&mut self, v: f32) { self.emit_f64(v as f64); } fn emit_f32(&mut self, v: f32) { self.emit_f64(v as f64); }
fn emit_char(&mut self, v: char) { self.emit_str(str::from_char(v)) } fn emit_char(&mut self, v: char) { self.emit_str(str::from_char(v)) }
fn emit_str(&mut self, v: &str) { fn emit_str(&mut self, v: &str) {
if_ok!(write!(self.wr, "{}", escape_str(v))) try!(write!(self.wr, "{}", escape_str(v)))
} }
fn emit_enum(&mut self, _name: &str, f: |&mut Encoder<'a>|) { f(self) } fn emit_enum(&mut self, _name: &str, f: |&mut Encoder<'a>|) { f(self) }
@ -385,19 +385,19 @@ impl<'a> serialize::Encoder for Encoder<'a> {
// Bunny => "Bunny" // Bunny => "Bunny"
// Kangaroo(34,"William") => {"variant": "Kangaroo", "fields": [34,"William"]} // Kangaroo(34,"William") => {"variant": "Kangaroo", "fields": [34,"William"]}
if cnt == 0 { if cnt == 0 {
if_ok!(write!(self.wr, "{}", escape_str(name))); try!(write!(self.wr, "{}", escape_str(name)));
} else { } else {
if_ok!(write!(self.wr, "\\{\"variant\":")); try!(write!(self.wr, "\\{\"variant\":"));
if_ok!(write!(self.wr, "{}", escape_str(name))); try!(write!(self.wr, "{}", escape_str(name)));
if_ok!(write!(self.wr, ",\"fields\":[")); try!(write!(self.wr, ",\"fields\":["));
f(self); f(self);
if_ok!(write!(self.wr, "]\\}")); try!(write!(self.wr, "]\\}"));
} }
} }
fn emit_enum_variant_arg(&mut self, idx: uint, f: |&mut Encoder<'a>|) { fn emit_enum_variant_arg(&mut self, idx: uint, f: |&mut Encoder<'a>|) {
if idx != 0 { if idx != 0 {
if_ok!(write!(self.wr, ",")); try!(write!(self.wr, ","));
} }
f(self); f(self);
} }
@ -418,17 +418,17 @@ impl<'a> serialize::Encoder for Encoder<'a> {
} }
fn emit_struct(&mut self, _: &str, _: uint, f: |&mut Encoder<'a>|) { fn emit_struct(&mut self, _: &str, _: uint, f: |&mut Encoder<'a>|) {
if_ok!(write!(self.wr, r"\{")); try!(write!(self.wr, r"\{"));
f(self); f(self);
if_ok!(write!(self.wr, r"\}")); try!(write!(self.wr, r"\}"));
} }
fn emit_struct_field(&mut self, fn emit_struct_field(&mut self,
name: &str, name: &str,
idx: uint, idx: uint,
f: |&mut Encoder<'a>|) { f: |&mut Encoder<'a>|) {
if idx != 0 { if_ok!(write!(self.wr, ",")) } if idx != 0 { try!(write!(self.wr, ",")) }
if_ok!(write!(self.wr, "{}:", escape_str(name))); try!(write!(self.wr, "{}:", escape_str(name)));
f(self); f(self);
} }
@ -454,31 +454,31 @@ impl<'a> serialize::Encoder for Encoder<'a> {
fn emit_option_some(&mut self, f: |&mut Encoder<'a>|) { f(self); } fn emit_option_some(&mut self, f: |&mut Encoder<'a>|) { f(self); }
fn emit_seq(&mut self, _len: uint, f: |&mut Encoder<'a>|) { fn emit_seq(&mut self, _len: uint, f: |&mut Encoder<'a>|) {
if_ok!(write!(self.wr, "[")); try!(write!(self.wr, "["));
f(self); f(self);
if_ok!(write!(self.wr, "]")); try!(write!(self.wr, "]"));
} }
fn emit_seq_elt(&mut self, idx: uint, f: |&mut Encoder<'a>|) { fn emit_seq_elt(&mut self, idx: uint, f: |&mut Encoder<'a>|) {
if idx != 0 { if idx != 0 {
if_ok!(write!(self.wr, ",")); try!(write!(self.wr, ","));
} }
f(self) f(self)
} }
fn emit_map(&mut self, _len: uint, f: |&mut Encoder<'a>|) { fn emit_map(&mut self, _len: uint, f: |&mut Encoder<'a>|) {
if_ok!(write!(self.wr, r"\{")); try!(write!(self.wr, r"\{"));
f(self); f(self);
if_ok!(write!(self.wr, r"\}")); try!(write!(self.wr, r"\}"));
} }
fn emit_map_elt_key(&mut self, idx: uint, f: |&mut Encoder<'a>|) { fn emit_map_elt_key(&mut self, idx: uint, f: |&mut Encoder<'a>|) {
if idx != 0 { if_ok!(write!(self.wr, ",")) } if idx != 0 { try!(write!(self.wr, ",")) }
f(self) f(self)
} }
fn emit_map_elt_val(&mut self, _idx: uint, f: |&mut Encoder<'a>|) { fn emit_map_elt_val(&mut self, _idx: uint, f: |&mut Encoder<'a>|) {
if_ok!(write!(self.wr, ":")); try!(write!(self.wr, ":"));
f(self) f(self)
} }
} }
@ -503,7 +503,7 @@ impl<'a> PrettyEncoder<'a> {
} }
impl<'a> serialize::Encoder for PrettyEncoder<'a> { impl<'a> serialize::Encoder for PrettyEncoder<'a> {
fn emit_nil(&mut self) { if_ok!(write!(self.wr, "null")); } fn emit_nil(&mut self) { try!(write!(self.wr, "null")); }
fn emit_uint(&mut self, v: uint) { self.emit_f64(v as f64); } fn emit_uint(&mut self, v: uint) { self.emit_f64(v as f64); }
fn emit_u64(&mut self, v: u64) { self.emit_f64(v as f64); } fn emit_u64(&mut self, v: u64) { self.emit_f64(v as f64); }
@ -519,20 +519,20 @@ impl<'a> serialize::Encoder for PrettyEncoder<'a> {
fn emit_bool(&mut self, v: bool) { fn emit_bool(&mut self, v: bool) {
if v { if v {
if_ok!(write!(self.wr, "true")); try!(write!(self.wr, "true"));
} else { } else {
if_ok!(write!(self.wr, "false")); try!(write!(self.wr, "false"));
} }
} }
fn emit_f64(&mut self, v: f64) { fn emit_f64(&mut self, v: f64) {
if_ok!(write!(self.wr, "{}", f64::to_str_digits(v, 6u))); try!(write!(self.wr, "{}", f64::to_str_digits(v, 6u)));
} }
fn emit_f32(&mut self, v: f32) { self.emit_f64(v as f64); } fn emit_f32(&mut self, v: f32) { self.emit_f64(v as f64); }
fn emit_char(&mut self, v: char) { self.emit_str(str::from_char(v)) } fn emit_char(&mut self, v: char) { self.emit_str(str::from_char(v)) }
fn emit_str(&mut self, v: &str) { fn emit_str(&mut self, v: &str) {
if_ok!(write!(self.wr, "{}", escape_str(v))); try!(write!(self.wr, "{}", escape_str(v)));
} }
fn emit_enum(&mut self, _name: &str, f: |&mut PrettyEncoder<'a>|) { fn emit_enum(&mut self, _name: &str, f: |&mut PrettyEncoder<'a>|) {
@ -545,14 +545,14 @@ impl<'a> serialize::Encoder for PrettyEncoder<'a> {
cnt: uint, cnt: uint,
f: |&mut PrettyEncoder<'a>|) { f: |&mut PrettyEncoder<'a>|) {
if cnt == 0 { if cnt == 0 {
if_ok!(write!(self.wr, "{}", escape_str(name))); try!(write!(self.wr, "{}", escape_str(name)));
} else { } else {
self.indent += 2; self.indent += 2;
if_ok!(write!(self.wr, "[\n{}{},\n", spaces(self.indent), try!(write!(self.wr, "[\n{}{},\n", spaces(self.indent),
escape_str(name))); escape_str(name)));
f(self); f(self);
self.indent -= 2; self.indent -= 2;
if_ok!(write!(self.wr, "\n{}]", spaces(self.indent))); try!(write!(self.wr, "\n{}]", spaces(self.indent)));
} }
} }
@ -560,9 +560,9 @@ impl<'a> serialize::Encoder for PrettyEncoder<'a> {
idx: uint, idx: uint,
f: |&mut PrettyEncoder<'a>|) { f: |&mut PrettyEncoder<'a>|) {
if idx != 0 { if idx != 0 {
if_ok!(write!(self.wr, ",\n")); try!(write!(self.wr, ",\n"));
} }
if_ok!(write!(self.wr, "{}", spaces(self.indent))); try!(write!(self.wr, "{}", spaces(self.indent)));
f(self) f(self)
} }
@ -587,13 +587,13 @@ impl<'a> serialize::Encoder for PrettyEncoder<'a> {
len: uint, len: uint,
f: |&mut PrettyEncoder<'a>|) { f: |&mut PrettyEncoder<'a>|) {
if len == 0 { if len == 0 {
if_ok!(write!(self.wr, "\\{\\}")); try!(write!(self.wr, "\\{\\}"));
} else { } else {
if_ok!(write!(self.wr, "\\{")); try!(write!(self.wr, "\\{"));
self.indent += 2; self.indent += 2;
f(self); f(self);
self.indent -= 2; self.indent -= 2;
if_ok!(write!(self.wr, "\n{}\\}", spaces(self.indent))); try!(write!(self.wr, "\n{}\\}", spaces(self.indent)));
} }
} }
@ -602,11 +602,11 @@ impl<'a> serialize::Encoder for PrettyEncoder<'a> {
idx: uint, idx: uint,
f: |&mut PrettyEncoder<'a>|) { f: |&mut PrettyEncoder<'a>|) {
if idx == 0 { if idx == 0 {
if_ok!(write!(self.wr, "\n")); try!(write!(self.wr, "\n"));
} else { } else {
if_ok!(write!(self.wr, ",\n")); try!(write!(self.wr, ",\n"));
} }
if_ok!(write!(self.wr, "{}{}: ", spaces(self.indent), escape_str(name))); try!(write!(self.wr, "{}{}: ", spaces(self.indent), escape_str(name)));
f(self); f(self);
} }
@ -635,50 +635,50 @@ impl<'a> serialize::Encoder for PrettyEncoder<'a> {
fn emit_seq(&mut self, len: uint, f: |&mut PrettyEncoder<'a>|) { fn emit_seq(&mut self, len: uint, f: |&mut PrettyEncoder<'a>|) {
if len == 0 { if len == 0 {
if_ok!(write!(self.wr, "[]")); try!(write!(self.wr, "[]"));
} else { } else {
if_ok!(write!(self.wr, "[")); try!(write!(self.wr, "["));
self.indent += 2; self.indent += 2;
f(self); f(self);
self.indent -= 2; self.indent -= 2;
if_ok!(write!(self.wr, "\n{}]", spaces(self.indent))); try!(write!(self.wr, "\n{}]", spaces(self.indent)));
} }
} }
fn emit_seq_elt(&mut self, idx: uint, f: |&mut PrettyEncoder<'a>|) { fn emit_seq_elt(&mut self, idx: uint, f: |&mut PrettyEncoder<'a>|) {
if idx == 0 { if idx == 0 {
if_ok!(write!(self.wr, "\n")); try!(write!(self.wr, "\n"));
} else { } else {
if_ok!(write!(self.wr, ",\n")); try!(write!(self.wr, ",\n"));
} }
if_ok!(write!(self.wr, "{}", spaces(self.indent))); try!(write!(self.wr, "{}", spaces(self.indent)));
f(self) f(self)
} }
fn emit_map(&mut self, len: uint, f: |&mut PrettyEncoder<'a>|) { fn emit_map(&mut self, len: uint, f: |&mut PrettyEncoder<'a>|) {
if len == 0 { if len == 0 {
if_ok!(write!(self.wr, "\\{\\}")); try!(write!(self.wr, "\\{\\}"));
} else { } else {
if_ok!(write!(self.wr, "\\{")); try!(write!(self.wr, "\\{"));
self.indent += 2; self.indent += 2;
f(self); f(self);
self.indent -= 2; self.indent -= 2;
if_ok!(write!(self.wr, "\n{}\\}", spaces(self.indent))); try!(write!(self.wr, "\n{}\\}", spaces(self.indent)));
} }
} }
fn emit_map_elt_key(&mut self, idx: uint, f: |&mut PrettyEncoder<'a>|) { fn emit_map_elt_key(&mut self, idx: uint, f: |&mut PrettyEncoder<'a>|) {
if idx == 0 { if idx == 0 {
if_ok!(write!(self.wr, "\n")); try!(write!(self.wr, "\n"));
} else { } else {
if_ok!(write!(self.wr, ",\n")); try!(write!(self.wr, ",\n"));
} }
if_ok!(write!(self.wr, "{}", spaces(self.indent))); try!(write!(self.wr, "{}", spaces(self.indent)));
f(self); f(self);
} }
fn emit_map_elt_val(&mut self, _idx: uint, f: |&mut PrettyEncoder<'a>|) { fn emit_map_elt_val(&mut self, _idx: uint, f: |&mut PrettyEncoder<'a>|) {
if_ok!(write!(self.wr, ": ")); try!(write!(self.wr, ": "));
f(self); f(self);
} }
} }

22
src/libextra/stats.rs
View file

@ -376,48 +376,48 @@ pub fn write_boxplot(w: &mut io::Writer, s: &Summary,
let range_width = width_hint - overhead_width;; let range_width = width_hint - overhead_width;;
let char_step = range / (range_width as f64); let char_step = range / (range_width as f64);
if_ok!(write!(w, "{} |", lostr)); try!(write!(w, "{} |", lostr));
let mut c = 0; let mut c = 0;
let mut v = lo; let mut v = lo;
while c < range_width && v < s.min { while c < range_width && v < s.min {
if_ok!(write!(w, " ")); try!(write!(w, " "));
v += char_step; v += char_step;
c += 1; c += 1;
} }
if_ok!(write!(w, "[")); try!(write!(w, "["));
c += 1; c += 1;
while c < range_width && v < q1 { while c < range_width && v < q1 {
if_ok!(write!(w, "-")); try!(write!(w, "-"));
v += char_step; v += char_step;
c += 1; c += 1;
} }
while c < range_width && v < q2 { while c < range_width && v < q2 {
if_ok!(write!(w, "*")); try!(write!(w, "*"));
v += char_step; v += char_step;
c += 1; c += 1;
} }
if_ok!(write!(w, r"\#")); try!(write!(w, r"\#"));
c += 1; c += 1;
while c < range_width && v < q3 { while c < range_width && v < q3 {
if_ok!(write!(w, "*")); try!(write!(w, "*"));
v += char_step; v += char_step;
c += 1; c += 1;
} }
while c < range_width && v < s.max { while c < range_width && v < s.max {
if_ok!(write!(w, "-")); try!(write!(w, "-"));
v += char_step; v += char_step;
c += 1; c += 1;
} }
if_ok!(write!(w, "]")); try!(write!(w, "]"));
while c < range_width { while c < range_width {
if_ok!(write!(w, " ")); try!(write!(w, " "));
v += char_step; v += char_step;
c += 1; c += 1;
} }
if_ok!(write!(w, "| {}", histr)); try!(write!(w, "| {}", histr));
Ok(()) Ok(())
} }

10
src/libnative/io/pipe_unix.rs
View file

@ -77,8 +77,8 @@ impl Drop for Inner {
} }
fn connect(addr: &CString, ty: libc::c_int) -> IoResult<Inner> { fn connect(addr: &CString, ty: libc::c_int) -> IoResult<Inner> {
let (addr, len) = if_ok!(addr_to_sockaddr_un(addr)); let (addr, len) = try!(addr_to_sockaddr_un(addr));
let inner = Inner { fd: if_ok!(unix_socket(ty)) }; let inner = Inner { fd: try!(unix_socket(ty)) };
let addrp = &addr as *libc::sockaddr_storage; let addrp = &addr as *libc::sockaddr_storage;
match retry(|| unsafe { match retry(|| unsafe {
libc::connect(inner.fd, addrp as *libc::sockaddr, libc::connect(inner.fd, addrp as *libc::sockaddr,
@ -90,8 +90,8 @@ fn connect(addr: &CString, ty: libc::c_int) -> IoResult<Inner> {
} }
fn bind(addr: &CString, ty: libc::c_int) -> IoResult<Inner> { fn bind(addr: &CString, ty: libc::c_int) -> IoResult<Inner> {
let (addr, len) = if_ok!(addr_to_sockaddr_un(addr)); let (addr, len) = try!(addr_to_sockaddr_un(addr));
let inner = Inner { fd: if_ok!(unix_socket(ty)) }; let inner = Inner { fd: try!(unix_socket(ty)) };
let addrp = &addr as *libc::sockaddr_storage; let addrp = &addr as *libc::sockaddr_storage;
match unsafe { match unsafe {
libc::bind(inner.fd, addrp as *libc::sockaddr, len as libc::socklen_t) libc::bind(inner.fd, addrp as *libc::sockaddr, len as libc::socklen_t)
@ -198,7 +198,7 @@ impl UnixDatagram {
} }
pub fn sendto(&mut self, buf: &[u8], dst: &CString) -> IoResult<()> { pub fn sendto(&mut self, buf: &[u8], dst: &CString) -> IoResult<()> {
let (dst, len) = if_ok!(addr_to_sockaddr_un(dst)); let (dst, len) = try!(addr_to_sockaddr_un(dst));
let dstp = &dst as *libc::sockaddr_storage; let dstp = &dst as *libc::sockaddr_storage;
let ret = retry(|| unsafe { let ret = retry(|| unsafe {
libc::sendto(self.fd(), libc::sendto(self.fd(),

6
src/libnative/io/pipe_win32.rs
View file

@ -262,7 +262,7 @@ impl UnixStream {
impl rtio::RtioPipe for UnixStream { impl rtio::RtioPipe for UnixStream {
fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> { fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> {
if self.read.is_none() { if self.read.is_none() {
self.read = Some(if_ok!(Event::new(true, false))); self.read = Some(try!(Event::new(true, false)));
} }
let mut bytes_read = 0; let mut bytes_read = 0;
@ -298,7 +298,7 @@ impl rtio::RtioPipe for UnixStream {
fn write(&mut self, buf: &[u8]) -> IoResult<()> { fn write(&mut self, buf: &[u8]) -> IoResult<()> {
if self.write.is_none() { if self.write.is_none() {
self.write = Some(if_ok!(Event::new(true, false))); self.write = Some(try!(Event::new(true, false)));
} }
let mut offset = 0; let mut offset = 0;
@ -371,7 +371,7 @@ impl UnixListener {
pub fn native_listen(self) -> IoResult<UnixAcceptor> { pub fn native_listen(self) -> IoResult<UnixAcceptor> {
Ok(UnixAcceptor { Ok(UnixAcceptor {
listener: self, listener: self,
event: if_ok!(Event::new(true, false)), event: try!(Event::new(true, false)),
}) })
} }
} }

4
src/librustc/back/archive.rs
View file

@ -161,7 +161,7 @@ impl Archive {
// We skip any files explicitly desired for skipping, and we also skip // We skip any files explicitly desired for skipping, and we also skip
// all SYMDEF files as these are just magical placeholders which get // all SYMDEF files as these are just magical placeholders which get
// re-created when we make a new archive anyway. // re-created when we make a new archive anyway.
let files = if_ok!(fs::readdir(loc.path())); let files = try!(fs::readdir(loc.path()));
let mut inputs = ~[]; let mut inputs = ~[];
for file in files.iter() { for file in files.iter() {
let filename = file.filename_str().unwrap(); let filename = file.filename_str().unwrap();
@ -170,7 +170,7 @@ impl Archive {
let filename = format!("r-{}-{}", name, filename); let filename = format!("r-{}-{}", name, filename);
let new_filename = file.with_filename(filename); let new_filename = file.with_filename(filename);
if_ok!(fs::rename(file, &new_filename)); try!(fs::rename(file, &new_filename));
inputs.push(new_filename); inputs.push(new_filename);
} }
if inputs.len() == 0 { return Ok(()) } if inputs.len() == 0 { return Ok(()) }

32
src/librustc/driver/driver.rs
View file

@ -521,9 +521,9 @@ fn write_out_deps(sess: Session,
}) })
.collect() .collect()
}; };
let mut file = if_ok!(io::File::create(&deps_filename)); let mut file = try!(io::File::create(&deps_filename));
for path in out_filenames.iter() { for path in out_filenames.iter() {
if_ok!(write!(&mut file as &mut Writer, try!(write!(&mut file as &mut Writer,
"{}: {}\n\n", path.display(), files.connect(" "))); "{}: {}\n\n", path.display(), files.connect(" ")));
} }
Ok(()) Ok(())
@ -575,21 +575,21 @@ impl pprust::PpAnn for IdentifiedAnnotation {
fn post(&self, node: pprust::AnnNode) -> io::IoResult<()> { fn post(&self, node: pprust::AnnNode) -> io::IoResult<()> {
match node { match node {
pprust::NodeItem(s, item) => { pprust::NodeItem(s, item) => {
if_ok!(pp::space(&mut s.s)); try!(pp::space(&mut s.s));
if_ok!(pprust::synth_comment(s, item.id.to_str())); try!(pprust::synth_comment(s, item.id.to_str()));
} }
pprust::NodeBlock(s, blk) => { pprust::NodeBlock(s, blk) => {
if_ok!(pp::space(&mut s.s)); try!(pp::space(&mut s.s));
if_ok!(pprust::synth_comment(s, ~"block " + blk.id.to_str())); try!(pprust::synth_comment(s, ~"block " + blk.id.to_str()));
} }
pprust::NodeExpr(s, expr) => { pprust::NodeExpr(s, expr) => {
if_ok!(pp::space(&mut s.s)); try!(pp::space(&mut s.s));
if_ok!(pprust::synth_comment(s, expr.id.to_str())); try!(pprust::synth_comment(s, expr.id.to_str()));
if_ok!(pprust::pclose(s)); try!(pprust::pclose(s));
} }
pprust::NodePat(s, pat) => { pprust::NodePat(s, pat) => {
if_ok!(pp::space(&mut s.s)); try!(pp::space(&mut s.s));
if_ok!(pprust::synth_comment(s, ~"pat " + pat.id.to_str())); try!(pprust::synth_comment(s, ~"pat " + pat.id.to_str()));
} }
} }
Ok(()) Ok(())
@ -611,12 +611,12 @@ impl pprust::PpAnn for TypedAnnotation {
let tcx = self.analysis.ty_cx; let tcx = self.analysis.ty_cx;
match node { match node {
pprust::NodeExpr(s, expr) => { pprust::NodeExpr(s, expr) => {
if_ok!(pp::space(&mut s.s)); try!(pp::space(&mut s.s));
if_ok!(pp::word(&mut s.s, "as")); try!(pp::word(&mut s.s, "as"));
if_ok!(pp::space(&mut s.s)); try!(pp::space(&mut s.s));
if_ok!(pp::word(&mut s.s, try!(pp::word(&mut s.s,
ppaux::ty_to_str(tcx, ty::expr_ty(tcx, expr)))); ppaux::ty_to_str(tcx, ty::expr_ty(tcx, expr))));
if_ok!(pprust::pclose(s)); try!(pprust::pclose(s));
} }
_ => () _ => ()
} }

12
src/librustc/metadata/decoder.rs
View file

@ -1088,11 +1088,11 @@ fn get_attributes(md: ebml::Doc) -> ~[ast::Attribute] {
fn list_crate_attributes(md: ebml::Doc, hash: &str, fn list_crate_attributes(md: ebml::Doc, hash: &str,
out: &mut io::Writer) -> io::IoResult<()> { out: &mut io::Writer) -> io::IoResult<()> {
if_ok!(write!(out, "=Crate Attributes ({})=\n", hash)); try!(write!(out, "=Crate Attributes ({})=\n", hash));
let r = get_attributes(md); let r = get_attributes(md);
for attr in r.iter() { for attr in r.iter() {
if_ok!(write!(out, "{}\n", pprust::attribute_to_str(attr))); try!(write!(out, "{}\n", pprust::attribute_to_str(attr)));
} }
write!(out, "\n\n") write!(out, "\n\n")
@ -1131,11 +1131,11 @@ pub fn get_crate_deps(data: &[u8]) -> ~[CrateDep] {
} }
fn list_crate_deps(data: &[u8], out: &mut io::Writer) -> io::IoResult<()> { fn list_crate_deps(data: &[u8], out: &mut io::Writer) -> io::IoResult<()> {
if_ok!(write!(out, "=External Dependencies=\n")); try!(write!(out, "=External Dependencies=\n"));
let r = get_crate_deps(data); let r = get_crate_deps(data);
for dep in r.iter() { for dep in r.iter() {
if_ok!(write!(out, try!(write!(out,
"{} {}-{}-{}\n", "{} {}-{}-{}\n",
dep.cnum, dep.cnum,
token::get_ident(dep.name), token::get_ident(dep.name),
@ -1143,7 +1143,7 @@ fn list_crate_deps(data: &[u8], out: &mut io::Writer) -> io::IoResult<()> {
dep.vers)); dep.vers));
} }
if_ok!(write!(out, "\n")); try!(write!(out, "\n"));
Ok(()) Ok(())
} }
@ -1164,7 +1164,7 @@ pub fn get_crate_vers(data: &[u8]) -> ~str {
pub fn list_crate_metadata(bytes: &[u8], out: &mut io::Writer) -> io::IoResult<()> { pub fn list_crate_metadata(bytes: &[u8], out: &mut io::Writer) -> io::IoResult<()> {
let hash = get_crate_hash(bytes); let hash = get_crate_hash(bytes);
let md = reader::Doc(bytes); let md = reader::Doc(bytes);
if_ok!(list_crate_attributes(md, hash, out)); try!(list_crate_attributes(md, hash, out));
list_crate_deps(bytes, out) list_crate_deps(bytes, out)
} }

12
src/librustc/middle/dataflow.rs
View file

@ -113,8 +113,8 @@ impl<O:DataFlowOperator> pprust::PpAnn for DataFlowContext<O> {
let comment_str = format!("id {}: {}{}{}", let comment_str = format!("id {}: {}{}{}",
id, entry_str, gens_str, kills_str); id, entry_str, gens_str, kills_str);
if_ok!(pprust::synth_comment(ps, comment_str)); try!(pprust::synth_comment(ps, comment_str));
if_ok!(pp::space(&mut ps.s)); try!(pp::space(&mut ps.s));
} }
Ok(()) Ok(())
} }
@ -351,10 +351,10 @@ impl<O:DataFlowOperator+Clone+'static> DataFlowContext<O> {
fn pretty_print_to(&self, wr: ~io::Writer, fn pretty_print_to(&self, wr: ~io::Writer,
blk: &ast::Block) -> io::IoResult<()> { blk: &ast::Block) -> io::IoResult<()> {
let mut ps = pprust::rust_printer_annotated(wr, self); let mut ps = pprust::rust_printer_annotated(wr, self);
if_ok!(pprust::cbox(&mut ps, pprust::indent_unit)); try!(pprust::cbox(&mut ps, pprust::indent_unit));
if_ok!(pprust::ibox(&mut ps, 0u)); try!(pprust::ibox(&mut ps, 0u));
if_ok!(pprust::print_block(&mut ps, blk)); try!(pprust::print_block(&mut ps, blk));
if_ok!(pp::eof(&mut ps.s)); try!(pp::eof(&mut ps.s));
Ok(()) Ok(())
} }
} }

2
src/librustc/middle/liveness.rs
View file

@ -740,7 +740,7 @@ impl Liveness {
for var_idx in range(0u, self.ir.num_vars.get()) { for var_idx in range(0u, self.ir.num_vars.get()) {
let idx = node_base_idx + var_idx; let idx = node_base_idx + var_idx;
if test(idx).is_valid() { if test(idx).is_valid() {
if_ok!(write!(wr, " {}", Variable(var_idx).to_str())); try!(write!(wr, " {}", Variable(var_idx).to_str()));
} }
} }
Ok(()) Ok(())

6
src/librustdoc/html/escape.rs
View file

@ -29,7 +29,7 @@ impl<'a> fmt::Show for Escape<'a> {
for (i, ch) in s.bytes().enumerate() { for (i, ch) in s.bytes().enumerate() {
match ch as char { match ch as char {
'<' | '>' | '&' | '\'' | '"' => { '<' | '>' | '&' | '\'' | '"' => {
if_ok!(fmt.buf.write(pile_o_bits.slice(last, i).as_bytes())); try!(fmt.buf.write(pile_o_bits.slice(last, i).as_bytes()));
let s = match ch as char { let s = match ch as char {
'>' => "&gt;", '>' => "&gt;",
'<' => "&lt;", '<' => "&lt;",
@ -38,7 +38,7 @@ impl<'a> fmt::Show for Escape<'a> {
'"' => "&quot;", '"' => "&quot;",
_ => unreachable!() _ => unreachable!()
}; };
if_ok!(fmt.buf.write(s.as_bytes())); try!(fmt.buf.write(s.as_bytes()));
last = i + 1; last = i + 1;
} }
_ => {} _ => {}
@ -46,7 +46,7 @@ impl<'a> fmt::Show for Escape<'a> {
} }
if last < s.len() { if last < s.len() {
if_ok!(fmt.buf.write(pile_o_bits.slice_from(last).as_bytes())); try!(fmt.buf.write(pile_o_bits.slice_from(last).as_bytes()));
} }
Ok(()) Ok(())
} }

88
src/librustdoc/html/format.rs
View file

@ -50,46 +50,46 @@ impl PuritySpace {
impl fmt::Show for clean::Generics { impl fmt::Show for clean::Generics {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
if self.lifetimes.len() == 0 && self.type_params.len() == 0 { return Ok(()) } if self.lifetimes.len() == 0 && self.type_params.len() == 0 { return Ok(()) }
if_ok!(f.buf.write("&lt;".as_bytes())); try!(f.buf.write("&lt;".as_bytes()));
for (i, life) in self.lifetimes.iter().enumerate() { for (i, life) in self.lifetimes.iter().enumerate() {
if i > 0 { if i > 0 {
if_ok!(f.buf.write(", ".as_bytes())); try!(f.buf.write(", ".as_bytes()));
} }
if_ok!(write!(f.buf, "{}", *life)); try!(write!(f.buf, "{}", *life));
} }
if self.type_params.len() > 0 { if self.type_params.len() > 0 {
if self.lifetimes.len() > 0 { if self.lifetimes.len() > 0 {
if_ok!(f.buf.write(", ".as_bytes())); try!(f.buf.write(", ".as_bytes()));
} }
for (i, tp) in self.type_params.iter().enumerate() { for (i, tp) in self.type_params.iter().enumerate() {
if i > 0 { if i > 0 {
if_ok!(f.buf.write(", ".as_bytes())) try!(f.buf.write(", ".as_bytes()))
} }
if_ok!(f.buf.write(tp.name.as_bytes())); try!(f.buf.write(tp.name.as_bytes()));
if tp.bounds.len() > 0 { if tp.bounds.len() > 0 {
if_ok!(f.buf.write(": ".as_bytes())); try!(f.buf.write(": ".as_bytes()));
for (i, bound) in tp.bounds.iter().enumerate() { for (i, bound) in tp.bounds.iter().enumerate() {
if i > 0 { if i > 0 {
if_ok!(f.buf.write(" + ".as_bytes())); try!(f.buf.write(" + ".as_bytes()));
} }
if_ok!(write!(f.buf, "{}", *bound)); try!(write!(f.buf, "{}", *bound));
} }
} }
} }
} }
if_ok!(f.buf.write("&gt;".as_bytes())); try!(f.buf.write("&gt;".as_bytes()));
Ok(()) Ok(())
} }
} }
impl fmt::Show for clean::Lifetime { impl fmt::Show for clean::Lifetime {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
if_ok!(f.buf.write("'".as_bytes())); try!(f.buf.write("'".as_bytes()));
if_ok!(f.buf.write(self.get_ref().as_bytes())); try!(f.buf.write(self.get_ref().as_bytes()));
Ok(()) Ok(())
} }
} }
@ -110,32 +110,32 @@ impl fmt::Show for clean::TyParamBound {
impl fmt::Show for clean::Path { impl fmt::Show for clean::Path {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
if self.global { if self.global {
if_ok!(f.buf.write("::".as_bytes())) try!(f.buf.write("::".as_bytes()))
} }
for (i, seg) in self.segments.iter().enumerate() { for (i, seg) in self.segments.iter().enumerate() {
if i > 0 { if i > 0 {
if_ok!(f.buf.write("::".as_bytes())) try!(f.buf.write("::".as_bytes()))
} }
if_ok!(f.buf.write(seg.name.as_bytes())); try!(f.buf.write(seg.name.as_bytes()));
if seg.lifetimes.len() > 0 || seg.types.len() > 0 { if seg.lifetimes.len() > 0 || seg.types.len() > 0 {
if_ok!(f.buf.write("&lt;".as_bytes())); try!(f.buf.write("&lt;".as_bytes()));
let mut comma = false; let mut comma = false;
for lifetime in seg.lifetimes.iter() { for lifetime in seg.lifetimes.iter() {
if comma { if comma {
if_ok!(f.buf.write(", ".as_bytes())); try!(f.buf.write(", ".as_bytes()));
} }
comma = true; comma = true;
if_ok!(write!(f.buf, "{}", *lifetime)); try!(write!(f.buf, "{}", *lifetime));
} }
for ty in seg.types.iter() { for ty in seg.types.iter() {
if comma { if comma {
if_ok!(f.buf.write(", ".as_bytes())); try!(f.buf.write(", ".as_bytes()));
} }
comma = true; comma = true;
if_ok!(write!(f.buf, "{}", *ty)); try!(write!(f.buf, "{}", *ty));
} }
if_ok!(f.buf.write("&gt;".as_bytes())); try!(f.buf.write("&gt;".as_bytes()));
} }
} }
Ok(()) Ok(())
@ -222,11 +222,11 @@ fn path(w: &mut io::Writer, path: &clean::Path, print_all: bool,
let mut root = root; let mut root = root;
for seg in path.segments.slice_to(amt).iter() { for seg in path.segments.slice_to(amt).iter() {
if "super" == seg.name || "self" == seg.name { if "super" == seg.name || "self" == seg.name {
if_ok!(write!(w, "{}::", seg.name)); try!(write!(w, "{}::", seg.name));
} else { } else {
root.push_str(seg.name); root.push_str(seg.name);
root.push_str("/"); root.push_str("/");
if_ok!(write!(w, "<a class='mod' try!(write!(w, "<a class='mod'
href='{}index.html'>{}</a>::", href='{}index.html'>{}</a>::",
root, root,
seg.name)); seg.name));
@ -235,7 +235,7 @@ fn path(w: &mut io::Writer, path: &clean::Path, print_all: bool,
} }
None => { None => {
for seg in path.segments.slice_to(amt).iter() { for seg in path.segments.slice_to(amt).iter() {
if_ok!(write!(w, "{}::", seg.name)); try!(write!(w, "{}::", seg.name));
} }
} }
} }
@ -263,15 +263,15 @@ fn path(w: &mut io::Writer, path: &clean::Path, print_all: bool,
} }
} }
if_ok!(write!(w, "<a class='{}' href='{}' title='{}'>{}</a>", try!(write!(w, "<a class='{}' href='{}' title='{}'>{}</a>",
shortty, url, fqp.connect("::"), last.name)); shortty, url, fqp.connect("::"), last.name));
} }
_ => { _ => {
if_ok!(write!(w, "{}", last.name)); try!(write!(w, "{}", last.name));
} }
} }
if_ok!(write!(w, "{}", generics)); try!(write!(w, "{}", generics));
Ok(()) Ok(())
}) })
}) })
@ -282,14 +282,14 @@ fn typarams(w: &mut io::Writer,
typarams: &Option<~[clean::TyParamBound]>) -> fmt::Result { typarams: &Option<~[clean::TyParamBound]>) -> fmt::Result {
match *typarams { match *typarams {
Some(ref params) => { Some(ref params) => {
if_ok!(write!(w, "&lt;")); try!(write!(w, "&lt;"));
for (i, param) in params.iter().enumerate() { for (i, param) in params.iter().enumerate() {
if i > 0 { if i > 0 {
if_ok!(write!(w, ", ")); try!(write!(w, ", "));
} }
if_ok!(write!(w, "{}", *param)); try!(write!(w, "{}", *param));
} }
if_ok!(write!(w, "&gt;")); try!(write!(w, "&gt;"));
Ok(()) Ok(())
} }
None => Ok(()) None => Ok(())
@ -306,12 +306,12 @@ impl fmt::Show for clean::Type {
}) })
} }
clean::ResolvedPath{id, typarams: ref tp, path: ref path} => { clean::ResolvedPath{id, typarams: ref tp, path: ref path} => {
if_ok!(resolved_path(f.buf, id, path, false)); try!(resolved_path(f.buf, id, path, false));
typarams(f.buf, tp) typarams(f.buf, tp)
} }
clean::ExternalPath{path: ref path, typarams: ref tp, clean::ExternalPath{path: ref path, typarams: ref tp,
fqn: ref fqn, kind, krate} => { fqn: ref fqn, kind, krate} => {
if_ok!(external_path(f.buf, path, false, fqn.as_slice(), kind, try!(external_path(f.buf, path, false, fqn.as_slice(), kind,
krate)) krate))
typarams(f.buf, tp) typarams(f.buf, tp)
} }
@ -364,12 +364,12 @@ impl fmt::Show for clean::Type {
decl.decl) decl.decl)
} }
clean::Tuple(ref typs) => { clean::Tuple(ref typs) => {
if_ok!(f.buf.write("(".as_bytes())); try!(f.buf.write("(".as_bytes()));
for (i, typ) in typs.iter().enumerate() { for (i, typ) in typs.iter().enumerate() {
if i > 0 { if i > 0 {
if_ok!(f.buf.write(", ".as_bytes())) try!(f.buf.write(", ".as_bytes()))
} }
if_ok!(write!(f.buf, "{}", *typ)); try!(write!(f.buf, "{}", *typ));
} }
f.buf.write(")".as_bytes()) f.buf.write(")".as_bytes())
} }
@ -407,11 +407,11 @@ impl fmt::Show for clean::Type {
impl fmt::Show for clean::Arguments { impl fmt::Show for clean::Arguments {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
for (i, input) in self.values.iter().enumerate() { for (i, input) in self.values.iter().enumerate() {
if i > 0 { if_ok!(write!(f.buf, ", ")); } if i > 0 { try!(write!(f.buf, ", ")); }
if input.name.len() > 0 { if input.name.len() > 0 {
if_ok!(write!(f.buf, "{}: ", input.name)); try!(write!(f.buf, "{}: ", input.name));
} }
if_ok!(write!(f.buf, "{}", input.type_)); try!(write!(f.buf, "{}", input.type_));
} }
Ok(()) Ok(())
} }
@ -495,12 +495,12 @@ impl fmt::Show for clean::ViewPath {
write!(f.buf, "use {}::*;", *src) write!(f.buf, "use {}::*;", *src)
} }
clean::ImportList(ref src, ref names) => { clean::ImportList(ref src, ref names) => {
if_ok!(write!(f.buf, "use {}::\\{", *src)); try!(write!(f.buf, "use {}::\\{", *src));
for (i, n) in names.iter().enumerate() { for (i, n) in names.iter().enumerate() {
if i > 0 { if i > 0 {
if_ok!(write!(f.buf, ", ")); try!(write!(f.buf, ", "));
} }
if_ok!(write!(f.buf, "{}", *n)); try!(write!(f.buf, "{}", *n));
} }
write!(f.buf, "\\};") write!(f.buf, "\\};")
} }
@ -518,9 +518,9 @@ impl fmt::Show for clean::ImportSource {
_ => { _ => {
for (i, seg) in self.path.segments.iter().enumerate() { for (i, seg) in self.path.segments.iter().enumerate() {
if i > 0 { if i > 0 {
if_ok!(write!(f.buf, "::")) try!(write!(f.buf, "::"))
} }
if_ok!(write!(f.buf, "{}", seg.name)); try!(write!(f.buf, "{}", seg.name));
} }
Ok(()) Ok(())
} }

324
src/librustdoc/html/render.rs
View file

@ -209,7 +209,7 @@ pub fn run(mut krate: clean::Crate, dst: Path) -> io::IoResult<()> {
}, },
include_sources: true, include_sources: true,
}; };
if_ok!(mkdir(&cx.dst)); try!(mkdir(&cx.dst));
match krate.module.as_ref().map(|m| m.doc_list().unwrap_or(&[])) { match krate.module.as_ref().map(|m| m.doc_list().unwrap_or(&[])) {
Some(attrs) => { Some(attrs) => {
@ -254,12 +254,12 @@ pub fn run(mut krate: clean::Crate, dst: Path) -> io::IoResult<()> {
// Add all the static files // Add all the static files
let mut dst = cx.dst.join(krate.name.as_slice()); let mut dst = cx.dst.join(krate.name.as_slice());
if_ok!(mkdir(&dst)); try!(mkdir(&dst));
if_ok!(write(dst.join("jquery.js"), try!(write(dst.join("jquery.js"),
include_str!("static/jquery-2.1.0.min.js"))); include_str!("static/jquery-2.1.0.min.js")));
if_ok!(write(dst.join("main.js"), include_str!("static/main.js"))); try!(write(dst.join("main.js"), include_str!("static/main.js")));
if_ok!(write(dst.join("main.css"), include_str!("static/main.css"))); try!(write(dst.join("main.css"), include_str!("static/main.css")));
if_ok!(write(dst.join("normalize.css"), try!(write(dst.join("normalize.css"),
include_str!("static/normalize.css"))); include_str!("static/normalize.css")));
// Publish the search index // Publish the search index
@ -267,42 +267,42 @@ pub fn run(mut krate: clean::Crate, dst: Path) -> io::IoResult<()> {
dst.push("search-index.js"); dst.push("search-index.js");
let mut w = BufferedWriter::new(File::create(&dst).unwrap()); let mut w = BufferedWriter::new(File::create(&dst).unwrap());
let w = &mut w as &mut Writer; let w = &mut w as &mut Writer;
if_ok!(write!(w, "var searchIndex = [")); try!(write!(w, "var searchIndex = ["));
for (i, item) in cache.search_index.iter().enumerate() { for (i, item) in cache.search_index.iter().enumerate() {
if i > 0 { if i > 0 {
if_ok!(write!(w, ",")); try!(write!(w, ","));
} }
if_ok!(write!(w, "\\{ty:\"{}\",name:\"{}\",path:\"{}\",desc:{}", try!(write!(w, "\\{ty:\"{}\",name:\"{}\",path:\"{}\",desc:{}",
item.ty, item.name, item.path, item.ty, item.name, item.path,
item.desc.to_json().to_str())); item.desc.to_json().to_str()));
match item.parent { match item.parent {
Some(id) => { Some(id) => {
if_ok!(write!(w, ",parent:'{}'", id)); try!(write!(w, ",parent:'{}'", id));
} }
None => {} None => {}
} }
if_ok!(write!(w, "\\}")); try!(write!(w, "\\}"));
} }
if_ok!(write!(w, "];")); try!(write!(w, "];"));
if_ok!(write!(w, "var allPaths = \\{")); try!(write!(w, "var allPaths = \\{"));
for (i, (&id, &(ref fqp, short))) in cache.paths.iter().enumerate() { for (i, (&id, &(ref fqp, short))) in cache.paths.iter().enumerate() {
if i > 0 { if i > 0 {
if_ok!(write!(w, ",")); try!(write!(w, ","));
} }
if_ok!(write!(w, "'{}':\\{type:'{}',name:'{}'\\}", try!(write!(w, "'{}':\\{type:'{}',name:'{}'\\}",
id, short, *fqp.last().unwrap())); id, short, *fqp.last().unwrap()));
} }
if_ok!(write!(w, "\\};")); try!(write!(w, "\\};"));
if_ok!(w.flush()); try!(w.flush());
} }
// Render all source files (this may turn into a giant no-op) // Render all source files (this may turn into a giant no-op)
{ {
info!("emitting source files"); info!("emitting source files");
let dst = cx.dst.join("src"); let dst = cx.dst.join("src");
if_ok!(mkdir(&dst)); try!(mkdir(&dst));
let dst = dst.join(krate.name.as_slice()); let dst = dst.join(krate.name.as_slice());
if_ok!(mkdir(&dst)); try!(mkdir(&dst));
let mut folder = SourceCollector { let mut folder = SourceCollector {
dst: dst, dst: dst,
seen: HashSet::new(), seen: HashSet::new(),
@ -442,7 +442,7 @@ impl<'a> SourceCollector<'a> {
}); });
cur.push(p.filename().expect("source has no filename") + bytes!(".html")); cur.push(p.filename().expect("source has no filename") + bytes!(".html"));
let mut w = BufferedWriter::new(if_ok!(File::create(&cur))); let mut w = BufferedWriter::new(try!(File::create(&cur)));
let title = format!("{} -- source", cur.filename_display()); let title = format!("{} -- source", cur.filename_display());
let page = layout::Page { let page = layout::Page {
@ -450,9 +450,9 @@ impl<'a> SourceCollector<'a> {
ty: "source", ty: "source",
root_path: root_path, root_path: root_path,
}; };
if_ok!(layout::render(&mut w as &mut Writer, &self.cx.layout, try!(layout::render(&mut w as &mut Writer, &self.cx.layout,
&page, &(""), &Source(contents.as_slice()))); &page, &(""), &Source(contents.as_slice())));
if_ok!(w.flush()); try!(w.flush());
return Ok(()); return Ok(());
} }
} }
@ -714,7 +714,7 @@ impl Context {
let mut work = ~[(self, item)]; let mut work = ~[(self, item)];
loop { loop {
match work.pop() { match work.pop() {
Some((mut cx, item)) => if_ok!(cx.item(item, |cx, item| { Some((mut cx, item)) => try!(cx.item(item, |cx, item| {
work.push((cx.clone(), item)); work.push((cx.clone(), item));
})), })),
None => break, None => break,
@ -753,7 +753,7 @@ impl Context {
// of the pain by using a buffered writer instead of invoking the // of the pain by using a buffered writer instead of invoking the
// write sycall all the time. // write sycall all the time.
let mut writer = BufferedWriter::new(w); let mut writer = BufferedWriter::new(w);
if_ok!(layout::render(&mut writer as &mut Writer, &cx.layout, &page, try!(layout::render(&mut writer as &mut Writer, &cx.layout, &page,
&Sidebar{ cx: cx, item: it }, &Sidebar{ cx: cx, item: it },
&Item{ cx: cx, item: it })); &Item{ cx: cx, item: it }));
writer.flush() writer.flush()
@ -768,8 +768,8 @@ impl Context {
self.recurse(name, |this| { self.recurse(name, |this| {
let item = item.take_unwrap(); let item = item.take_unwrap();
let dst = this.dst.join("index.html"); let dst = this.dst.join("index.html");
let dst = if_ok!(File::create(&dst)); let dst = try!(File::create(&dst));
if_ok!(render(dst, this, &item, false)); try!(render(dst, this, &item, false));
let m = match item.inner { let m = match item.inner {
clean::ModuleItem(m) => m, clean::ModuleItem(m) => m,
@ -787,7 +787,7 @@ impl Context {
// pages dedicated to them. // pages dedicated to them.
_ if item.name.is_some() => { _ if item.name.is_some() => {
let dst = self.dst.join(item_path(&item)); let dst = self.dst.join(item_path(&item));
let dst = if_ok!(File::create(&dst)); let dst = try!(File::create(&dst));
render(dst, self, &item, true) render(dst, self, &item, true)
} }
@ -829,7 +829,7 @@ impl<'a> fmt::Show for Item<'a> {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
match attr::find_stability(self.item.attrs.iter()) { match attr::find_stability(self.item.attrs.iter()) {
Some(ref stability) => { Some(ref stability) => {
if_ok!(write!(fmt.buf, try!(write!(fmt.buf,
"<a class='stability {lvl}' title='{reason}'>{lvl}</a>", "<a class='stability {lvl}' title='{reason}'>{lvl}</a>",
lvl = stability.level.to_str(), lvl = stability.level.to_str(),
reason = match stability.text { reason = match stability.text {
@ -850,7 +850,7 @@ impl<'a> fmt::Show for Item<'a> {
} else { } else {
format!("{}-{}", self.item.source.loline, self.item.source.hiline) format!("{}-{}", self.item.source.loline, self.item.source.hiline)
}; };
if_ok!(write!(fmt.buf, try!(write!(fmt.buf,
"<a class='source' "<a class='source'
href='{root}src/{krate}/{path}.html\\#{href}'>\ href='{root}src/{krate}/{path}.html\\#{href}'>\
[src]</a>", [src]</a>",
@ -861,13 +861,13 @@ impl<'a> fmt::Show for Item<'a> {
} }
// Write the breadcrumb trail header for the top // Write the breadcrumb trail header for the top
if_ok!(write!(fmt.buf, "<h1 class='fqn'>")); try!(write!(fmt.buf, "<h1 class='fqn'>"));
match self.item.inner { match self.item.inner {
clean::ModuleItem(..) => if_ok!(write!(fmt.buf, "Module ")), clean::ModuleItem(..) => try!(write!(fmt.buf, "Module ")),
clean::FunctionItem(..) => if_ok!(write!(fmt.buf, "Function ")), clean::FunctionItem(..) => try!(write!(fmt.buf, "Function ")),
clean::TraitItem(..) => if_ok!(write!(fmt.buf, "Trait ")), clean::TraitItem(..) => try!(write!(fmt.buf, "Trait ")),
clean::StructItem(..) => if_ok!(write!(fmt.buf, "Struct ")), clean::StructItem(..) => try!(write!(fmt.buf, "Struct ")),
clean::EnumItem(..) => if_ok!(write!(fmt.buf, "Enum ")), clean::EnumItem(..) => try!(write!(fmt.buf, "Enum ")),
_ => {} _ => {}
} }
let cur = self.cx.current.as_slice(); let cur = self.cx.current.as_slice();
@ -877,10 +877,10 @@ impl<'a> fmt::Show for Item<'a> {
for _ in range(0, cur.len() - i - 1) { for _ in range(0, cur.len() - i - 1) {
trail.push_str("../"); trail.push_str("../");
} }
if_ok!(write!(fmt.buf, "<a href='{}index.html'>{}</a>::", try!(write!(fmt.buf, "<a href='{}index.html'>{}</a>::",
trail, component.as_slice())); trail, component.as_slice()));
} }
if_ok!(write!(fmt.buf, "<a class='{}' href=''>{}</a></h1>", try!(write!(fmt.buf, "<a class='{}' href=''>{}</a></h1>",
shortty(self.item), self.item.name.get_ref().as_slice())); shortty(self.item), self.item.name.get_ref().as_slice()));
match self.item.inner { match self.item.inner {
@ -932,7 +932,7 @@ fn shorter<'a>(s: Option<&'a str>) -> &'a str {
fn document(w: &mut Writer, item: &clean::Item) -> fmt::Result { fn document(w: &mut Writer, item: &clean::Item) -> fmt::Result {
match item.doc_value() { match item.doc_value() {
Some(s) => { Some(s) => {
if_ok!(write!(w, "<div class='docblock'>{}</div>", Markdown(s))); try!(write!(w, "<div class='docblock'>{}</div>", Markdown(s)));
} }
None => {} None => {}
} }
@ -941,7 +941,7 @@ fn document(w: &mut Writer, item: &clean::Item) -> fmt::Result {
fn item_module(w: &mut Writer, cx: &Context, fn item_module(w: &mut Writer, cx: &Context,
item: &clean::Item, items: &[clean::Item]) -> fmt::Result { item: &clean::Item, items: &[clean::Item]) -> fmt::Result {
if_ok!(document(w, item)); try!(document(w, item));
debug!("{:?}", items); debug!("{:?}", items);
let mut indices = vec::from_fn(items.len(), |i| i); let mut indices = vec::from_fn(items.len(), |i| i);
@ -994,10 +994,10 @@ fn item_module(w: &mut Writer, cx: &Context,
let myty = shortty(myitem); let myty = shortty(myitem);
if myty != curty { if myty != curty {
if curty != "" { if curty != "" {
if_ok!(write!(w, "</table>")); try!(write!(w, "</table>"));
} }
curty = myty; curty = myty;
if_ok!(write!(w, "<h2>{}</h2>\n<table>", match myitem.inner { try!(write!(w, "<h2>{}</h2>\n<table>", match myitem.inner {
clean::ModuleItem(..) => "Modules", clean::ModuleItem(..) => "Modules",
clean::StructItem(..) => "Structs", clean::StructItem(..) => "Structs",
clean::EnumItem(..) => "Enums", clean::EnumItem(..) => "Enums",
@ -1024,15 +1024,15 @@ fn item_module(w: &mut Writer, cx: &Context,
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let Initializer(s) = *self; let Initializer(s) = *self;
if s.len() == 0 { return Ok(()); } if s.len() == 0 { return Ok(()); }
if_ok!(write!(f.buf, "<code> = </code>")); try!(write!(f.buf, "<code> = </code>"));
let tag = if s.contains("\n") { "pre" } else { "code" }; let tag = if s.contains("\n") { "pre" } else { "code" };
if_ok!(write!(f.buf, "<{tag}>{}</{tag}>", try!(write!(f.buf, "<{tag}>{}</{tag}>",
s.as_slice(), tag=tag)); s.as_slice(), tag=tag));
Ok(()) Ok(())
} }
} }
if_ok!(write!(w, " try!(write!(w, "
<tr> <tr>
<td><code>{}static {}: {}</code>{}</td> <td><code>{}static {}: {}</code>{}</td>
<td class='docblock'>{}&nbsp;</td> <td class='docblock'>{}&nbsp;</td>
@ -1048,19 +1048,19 @@ fn item_module(w: &mut Writer, cx: &Context,
clean::ViewItemItem(ref item) => { clean::ViewItemItem(ref item) => {
match item.inner { match item.inner {
clean::ExternMod(ref name, ref src, _) => { clean::ExternMod(ref name, ref src, _) => {
if_ok!(write!(w, "<tr><td><code>extern crate {}", try!(write!(w, "<tr><td><code>extern crate {}",
name.as_slice())); name.as_slice()));
match *src { match *src {
Some(ref src) => if_ok!(write!(w, " = \"{}\"", Some(ref src) => try!(write!(w, " = \"{}\"",
src.as_slice())), src.as_slice())),
None => {} None => {}
} }
if_ok!(write!(w, ";</code></td></tr>")); try!(write!(w, ";</code></td></tr>"));
} }
clean::Import(ref imports) => { clean::Import(ref imports) => {
for import in imports.iter() { for import in imports.iter() {
if_ok!(write!(w, "<tr><td><code>{}{}</code></td></tr>", try!(write!(w, "<tr><td><code>{}{}</code></td></tr>",
VisSpace(myitem.visibility), VisSpace(myitem.visibility),
*import)); *import));
} }
@ -1071,7 +1071,7 @@ fn item_module(w: &mut Writer, cx: &Context,
_ => { _ => {
if myitem.name.is_none() { continue } if myitem.name.is_none() { continue }
if_ok!(write!(w, " try!(write!(w, "
<tr> <tr>
<td><a class='{class}' href='{href}' <td><a class='{class}' href='{href}'
title='{title}'>{}</a></td> title='{title}'>{}</a></td>
@ -1091,7 +1091,7 @@ fn item_module(w: &mut Writer, cx: &Context,
fn item_function(w: &mut Writer, it: &clean::Item, fn item_function(w: &mut Writer, it: &clean::Item,
f: &clean::Function) -> fmt::Result { f: &clean::Function) -> fmt::Result {
if_ok!(write!(w, "<pre class='fn'>{vis}{purity}fn {name}{generics}{decl}</pre>", try!(write!(w, "<pre class='fn'>{vis}{purity}fn {name}{generics}{decl}</pre>",
vis = VisSpace(it.visibility), vis = VisSpace(it.visibility),
purity = PuritySpace(f.purity), purity = PuritySpace(f.purity),
name = it.name.get_ref().as_slice(), name = it.name.get_ref().as_slice(),
@ -1112,7 +1112,7 @@ fn item_trait(w: &mut Writer, it: &clean::Item,
} }
// Output the trait definition // Output the trait definition
if_ok!(write!(w, "<pre class='trait'>{}trait {}{}{} ", try!(write!(w, "<pre class='trait'>{}trait {}{}{} ",
VisSpace(it.visibility), VisSpace(it.visibility),
it.name.get_ref().as_slice(), it.name.get_ref().as_slice(),
t.generics, t.generics,
@ -1121,81 +1121,81 @@ fn item_trait(w: &mut Writer, it: &clean::Item,
let provided = t.methods.iter().filter(|m| !m.is_req()).to_owned_vec(); let provided = t.methods.iter().filter(|m| !m.is_req()).to_owned_vec();
if t.methods.len() == 0 { if t.methods.len() == 0 {
if_ok!(write!(w, "\\{ \\}")); try!(write!(w, "\\{ \\}"));
} else { } else {
if_ok!(write!(w, "\\{\n")); try!(write!(w, "\\{\n"));
for m in required.iter() { for m in required.iter() {
if_ok!(write!(w, " ")); try!(write!(w, " "));
if_ok!(render_method(w, m.item())); try!(render_method(w, m.item()));
if_ok!(write!(w, ";\n")); try!(write!(w, ";\n"));
} }
if required.len() > 0 && provided.len() > 0 { if required.len() > 0 && provided.len() > 0 {
if_ok!(w.write("\n".as_bytes())); try!(w.write("\n".as_bytes()));
} }
for m in provided.iter() { for m in provided.iter() {
if_ok!(write!(w, " ")); try!(write!(w, " "));
if_ok!(render_method(w, m.item())); try!(render_method(w, m.item()));
if_ok!(write!(w, " \\{ ... \\}\n")); try!(write!(w, " \\{ ... \\}\n"));
} }
if_ok!(write!(w, "\\}")); try!(write!(w, "\\}"));
} }
if_ok!(write!(w, "</pre>")); try!(write!(w, "</pre>"));
// Trait documentation // Trait documentation
if_ok!(document(w, it)); try!(document(w, it));
fn meth(w: &mut Writer, m: &clean::TraitMethod) -> fmt::Result { fn meth(w: &mut Writer, m: &clean::TraitMethod) -> fmt::Result {
if_ok!(write!(w, "<h3 id='{}.{}' class='method'><code>", try!(write!(w, "<h3 id='{}.{}' class='method'><code>",
shortty(m.item()), shortty(m.item()),
*m.item().name.get_ref())); *m.item().name.get_ref()));
if_ok!(render_method(w, m.item())); try!(render_method(w, m.item()));
if_ok!(write!(w, "</code></h3>")); try!(write!(w, "</code></h3>"));
if_ok!(document(w, m.item())); try!(document(w, m.item()));
Ok(()) Ok(())
} }
// Output the documentation for each function individually // Output the documentation for each function individually
if required.len() > 0 { if required.len() > 0 {
if_ok!(write!(w, " try!(write!(w, "
<h2 id='required-methods'>Required Methods</h2> <h2 id='required-methods'>Required Methods</h2>
<div class='methods'> <div class='methods'>
")); "));
for m in required.iter() { for m in required.iter() {
if_ok!(meth(w, *m)); try!(meth(w, *m));
} }
if_ok!(write!(w, "</div>")); try!(write!(w, "</div>"));
} }
if provided.len() > 0 { if provided.len() > 0 {
if_ok!(write!(w, " try!(write!(w, "
<h2 id='provided-methods'>Provided Methods</h2> <h2 id='provided-methods'>Provided Methods</h2>
<div class='methods'> <div class='methods'>
")); "));
for m in provided.iter() { for m in provided.iter() {
if_ok!(meth(w, *m)); try!(meth(w, *m));
} }
if_ok!(write!(w, "</div>")); try!(write!(w, "</div>"));
} }
local_data::get(cache_key, |cache| { local_data::get(cache_key, |cache| {
let cache = cache.unwrap().get(); let cache = cache.unwrap().get();
match cache.implementors.find(&it.id) { match cache.implementors.find(&it.id) {
Some(implementors) => { Some(implementors) => {
if_ok!(write!(w, " try!(write!(w, "
<h2 id='implementors'>Implementors</h2> <h2 id='implementors'>Implementors</h2>
<ul class='item-list'> <ul class='item-list'>
")); "));
for i in implementors.iter() { for i in implementors.iter() {
match *i { match *i {
PathType(ref ty) => { PathType(ref ty) => {
if_ok!(write!(w, "<li><code>{}</code></li>", *ty)); try!(write!(w, "<li><code>{}</code></li>", *ty));
} }
OtherType(ref generics, ref trait_, ref for_) => { OtherType(ref generics, ref trait_, ref for_) => {
if_ok!(write!(w, "<li><code>impl{} {} for {}</code></li>", try!(write!(w, "<li><code>impl{} {} for {}</code></li>",
*generics, *trait_, *for_)); *generics, *trait_, *for_));
} }
} }
} }
if_ok!(write!(w, "</ul>")); try!(write!(w, "</ul>"));
} }
None => {} None => {}
} }
@ -1231,23 +1231,23 @@ fn render_method(w: &mut Writer, meth: &clean::Item) -> fmt::Result {
fn item_struct(w: &mut Writer, it: &clean::Item, fn item_struct(w: &mut Writer, it: &clean::Item,
s: &clean::Struct) -> fmt::Result { s: &clean::Struct) -> fmt::Result {
if_ok!(write!(w, "<pre class='struct'>")); try!(write!(w, "<pre class='struct'>"));
if_ok!(render_struct(w, it, Some(&s.generics), s.struct_type, s.fields, try!(render_struct(w, it, Some(&s.generics), s.struct_type, s.fields,
s.fields_stripped, "", true)); s.fields_stripped, "", true));
if_ok!(write!(w, "</pre>")); try!(write!(w, "</pre>"));
if_ok!(document(w, it)); try!(document(w, it));
match s.struct_type { match s.struct_type {
doctree::Plain if s.fields.len() > 0 => { doctree::Plain if s.fields.len() > 0 => {
if_ok!(write!(w, "<h2 class='fields'>Fields</h2>\n<table>")); try!(write!(w, "<h2 class='fields'>Fields</h2>\n<table>"));
for field in s.fields.iter() { for field in s.fields.iter() {
if_ok!(write!(w, "<tr><td id='structfield.{name}'>\ try!(write!(w, "<tr><td id='structfield.{name}'>\
<code>{name}</code></td><td>", <code>{name}</code></td><td>",
name = field.name.get_ref().as_slice())); name = field.name.get_ref().as_slice()));
if_ok!(document(w, field)); try!(document(w, field));
if_ok!(write!(w, "</td></tr>")); try!(write!(w, "</td></tr>"));
} }
if_ok!(write!(w, "</table>")); try!(write!(w, "</table>"));
} }
_ => {} _ => {}
} }
@ -1255,33 +1255,33 @@ fn item_struct(w: &mut Writer, it: &clean::Item,
} }
fn item_enum(w: &mut Writer, it: &clean::Item, e: &clean::Enum) -> fmt::Result { fn item_enum(w: &mut Writer, it: &clean::Item, e: &clean::Enum) -> fmt::Result {
if_ok!(write!(w, "<pre class='enum'>{}enum {}{}", try!(write!(w, "<pre class='enum'>{}enum {}{}",
VisSpace(it.visibility), VisSpace(it.visibility),
it.name.get_ref().as_slice(), it.name.get_ref().as_slice(),
e.generics)); e.generics));
if e.variants.len() == 0 && !e.variants_stripped { if e.variants.len() == 0 && !e.variants_stripped {
if_ok!(write!(w, " \\{\\}")); try!(write!(w, " \\{\\}"));
} else { } else {
if_ok!(write!(w, " \\{\n")); try!(write!(w, " \\{\n"));
for v in e.variants.iter() { for v in e.variants.iter() {
if_ok!(write!(w, " ")); try!(write!(w, " "));
let name = v.name.get_ref().as_slice(); let name = v.name.get_ref().as_slice();
match v.inner { match v.inner {
clean::VariantItem(ref var) => { clean::VariantItem(ref var) => {
match var.kind { match var.kind {
clean::CLikeVariant => if_ok!(write!(w, "{}", name)), clean::CLikeVariant => try!(write!(w, "{}", name)),
clean::TupleVariant(ref tys) => { clean::TupleVariant(ref tys) => {
if_ok!(write!(w, "{}(", name)); try!(write!(w, "{}(", name));
for (i, ty) in tys.iter().enumerate() { for (i, ty) in tys.iter().enumerate() {
if i > 0 { if i > 0 {
if_ok!(write!(w, ", ")) try!(write!(w, ", "))
} }
if_ok!(write!(w, "{}", *ty)); try!(write!(w, "{}", *ty));
} }
if_ok!(write!(w, ")")); try!(write!(w, ")"));
} }
clean::StructVariant(ref s) => { clean::StructVariant(ref s) => {
if_ok!(render_struct(w, v, None, s.struct_type, try!(render_struct(w, v, None, s.struct_type,
s.fields, s.fields_stripped, s.fields, s.fields_stripped,
" ", false)); " ", false));
} }
@ -1289,51 +1289,51 @@ fn item_enum(w: &mut Writer, it: &clean::Item, e: &clean::Enum) -> fmt::Result {
} }
_ => unreachable!() _ => unreachable!()
} }
if_ok!(write!(w, ",\n")); try!(write!(w, ",\n"));
} }
if e.variants_stripped { if e.variants_stripped {
if_ok!(write!(w, " // some variants omitted\n")); try!(write!(w, " // some variants omitted\n"));
} }
if_ok!(write!(w, "\\}")); try!(write!(w, "\\}"));
} }
if_ok!(write!(w, "</pre>")); try!(write!(w, "</pre>"));
if_ok!(document(w, it)); try!(document(w, it));
if e.variants.len() > 0 { if e.variants.len() > 0 {
if_ok!(write!(w, "<h2 class='variants'>Variants</h2>\n<table>")); try!(write!(w, "<h2 class='variants'>Variants</h2>\n<table>"));
for variant in e.variants.iter() { for variant in e.variants.iter() {
if_ok!(write!(w, "<tr><td id='variant.{name}'><code>{name}</code></td><td>", try!(write!(w, "<tr><td id='variant.{name}'><code>{name}</code></td><td>",
name = variant.name.get_ref().as_slice())); name = variant.name.get_ref().as_slice()));
if_ok!(document(w, variant)); try!(document(w, variant));
match variant.inner { match variant.inner {
clean::VariantItem(ref var) => { clean::VariantItem(ref var) => {
match var.kind { match var.kind {
clean::StructVariant(ref s) => { clean::StructVariant(ref s) => {
if_ok!(write!(w, "<h3 class='fields'>Fields</h3>\n try!(write!(w, "<h3 class='fields'>Fields</h3>\n
<table>")); <table>"));
for field in s.fields.iter() { for field in s.fields.iter() {
if_ok!(write!(w, "<tr><td \ try!(write!(w, "<tr><td \
id='variant.{v}.field.{f}'>\ id='variant.{v}.field.{f}'>\
<code>{f}</code></td><td>", <code>{f}</code></td><td>",
v = variant.name.get_ref().as_slice(), v = variant.name.get_ref().as_slice(),
f = field.name.get_ref().as_slice())); f = field.name.get_ref().as_slice()));
if_ok!(document(w, field)); try!(document(w, field));
if_ok!(write!(w, "</td></tr>")); try!(write!(w, "</td></tr>"));
} }
if_ok!(write!(w, "</table>")); try!(write!(w, "</table>"));
} }
_ => () _ => ()
} }
} }
_ => () _ => ()
} }
if_ok!(write!(w, "</td></tr>")); try!(write!(w, "</td></tr>"));
} }
if_ok!(write!(w, "</table>")); try!(write!(w, "</table>"));
} }
if_ok!(render_methods(w, it)); try!(render_methods(w, it));
Ok(()) Ok(())
} }
@ -1344,21 +1344,21 @@ fn render_struct(w: &mut Writer, it: &clean::Item,
fields_stripped: bool, fields_stripped: bool,
tab: &str, tab: &str,
structhead: bool) -> fmt::Result { structhead: bool) -> fmt::Result {
if_ok!(write!(w, "{}{}{}", try!(write!(w, "{}{}{}",
VisSpace(it.visibility), VisSpace(it.visibility),
if structhead {"struct "} else {""}, if structhead {"struct "} else {""},
it.name.get_ref().as_slice())); it.name.get_ref().as_slice()));
match g { match g {
Some(g) => if_ok!(write!(w, "{}", *g)), Some(g) => try!(write!(w, "{}", *g)),
None => {} None => {}
} }
match ty { match ty {
doctree::Plain => { doctree::Plain => {
if_ok!(write!(w, " \\{\n{}", tab)); try!(write!(w, " \\{\n{}", tab));
for field in fields.iter() { for field in fields.iter() {
match field.inner { match field.inner {
clean::StructFieldItem(ref ty) => { clean::StructFieldItem(ref ty) => {
if_ok!(write!(w, " {}{}: {},\n{}", try!(write!(w, " {}{}: {},\n{}",
VisSpace(field.visibility), VisSpace(field.visibility),
field.name.get_ref().as_slice(), field.name.get_ref().as_slice(),
ty.type_, ty.type_,
@ -1369,27 +1369,27 @@ fn render_struct(w: &mut Writer, it: &clean::Item,
} }
if fields_stripped { if fields_stripped {
if_ok!(write!(w, " // some fields omitted\n{}", tab)); try!(write!(w, " // some fields omitted\n{}", tab));
} }
if_ok!(write!(w, "\\}")); try!(write!(w, "\\}"));
} }
doctree::Tuple | doctree::Newtype => { doctree::Tuple | doctree::Newtype => {
if_ok!(write!(w, "(")); try!(write!(w, "("));
for (i, field) in fields.iter().enumerate() { for (i, field) in fields.iter().enumerate() {
if i > 0 { if i > 0 {
if_ok!(write!(w, ", ")); try!(write!(w, ", "));
} }
match field.inner { match field.inner {
clean::StructFieldItem(ref field) => { clean::StructFieldItem(ref field) => {
if_ok!(write!(w, "{}", field.type_)); try!(write!(w, "{}", field.type_));
} }
_ => unreachable!() _ => unreachable!()
} }
} }
if_ok!(write!(w, ");")); try!(write!(w, ");"));
} }
doctree::Unit => { doctree::Unit => {
if_ok!(write!(w, ";")); try!(write!(w, ";"));
} }
} }
Ok(()) Ok(())
@ -1410,16 +1410,16 @@ fn render_methods(w: &mut Writer, it: &clean::Item) -> fmt::Result {
let traits = traits.to_owned_vec(); let traits = traits.to_owned_vec();
if non_trait.len() > 0 { if non_trait.len() > 0 {
if_ok!(write!(w, "<h2 id='methods'>Methods</h2>")); try!(write!(w, "<h2 id='methods'>Methods</h2>"));
for &(ref i, ref dox) in non_trait.move_iter() { for &(ref i, ref dox) in non_trait.move_iter() {
if_ok!(render_impl(w, i, dox)); try!(render_impl(w, i, dox));
} }
} }
if traits.len() > 0 { if traits.len() > 0 {
if_ok!(write!(w, "<h2 id='implementations'>Trait \ try!(write!(w, "<h2 id='implementations'>Trait \
Implementations</h2>")); Implementations</h2>"));
for &(ref i, ref dox) in traits.move_iter() { for &(ref i, ref dox) in traits.move_iter() {
if_ok!(render_impl(w, i, dox)); try!(render_impl(w, i, dox));
} }
} }
} }
@ -1431,10 +1431,10 @@ fn render_methods(w: &mut Writer, it: &clean::Item) -> fmt::Result {
fn render_impl(w: &mut Writer, i: &clean::Impl, fn render_impl(w: &mut Writer, i: &clean::Impl,
dox: &Option<~str>) -> fmt::Result { dox: &Option<~str>) -> fmt::Result {
if_ok!(write!(w, "<h3 class='impl'><code>impl{} ", i.generics)); try!(write!(w, "<h3 class='impl'><code>impl{} ", i.generics));
let trait_id = match i.trait_ { let trait_id = match i.trait_ {
Some(ref ty) => { Some(ref ty) => {
if_ok!(write!(w, "{} for ", *ty)); try!(write!(w, "{} for ", *ty));
match *ty { match *ty {
clean::ResolvedPath { id, .. } => Some(id), clean::ResolvedPath { id, .. } => Some(id),
_ => None, _ => None,
@ -1442,32 +1442,32 @@ fn render_impl(w: &mut Writer, i: &clean::Impl,
} }
None => None None => None
}; };
if_ok!(write!(w, "{}</code></h3>", i.for_)); try!(write!(w, "{}</code></h3>", i.for_));
match *dox { match *dox {
Some(ref dox) => { Some(ref dox) => {
if_ok!(write!(w, "<div class='docblock'>{}</div>", try!(write!(w, "<div class='docblock'>{}</div>",
Markdown(dox.as_slice()))); Markdown(dox.as_slice())));
} }
None => {} None => {}
} }
fn docmeth(w: &mut Writer, item: &clean::Item) -> io::IoResult<bool> { fn docmeth(w: &mut Writer, item: &clean::Item) -> io::IoResult<bool> {
if_ok!(write!(w, "<h4 id='method.{}' class='method'><code>", try!(write!(w, "<h4 id='method.{}' class='method'><code>",
*item.name.get_ref())); *item.name.get_ref()));
if_ok!(render_method(w, item)); try!(render_method(w, item));
if_ok!(write!(w, "</code></h4>\n")); try!(write!(w, "</code></h4>\n"));
match item.doc_value() { match item.doc_value() {
Some(s) => { Some(s) => {
if_ok!(write!(w, "<div class='docblock'>{}</div>", Markdown(s))); try!(write!(w, "<div class='docblock'>{}</div>", Markdown(s)));
Ok(true) Ok(true)
} }
None => Ok(false) None => Ok(false)
} }
} }
if_ok!(write!(w, "<div class='methods'>")); try!(write!(w, "<div class='methods'>"));
for meth in i.methods.iter() { for meth in i.methods.iter() {
if if_ok!(docmeth(w, meth)) { if try!(docmeth(w, meth)) {
continue continue
} }
@ -1476,7 +1476,7 @@ fn render_impl(w: &mut Writer, i: &clean::Impl,
None => continue, None => continue,
Some(id) => id, Some(id) => id,
}; };
if_ok!(local_data::get(cache_key, |cache| { try!(local_data::get(cache_key, |cache| {
let cache = cache.unwrap().get(); let cache = cache.unwrap().get();
match cache.traits.find(&trait_id) { match cache.traits.find(&trait_id) {
Some(t) => { Some(t) => {
@ -1485,7 +1485,7 @@ fn render_impl(w: &mut Writer, i: &clean::Impl,
Some(method) => { Some(method) => {
match method.item().doc_value() { match method.item().doc_value() {
Some(s) => { Some(s) => {
if_ok!(write!(w, try!(write!(w,
"<div class='docblock'>{}</div>", "<div class='docblock'>{}</div>",
Markdown(s))); Markdown(s)));
} }
@ -1506,7 +1506,7 @@ fn render_impl(w: &mut Writer, i: &clean::Impl,
match trait_id { match trait_id {
None => {} None => {}
Some(id) => { Some(id) => {
if_ok!(local_data::get(cache_key, |cache| { try!(local_data::get(cache_key, |cache| {
let cache = cache.unwrap().get(); let cache = cache.unwrap().get();
match cache.traits.find(&id) { match cache.traits.find(&id) {
Some(t) => { Some(t) => {
@ -1517,7 +1517,7 @@ fn render_impl(w: &mut Writer, i: &clean::Impl,
None => {} None => {}
} }
if_ok!(docmeth(w, method.item())); try!(docmeth(w, method.item()));
} }
} }
None => {} None => {}
@ -1526,13 +1526,13 @@ fn render_impl(w: &mut Writer, i: &clean::Impl,
})) }))
} }
} }
if_ok!(write!(w, "</div>")); try!(write!(w, "</div>"));
Ok(()) Ok(())
} }
fn item_typedef(w: &mut Writer, it: &clean::Item, fn item_typedef(w: &mut Writer, it: &clean::Item,
t: &clean::Typedef) -> fmt::Result { t: &clean::Typedef) -> fmt::Result {
if_ok!(write!(w, "<pre class='typedef'>type {}{} = {};</pre>", try!(write!(w, "<pre class='typedef'>type {}{} = {};</pre>",
it.name.get_ref().as_slice(), it.name.get_ref().as_slice(),
t.generics, t.generics,
t.type_)); t.type_));
@ -1544,17 +1544,17 @@ impl<'a> fmt::Show for Sidebar<'a> {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
let cx = self.cx; let cx = self.cx;
let it = self.item; let it = self.item;
if_ok!(write!(fmt.buf, "<p class='location'>")); try!(write!(fmt.buf, "<p class='location'>"));
let len = cx.current.len() - if it.is_mod() {1} else {0}; let len = cx.current.len() - if it.is_mod() {1} else {0};
for (i, name) in cx.current.iter().take(len).enumerate() { for (i, name) in cx.current.iter().take(len).enumerate() {
if i > 0 { if i > 0 {
if_ok!(write!(fmt.buf, "&\\#8203;::")); try!(write!(fmt.buf, "&\\#8203;::"));
} }
if_ok!(write!(fmt.buf, "<a href='{}index.html'>{}</a>", try!(write!(fmt.buf, "<a href='{}index.html'>{}</a>",
cx.root_path.slice_to((cx.current.len() - i - 1) * 3), cx.root_path.slice_to((cx.current.len() - i - 1) * 3),
*name)); *name));
} }
if_ok!(write!(fmt.buf, "</p>")); try!(write!(fmt.buf, "</p>"));
fn block(w: &mut Writer, short: &str, longty: &str, fn block(w: &mut Writer, short: &str, longty: &str,
cur: &clean::Item, cx: &Context) -> fmt::Result { cur: &clean::Item, cx: &Context) -> fmt::Result {
@ -1562,11 +1562,11 @@ impl<'a> fmt::Show for Sidebar<'a> {
Some(items) => items.as_slice(), Some(items) => items.as_slice(),
None => return Ok(()) None => return Ok(())
}; };
if_ok!(write!(w, "<div class='block {}'><h2>{}</h2>", short, longty)); try!(write!(w, "<div class='block {}'><h2>{}</h2>", short, longty));
for item in items.iter() { for item in items.iter() {
let class = if cur.name.get_ref() == item && let class = if cur.name.get_ref() == item &&
short == shortty(cur) { "current" } else { "" }; short == shortty(cur) { "current" } else { "" };
if_ok!(write!(w, "<a class='{ty} {class}' href='{curty, select, try!(write!(w, "<a class='{ty} {class}' href='{curty, select,
mod{../} mod{../}
other{} other{}
}{tysel, select, }{tysel, select,
@ -1579,15 +1579,15 @@ impl<'a> fmt::Show for Sidebar<'a> {
curty = shortty(cur), curty = shortty(cur),
name = item.as_slice())); name = item.as_slice()));
} }
if_ok!(write!(w, "</div>")); try!(write!(w, "</div>"));
Ok(()) Ok(())
} }
if_ok!(block(fmt.buf, "mod", "Modules", it, cx)); try!(block(fmt.buf, "mod", "Modules", it, cx));
if_ok!(block(fmt.buf, "struct", "Structs", it, cx)); try!(block(fmt.buf, "struct", "Structs", it, cx));
if_ok!(block(fmt.buf, "enum", "Enums", it, cx)); try!(block(fmt.buf, "enum", "Enums", it, cx));
if_ok!(block(fmt.buf, "trait", "Traits", it, cx)); try!(block(fmt.buf, "trait", "Traits", it, cx));
if_ok!(block(fmt.buf, "fn", "Functions", it, cx)); try!(block(fmt.buf, "fn", "Functions", it, cx));
Ok(()) Ok(())
} }
} }
@ -1620,20 +1620,20 @@ impl<'a> fmt::Show for Source<'a> {
cols += 1; cols += 1;
tmp /= 10; tmp /= 10;
} }
if_ok!(write!(fmt.buf, "<pre class='line-numbers'>")); try!(write!(fmt.buf, "<pre class='line-numbers'>"));
for i in range(1, lines + 1) { for i in range(1, lines + 1) {
if_ok!(write!(fmt.buf, "<span id='{0:u}'>{0:1$u}</span>\n", i, cols)); try!(write!(fmt.buf, "<span id='{0:u}'>{0:1$u}</span>\n", i, cols));
} }
if_ok!(write!(fmt.buf, "</pre>")); try!(write!(fmt.buf, "</pre>"));
if_ok!(write!(fmt.buf, "<pre class='rust'>")); try!(write!(fmt.buf, "<pre class='rust'>"));
if_ok!(write!(fmt.buf, "{}", Escape(s.as_slice()))); try!(write!(fmt.buf, "{}", Escape(s.as_slice())));
if_ok!(write!(fmt.buf, "</pre>")); try!(write!(fmt.buf, "</pre>"));
Ok(()) Ok(())
} }
} }
fn item_macro(w: &mut Writer, it: &clean::Item, fn item_macro(w: &mut Writer, it: &clean::Item,
t: &clean::Macro) -> fmt::Result { t: &clean::Macro) -> fmt::Result {
if_ok!(write!(w, "<pre class='macro'>{}</pre>", t.source)); try!(write!(w, "<pre class='macro'>{}</pre>", t.source));
document(w, it) document(w, it)
} }

4
src/librustdoc/lib.rs
View file

@ -351,7 +351,7 @@ fn json_output(krate: clean::Crate, res: ~[plugins::PluginJson],
json.insert(~"crate", crate_json); json.insert(~"crate", crate_json);
json.insert(~"plugins", json::Object(plugins_json)); json.insert(~"plugins", json::Object(plugins_json));
let mut file = if_ok!(File::create(&dst)); let mut file = try!(File::create(&dst));
if_ok!(json::Object(json).to_writer(&mut file)); try!(json::Object(json).to_writer(&mut file));
Ok(()) Ok(())
} }

14
src/libsemver/lib.rs
View file

@ -99,19 +99,19 @@ pub struct Version {
impl fmt::Show for Version { impl fmt::Show for Version {
#[inline] #[inline]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
if_ok!(write!(f.buf, "{}.{}.{}", self.major, self.minor, self.patch)) try!(write!(f.buf, "{}.{}.{}", self.major, self.minor, self.patch))
if !self.pre.is_empty() { if !self.pre.is_empty() {
if_ok!(write!(f.buf, "-")); try!(write!(f.buf, "-"));
for (i, x) in self.pre.iter().enumerate() { for (i, x) in self.pre.iter().enumerate() {
if i != 0 { if_ok!(write!(f.buf, ".")) }; if i != 0 { try!(write!(f.buf, ".")) };
if_ok!(x.fmt(f)); try!(x.fmt(f));
} }
} }
if !self.build.is_empty() { if !self.build.is_empty() {
if_ok!(write!(f.buf, "+")); try!(write!(f.buf, "+"));
for (i, x) in self.build.iter().enumerate() { for (i, x) in self.build.iter().enumerate() {
if i != 0 { if_ok!(write!(f.buf, ".")) }; if i != 0 { try!(write!(f.buf, ".")) };
if_ok!(x.fmt(f)); try!(x.fmt(f));
} }
} }
Ok(()) Ok(())

12
src/libserialize/ebml.rs
View file

@ -12,7 +12,7 @@
use std::str; use std::str;
macro_rules! if_ok( ($e:expr) => ( macro_rules! try( ($e:expr) => (
match $e { Ok(e) => e, Err(e) => { self.last_error = Err(e); return } } match $e { Ok(e) => e, Err(e) => { self.last_error = Err(e); return } }
) ) ) )
@ -665,18 +665,18 @@ pub mod writer {
write_vuint(self.writer, tag_id); write_vuint(self.writer, tag_id);
// Write a placeholder four-byte size. // Write a placeholder four-byte size.
self.size_positions.push(if_ok!(self.writer.tell()) as uint); self.size_positions.push(try!(self.writer.tell()) as uint);
let zeroes: &[u8] = &[0u8, 0u8, 0u8, 0u8]; let zeroes: &[u8] = &[0u8, 0u8, 0u8, 0u8];
if_ok!(self.writer.write(zeroes)); try!(self.writer.write(zeroes));
} }
pub fn end_tag(&mut self) { pub fn end_tag(&mut self) {
let last_size_pos = self.size_positions.pop().unwrap(); let last_size_pos = self.size_positions.pop().unwrap();
let cur_pos = if_ok!(self.writer.tell()); let cur_pos = try!(self.writer.tell());
if_ok!(self.writer.seek(last_size_pos as i64, io::SeekSet)); try!(self.writer.seek(last_size_pos as i64, io::SeekSet));
let size = (cur_pos as uint - last_size_pos - 4); let size = (cur_pos as uint - last_size_pos - 4);
write_sized_vuint(self.writer, size, 4u); write_sized_vuint(self.writer, size, 4u);
if_ok!(self.writer.seek(cur_pos as i64, io::SeekSet)); try!(self.writer.seek(cur_pos as i64, io::SeekSet));
debug!("End tag (size = {})", size); debug!("End tag (size = {})", size);
} }

22
src/libstd/fmt/mod.rs
View file

@ -702,7 +702,7 @@ pub unsafe fn write_unsafe(output: &mut io::Writer,
curarg: args.iter(), curarg: args.iter(),
}; };
for piece in fmt.iter() { for piece in fmt.iter() {
if_ok!(formatter.run(piece, None)); try!(formatter.run(piece, None));
} }
Ok(()) Ok(())
} }
@ -859,13 +859,13 @@ impl<'a> Formatter<'a> {
for s in selectors.iter() { for s in selectors.iter() {
if s.selector == value { if s.selector == value {
for piece in s.result.iter() { for piece in s.result.iter() {
if_ok!(self.run(piece, Some(value))); try!(self.run(piece, Some(value)));
} }
return Ok(()); return Ok(());
} }
} }
for piece in default.iter() { for piece in default.iter() {
if_ok!(self.run(piece, Some(value))); try!(self.run(piece, Some(value)));
} }
Ok(()) Ok(())
} }
@ -876,7 +876,7 @@ impl<'a> Formatter<'a> {
::uint::to_str_bytes(value, 10, |buf| { ::uint::to_str_bytes(value, 10, |buf| {
let valuestr = str::from_utf8(buf).unwrap(); let valuestr = str::from_utf8(buf).unwrap();
for piece in pieces.iter() { for piece in pieces.iter() {
if_ok!(self.run(piece, Some(valuestr))); try!(self.run(piece, Some(valuestr)));
} }
Ok(()) Ok(())
}) })
@ -917,12 +917,12 @@ impl<'a> Formatter<'a> {
let sign = |this: &mut Formatter| { let sign = |this: &mut Formatter| {
if !signprinted { if !signprinted {
if this.flags & 1 << (FlagSignPlus as uint) != 0 && positive { if this.flags & 1 << (FlagSignPlus as uint) != 0 && positive {
if_ok!(this.buf.write(['+' as u8])); try!(this.buf.write(['+' as u8]));
} else if !positive { } else if !positive {
if_ok!(this.buf.write(['-' as u8])); try!(this.buf.write(['-' as u8]));
} }
if this.flags & 1 << (FlagAlternate as uint) != 0 { if this.flags & 1 << (FlagAlternate as uint) != 0 {
if_ok!(this.buf.write(alternate_prefix.as_bytes())); try!(this.buf.write(alternate_prefix.as_bytes()));
} }
signprinted = true; signprinted = true;
} }
@ -939,7 +939,7 @@ impl<'a> Formatter<'a> {
Some(min) => { Some(min) => {
if self.flags & 1 << (FlagSignAwareZeroPad as uint) != 0 { if self.flags & 1 << (FlagSignAwareZeroPad as uint) != 0 {
self.fill = '0'; self.fill = '0';
if_ok!(sign(self)); try!(sign(self));
} }
self.with_padding(min - actual_len, parse::AlignRight, |me| { self.with_padding(min - actual_len, parse::AlignRight, |me| {
emit(me) emit(me)
@ -1011,15 +1011,15 @@ impl<'a> Formatter<'a> {
parse::AlignLeft | parse::AlignRight => self.align parse::AlignLeft | parse::AlignRight => self.align
}; };
if align == parse::AlignLeft { if align == parse::AlignLeft {
if_ok!(f(self)); try!(f(self));
} }
let mut fill = [0u8, ..4]; let mut fill = [0u8, ..4];
let len = self.fill.encode_utf8(fill); let len = self.fill.encode_utf8(fill);
for _ in range(0, padding) { for _ in range(0, padding) {
if_ok!(self.buf.write(fill.slice_to(len))); try!(self.buf.write(fill.slice_to(len)));
} }
if align == parse::AlignRight { if align == parse::AlignRight {
if_ok!(f(self)); try!(f(self));
} }
Ok(()) Ok(())
} }

12
src/libstd/hashmap.rs
View file

@ -599,15 +599,15 @@ impl<K:Hash + Eq + Clone,V:Clone> Clone for HashMap<K,V> {
impl<A: fmt::Show + Hash + Eq, B: fmt::Show> fmt::Show for HashMap<A, B> { impl<A: fmt::Show + Hash + Eq, B: fmt::Show> fmt::Show for HashMap<A, B> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
if_ok!(write!(f.buf, r"\{")) try!(write!(f.buf, r"\{"))
let mut first = true; let mut first = true;
for (key, value) in self.iter() { for (key, value) in self.iter() {
if first { if first {
first = false; first = false;
} else { } else {
if_ok!(write!(f.buf, ", ")); try!(write!(f.buf, ", "));
} }
if_ok!(write!(f.buf, "{}: {}", *key, *value)); try!(write!(f.buf, "{}: {}", *key, *value));
} }
write!(f.buf, r"\}") write!(f.buf, r"\}")
} }
@ -877,15 +877,15 @@ impl<T:Hash + Eq + Clone> Clone for HashSet<T> {
impl<A: fmt::Show + Hash + Eq> fmt::Show for HashSet<A> { impl<A: fmt::Show + Hash + Eq> fmt::Show for HashSet<A> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
if_ok!(write!(f.buf, r"\{")) try!(write!(f.buf, r"\{"))
let mut first = true; let mut first = true;
for x in self.iter() { for x in self.iter() {
if first { if first {
first = false; first = false;
} else { } else {
if_ok!(write!(f.buf, ", ")); try!(write!(f.buf, ", "));
} }
if_ok!(write!(f.buf, "{}", *x)); try!(write!(f.buf, "{}", *x));
} }
write!(f.buf, r"\}") write!(f.buf, r"\}")
} }

12
src/libstd/io/buffered.rs
View file

@ -88,7 +88,7 @@ impl<R: Reader> BufferedReader<R> {
impl<R: Reader> Buffer for BufferedReader<R> { impl<R: Reader> Buffer for BufferedReader<R> {
fn fill<'a>(&'a mut self) -> IoResult<&'a [u8]> { fn fill<'a>(&'a mut self) -> IoResult<&'a [u8]> {
if self.pos == self.cap { if self.pos == self.cap {
self.cap = if_ok!(self.inner.read(self.buf)); self.cap = try!(self.inner.read(self.buf));
self.pos = 0; self.pos = 0;
} }
Ok(self.buf.slice(self.pos, self.cap)) Ok(self.buf.slice(self.pos, self.cap))
@ -103,7 +103,7 @@ impl<R: Reader> Buffer for BufferedReader<R> {
impl<R: Reader> Reader for BufferedReader<R> { impl<R: Reader> Reader for BufferedReader<R> {
fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> { fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> {
let nread = { let nread = {
let available = if_ok!(self.fill()); let available = try!(self.fill());
let nread = cmp::min(available.len(), buf.len()); let nread = cmp::min(available.len(), buf.len());
vec::bytes::copy_memory(buf, available.slice_to(nread)); vec::bytes::copy_memory(buf, available.slice_to(nread));
nread nread
@ -182,7 +182,7 @@ impl<W: Writer> BufferedWriter<W> {
impl<W: Writer> Writer for BufferedWriter<W> { impl<W: Writer> Writer for BufferedWriter<W> {
fn write(&mut self, buf: &[u8]) -> IoResult<()> { fn write(&mut self, buf: &[u8]) -> IoResult<()> {
if self.pos + buf.len() > self.buf.len() { if self.pos + buf.len() > self.buf.len() {
if_ok!(self.flush_buf()); try!(self.flush_buf());
} }
if buf.len() > self.buf.len() { if buf.len() > self.buf.len() {
@ -233,9 +233,9 @@ impl<W: Writer> Writer for LineBufferedWriter<W> {
fn write(&mut self, buf: &[u8]) -> IoResult<()> { fn write(&mut self, buf: &[u8]) -> IoResult<()> {
match buf.iter().rposition(|&b| b == '\n' as u8) { match buf.iter().rposition(|&b| b == '\n' as u8) {
Some(i) => { Some(i) => {
if_ok!(self.inner.write(buf.slice_to(i + 1))); try!(self.inner.write(buf.slice_to(i + 1)));
if_ok!(self.inner.flush()); try!(self.inner.flush());
if_ok!(self.inner.write(buf.slice_from(i + 1))); try!(self.inner.write(buf.slice_from(i + 1)));
Ok(()) Ok(())
} }
None => self.inner.write(buf), None => self.inner.write(buf),

22
src/libstd/io/fs.rs
View file

@ -339,8 +339,8 @@ pub fn copy(from: &Path, to: &Path) -> IoResult<()> {
}) })
} }
let mut reader = if_ok!(File::open(from)); let mut reader = try!(File::open(from));
let mut writer = if_ok!(File::create(to)); let mut writer = try!(File::create(to));
let mut buf = [0, ..io::DEFAULT_BUF_SIZE]; let mut buf = [0, ..io::DEFAULT_BUF_SIZE];
loop { loop {
@ -349,10 +349,10 @@ pub fn copy(from: &Path, to: &Path) -> IoResult<()> {
Err(ref e) if e.kind == io::EndOfFile => { break } Err(ref e) if e.kind == io::EndOfFile => { break }
Err(e) => return Err(e) Err(e) => return Err(e)
}; };
if_ok!(writer.write(buf.slice_to(amt))); try!(writer.write(buf.slice_to(amt)));
} }
chmod(to, if_ok!(from.stat()).perm) chmod(to, try!(from.stat()).perm)
} }
/// Changes the permission mode bits found on a file or a directory. This /// Changes the permission mode bits found on a file or a directory. This
@ -460,10 +460,10 @@ pub fn rmdir(path: &Path) -> IoResult<()> {
/// // one possible implementation of fs::walk_dir only visiting files /// // one possible implementation of fs::walk_dir only visiting files
/// fn visit_dirs(dir: &Path, cb: |&Path|) -> io::IoResult<()> { /// fn visit_dirs(dir: &Path, cb: |&Path|) -> io::IoResult<()> {
/// if dir.is_dir() { /// if dir.is_dir() {
/// let contents = if_ok!(fs::readdir(dir)); /// let contents = try!(fs::readdir(dir));
/// for entry in contents.iter() { /// for entry in contents.iter() {
/// if entry.is_dir() { /// if entry.is_dir() {
/// if_ok!(visit_dirs(entry, |p| cb(p))); /// try!(visit_dirs(entry, |p| cb(p)));
/// } else { /// } else {
/// cb(entry); /// cb(entry);
/// } /// }
@ -490,7 +490,7 @@ pub fn readdir(path: &Path) -> IoResult<~[Path]> {
/// rooted at `path`. The path given will not be iterated over, and this will /// rooted at `path`. The path given will not be iterated over, and this will
/// perform iteration in a top-down order. /// perform iteration in a top-down order.
pub fn walk_dir(path: &Path) -> IoResult<Directories> { pub fn walk_dir(path: &Path) -> IoResult<Directories> {
Ok(Directories { stack: if_ok!(readdir(path)) }) Ok(Directories { stack: try!(readdir(path)) })
} }
/// An iterator which walks over a directory /// An iterator which walks over a directory
@ -529,7 +529,7 @@ pub fn mkdir_recursive(path: &Path, mode: FilePermission) -> IoResult<()> {
return Ok(()) return Ok(())
} }
if path.filename().is_some() { if path.filename().is_some() {
if_ok!(mkdir_recursive(&path.dir_path(), mode)); try!(mkdir_recursive(&path.dir_path(), mode));
} }
mkdir(path, mode) mkdir(path, mode)
} }
@ -542,12 +542,12 @@ pub fn mkdir_recursive(path: &Path, mode: FilePermission) -> IoResult<()> {
/// This function will return an `Err` value if an error happens. See /// This function will return an `Err` value if an error happens. See
/// `file::unlink` and `fs::readdir` for possible error conditions. /// `file::unlink` and `fs::readdir` for possible error conditions.
pub fn rmdir_recursive(path: &Path) -> IoResult<()> { pub fn rmdir_recursive(path: &Path) -> IoResult<()> {
let children = if_ok!(readdir(path)); let children = try!(readdir(path));
for child in children.iter() { for child in children.iter() {
if child.is_dir() { if child.is_dir() {
if_ok!(rmdir_recursive(child)); try!(rmdir_recursive(child));
} else { } else {
if_ok!(unlink(child)); try!(unlink(child));
} }
} }
// Directory should now be empty // Directory should now be empty

8
src/libstd/io/mem.rs
View file

@ -113,7 +113,7 @@ impl Writer for MemWriter {
impl Seek for MemWriter { impl Seek for MemWriter {
fn tell(&self) -> IoResult<u64> { Ok(self.pos as u64) } fn tell(&self) -> IoResult<u64> { Ok(self.pos as u64) }
fn seek(&mut self, pos: i64, style: SeekStyle) -> IoResult<()> { fn seek(&mut self, pos: i64, style: SeekStyle) -> IoResult<()> {
let new = if_ok!(combine(style, self.pos, self.buf.len(), pos)); let new = try!(combine(style, self.pos, self.buf.len(), pos));
self.pos = new as uint; self.pos = new as uint;
Ok(()) Ok(())
} }
@ -183,7 +183,7 @@ impl Reader for MemReader {
impl Seek for MemReader { impl Seek for MemReader {
fn tell(&self) -> IoResult<u64> { Ok(self.pos as u64) } fn tell(&self) -> IoResult<u64> { Ok(self.pos as u64) }
fn seek(&mut self, pos: i64, style: SeekStyle) -> IoResult<()> { fn seek(&mut self, pos: i64, style: SeekStyle) -> IoResult<()> {
let new = if_ok!(combine(style, self.pos, self.buf.len(), pos)); let new = try!(combine(style, self.pos, self.buf.len(), pos));
self.pos = new as uint; self.pos = new as uint;
Ok(()) Ok(())
} }
@ -253,7 +253,7 @@ impl<'a> Writer for BufWriter<'a> {
impl<'a> Seek for BufWriter<'a> { impl<'a> Seek for BufWriter<'a> {
fn tell(&self) -> IoResult<u64> { Ok(self.pos as u64) } fn tell(&self) -> IoResult<u64> { Ok(self.pos as u64) }
fn seek(&mut self, pos: i64, style: SeekStyle) -> IoResult<()> { fn seek(&mut self, pos: i64, style: SeekStyle) -> IoResult<()> {
let new = if_ok!(combine(style, self.pos, self.buf.len(), pos)); let new = try!(combine(style, self.pos, self.buf.len(), pos));
self.pos = new as uint; self.pos = new as uint;
Ok(()) Ok(())
} }
@ -313,7 +313,7 @@ impl<'a> Reader for BufReader<'a> {
impl<'a> Seek for BufReader<'a> { impl<'a> Seek for BufReader<'a> {
fn tell(&self) -> IoResult<u64> { Ok(self.pos as u64) } fn tell(&self) -> IoResult<u64> { Ok(self.pos as u64) }
fn seek(&mut self, pos: i64, style: SeekStyle) -> IoResult<()> { fn seek(&mut self, pos: i64, style: SeekStyle) -> IoResult<()> {
let new = if_ok!(combine(style, self.pos, self.buf.len(), pos)); let new = try!(combine(style, self.pos, self.buf.len(), pos));
self.pos = new as uint; self.pos = new as uint;
Ok(()) Ok(())
} }

10
src/libstd/io/mod.rs
View file

@ -365,7 +365,7 @@ pub struct IoError {
impl fmt::Show for IoError { impl fmt::Show for IoError {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
if_ok!(fmt.buf.write_str(self.desc)); try!(fmt.buf.write_str(self.desc));
match self.detail { match self.detail {
Some(ref s) => write!(fmt.buf, " ({})", *s), Some(ref s) => write!(fmt.buf, " ({})", *s),
None => Ok(()) None => Ok(())
@ -581,7 +581,7 @@ pub trait Reader {
let mut pos = 0; let mut pos = 0;
let mut i = nbytes; let mut i = nbytes;
while i > 0 { while i > 0 {
val += (if_ok!(self.read_u8()) as u64) << pos; val += (try!(self.read_u8()) as u64) << pos;
pos += 8; pos += 8;
i -= 1; i -= 1;
} }
@ -605,7 +605,7 @@ pub trait Reader {
let mut i = nbytes; let mut i = nbytes;
while i > 0 { while i > 0 {
i -= 1; i -= 1;
val += (if_ok!(self.read_u8()) as u64) << i * 8; val += (try!(self.read_u8()) as u64) << i * 8;
} }
Ok(val) Ok(val)
} }
@ -1191,7 +1191,7 @@ pub trait Buffer: Reader {
/// This function will also return error if the stream does not contain a /// This function will also return error if the stream does not contain a
/// valid utf-8 encoded codepoint as the next few bytes in the stream. /// valid utf-8 encoded codepoint as the next few bytes in the stream.
fn read_char(&mut self) -> IoResult<char> { fn read_char(&mut self) -> IoResult<char> {
let first_byte = if_ok!(self.read_byte()); let first_byte = try!(self.read_byte());
let width = str::utf8_char_width(first_byte); let width = str::utf8_char_width(first_byte);
if width == 1 { return Ok(first_byte as char) } if width == 1 { return Ok(first_byte as char) }
if width == 0 { return Err(standard_error(InvalidInput)) } // not utf8 if width == 0 { return Err(standard_error(InvalidInput)) } // not utf8
@ -1199,7 +1199,7 @@ pub trait Buffer: Reader {
{ {
let mut start = 1; let mut start = 1;
while start < width { while start < width {
match if_ok!(self.read(buf.mut_slice(start, width))) { match try!(self.read(buf.mut_slice(start, width))) {
n if n == width - start => break, n if n == width - start => break,
n if n < width - start => { start += n; } n if n < width - start => { start += n; }
_ => return Err(standard_error(InvalidInput)), _ => return Err(standard_error(InvalidInput)),

2
src/libstd/io/util.rs
View file

@ -189,7 +189,7 @@ pub fn copy<R: Reader, W: Writer>(r: &mut R, w: &mut W) -> io::IoResult<()> {
Err(ref e) if e.kind == io::EndOfFile => return Ok(()), Err(ref e) if e.kind == io::EndOfFile => return Ok(()),
Err(e) => return Err(e), Err(e) => return Err(e),
}; };
if_ok!(w.write(buf.slice_to(len))); try!(w.write(buf.slice_to(len)));
} }
} }

2
src/libstd/macros.rs
View file

@ -355,6 +355,6 @@ macro_rules! local_data_key(
/// error if the value of the expression is `Err`. For more information, see /// error if the value of the expression is `Err`. For more information, see
/// `std::io`. /// `std::io`.
#[macro_export] #[macro_export]
macro_rules! if_ok( macro_rules! try(
($e:expr) => (match $e { Ok(e) => e, Err(e) => return Err(e) }) ($e:expr) => (match $e { Ok(e) => e, Err(e) => return Err(e) })
) )

100
src/libstd/repr.rs
View file

@ -32,7 +32,7 @@ use vec::OwnedVector;
use unstable::intrinsics::{Disr, Opaque, TyDesc, TyVisitor, get_tydesc, visit_tydesc}; use unstable::intrinsics::{Disr, Opaque, TyDesc, TyVisitor, get_tydesc, visit_tydesc};
use unstable::raw; use unstable::raw;
macro_rules! if_ok( ($me:expr, $e:expr) => ( macro_rules! try( ($me:expr, $e:expr) => (
match $e { match $e {
Ok(()) => {}, Ok(()) => {},
Err(e) => { $me.last_err = Some(e); return false; } Err(e) => { $me.last_err = Some(e); return false; }
@ -181,23 +181,23 @@ impl<'a> ReprVisitor<'a> {
#[inline] #[inline]
pub fn write<T:Repr>(&mut self) -> bool { pub fn write<T:Repr>(&mut self) -> bool {
self.get(|this, v:&T| { self.get(|this, v:&T| {
if_ok!(this, v.write_repr(this.writer)); try!(this, v.write_repr(this.writer));
true true
}) })
} }
pub fn write_escaped_slice(&mut self, slice: &str) -> bool { pub fn write_escaped_slice(&mut self, slice: &str) -> bool {
if_ok!(self, self.writer.write(['"' as u8])); try!(self, self.writer.write(['"' as u8]));
for ch in slice.chars() { for ch in slice.chars() {
if !self.write_escaped_char(ch, true) { return false } if !self.write_escaped_char(ch, true) { return false }
} }
if_ok!(self, self.writer.write(['"' as u8])); try!(self, self.writer.write(['"' as u8]));
true true
} }
pub fn write_mut_qualifier(&mut self, mtbl: uint) -> bool { pub fn write_mut_qualifier(&mut self, mtbl: uint) -> bool {
if mtbl == 0 { if mtbl == 0 {
if_ok!(self, self.writer.write("mut ".as_bytes())); try!(self, self.writer.write("mut ".as_bytes()));
} else if mtbl == 1 { } else if mtbl == 1 {
// skip, this is ast::m_imm // skip, this is ast::m_imm
} else { } else {
@ -209,7 +209,7 @@ impl<'a> ReprVisitor<'a> {
pub fn write_vec_range(&mut self, ptr: *(), len: uint, inner: *TyDesc) -> bool { pub fn write_vec_range(&mut self, ptr: *(), len: uint, inner: *TyDesc) -> bool {
let mut p = ptr as *u8; let mut p = ptr as *u8;
let (sz, al) = unsafe { ((*inner).size, (*inner).align) }; let (sz, al) = unsafe { ((*inner).size, (*inner).align) };
if_ok!(self, self.writer.write(['[' as u8])); try!(self, self.writer.write(['[' as u8]));
let mut first = true; let mut first = true;
let mut left = len; let mut left = len;
// unit structs have 0 size, and don't loop forever. // unit structs have 0 size, and don't loop forever.
@ -218,13 +218,13 @@ impl<'a> ReprVisitor<'a> {
if first { if first {
first = false; first = false;
} else { } else {
if_ok!(self, self.writer.write(", ".as_bytes())); try!(self, self.writer.write(", ".as_bytes()));
} }
self.visit_ptr_inner(p as *u8, inner); self.visit_ptr_inner(p as *u8, inner);
p = align(unsafe { p.offset(sz as int) as uint }, al) as *u8; p = align(unsafe { p.offset(sz as int) as uint }, al) as *u8;
left -= dec; left -= dec;
} }
if_ok!(self, self.writer.write([']' as u8])); try!(self, self.writer.write([']' as u8]));
true true
} }
@ -233,7 +233,7 @@ impl<'a> ReprVisitor<'a> {
} }
fn write_escaped_char(&mut self, ch: char, is_str: bool) -> bool { fn write_escaped_char(&mut self, ch: char, is_str: bool) -> bool {
if_ok!(self, match ch { try!(self, match ch {
'\t' => self.writer.write("\\t".as_bytes()), '\t' => self.writer.write("\\t".as_bytes()),
'\r' => self.writer.write("\\r".as_bytes()), '\r' => self.writer.write("\\r".as_bytes()),
'\n' => self.writer.write("\\n".as_bytes()), '\n' => self.writer.write("\\n".as_bytes()),
@ -266,7 +266,7 @@ impl<'a> ReprVisitor<'a> {
impl<'a> TyVisitor for ReprVisitor<'a> { impl<'a> TyVisitor for ReprVisitor<'a> {
fn visit_bot(&mut self) -> bool { fn visit_bot(&mut self) -> bool {
if_ok!(self, self.writer.write("!".as_bytes())); try!(self, self.writer.write("!".as_bytes()));
true true
} }
fn visit_nil(&mut self) -> bool { self.write::<()>() } fn visit_nil(&mut self) -> bool { self.write::<()>() }
@ -288,9 +288,9 @@ impl<'a> TyVisitor for ReprVisitor<'a> {
fn visit_char(&mut self) -> bool { fn visit_char(&mut self) -> bool {
self.get::<char>(|this, &ch| { self.get::<char>(|this, &ch| {
if_ok!(this, this.writer.write(['\'' as u8])); try!(this, this.writer.write(['\'' as u8]));
if !this.write_escaped_char(ch, false) { return false } if !this.write_escaped_char(ch, false) { return false }
if_ok!(this, this.writer.write(['\'' as u8])); try!(this, this.writer.write(['\'' as u8]));
true true
}) })
} }
@ -301,7 +301,7 @@ impl<'a> TyVisitor for ReprVisitor<'a> {
fn visit_estr_uniq(&mut self) -> bool { fn visit_estr_uniq(&mut self) -> bool {
self.get::<~str>(|this, s| { self.get::<~str>(|this, s| {
if_ok!(this, this.writer.write(['~' as u8])); try!(this, this.writer.write(['~' as u8]));
this.write_escaped_slice(*s) this.write_escaped_slice(*s)
}) })
} }
@ -315,7 +315,7 @@ impl<'a> TyVisitor for ReprVisitor<'a> {
_align: uint) -> bool { fail!(); } _align: uint) -> bool { fail!(); }
fn visit_box(&mut self, mtbl: uint, inner: *TyDesc) -> bool { fn visit_box(&mut self, mtbl: uint, inner: *TyDesc) -> bool {
if_ok!(self, self.writer.write(['@' as u8])); try!(self, self.writer.write(['@' as u8]));
self.write_mut_qualifier(mtbl); self.write_mut_qualifier(mtbl);
self.get::<&raw::Box<()>>(|this, b| { self.get::<&raw::Box<()>>(|this, b| {
let p = &b.data as *() as *u8; let p = &b.data as *() as *u8;
@ -324,7 +324,7 @@ impl<'a> TyVisitor for ReprVisitor<'a> {
} }
fn visit_uniq(&mut self, _mtbl: uint, inner: *TyDesc) -> bool { fn visit_uniq(&mut self, _mtbl: uint, inner: *TyDesc) -> bool {
if_ok!(self, self.writer.write(['~' as u8])); try!(self, self.writer.write(['~' as u8]));
self.get::<*u8>(|this, b| { self.get::<*u8>(|this, b| {
this.visit_ptr_inner(*b, inner) this.visit_ptr_inner(*b, inner)
}) })
@ -332,15 +332,15 @@ impl<'a> TyVisitor for ReprVisitor<'a> {
fn visit_ptr(&mut self, mtbl: uint, _inner: *TyDesc) -> bool { fn visit_ptr(&mut self, mtbl: uint, _inner: *TyDesc) -> bool {
self.get::<*u8>(|this, p| { self.get::<*u8>(|this, p| {
if_ok!(this, write!(this.writer, "({} as *", *p)); try!(this, write!(this.writer, "({} as *", *p));
this.write_mut_qualifier(mtbl); this.write_mut_qualifier(mtbl);
if_ok!(this, this.writer.write("())".as_bytes())); try!(this, this.writer.write("())".as_bytes()));
true true
}) })
} }
fn visit_rptr(&mut self, mtbl: uint, inner: *TyDesc) -> bool { fn visit_rptr(&mut self, mtbl: uint, inner: *TyDesc) -> bool {
if_ok!(self, self.writer.write(['&' as u8])); try!(self, self.writer.write(['&' as u8]));
self.write_mut_qualifier(mtbl); self.write_mut_qualifier(mtbl);
self.get::<*u8>(|this, p| { self.get::<*u8>(|this, p| {
this.visit_ptr_inner(*p, inner) this.visit_ptr_inner(*p, inner)
@ -358,7 +358,7 @@ impl<'a> TyVisitor for ReprVisitor<'a> {
fn visit_evec_box(&mut self, mtbl: uint, inner: *TyDesc) -> bool { fn visit_evec_box(&mut self, mtbl: uint, inner: *TyDesc) -> bool {
self.get::<&raw::Box<raw::Vec<()>>>(|this, b| { self.get::<&raw::Box<raw::Vec<()>>>(|this, b| {
if_ok!(this, this.writer.write(['@' as u8])); try!(this, this.writer.write(['@' as u8]));
this.write_mut_qualifier(mtbl); this.write_mut_qualifier(mtbl);
this.write_unboxed_vec_repr(mtbl, &b.data, inner) this.write_unboxed_vec_repr(mtbl, &b.data, inner)
}) })
@ -366,14 +366,14 @@ impl<'a> TyVisitor for ReprVisitor<'a> {
fn visit_evec_uniq(&mut self, mtbl: uint, inner: *TyDesc) -> bool { fn visit_evec_uniq(&mut self, mtbl: uint, inner: *TyDesc) -> bool {
self.get::<&raw::Vec<()>>(|this, b| { self.get::<&raw::Vec<()>>(|this, b| {
if_ok!(this, this.writer.write(['~' as u8])); try!(this, this.writer.write(['~' as u8]));
this.write_unboxed_vec_repr(mtbl, *b, inner) this.write_unboxed_vec_repr(mtbl, *b, inner)
}) })
} }
fn visit_evec_slice(&mut self, mtbl: uint, inner: *TyDesc) -> bool { fn visit_evec_slice(&mut self, mtbl: uint, inner: *TyDesc) -> bool {
self.get::<raw::Slice<()>>(|this, s| { self.get::<raw::Slice<()>>(|this, s| {
if_ok!(this, this.writer.write(['&' as u8])); try!(this, this.writer.write(['&' as u8]));
this.write_mut_qualifier(mtbl); this.write_mut_qualifier(mtbl);
let size = unsafe { let size = unsafe {
if (*inner).size == 0 { 1 } else { (*inner).size } if (*inner).size == 0 { 1 } else { (*inner).size }
@ -392,36 +392,36 @@ impl<'a> TyVisitor for ReprVisitor<'a> {
fn visit_enter_rec(&mut self, _n_fields: uint, fn visit_enter_rec(&mut self, _n_fields: uint,
_sz: uint, _align: uint) -> bool { _sz: uint, _align: uint) -> bool {
if_ok!(self, self.writer.write(['{' as u8])); try!(self, self.writer.write(['{' as u8]));
true true
} }
fn visit_rec_field(&mut self, i: uint, name: &str, fn visit_rec_field(&mut self, i: uint, name: &str,
mtbl: uint, inner: *TyDesc) -> bool { mtbl: uint, inner: *TyDesc) -> bool {
if i != 0 { if i != 0 {
if_ok!(self, self.writer.write(", ".as_bytes())); try!(self, self.writer.write(", ".as_bytes()));
} }
self.write_mut_qualifier(mtbl); self.write_mut_qualifier(mtbl);
if_ok!(self, self.writer.write(name.as_bytes())); try!(self, self.writer.write(name.as_bytes()));
if_ok!(self, self.writer.write(": ".as_bytes())); try!(self, self.writer.write(": ".as_bytes()));
self.visit_inner(inner); self.visit_inner(inner);
true true
} }
fn visit_leave_rec(&mut self, _n_fields: uint, fn visit_leave_rec(&mut self, _n_fields: uint,
_sz: uint, _align: uint) -> bool { _sz: uint, _align: uint) -> bool {
if_ok!(self, self.writer.write(['}' as u8])); try!(self, self.writer.write(['}' as u8]));
true true
} }
fn visit_enter_class(&mut self, name: &str, named_fields: bool, n_fields: uint, fn visit_enter_class(&mut self, name: &str, named_fields: bool, n_fields: uint,
_sz: uint, _align: uint) -> bool { _sz: uint, _align: uint) -> bool {
if_ok!(self, self.writer.write(name.as_bytes())); try!(self, self.writer.write(name.as_bytes()));
if n_fields != 0 { if n_fields != 0 {
if named_fields { if named_fields {
if_ok!(self, self.writer.write(['{' as u8])); try!(self, self.writer.write(['{' as u8]));
} else { } else {
if_ok!(self, self.writer.write(['(' as u8])); try!(self, self.writer.write(['(' as u8]));
} }
} }
true true
@ -430,11 +430,11 @@ impl<'a> TyVisitor for ReprVisitor<'a> {
fn visit_class_field(&mut self, i: uint, name: &str, named: bool, fn visit_class_field(&mut self, i: uint, name: &str, named: bool,
_mtbl: uint, inner: *TyDesc) -> bool { _mtbl: uint, inner: *TyDesc) -> bool {
if i != 0 { if i != 0 {
if_ok!(self, self.writer.write(", ".as_bytes())); try!(self, self.writer.write(", ".as_bytes()));
} }
if named { if named {
if_ok!(self, self.writer.write(name.as_bytes())); try!(self, self.writer.write(name.as_bytes()));
if_ok!(self, self.writer.write(": ".as_bytes())); try!(self, self.writer.write(": ".as_bytes()));
} }
self.visit_inner(inner); self.visit_inner(inner);
true true
@ -444,9 +444,9 @@ impl<'a> TyVisitor for ReprVisitor<'a> {
_sz: uint, _align: uint) -> bool { _sz: uint, _align: uint) -> bool {
if n_fields != 0 { if n_fields != 0 {
if named_fields { if named_fields {
if_ok!(self, self.writer.write(['}' as u8])); try!(self, self.writer.write(['}' as u8]));
} else { } else {
if_ok!(self, self.writer.write([')' as u8])); try!(self, self.writer.write([')' as u8]));
} }
} }
true true
@ -454,13 +454,13 @@ impl<'a> TyVisitor for ReprVisitor<'a> {
fn visit_enter_tup(&mut self, _n_fields: uint, fn visit_enter_tup(&mut self, _n_fields: uint,
_sz: uint, _align: uint) -> bool { _sz: uint, _align: uint) -> bool {
if_ok!(self, self.writer.write(['(' as u8])); try!(self, self.writer.write(['(' as u8]));
true true
} }
fn visit_tup_field(&mut self, i: uint, inner: *TyDesc) -> bool { fn visit_tup_field(&mut self, i: uint, inner: *TyDesc) -> bool {
if i != 0 { if i != 0 {
if_ok!(self, self.writer.write(", ".as_bytes())); try!(self, self.writer.write(", ".as_bytes()));
} }
self.visit_inner(inner); self.visit_inner(inner);
true true
@ -469,9 +469,9 @@ impl<'a> TyVisitor for ReprVisitor<'a> {
fn visit_leave_tup(&mut self, _n_fields: uint, fn visit_leave_tup(&mut self, _n_fields: uint,
_sz: uint, _align: uint) -> bool { _sz: uint, _align: uint) -> bool {
if _n_fields == 1 { if _n_fields == 1 {
if_ok!(self, self.writer.write([',' as u8])); try!(self, self.writer.write([',' as u8]));
} }
if_ok!(self, self.writer.write([')' as u8])); try!(self, self.writer.write([')' as u8]));
true true
} }
@ -507,9 +507,9 @@ impl<'a> TyVisitor for ReprVisitor<'a> {
} }
if write { if write {
if_ok!(self, self.writer.write(name.as_bytes())); try!(self, self.writer.write(name.as_bytes()));
if n_fields > 0 { if n_fields > 0 {
if_ok!(self, self.writer.write(['(' as u8])); try!(self, self.writer.write(['(' as u8]));
} }
} }
true true
@ -523,7 +523,7 @@ impl<'a> TyVisitor for ReprVisitor<'a> {
match self.var_stk[self.var_stk.len() - 1] { match self.var_stk[self.var_stk.len() - 1] {
Matched => { Matched => {
if i != 0 { if i != 0 {
if_ok!(self, self.writer.write(", ".as_bytes())); try!(self, self.writer.write(", ".as_bytes()));
} }
if ! self.visit_inner(inner) { if ! self.visit_inner(inner) {
return false; return false;
@ -541,7 +541,7 @@ impl<'a> TyVisitor for ReprVisitor<'a> {
match self.var_stk[self.var_stk.len() - 1] { match self.var_stk[self.var_stk.len() - 1] {
Matched => { Matched => {
if n_fields > 0 { if n_fields > 0 {
if_ok!(self, self.writer.write([')' as u8])); try!(self, self.writer.write([')' as u8]));
} }
} }
_ => () _ => ()
@ -563,29 +563,29 @@ impl<'a> TyVisitor for ReprVisitor<'a> {
fn visit_enter_fn(&mut self, _purity: uint, _proto: uint, fn visit_enter_fn(&mut self, _purity: uint, _proto: uint,
_n_inputs: uint, _retstyle: uint) -> bool { _n_inputs: uint, _retstyle: uint) -> bool {
if_ok!(self, self.writer.write("fn(".as_bytes())); try!(self, self.writer.write("fn(".as_bytes()));
true true
} }
fn visit_fn_input(&mut self, i: uint, _mode: uint, inner: *TyDesc) -> bool { fn visit_fn_input(&mut self, i: uint, _mode: uint, inner: *TyDesc) -> bool {
if i != 0 { if i != 0 {
if_ok!(self, self.writer.write(", ".as_bytes())); try!(self, self.writer.write(", ".as_bytes()));
} }
let name = unsafe { (*inner).name }; let name = unsafe { (*inner).name };
if_ok!(self, self.writer.write(name.as_bytes())); try!(self, self.writer.write(name.as_bytes()));
true true
} }
fn visit_fn_output(&mut self, _retstyle: uint, variadic: bool, fn visit_fn_output(&mut self, _retstyle: uint, variadic: bool,
inner: *TyDesc) -> bool { inner: *TyDesc) -> bool {
if variadic { if variadic {
if_ok!(self, self.writer.write(", ...".as_bytes())); try!(self, self.writer.write(", ...".as_bytes()));
} }
if_ok!(self, self.writer.write(")".as_bytes())); try!(self, self.writer.write(")".as_bytes()));
let name = unsafe { (*inner).name }; let name = unsafe { (*inner).name };
if name != "()" { if name != "()" {
if_ok!(self, self.writer.write(" -> ".as_bytes())); try!(self, self.writer.write(" -> ".as_bytes()));
if_ok!(self, self.writer.write(name.as_bytes())); try!(self, self.writer.write(name.as_bytes()));
} }
true true
} }
@ -595,7 +595,7 @@ impl<'a> TyVisitor for ReprVisitor<'a> {
fn visit_trait(&mut self, name: &str) -> bool { fn visit_trait(&mut self, name: &str) -> bool {
if_ok!(self, self.writer.write(name.as_bytes())); try!(self, self.writer.write(name.as_bytes()));
true true
} }

6
src/libstd/tuple.rs
View file

@ -161,9 +161,9 @@ macro_rules! write_tuple {
write!($buf, "({},)", *$x) write!($buf, "({},)", *$x)
); );
($buf:expr, $hd:expr, $($tl:expr),+) => ({ ($buf:expr, $hd:expr, $($tl:expr),+) => ({
if_ok!(write!($buf, "(")); try!(write!($buf, "("));
if_ok!(write!($buf, "{}", *$hd)); try!(write!($buf, "{}", *$hd));
$(if_ok!(write!($buf, ", {}", *$tl));)+ $(try!(write!($buf, ", {}", *$tl));)+
write!($buf, ")") write!($buf, ")")
}); });
} }

6
src/libstd/vec.rs
View file

@ -2645,15 +2645,15 @@ impl<A: DeepClone> DeepClone for ~[A] {
impl<'a, T: fmt::Show> fmt::Show for &'a [T] { impl<'a, T: fmt::Show> fmt::Show for &'a [T] {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
if_ok!(write!(f.buf, "[")); try!(write!(f.buf, "["));
let mut is_first = true; let mut is_first = true;
for x in self.iter() { for x in self.iter() {
if is_first { if is_first {
is_first = false; is_first = false;
} else { } else {
if_ok!(write!(f.buf, ", ")); try!(write!(f.buf, ", "));
} }
if_ok!(write!(f.buf, "{}", *x)) try!(write!(f.buf, "{}", *x))
} }
write!(f.buf, "]") write!(f.buf, "]")
} }

42
src/libsyntax/diagnostic.rs
View file

@ -192,9 +192,9 @@ fn print_maybe_styled(msg: &str, color: term::attr::Attr) -> io::IoResult<()> {
} }
fn write_pretty<T: Writer>(term: &mut term::Terminal<T>, s: &str, fn write_pretty<T: Writer>(term: &mut term::Terminal<T>, s: &str,
c: term::attr::Attr) -> io::IoResult<()> { c: term::attr::Attr) -> io::IoResult<()> {
if_ok!(term.attr(c)); try!(term.attr(c));
if_ok!(term.write(s.as_bytes())); try!(term.write(s.as_bytes()));
if_ok!(term.reset()); try!(term.reset());
Ok(()) Ok(())
} }
@ -230,12 +230,12 @@ fn print_maybe_styled(msg: &str, color: term::attr::Attr) -> io::IoResult<()> {
fn print_diagnostic(topic: &str, lvl: Level, msg: &str) -> io::IoResult<()> { fn print_diagnostic(topic: &str, lvl: Level, msg: &str) -> io::IoResult<()> {
if !topic.is_empty() { if !topic.is_empty() {
let mut stderr = io::stderr(); let mut stderr = io::stderr();
if_ok!(write!(&mut stderr as &mut io::Writer, "{} ", topic)); try!(write!(&mut stderr as &mut io::Writer, "{} ", topic));
} }
if_ok!(print_maybe_styled(format!("{}: ", lvl.to_str()), try!(print_maybe_styled(format!("{}: ", lvl.to_str()),
term::attr::ForegroundColor(lvl.color()))); term::attr::ForegroundColor(lvl.color())));
if_ok!(print_maybe_styled(format!("{}\n", msg), term::attr::Bold)); try!(print_maybe_styled(format!("{}\n", msg), term::attr::Bold));
Ok(()) Ok(())
} }
@ -276,11 +276,11 @@ fn emit(cm: &codemap::CodeMap, sp: Span,
// the span) // the span)
let span_end = Span { lo: sp.hi, hi: sp.hi, expn_info: sp.expn_info}; let span_end = Span { lo: sp.hi, hi: sp.hi, expn_info: sp.expn_info};
let ses = cm.span_to_str(span_end); let ses = cm.span_to_str(span_end);
if_ok!(print_diagnostic(ses, lvl, msg)); try!(print_diagnostic(ses, lvl, msg));
if_ok!(custom_highlight_lines(cm, sp, lvl, lines)); try!(custom_highlight_lines(cm, sp, lvl, lines));
} else { } else {
if_ok!(print_diagnostic(ss, lvl, msg)); try!(print_diagnostic(ss, lvl, msg));
if_ok!(highlight_lines(cm, sp, lvl, lines)); try!(highlight_lines(cm, sp, lvl, lines));
} }
print_macro_backtrace(cm, sp) print_macro_backtrace(cm, sp)
} }
@ -301,13 +301,13 @@ fn highlight_lines(cm: &codemap::CodeMap,
} }
// Print the offending lines // Print the offending lines
for line in display_lines.iter() { for line in display_lines.iter() {
if_ok!(write!(err, "{}:{} {}\n", fm.name, *line + 1, try!(write!(err, "{}:{} {}\n", fm.name, *line + 1,
fm.get_line(*line as int))); fm.get_line(*line as int)));
} }
if elided { if elided {
let last_line = display_lines[display_lines.len() - 1u]; let last_line = display_lines[display_lines.len() - 1u];
let s = format!("{}:{} ", fm.name, last_line + 1u); let s = format!("{}:{} ", fm.name, last_line + 1u);
if_ok!(write!(err, "{0:1$}...\n", "", s.len())); try!(write!(err, "{0:1$}...\n", "", s.len()));
} }
// FIXME (#3260) // FIXME (#3260)
@ -339,7 +339,7 @@ fn highlight_lines(cm: &codemap::CodeMap,
_ => s.push_char(' '), _ => s.push_char(' '),
}; };
} }
if_ok!(write!(err, "{}", s)); try!(write!(err, "{}", s));
let mut s = ~"^"; let mut s = ~"^";
let hi = cm.lookup_char_pos(sp.hi); let hi = cm.lookup_char_pos(sp.hi);
if hi.col != lo.col { if hi.col != lo.col {
@ -347,7 +347,7 @@ fn highlight_lines(cm: &codemap::CodeMap,
let num_squigglies = hi.col.to_uint()-lo.col.to_uint()-1u; let num_squigglies = hi.col.to_uint()-lo.col.to_uint()-1u;
for _ in range(0, num_squigglies) { s.push_char('~'); } for _ in range(0, num_squigglies) { s.push_char('~'); }
} }
if_ok!(print_maybe_styled(s + "\n", try!(print_maybe_styled(s + "\n",
term::attr::ForegroundColor(lvl.color()))); term::attr::ForegroundColor(lvl.color())));
} }
Ok(()) Ok(())
@ -369,15 +369,15 @@ fn custom_highlight_lines(cm: &codemap::CodeMap,
let lines = lines.lines.as_slice(); let lines = lines.lines.as_slice();
if lines.len() > MAX_LINES { if lines.len() > MAX_LINES {
if_ok!(write!(err, "{}:{} {}\n", fm.name, try!(write!(err, "{}:{} {}\n", fm.name,
lines[0] + 1, fm.get_line(lines[0] as int))); lines[0] + 1, fm.get_line(lines[0] as int)));
if_ok!(write!(err, "...\n")); try!(write!(err, "...\n"));
let last_line = lines[lines.len()-1]; let last_line = lines[lines.len()-1];
if_ok!(write!(err, "{}:{} {}\n", fm.name, try!(write!(err, "{}:{} {}\n", fm.name,
last_line + 1, fm.get_line(last_line as int))); last_line + 1, fm.get_line(last_line as int)));
} else { } else {
for line in lines.iter() { for line in lines.iter() {
if_ok!(write!(err, "{}:{} {}\n", fm.name, try!(write!(err, "{}:{} {}\n", fm.name,
*line + 1, fm.get_line(*line as int))); *line + 1, fm.get_line(*line as int)));
} }
} }
@ -398,12 +398,12 @@ fn print_macro_backtrace(cm: &codemap::CodeMap, sp: Span) -> io::IoResult<()> {
codemap::MacroAttribute => ("#[", "]"), codemap::MacroAttribute => ("#[", "]"),
codemap::MacroBang => ("", "!") codemap::MacroBang => ("", "!")
}; };
if_ok!(print_diagnostic(ss, Note, try!(print_diagnostic(ss, Note,
format!("in expansion of {}{}{}", pre, format!("in expansion of {}{}{}", pre,
ei.callee.name, post))); ei.callee.name, post)));
let ss = cm.span_to_str(ei.call_site); let ss = cm.span_to_str(ei.call_site);
if_ok!(print_diagnostic(ss, Note, "expansion site")); try!(print_diagnostic(ss, Note, "expansion site"));
if_ok!(print_macro_backtrace(cm, ei.call_site)); try!(print_macro_backtrace(cm, ei.call_site));
} }
Ok(()) Ok(())
} }

10
src/libsyntax/print/pp.rs
View file

@ -299,7 +299,7 @@ impl Printer {
if !self.scan_stack_empty { if !self.scan_stack_empty {
self.check_stack(0); self.check_stack(0);
let left = self.token[self.left].clone(); let left = self.token[self.left].clone();
if_ok!(self.advance_left(left, self.size[self.left])); try!(self.advance_left(left, self.size[self.left]));
} }
self.indent(0); self.indent(0);
Ok(()) Ok(())
@ -377,9 +377,9 @@ impl Printer {
} }
} }
let left = self.token[self.left].clone(); let left = self.token[self.left].clone();
if_ok!(self.advance_left(left, self.size[self.left])); try!(self.advance_left(left, self.size[self.left]));
if self.left != self.right { if self.left != self.right {
if_ok!(self.check_stream()); try!(self.check_stream());
} }
} }
Ok(()) Ok(())
@ -436,7 +436,7 @@ impl Printer {
self.left += 1u; self.left += 1u;
self.left %= self.buf_len; self.left %= self.buf_len;
let left = self.token[self.left].clone(); let left = self.token[self.left].clone();
if_ok!(self.advance_left(left, self.size[self.left])); try!(self.advance_left(left, self.size[self.left]));
} }
ret ret
} else { } else {
@ -491,7 +491,7 @@ impl Printer {
} }
pub fn print_str(&mut self, s: &str) -> io::IoResult<()> { pub fn print_str(&mut self, s: &str) -> io::IoResult<()> {
while self.pending_indentation > 0 { while self.pending_indentation > 0 {
if_ok!(write!(self.out, " ")); try!(write!(self.out, " "));
self.pending_indentation -= 1; self.pending_indentation -= 1;
} }
write!(self.out, "{}", s) write!(self.out, "{}", s)

1412
src/libsyntax/print/pprust.rs
View file

File diff suppressed because it is too large Load diff

10
src/libterm/lib.rs
View file

@ -30,10 +30,6 @@ use terminfo::searcher::open;
use terminfo::parser::compiled::{parse, msys_terminfo}; use terminfo::parser::compiled::{parse, msys_terminfo};
use terminfo::parm::{expand, Number, Variables}; use terminfo::parm::{expand, Number, Variables};
macro_rules! if_ok (
($e:expr) => (match $e { Ok(e) => e, Err(e) => return Err(e) })
)
pub mod terminfo; pub mod terminfo;
// FIXME (#2807): Windows support. // FIXME (#2807): Windows support.
@ -155,7 +151,7 @@ impl<T: Writer> Terminal<T> {
let s = expand(*self.ti.strings.find_equiv(&("setaf")).unwrap(), let s = expand(*self.ti.strings.find_equiv(&("setaf")).unwrap(),
[Number(color as int)], &mut Variables::new()); [Number(color as int)], &mut Variables::new());
if s.is_ok() { if s.is_ok() {
if_ok!(self.out.write(s.unwrap())); try!(self.out.write(s.unwrap()));
return Ok(true) return Ok(true)
} else { } else {
warn!("{}", s.unwrap_err()); warn!("{}", s.unwrap_err());
@ -176,7 +172,7 @@ impl<T: Writer> Terminal<T> {
let s = expand(*self.ti.strings.find_equiv(&("setab")).unwrap(), let s = expand(*self.ti.strings.find_equiv(&("setab")).unwrap(),
[Number(color as int)], &mut Variables::new()); [Number(color as int)], &mut Variables::new());
if s.is_ok() { if s.is_ok() {
if_ok!(self.out.write(s.unwrap())); try!(self.out.write(s.unwrap()));
return Ok(true) return Ok(true)
} else { } else {
warn!("{}", s.unwrap_err()); warn!("{}", s.unwrap_err());
@ -198,7 +194,7 @@ impl<T: Writer> Terminal<T> {
if parm.is_some() { if parm.is_some() {
let s = expand(*parm.unwrap(), [], &mut Variables::new()); let s = expand(*parm.unwrap(), [], &mut Variables::new());
if s.is_ok() { if s.is_ok() {
if_ok!(self.out.write(s.unwrap())); try!(self.out.write(s.unwrap()));
return Ok(true) return Ok(true)
} else { } else {
warn!("{}", s.unwrap_err()); warn!("{}", s.unwrap_err());

28
src/libterm/terminfo/parser/compiled.rs
View file

@ -162,7 +162,7 @@ pub static stringnames: &'static[&'static str] = &'static[ "cbt", "_", "cr", "cs
/// Parse a compiled terminfo entry, using long capability names if `longnames` is true /// Parse a compiled terminfo entry, using long capability names if `longnames` is true
pub fn parse(file: &mut io::Reader, pub fn parse(file: &mut io::Reader,
longnames: bool) -> Result<~TermInfo, ~str> { longnames: bool) -> Result<~TermInfo, ~str> {
macro_rules! if_ok( ($e:expr) => ( macro_rules! try( ($e:expr) => (
match $e { Ok(e) => e, Err(e) => return Err(format!("{}", e)) } match $e { Ok(e) => e, Err(e) => return Err(format!("{}", e)) }
) ) ) )
@ -181,17 +181,17 @@ pub fn parse(file: &mut io::Reader,
} }
// Check magic number // Check magic number
let magic = if_ok!(file.read_le_u16()); let magic = try!(file.read_le_u16());
if magic != 0x011A { if magic != 0x011A {
return Err(format!("invalid magic number: expected {:x} but found {:x}", return Err(format!("invalid magic number: expected {:x} but found {:x}",
0x011A, magic as uint)); 0x011A, magic as uint));
} }
let names_bytes = if_ok!(file.read_le_i16()) as int; let names_bytes = try!(file.read_le_i16()) as int;
let bools_bytes = if_ok!(file.read_le_i16()) as int; let bools_bytes = try!(file.read_le_i16()) as int;
let numbers_count = if_ok!(file.read_le_i16()) as int; let numbers_count = try!(file.read_le_i16()) as int;
let string_offsets_count = if_ok!(file.read_le_i16()) as int; let string_offsets_count = try!(file.read_le_i16()) as int;
let string_table_bytes = if_ok!(file.read_le_i16()) as int; let string_table_bytes = try!(file.read_le_i16()) as int;
assert!(names_bytes > 0); assert!(names_bytes > 0);
@ -220,21 +220,21 @@ pub fn parse(file: &mut io::Reader,
} }
// don't read NUL // don't read NUL
let bytes = if_ok!(file.read_bytes(names_bytes as uint - 1)); let bytes = try!(file.read_bytes(names_bytes as uint - 1));
let names_str = match str::from_utf8_owned(bytes) { let names_str = match str::from_utf8_owned(bytes) {
Some(s) => s, None => return Err(~"input not utf-8"), Some(s) => s, None => return Err(~"input not utf-8"),
}; };
let term_names: ~[~str] = names_str.split('|').map(|s| s.to_owned()).collect(); let term_names: ~[~str] = names_str.split('|').map(|s| s.to_owned()).collect();
if_ok!(file.read_byte()); // consume NUL try!(file.read_byte()); // consume NUL
debug!("term names: {:?}", term_names); debug!("term names: {:?}", term_names);
let mut bools_map = HashMap::new(); let mut bools_map = HashMap::new();
if bools_bytes != 0 { if bools_bytes != 0 {
for i in range(0, bools_bytes) { for i in range(0, bools_bytes) {
let b = if_ok!(file.read_byte()); let b = try!(file.read_byte());
if b < 0 { if b < 0 {
error!("EOF reading bools after {} entries", i); error!("EOF reading bools after {} entries", i);
return Err(~"error: expected more bools but hit EOF"); return Err(~"error: expected more bools but hit EOF");
@ -249,13 +249,13 @@ pub fn parse(file: &mut io::Reader,
if (bools_bytes + names_bytes) % 2 == 1 { if (bools_bytes + names_bytes) % 2 == 1 {
debug!("adjusting for padding between bools and numbers"); debug!("adjusting for padding between bools and numbers");
if_ok!(file.read_byte()); // compensate for padding try!(file.read_byte()); // compensate for padding
} }
let mut numbers_map = HashMap::new(); let mut numbers_map = HashMap::new();
if numbers_count != 0 { if numbers_count != 0 {
for i in range(0, numbers_count) { for i in range(0, numbers_count) {
let n = if_ok!(file.read_le_u16()); let n = try!(file.read_le_u16());
if n != 0xFFFF { if n != 0xFFFF {
debug!("{}\\#{}", nnames[i], n); debug!("{}\\#{}", nnames[i], n);
numbers_map.insert(nnames[i].to_owned(), n); numbers_map.insert(nnames[i].to_owned(), n);
@ -270,12 +270,12 @@ pub fn parse(file: &mut io::Reader,
if string_offsets_count != 0 { if string_offsets_count != 0 {
let mut string_offsets = vec::with_capacity(10); let mut string_offsets = vec::with_capacity(10);
for _ in range(0, string_offsets_count) { for _ in range(0, string_offsets_count) {
string_offsets.push(if_ok!(file.read_le_u16())); string_offsets.push(try!(file.read_le_u16()));
} }
debug!("offsets: {:?}", string_offsets); debug!("offsets: {:?}", string_offsets);
let string_table = if_ok!(file.read_bytes(string_table_bytes as uint)); let string_table = try!(file.read_bytes(string_table_bytes as uint));
if string_table.len() != string_table_bytes as uint { if string_table.len() != string_table_bytes as uint {
error!("EOF reading string table after {} bytes, wanted {}", string_table.len(), error!("EOF reading string table after {} bytes, wanted {}", string_table.len(),

92
src/libtest/lib.rs
View file

@ -397,7 +397,7 @@ impl<T: Writer> ConsoleTestState<T> {
pub fn new(opts: &TestOpts, pub fn new(opts: &TestOpts,
_: Option<T>) -> io::IoResult<ConsoleTestState<StdWriter>> { _: Option<T>) -> io::IoResult<ConsoleTestState<StdWriter>> {
let log_out = match opts.logfile { let log_out = match opts.logfile {
Some(ref path) => Some(if_ok!(File::create(path))), Some(ref path) => Some(try!(File::create(path))),
None => None None => None
}; };
let out = match term::Terminal::new(io::stdout()) { let out = match term::Terminal::new(io::stdout()) {
@ -461,11 +461,11 @@ impl<T: Writer> ConsoleTestState<T> {
match self.out { match self.out {
Pretty(ref mut term) => { Pretty(ref mut term) => {
if self.use_color { if self.use_color {
if_ok!(term.fg(color)); try!(term.fg(color));
} }
if_ok!(term.write(word.as_bytes())); try!(term.write(word.as_bytes()));
if self.use_color { if self.use_color {
if_ok!(term.reset()); try!(term.reset());
} }
Ok(()) Ok(())
} }
@ -493,16 +493,16 @@ impl<T: Writer> ConsoleTestState<T> {
} }
pub fn write_result(&mut self, result: &TestResult) -> io::IoResult<()> { pub fn write_result(&mut self, result: &TestResult) -> io::IoResult<()> {
if_ok!(match *result { try!(match *result {
TrOk => self.write_ok(), TrOk => self.write_ok(),
TrFailed => self.write_failed(), TrFailed => self.write_failed(),
TrIgnored => self.write_ignored(), TrIgnored => self.write_ignored(),
TrMetrics(ref mm) => { TrMetrics(ref mm) => {
if_ok!(self.write_metric()); try!(self.write_metric());
self.write_plain(format!(": {}", fmt_metrics(mm))) self.write_plain(format!(": {}", fmt_metrics(mm)))
} }
TrBench(ref bs) => { TrBench(ref bs) => {
if_ok!(self.write_bench()); try!(self.write_bench());
self.write_plain(format!(": {}", fmt_bench_samples(bs))) self.write_plain(format!(": {}", fmt_bench_samples(bs)))
} }
}); });
@ -527,7 +527,7 @@ impl<T: Writer> ConsoleTestState<T> {
} }
pub fn write_failures(&mut self) -> io::IoResult<()> { pub fn write_failures(&mut self) -> io::IoResult<()> {
if_ok!(self.write_plain("\nfailures:\n")); try!(self.write_plain("\nfailures:\n"));
let mut failures = ~[]; let mut failures = ~[];
let mut fail_out = ~""; let mut fail_out = ~"";
for &(ref f, ref stdout) in self.failures.iter() { for &(ref f, ref stdout) in self.failures.iter() {
@ -541,14 +541,14 @@ impl<T: Writer> ConsoleTestState<T> {
} }
} }
if fail_out.len() > 0 { if fail_out.len() > 0 {
if_ok!(self.write_plain("\n")); try!(self.write_plain("\n"));
if_ok!(self.write_plain(fail_out)); try!(self.write_plain(fail_out));
} }
if_ok!(self.write_plain("\nfailures:\n")); try!(self.write_plain("\nfailures:\n"));
failures.sort(); failures.sort();
for name in failures.iter() { for name in failures.iter() {
if_ok!(self.write_plain(format!(" {}\n", name.to_str()))); try!(self.write_plain(format!(" {}\n", name.to_str())));
} }
Ok(()) Ok(())
} }
@ -565,37 +565,37 @@ impl<T: Writer> ConsoleTestState<T> {
LikelyNoise => noise += 1, LikelyNoise => noise += 1,
MetricAdded => { MetricAdded => {
added += 1; added += 1;
if_ok!(self.write_added()); try!(self.write_added());
if_ok!(self.write_plain(format!(": {}\n", *k))); try!(self.write_plain(format!(": {}\n", *k)));
} }
MetricRemoved => { MetricRemoved => {
removed += 1; removed += 1;
if_ok!(self.write_removed()); try!(self.write_removed());
if_ok!(self.write_plain(format!(": {}\n", *k))); try!(self.write_plain(format!(": {}\n", *k)));
} }
Improvement(pct) => { Improvement(pct) => {
improved += 1; improved += 1;
if_ok!(self.write_plain(format!(": {}", *k))); try!(self.write_plain(format!(": {}", *k)));
if_ok!(self.write_improved()); try!(self.write_improved());
if_ok!(self.write_plain(format!(" by {:.2f}%\n", pct as f64))); try!(self.write_plain(format!(" by {:.2f}%\n", pct as f64)));
} }
Regression(pct) => { Regression(pct) => {
regressed += 1; regressed += 1;
if_ok!(self.write_plain(format!(": {}", *k))); try!(self.write_plain(format!(": {}", *k)));
if_ok!(self.write_regressed()); try!(self.write_regressed());
if_ok!(self.write_plain(format!(" by {:.2f}%\n", pct as f64))); try!(self.write_plain(format!(" by {:.2f}%\n", pct as f64)));
} }
} }
} }
if_ok!(self.write_plain(format!("result of ratchet: {} metrics added, \ try!(self.write_plain(format!("result of ratchet: {} metrics added, \
{} removed, {} improved, {} regressed, \ {} removed, {} improved, {} regressed, \
{} noise\n", {} noise\n",
added, removed, improved, regressed, added, removed, improved, regressed,
noise))); noise)));
if regressed == 0 { if regressed == 0 {
if_ok!(self.write_plain("updated ratchet file\n")); try!(self.write_plain("updated ratchet file\n"));
} else { } else {
if_ok!(self.write_plain("left ratchet file untouched\n")); try!(self.write_plain("left ratchet file untouched\n"));
} }
Ok(()) Ok(())
} }
@ -608,38 +608,38 @@ impl<T: Writer> ConsoleTestState<T> {
let ratchet_success = match *ratchet_metrics { let ratchet_success = match *ratchet_metrics {
None => true, None => true,
Some(ref pth) => { Some(ref pth) => {
if_ok!(self.write_plain(format!("\nusing metrics ratcher: {}\n", try!(self.write_plain(format!("\nusing metrics ratcher: {}\n",
pth.display()))); pth.display())));
match ratchet_pct { match ratchet_pct {
None => (), None => (),
Some(pct) => Some(pct) =>
if_ok!(self.write_plain(format!("with noise-tolerance \ try!(self.write_plain(format!("with noise-tolerance \
forced to: {}%\n", forced to: {}%\n",
pct))) pct)))
} }
let (diff, ok) = self.metrics.ratchet(pth, ratchet_pct); let (diff, ok) = self.metrics.ratchet(pth, ratchet_pct);
if_ok!(self.write_metric_diff(&diff)); try!(self.write_metric_diff(&diff));
ok ok
} }
}; };
let test_success = self.failed == 0u; let test_success = self.failed == 0u;
if !test_success { if !test_success {
if_ok!(self.write_failures()); try!(self.write_failures());
} }
let success = ratchet_success && test_success; let success = ratchet_success && test_success;
if_ok!(self.write_plain("\ntest result: ")); try!(self.write_plain("\ntest result: "));
if success { if success {
// There's no parallelism at this point so it's safe to use color // There's no parallelism at this point so it's safe to use color
if_ok!(self.write_ok()); try!(self.write_ok());
} else { } else {
if_ok!(self.write_failed()); try!(self.write_failed());
} }
let s = format!(". {} passed; {} failed; {} ignored; {} measured\n\n", let s = format!(". {} passed; {} failed; {} ignored; {} measured\n\n",
self.passed, self.failed, self.ignored, self.measured); self.passed, self.failed, self.ignored, self.measured);
if_ok!(self.write_plain(s)); try!(self.write_plain(s));
return Ok(success); return Ok(success);
} }
} }
@ -678,8 +678,8 @@ pub fn run_tests_console(opts: &TestOpts,
TeFiltered(ref filtered_tests) => st.write_run_start(filtered_tests.len()), TeFiltered(ref filtered_tests) => st.write_run_start(filtered_tests.len()),
TeWait(ref test, padding) => st.write_test_start(test, padding), TeWait(ref test, padding) => st.write_test_start(test, padding),
TeResult(test, result, stdout) => { TeResult(test, result, stdout) => {
if_ok!(st.write_log(&test, &result)); try!(st.write_log(&test, &result));
if_ok!(st.write_result(&result)); try!(st.write_result(&result));
match result { match result {
TrOk => st.passed += 1, TrOk => st.passed += 1,
TrIgnored => st.ignored += 1, TrIgnored => st.ignored += 1,
@ -707,7 +707,7 @@ pub fn run_tests_console(opts: &TestOpts,
} }
} }
} }
let mut st = if_ok!(ConsoleTestState::new(opts, None::<StdWriter>)); let mut st = try!(ConsoleTestState::new(opts, None::<StdWriter>));
fn len_if_padded(t: &TestDescAndFn) -> uint { fn len_if_padded(t: &TestDescAndFn) -> uint {
match t.testfn.padding() { match t.testfn.padding() {
PadNone => 0u, PadNone => 0u,
@ -722,12 +722,12 @@ pub fn run_tests_console(opts: &TestOpts,
}, },
None => {} None => {}
} }
if_ok!(run_tests(opts, tests, |x| callback(&x, &mut st))); try!(run_tests(opts, tests, |x| callback(&x, &mut st)));
match opts.save_metrics { match opts.save_metrics {
None => (), None => (),
Some(ref pth) => { Some(ref pth) => {
if_ok!(st.metrics.save(pth)); try!(st.metrics.save(pth));
if_ok!(st.write_plain(format!("\nmetrics saved to: {}", try!(st.write_plain(format!("\nmetrics saved to: {}",
pth.display()))); pth.display())));
} }
} }
@ -793,7 +793,7 @@ fn run_tests(opts: &TestOpts,
let filtered_tests = filter_tests(opts, tests); let filtered_tests = filter_tests(opts, tests);
let filtered_descs = filtered_tests.map(|t| t.desc.clone()); let filtered_descs = filtered_tests.map(|t| t.desc.clone());
if_ok!(callback(TeFiltered(filtered_descs))); try!(callback(TeFiltered(filtered_descs)));
let (filtered_tests, filtered_benchs_and_metrics) = let (filtered_tests, filtered_benchs_and_metrics) =
filtered_tests.partition(|e| { filtered_tests.partition(|e| {
@ -821,7 +821,7 @@ fn run_tests(opts: &TestOpts,
// We are doing one test at a time so we can print the name // We are doing one test at a time so we can print the name
// of the test before we run it. Useful for debugging tests // of the test before we run it. Useful for debugging tests
// that hang forever. // that hang forever.
if_ok!(callback(TeWait(test.desc.clone(), test.testfn.padding()))); try!(callback(TeWait(test.desc.clone(), test.testfn.padding())));
} }
run_test(!opts.run_tests, test, ch.clone()); run_test(!opts.run_tests, test, ch.clone());
pending += 1; pending += 1;
@ -829,19 +829,19 @@ fn run_tests(opts: &TestOpts,
let (desc, result, stdout) = p.recv(); let (desc, result, stdout) = p.recv();
if concurrency != 1 { if concurrency != 1 {
if_ok!(callback(TeWait(desc.clone(), PadNone))); try!(callback(TeWait(desc.clone(), PadNone)));
} }
if_ok!(callback(TeResult(desc, result, stdout))); try!(callback(TeResult(desc, result, stdout)));
pending -= 1; pending -= 1;
} }
// All benchmarks run at the end, in serial. // All benchmarks run at the end, in serial.
// (this includes metric fns) // (this includes metric fns)
for b in filtered_benchs_and_metrics.move_iter() { for b in filtered_benchs_and_metrics.move_iter() {
if_ok!(callback(TeWait(b.desc.clone(), b.testfn.padding()))); try!(callback(TeWait(b.desc.clone(), b.testfn.padding())));
run_test(!opts.run_benchmarks, b, ch.clone()); run_test(!opts.run_benchmarks, b, ch.clone());
let (test, result, stdout) = p.recv(); let (test, result, stdout) = p.recv();
if_ok!(callback(TeResult(test, result, stdout))); try!(callback(TeResult(test, result, stdout)));
} }
Ok(()) Ok(())
} }
@ -1026,7 +1026,7 @@ impl MetricMap {
/// Write MetricDiff to a file. /// Write MetricDiff to a file.
pub fn save(&self, p: &Path) -> io::IoResult<()> { pub fn save(&self, p: &Path) -> io::IoResult<()> {
let mut file = if_ok!(File::create(p)); let mut file = try!(File::create(p));
let MetricMap(ref map) = *self; let MetricMap(ref map) = *self;
map.to_json().to_pretty_writer(&mut file) map.to_json().to_pretty_writer(&mut file)
} }