diff options
| author | bors <bors@rust-lang.org> | 2016-03-23 08:59:10 -0700 |
|---|---|---|
| committer | bors <bors@rust-lang.org> | 2016-03-23 08:59:10 -0700 |
| commit | b76f818cad31c7910fb6f0fa5e628dbaf4db1108 (patch) | |
| tree | 90110988cefffe1b4a5c104e92eae64f798d4cab /src/libstd | |
| parent | 26cfc269a0ec6a7c895c38954e9701b62940df07 (diff) | |
| parent | c063c5153f778893d6d7296da1c8717ed8212bec (diff) | |
| download | rust-b76f818cad31c7910fb6f0fa5e628dbaf4db1108.tar.gz rust-b76f818cad31c7910fb6f0fa5e628dbaf4db1108.zip | |
Auto merge of #32390 - japaric:untry, r=pnkfelix
convert 99.9% of `try!`s to `?`s The first commit is an automated conversion using the [untry] tool and the following command: ``` $ find -name '*.rs' -type f | xargs untry ``` at the root of the Rust repo. [untry]: https://github.com/japaric/untry cc @rust-lang/lang @alexcrichton @brson
Diffstat (limited to 'src/libstd')
42 files changed, 357 insertions, 356 deletions
diff --git a/src/libstd/ffi/c_str.rs b/src/libstd/ffi/c_str.rs index 1db45764552..52d7bb128d5 100644 --- a/src/libstd/ffi/c_str.rs +++ b/src/libstd/ffi/c_str.rs @@ -318,9 +318,9 @@ impl From<CString> for Vec<u8> { #[stable(feature = "cstr_debug", since = "1.3.0")] impl fmt::Debug for CStr { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - try!(write!(f, "\"")); + write!(f, "\"")?; for byte in self.to_bytes().iter().flat_map(|&b| ascii::escape_default(b)) { - try!(f.write_char(byte as char)); + f.write_char(byte as char)?; } write!(f, "\"") } diff --git a/src/libstd/fs.rs b/src/libstd/fs.rs index 96534f817f8..d8af73816c9 100644 --- a/src/libstd/fs.rs +++ b/src/libstd/fs.rs @@ -305,7 +305,7 @@ impl File { #[unstable(feature = "file_try_clone", reason = "newly added", issue = "31405")] pub fn try_clone(&self) -> io::Result<File> { Ok(File { - inner: try!(self.inner.duplicate()) + inner: self.inner.duplicate()? }) } } @@ -565,7 +565,7 @@ impl OpenOptions { } fn _open(&self, path: &Path) -> io::Result<File> { - let inner = try!(fs_imp::File::open(path, &self.0)); + let inner = fs_imp::File::open(path, &self.0)?; Ok(File { inner: inner }) } } @@ -1440,7 +1440,7 @@ impl DirBuilder { fn create_dir_all(&self, path: &Path) -> io::Result<()> { if path == Path::new("") || path.is_dir() { return Ok(()) } if let Some(p) = path.parent() { - try!(self.create_dir_all(p)) + self.create_dir_all(p)? } self.inner.mkdir(path) } diff --git a/src/libstd/io/buffered.rs b/src/libstd/io/buffered.rs index 08877fe9744..632ef3db804 100644 --- a/src/libstd/io/buffered.rs +++ b/src/libstd/io/buffered.rs @@ -172,8 +172,8 @@ impl<R: Read> Read for BufReader<R> { return self.inner.read(buf); } let nread = { - let mut rem = try!(self.fill_buf()); - try!(rem.read(buf)) + let mut rem = self.fill_buf()?; + rem.read(buf)? }; self.consume(nread); Ok(nread) @@ -186,7 +186,7 @@ impl<R: Read> BufRead for BufReader<R> { // If we've reached the end of our internal buffer then we need to fetch // some more data from the underlying reader. if self.pos == self.cap { - self.cap = try!(self.inner.read(&mut self.buf)); + self.cap = self.inner.read(&mut self.buf)?; self.pos = 0; } Ok(&self.buf[self.pos..self.cap]) @@ -237,16 +237,16 @@ impl<R: Seek> Seek for BufReader<R> { // support seeking by i64::min_value() so we need to handle underflow when subtracting // remainder. if let Some(offset) = n.checked_sub(remainder) { - result = try!(self.inner.seek(SeekFrom::Current(offset))); + result = self.inner.seek(SeekFrom::Current(offset))?; } else { // seek backwards by our remainder, and then by the offset - try!(self.inner.seek(SeekFrom::Current(-remainder))); + self.inner.seek(SeekFrom::Current(-remainder))?; self.pos = self.cap; // empty the buffer - result = try!(self.inner.seek(SeekFrom::Current(n))); + result = self.inner.seek(SeekFrom::Current(n))?; } } else { // Seeking with Start/End doesn't care about our buffer length. - result = try!(self.inner.seek(pos)); + result = self.inner.seek(pos)?; } self.pos = self.cap; // empty the buffer Ok(result) @@ -461,7 +461,7 @@ impl<W: Write> BufWriter<W> { impl<W: Write> Write for BufWriter<W> { fn write(&mut self, buf: &[u8]) -> io::Result<usize> { if self.buf.len() + buf.len() > self.buf.capacity() { - try!(self.flush_buf()); + self.flush_buf()?; } if buf.len() >= self.buf.capacity() { self.panicked = true; @@ -761,7 +761,7 @@ impl<W: Write> Write for LineWriter<W> { fn write(&mut self, buf: &[u8]) -> io::Result<usize> { match memchr::memrchr(b'\n', buf) { Some(i) => { - let n = try!(self.inner.write(&buf[..i + 1])); + let n = self.inner.write(&buf[..i + 1])?; if n != i + 1 || self.inner.flush().is_err() { // Do not return errors on partial writes. return Ok(n); diff --git a/src/libstd/io/cursor.rs b/src/libstd/io/cursor.rs index 420fede34d2..a1002fdb645 100644 --- a/src/libstd/io/cursor.rs +++ b/src/libstd/io/cursor.rs @@ -213,7 +213,7 @@ impl<T> io::Seek for Cursor<T> where T: AsRef<[u8]> { #[stable(feature = "rust1", since = "1.0.0")] impl<T> Read for Cursor<T> where T: AsRef<[u8]> { fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> { - let n = try!(Read::read(&mut try!(self.fill_buf()), buf)); + let n = Read::read(&mut self.fill_buf()?, buf)?; self.pos += n as u64; Ok(n) } @@ -232,7 +232,7 @@ impl<T> BufRead for Cursor<T> where T: AsRef<[u8]> { impl<'a> Write for Cursor<&'a mut [u8]> { fn write(&mut self, data: &[u8]) -> io::Result<usize> { let pos = cmp::min(self.pos, self.inner.len() as u64); - let amt = try!((&mut self.inner[(pos as usize)..]).write(data)); + let amt = (&mut self.inner[(pos as usize)..]).write(data)?; self.pos += amt as u64; Ok(amt) } @@ -271,7 +271,7 @@ impl Write for Cursor<Vec<u8>> { impl Write for Cursor<Box<[u8]>> { fn write(&mut self, buf: &[u8]) -> io::Result<usize> { let pos = cmp::min(self.pos, self.inner.len() as u64); - let amt = try!((&mut self.inner[(pos as usize)..]).write(buf)); + let amt = (&mut self.inner[(pos as usize)..]).write(buf)?; self.pos += amt as u64; Ok(amt) } diff --git a/src/libstd/io/impls.rs b/src/libstd/io/impls.rs index ec63f14d453..31799381563 100644 --- a/src/libstd/io/impls.rs +++ b/src/libstd/io/impls.rs @@ -196,7 +196,7 @@ impl<'a> Write for &'a mut [u8] { #[inline] fn write_all(&mut self, data: &[u8]) -> io::Result<()> { - if try!(self.write(data)) == data.len() { + if self.write(data)? == data.len() { Ok(()) } else { Err(Error::new(ErrorKind::WriteZero, "failed to write whole buffer")) diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs index 60a720efb79..28492b30e0f 100644 --- a/src/libstd/io/mod.rs +++ b/src/libstd/io/mod.rs @@ -1433,7 +1433,7 @@ pub struct Chain<T, U> { impl<T: Read, U: Read> Read for Chain<T, U> { fn read(&mut self, buf: &mut [u8]) -> Result<usize> { if !self.done_first { - match try!(self.first.read(buf)) { + match self.first.read(buf)? { 0 => { self.done_first = true; } n => return Ok(n), } @@ -1475,7 +1475,7 @@ impl<T: Read> Read for Take<T> { } let max = cmp::min(buf.len() as u64, self.limit) as usize; - let n = try!(self.inner.read(&mut buf[..max])); + let n = self.inner.read(&mut buf[..max])?; self.limit -= n as u64; Ok(n) } @@ -1484,7 +1484,7 @@ impl<T: Read> Read for Take<T> { #[stable(feature = "rust1", since = "1.0.0")] impl<T: BufRead> BufRead for Take<T> { fn fill_buf(&mut self) -> Result<&[u8]> { - let buf = try!(self.inner.fill_buf()); + let buf = self.inner.fill_buf()?; let cap = cmp::min(buf.len() as u64, self.limit) as usize; Ok(&buf[..cap]) } diff --git a/src/libstd/io/util.rs b/src/libstd/io/util.rs index fddb095f21e..2815c0163d6 100644 --- a/src/libstd/io/util.rs +++ b/src/libstd/io/util.rs @@ -55,7 +55,7 @@ pub fn copy<R: ?Sized, W: ?Sized>(reader: &mut R, writer: &mut W) -> io::Result< Err(ref e) if e.kind() == ErrorKind::Interrupted => continue, Err(e) => return Err(e), }; - try!(writer.write_all(&buf[..len])); + writer.write_all(&buf[..len])?; written += len as u64; } } diff --git a/src/libstd/lib.rs b/src/libstd/lib.rs index 85e48f85d3d..5608bb646a4 100644 --- a/src/libstd/lib.rs +++ b/src/libstd/lib.rs @@ -270,6 +270,7 @@ #![feature(unwind_attributes)] #![feature(vec_push_all)] #![feature(zero_one)] +#![feature(question_mark)] // Issue# 30592: Systematically use alloc_system during stage0 since jemalloc // might be unavailable or disabled diff --git a/src/libstd/net/addr.rs b/src/libstd/net/addr.rs index 78da9412212..273a2004fc0 100644 --- a/src/libstd/net/addr.rs +++ b/src/libstd/net/addr.rs @@ -431,13 +431,13 @@ impl ToSocketAddrs for (Ipv6Addr, u16) { } fn resolve_socket_addr(s: &str, p: u16) -> io::Result<vec::IntoIter<SocketAddr>> { - let ips = try!(lookup_host(s)); - let v: Vec<_> = try!(ips.map(|a| { + let ips = lookup_host(s)?; + let v: Vec<_> = ips.map(|a| { a.map(|mut a| { a.set_port(p); a }) - }).collect()); + }).collect()?; Ok(v.into_iter()) } diff --git a/src/libstd/net/ip.rs b/src/libstd/net/ip.rs index 934d0468a38..541daf86c31 100644 --- a/src/libstd/net/ip.rs +++ b/src/libstd/net/ip.rs @@ -487,16 +487,16 @@ impl fmt::Display for Ipv6Addr { if zeros_len > 1 { fn fmt_subslice(segments: &[u16], fmt: &mut fmt::Formatter) -> fmt::Result { if !segments.is_empty() { - try!(write!(fmt, "{:x}", segments[0])); + write!(fmt, "{:x}", segments[0])?; for &seg in &segments[1..] { - try!(write!(fmt, ":{:x}", seg)); + write!(fmt, ":{:x}", seg)?; } } Ok(()) } - try!(fmt_subslice(&self.segments()[..zeros_at], fmt)); - try!(fmt.write_str("::")); + fmt_subslice(&self.segments()[..zeros_at], fmt)?; + fmt.write_str("::")?; fmt_subslice(&self.segments()[zeros_at + zeros_len..], fmt) } else { let &[a, b, c, d, e, f, g, h] = &self.segments(); diff --git a/src/libstd/net/mod.rs b/src/libstd/net/mod.rs index 22332b709ce..45070460282 100644 --- a/src/libstd/net/mod.rs +++ b/src/libstd/net/mod.rs @@ -74,7 +74,7 @@ fn each_addr<A: ToSocketAddrs, F, T>(addr: A, mut f: F) -> io::Result<T> where F: FnMut(&SocketAddr) -> io::Result<T> { let mut last_err = None; - for addr in try!(addr.to_socket_addrs()) { + for addr in addr.to_socket_addrs()? { match f(&addr) { Ok(l) => return Ok(l), Err(e) => last_err = Some(e), diff --git a/src/libstd/net/udp.rs b/src/libstd/net/udp.rs index bce82565fdf..da1cf115e8d 100644 --- a/src/libstd/net/udp.rs +++ b/src/libstd/net/udp.rs @@ -70,7 +70,7 @@ impl UdpSocket { #[stable(feature = "rust1", since = "1.0.0")] pub fn send_to<A: ToSocketAddrs>(&self, buf: &[u8], addr: A) -> io::Result<usize> { - match try!(addr.to_socket_addrs()).next() { + match addr.to_socket_addrs()?.next() { Some(addr) => self.0.send_to(buf, &addr), None => Err(Error::new(ErrorKind::InvalidInput, "no addresses to send data to")), diff --git a/src/libstd/panic.rs b/src/libstd/panic.rs index f2789949887..4462ce24dce 100644 --- a/src/libstd/panic.rs +++ b/src/libstd/panic.rs @@ -315,7 +315,7 @@ pub fn recover<F: FnOnce() -> R + RecoverSafe, R>(f: F) -> Result<R> { let mut result = None; unsafe { let result = &mut result; - try!(unwind::try(move || *result = Some(f()))) + unwind::try(move || *result = Some(f()))? } Ok(result.unwrap()) } diff --git a/src/libstd/process.rs b/src/libstd/process.rs index 5813d82a315..e86026758aa 100644 --- a/src/libstd/process.rs +++ b/src/libstd/process.rs @@ -520,7 +520,7 @@ impl Child { } } - let status = try!(self.wait()); + let status = self.wait()?; Ok(Output { status: status, stdout: stdout, diff --git a/src/libstd/sync/mutex.rs b/src/libstd/sync/mutex.rs index 34c9c7cf1e9..e0946a5c12a 100644 --- a/src/libstd/sync/mutex.rs +++ b/src/libstd/sync/mutex.rs @@ -234,7 +234,7 @@ impl<T: ?Sized> Mutex<T> { pub fn try_lock(&self) -> TryLockResult<MutexGuard<T>> { unsafe { if self.inner.lock.try_lock() { - Ok(try!(MutexGuard::new(&*self.inner, &self.data))) + Ok(MutexGuard::new(&*self.inner, &self.data)?) } else { Err(TryLockError::WouldBlock) } @@ -353,7 +353,7 @@ impl StaticMutex { pub fn try_lock(&'static self) -> TryLockResult<MutexGuard<()>> { unsafe { if self.lock.try_lock() { - Ok(try!(MutexGuard::new(self, &DUMMY.0))) + Ok(MutexGuard::new(self, &DUMMY.0)?) } else { Err(TryLockError::WouldBlock) } diff --git a/src/libstd/sync/rwlock.rs b/src/libstd/sync/rwlock.rs index 0603dad4528..a37c1c16a45 100644 --- a/src/libstd/sync/rwlock.rs +++ b/src/libstd/sync/rwlock.rs @@ -205,7 +205,7 @@ impl<T: ?Sized> RwLock<T> { pub fn try_read(&self) -> TryLockResult<RwLockReadGuard<T>> { unsafe { if self.inner.lock.try_read() { - Ok(try!(RwLockReadGuard::new(&*self.inner, &self.data))) + Ok(RwLockReadGuard::new(&*self.inner, &self.data)?) } else { Err(TryLockError::WouldBlock) } @@ -257,7 +257,7 @@ impl<T: ?Sized> RwLock<T> { pub fn try_write(&self) -> TryLockResult<RwLockWriteGuard<T>> { unsafe { if self.inner.lock.try_write() { - Ok(try!(RwLockWriteGuard::new(&*self.inner, &self.data))) + Ok(RwLockWriteGuard::new(&*self.inner, &self.data)?) } else { Err(TryLockError::WouldBlock) } @@ -382,7 +382,7 @@ impl StaticRwLock { -> TryLockResult<RwLockReadGuard<'static, ()>> { unsafe { if self.lock.try_read(){ - Ok(try!(RwLockReadGuard::new(self, &DUMMY.0))) + Ok(RwLockReadGuard::new(self, &DUMMY.0)?) } else { Err(TryLockError::WouldBlock) } @@ -409,7 +409,7 @@ impl StaticRwLock { -> TryLockResult<RwLockWriteGuard<'static, ()>> { unsafe { if self.lock.try_write() { - Ok(try!(RwLockWriteGuard::new(self, &DUMMY.0))) + Ok(RwLockWriteGuard::new(self, &DUMMY.0)?) } else { Err(TryLockError::WouldBlock) } diff --git a/src/libstd/sys/common/backtrace.rs b/src/libstd/sys/common/backtrace.rs index 3c84783d215..b81fb3011c7 100644 --- a/src/libstd/sys/common/backtrace.rs +++ b/src/libstd/sys/common/backtrace.rs @@ -46,10 +46,10 @@ pub fn log_enabled() -> bool { // These output functions should now be used everywhere to ensure consistency. pub fn output(w: &mut Write, idx: isize, addr: *mut libc::c_void, s: Option<&[u8]>) -> io::Result<()> { - try!(write!(w, " {:2}: {:2$?} - ", idx, addr, HEX_WIDTH)); + write!(w, " {:2}: {:2$?} - ", idx, addr, HEX_WIDTH)?; match s.and_then(|s| str::from_utf8(s).ok()) { - Some(string) => try!(demangle(w, string)), - None => try!(write!(w, "<unknown>")), + Some(string) => demangle(w, string)?, + None => write!(w, "<unknown>")?, } w.write_all(&['\n' as u8]) } @@ -59,9 +59,9 @@ pub fn output_fileline(w: &mut Write, file: &[u8], line: libc::c_int, more: bool) -> io::Result<()> { let file = str::from_utf8(file).unwrap_or("<unknown>"); // prior line: " ##: {:2$} - func" - try!(write!(w, " {:3$}at {}:{}", "", file, line, HEX_WIDTH)); + write!(w, " {:3$}at {}:{}", "", file, line, HEX_WIDTH)?; if more { - try!(write!(w, " <... and possibly more>")); + write!(w, " <... and possibly more>")?; } w.write_all(&['\n' as u8]) } @@ -121,12 +121,12 @@ pub fn demangle(writer: &mut Write, s: &str) -> io::Result<()> { // Alright, let's do this. if !valid { - try!(writer.write_all(s.as_bytes())); + writer.write_all(s.as_bytes())?; } else { let mut first = true; while !inner.is_empty() { if !first { - try!(writer.write_all(b"::")); + writer.write_all(b"::")?; } else { first = false; } @@ -177,7 +177,7 @@ pub fn demangle(writer: &mut Write, s: &str) -> io::Result<()> { None => rest.len(), Some(i) => i, }; - try!(writer.write_all(rest[..idx].as_bytes())); + writer.write_all(rest[..idx].as_bytes())?; rest = &rest[idx..]; } } diff --git a/src/libstd/sys/common/gnu/libbacktrace.rs b/src/libstd/sys/common/gnu/libbacktrace.rs index 8b3cb04030c..db719ccce61 100644 --- a/src/libstd/sys/common/gnu/libbacktrace.rs +++ b/src/libstd/sys/common/gnu/libbacktrace.rs @@ -172,9 +172,9 @@ pub fn print(w: &mut Write, idx: isize, addr: *mut libc::c_void, data_addr as *mut libc::c_void) }; if ret == 0 || data.is_null() { - try!(output(w, idx, addr, None)); + output(w, idx, addr, None)?; } else { - try!(output(w, idx, addr, Some(unsafe { CStr::from_ptr(data).to_bytes() }))); + output(w, idx, addr, Some(unsafe { CStr::from_ptr(data).to_bytes() }))?; } // pcinfo may return an arbitrary number of file:line pairs, @@ -198,7 +198,7 @@ pub fn print(w: &mut Write, idx: isize, addr: *mut libc::c_void, for (i, &(file, line)) in fileline_buf[..fileline_count].iter().enumerate() { if file.is_null() { continue; } // just to be sure let file = unsafe { CStr::from_ptr(file).to_bytes() }; - try!(output_fileline(w, file, line, i == FILELINE_SIZE - 1)); + output_fileline(w, file, line, i == FILELINE_SIZE - 1)?; } } diff --git a/src/libstd/sys/common/net.rs b/src/libstd/sys/common/net.rs index 3fa70d0ce4b..d5d967114c4 100644 --- a/src/libstd/sys/common/net.rs +++ b/src/libstd/sys/common/net.rs @@ -48,8 +48,8 @@ pub fn setsockopt<T>(sock: &Socket, opt: c_int, val: c_int, payload: T) -> io::Result<()> { unsafe { let payload = &payload as *const T as *const c_void; - try!(cvt(c::setsockopt(*sock.as_inner(), opt, val, payload, - mem::size_of::<T>() as c::socklen_t))); + cvt(c::setsockopt(*sock.as_inner(), opt, val, payload, + mem::size_of::<T>() as c::socklen_t))?; Ok(()) } } @@ -59,9 +59,9 @@ pub fn getsockopt<T: Copy>(sock: &Socket, opt: c_int, unsafe { let mut slot: T = mem::zeroed(); let mut len = mem::size_of::<T>() as c::socklen_t; - try!(cvt(c::getsockopt(*sock.as_inner(), opt, val, - &mut slot as *mut _ as *mut _, - &mut len))); + cvt(c::getsockopt(*sock.as_inner(), opt, val, + &mut slot as *mut _ as *mut _, + &mut len))?; assert_eq!(len as usize, mem::size_of::<T>()); Ok(slot) } @@ -73,7 +73,7 @@ fn sockname<F>(f: F) -> io::Result<SocketAddr> unsafe { let mut storage: c::sockaddr_storage = mem::zeroed(); let mut len = mem::size_of_val(&storage) as c::socklen_t; - try!(cvt(f(&mut storage as *mut _ as *mut _, &mut len))); + cvt(f(&mut storage as *mut _ as *mut _, &mut len))?; sockaddr_to_addr(&storage, len as usize) } } @@ -143,11 +143,11 @@ impl Drop for LookupHost { pub fn lookup_host(host: &str) -> io::Result<LookupHost> { init(); - let c_host = try!(CString::new(host)); + let c_host = CString::new(host)?; let mut res = ptr::null_mut(); unsafe { - try!(cvt_gai(c::getaddrinfo(c_host.as_ptr(), ptr::null(), ptr::null(), - &mut res))); + cvt_gai(c::getaddrinfo(c_host.as_ptr(), ptr::null(), ptr::null(), + &mut res))?; Ok(LookupHost { original: res, cur: res }) } } @@ -164,10 +164,10 @@ impl TcpStream { pub fn connect(addr: &SocketAddr) -> io::Result<TcpStream> { init(); - let sock = try!(Socket::new(addr, c::SOCK_STREAM)); + let sock = Socket::new(addr, c::SOCK_STREAM)?; let (addrp, len) = addr.into_inner(); - try!(cvt_r(|| unsafe { c::connect(*sock.as_inner(), addrp, len) })); + cvt_r(|| unsafe { c::connect(*sock.as_inner(), addrp, len) })?; Ok(TcpStream { inner: sock }) } @@ -201,12 +201,12 @@ impl TcpStream { pub fn write(&self, buf: &[u8]) -> io::Result<usize> { let len = cmp::min(buf.len(), <wrlen_t>::max_value() as usize) as wrlen_t; - let ret = try!(cvt(unsafe { + let ret = cvt(unsafe { c::send(*self.inner.as_inner(), buf.as_ptr() as *const c_void, len, 0) - })); + })?; Ok(ret as usize) } @@ -243,7 +243,7 @@ impl TcpStream { } pub fn ttl(&self) -> io::Result<u32> { - let raw: c_int = try!(getsockopt(&self.inner, c::IPPROTO_IP, c::IP_TTL)); + let raw: c_int = getsockopt(&self.inner, c::IPPROTO_IP, c::IP_TTL)?; Ok(raw as u32) } @@ -252,7 +252,7 @@ impl TcpStream { } pub fn only_v6(&self) -> io::Result<bool> { - let raw: c_int = try!(getsockopt(&self.inner, c::IPPROTO_IPV6, c::IPV6_V6ONLY)); + let raw: c_int = getsockopt(&self.inner, c::IPPROTO_IPV6, c::IPV6_V6ONLY)?; Ok(raw != 0) } @@ -301,22 +301,22 @@ impl TcpListener { pub fn bind(addr: &SocketAddr) -> io::Result<TcpListener> { init(); - let sock = try!(Socket::new(addr, c::SOCK_STREAM)); + let sock = Socket::new(addr, c::SOCK_STREAM)?; // On platforms with Berkeley-derived sockets, this allows // to quickly rebind a socket, without needing to wait for // the OS to clean up the previous one. if !cfg!(windows) { - try!(setsockopt(&sock, c::SOL_SOCKET, c::SO_REUSEADDR, - 1 as c_int)); + setsockopt(&sock, c::SOL_SOCKET, c::SO_REUSEADDR, + 1 as c_int)?; } // Bind our new socket let (addrp, len) = addr.into_inner(); - try!(cvt(unsafe { c::bind(*sock.as_inner(), addrp, len) })); + cvt(unsafe { c::bind(*sock.as_inner(), addrp, len) })?; // Start listening - try!(cvt(unsafe { c::listen(*sock.as_inner(), 128) })); + cvt(unsafe { c::listen(*sock.as_inner(), 128) })?; Ok(TcpListener { inner: sock }) } @@ -333,9 +333,9 @@ impl TcpListener { pub fn accept(&self) -> io::Result<(TcpStream, SocketAddr)> { let mut storage: c::sockaddr_storage = unsafe { mem::zeroed() }; let mut len = mem::size_of_val(&storage) as c::socklen_t; - let sock = try!(self.inner.accept(&mut storage as *mut _ as *mut _, - &mut len)); - let addr = try!(sockaddr_to_addr(&storage, len as usize)); + let sock = self.inner.accept(&mut storage as *mut _ as *mut _, + &mut len)?; + let addr = sockaddr_to_addr(&storage, len as usize)?; Ok((TcpStream { inner: sock, }, addr)) } @@ -348,7 +348,7 @@ impl TcpListener { } pub fn ttl(&self) -> io::Result<u32> { - let raw: c_int = try!(getsockopt(&self.inner, c::IPPROTO_IP, c::IP_TTL)); + let raw: c_int = getsockopt(&self.inner, c::IPPROTO_IP, c::IP_TTL)?; Ok(raw as u32) } @@ -357,7 +357,7 @@ impl TcpListener { } pub fn only_v6(&self) -> io::Result<bool> { - let raw: c_int = try!(getsockopt(&self.inner, c::IPPROTO_IPV6, c::IPV6_V6ONLY)); + let raw: c_int = getsockopt(&self.inner, c::IPPROTO_IPV6, c::IPV6_V6ONLY)?; Ok(raw != 0) } @@ -402,9 +402,9 @@ impl UdpSocket { pub fn bind(addr: &SocketAddr) -> io::Result<UdpSocket> { init(); - let sock = try!(Socket::new(addr, c::SOCK_DGRAM)); + let sock = Socket::new(addr, c::SOCK_DGRAM)?; let (addrp, len) = addr.into_inner(); - try!(cvt(unsafe { c::bind(*sock.as_inner(), addrp, len) })); + cvt(unsafe { c::bind(*sock.as_inner(), addrp, len) })?; Ok(UdpSocket { inner: sock }) } @@ -423,23 +423,23 @@ impl UdpSocket { let mut addrlen = mem::size_of_val(&storage) as c::socklen_t; let len = cmp::min(buf.len(), <wrlen_t>::max_value() as usize) as wrlen_t; - let n = try!(cvt(unsafe { + let n = cvt(unsafe { c::recvfrom(*self.inner.as_inner(), buf.as_mut_ptr() as *mut c_void, len, 0, &mut storage as *mut _ as *mut _, &mut addrlen) - })); - Ok((n as usize, try!(sockaddr_to_addr(&storage, addrlen as usize)))) + })?; + Ok((n as usize, sockaddr_to_addr(&storage, addrlen as usize)?)) } pub fn send_to(&self, buf: &[u8], dst: &SocketAddr) -> io::Result<usize> { let len = cmp::min(buf.len(), <wrlen_t>::max_value() as usize) as wrlen_t; let (dstp, dstlen) = dst.into_inner(); - let ret = try!(cvt(unsafe { + let ret = cvt(unsafe { c::sendto(*self.inner.as_inner(), buf.as_ptr() as *const c_void, len, 0, dstp, dstlen) - })); + })?; Ok(ret as usize) } @@ -468,7 +468,7 @@ impl UdpSocket { } pub fn broadcast(&self) -> io::Result<bool> { - let raw: c_int = try!(getsockopt(&self.inner, c::SOL_SOCKET, c::SO_BROADCAST)); + let raw: c_int = getsockopt(&self.inner, c::SOL_SOCKET, c::SO_BROADCAST)?; Ok(raw != 0) } @@ -477,7 +477,7 @@ impl UdpSocket { } pub fn multicast_loop_v4(&self) -> io::Result<bool> { - let raw: c_int = try!(getsockopt(&self.inner, c::IPPROTO_IP, c::IP_MULTICAST_LOOP)); + let raw: c_int = getsockopt(&self.inner, c::IPPROTO_IP, c::IP_MULTICAST_LOOP)?; Ok(raw != 0) } @@ -486,7 +486,7 @@ impl UdpSocket { } pub fn multicast_ttl_v4(&self) -> io::Result<u32> { - let raw: c_int = try!(getsockopt(&self.inner, c::IPPROTO_IP, c::IP_MULTICAST_TTL)); + let raw: c_int = getsockopt(&self.inner, c::IPPROTO_IP, c::IP_MULTICAST_TTL)?; Ok(raw as u32) } @@ -495,7 +495,7 @@ impl UdpSocket { } pub fn multicast_loop_v6(&self) -> io::Result<bool> { - let raw: c_int = try!(getsockopt(&self.inner, c::IPPROTO_IPV6, c::IPV6_MULTICAST_LOOP)); + let raw: c_int = getsockopt(&self.inner, c::IPPROTO_IPV6, c::IPV6_MULTICAST_LOOP)?; Ok(raw != 0) } @@ -540,7 +540,7 @@ impl UdpSocket { } pub fn ttl(&self) -> io::Result<u32> { - let raw: c_int = try!(getsockopt(&self.inner, c::IPPROTO_IP, c::IP_TTL)); + let raw: c_int = getsockopt(&self.inner, c::IPPROTO_IP, c::IP_TTL)?; Ok(raw as u32) } @@ -549,7 +549,7 @@ impl UdpSocket { } pub fn only_v6(&self) -> io::Result<bool> { - let raw: c_int = try!(getsockopt(&self.inner, c::IPPROTO_IPV6, c::IPV6_V6ONLY)); + let raw: c_int = getsockopt(&self.inner, c::IPPROTO_IPV6, c::IPV6_V6ONLY)?; Ok(raw != 0) } @@ -567,12 +567,12 @@ impl UdpSocket { pub fn send(&self, buf: &[u8]) -> io::Result<usize> { let len = cmp::min(buf.len(), <wrlen_t>::max_value() as usize) as wrlen_t; - let ret = try!(cvt(unsafe { + let ret = cvt(unsafe { c::send(*self.inner.as_inner(), buf.as_ptr() as *const c_void, len, 0) - })); + })?; Ok(ret as usize) } diff --git a/src/libstd/sys/common/remutex.rs b/src/libstd/sys/common/remutex.rs index 1793ad0e445..39d41042467 100644 --- a/src/libstd/sys/common/remutex.rs +++ b/src/libstd/sys/common/remutex.rs @@ -99,7 +99,7 @@ impl<T> ReentrantMutex<T> { /// acquired. pub fn try_lock(&self) -> TryLockResult<ReentrantMutexGuard<T>> { if unsafe { self.inner.try_lock() } { - Ok(try!(ReentrantMutexGuard::new(&self))) + Ok(ReentrantMutexGuard::new(&self)?) } else { Err(TryLockError::WouldBlock) } diff --git a/src/libstd/sys/common/wtf8.rs b/src/libstd/sys/common/wtf8.rs index db3bc2ed751..8b79016c251 100644 --- a/src/libstd/sys/common/wtf8.rs +++ b/src/libstd/sys/common/wtf8.rs @@ -388,32 +388,32 @@ impl fmt::Debug for Wtf8 { fn write_str_escaped(f: &mut fmt::Formatter, s: &str) -> fmt::Result { use fmt::Write; for c in s.chars().flat_map(|c| c.escape_default()) { - try!(f.write_char(c)) + f.write_char(c)? } Ok(()) } - try!(formatter.write_str("\"")); + formatter.write_str("\"")?; let mut pos = 0; loop { match self.next_surrogate(pos) { None => break, Some((surrogate_pos, surrogate)) => { - try!(write_str_escaped( + write_str_escaped( formatter, unsafe { str::from_utf8_unchecked( &self.bytes[pos .. surrogate_pos] )}, - )); - try!(write!(formatter, "\\u{{{:X}}}", surrogate)); + )?; + write!(formatter, "\\u{{{:X}}}", surrogate)?; pos = surrogate_pos + 3; } } } - try!(write_str_escaped( + write_str_escaped( formatter, unsafe { str::from_utf8_unchecked(&self.bytes[pos..]) }, - )); + )?; formatter.write_str("\"") } } diff --git a/src/libstd/sys/unix/backtrace/tracing/backtrace_fn.rs b/src/libstd/sys/unix/backtrace/tracing/backtrace_fn.rs index 46f276aecf4..de93d3d4e50 100644 --- a/src/libstd/sys/unix/backtrace/tracing/backtrace_fn.rs +++ b/src/libstd/sys/unix/backtrace/tracing/backtrace_fn.rs @@ -40,7 +40,7 @@ pub fn write(w: &mut Write) -> io::Result<()> { static LOCK: StaticMutex = StaticMutex::new(); let _g = LOCK.lock(); - try!(writeln!(w, "stack backtrace:")); + writeln!(w, "stack backtrace:")?; // 100 lines should be enough const SIZE: usize = 100; let mut buf: [*mut libc::c_void; SIZE] = unsafe { mem::zeroed() }; @@ -48,7 +48,7 @@ pub fn write(w: &mut Write) -> io::Result<()> { // skipping the first one as it is write itself for i in 1..cnt { - try!(print(w, i as isize, buf[i], buf[i])) + print(w, i as isize, buf[i], buf[i])? } Ok(()) } diff --git a/src/libstd/sys/unix/backtrace/tracing/gcc_s.rs b/src/libstd/sys/unix/backtrace/tracing/gcc_s.rs index 8b32b5ec040..8d880917166 100644 --- a/src/libstd/sys/unix/backtrace/tracing/gcc_s.rs +++ b/src/libstd/sys/unix/backtrace/tracing/gcc_s.rs @@ -33,7 +33,7 @@ pub fn write(w: &mut Write) -> io::Result<()> { static LOCK: StaticMutex = StaticMutex::new(); let _g = LOCK.lock(); - try!(writeln!(w, "stack backtrace:")); + writeln!(w, "stack backtrace:")?; let mut cx = Context { writer: w, last_error: None, idx: 0 }; return match unsafe { diff --git a/src/libstd/sys/unix/ext/net.rs b/src/libstd/sys/unix/ext/net.rs index 2ee825f1ec2..a74f7ea13b4 100644 --- a/src/libstd/sys/unix/ext/net.rs +++ b/src/libstd/sys/unix/ext/net.rs @@ -87,7 +87,7 @@ impl SocketAddr { unsafe { let mut addr: libc::sockaddr_un = mem::zeroed(); let mut len = mem::size_of::<libc::sockaddr_un>() as libc::socklen_t; - try!(cvt(f(&mut addr as *mut _ as *mut _, &mut len))); + cvt(f(&mut addr as *mut _ as *mut _, &mut len))?; SocketAddr::from_parts(addr, len) } } @@ -155,9 +155,9 @@ struct AsciiEscaped<'a>(&'a [u8]); impl<'a> fmt::Display for AsciiEscaped<'a> { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { - try!(write!(fmt, "\"")); + write!(fmt, "\"")?; for byte in self.0.iter().cloned().flat_map(ascii::escape_default) { - try!(write!(fmt, "{}", byte as char)); + write!(fmt, "{}", byte as char)?; } write!(fmt, "\"") } @@ -200,10 +200,10 @@ impl UnixStream { pub fn connect<P: AsRef<Path>>(path: P) -> io::Result<UnixStream> { fn inner(path: &Path) -> io::Result<UnixStream> { unsafe { - let inner = try!(Socket::new_raw(libc::AF_UNIX, libc::SOCK_STREAM)); - let (addr, len) = try!(sockaddr_un(path)); + let inner = Socket::new_raw(libc::AF_UNIX, libc::SOCK_STREAM)?; + let (addr, len) = sockaddr_un(path)?; - try!(cvt(libc::connect(*inner.as_inner(), &addr as *const _ as *const _, len))); + cvt(libc::connect(*inner.as_inner(), &addr as *const _ as *const _, len))?; Ok(UnixStream(inner)) } } @@ -214,7 +214,7 @@ impl UnixStream { /// /// Returns two `UnixStream`s which are connected to each other. pub fn pair() -> io::Result<(UnixStream, UnixStream)> { - let (i1, i2) = try!(Socket::new_pair(libc::AF_UNIX, libc::SOCK_STREAM)); + let (i1, i2) = Socket::new_pair(libc::AF_UNIX, libc::SOCK_STREAM)?; Ok((UnixStream(i1), UnixStream(i2))) } @@ -395,11 +395,11 @@ impl UnixListener { pub fn bind<P: AsRef<Path>>(path: P) -> io::Result<UnixListener> { fn inner(path: &Path) -> io::Result<UnixListener> { unsafe { - let inner = try!(Socket::new_raw(libc::AF_UNIX, libc::SOCK_STREAM)); - let (addr, len) = try!(sockaddr_un(path)); + let inner = Socket::new_raw(libc::AF_UNIX, libc::SOCK_STREAM)?; + let (addr, len) = sockaddr_un(path)?; - try!(cvt(libc::bind(*inner.as_inner(), &addr as *const _ as *const _, len))); - try!(cvt(libc::listen(*inner.as_inner(), 128))); + cvt(libc::bind(*inner.as_inner(), &addr as *const _ as *const _, len))?; + cvt(libc::listen(*inner.as_inner(), 128))?; Ok(UnixListener(inner)) } @@ -415,8 +415,8 @@ impl UnixListener { pub fn accept(&self) -> io::Result<(UnixStream, SocketAddr)> { let mut storage: libc::sockaddr_un = unsafe { mem::zeroed() }; let mut len = mem::size_of_val(&storage) as libc::socklen_t; - let sock = try!(self.0.accept(&mut storage as *mut _ as *mut _, &mut len)); - let addr = try!(SocketAddr::from_parts(storage, len)); + let sock = self.0.accept(&mut storage as *mut _ as *mut _, &mut len)?; + let addr = SocketAddr::from_parts(storage, len)?; Ok((UnixStream(sock), addr)) } @@ -536,10 +536,10 @@ impl UnixDatagram { pub fn bind<P: AsRef<Path>>(path: P) -> io::Result<UnixDatagram> { fn inner(path: &Path) -> io::Result<UnixDatagram> { unsafe { - let socket = try!(UnixDatagram::unbound()); - let (addr, len) = try!(sockaddr_un(path)); + let socket = UnixDatagram::unbound()?; + let (addr, len) = sockaddr_un(path)?; - try!(cvt(libc::bind(*socket.0.as_inner(), &addr as *const _ as *const _, len))); + cvt(libc::bind(*socket.0.as_inner(), &addr as *const _ as *const _, len))?; Ok(socket) } @@ -549,7 +549,7 @@ impl UnixDatagram { /// Creates a Unix Datagram socket which is not bound to any address. pub fn unbound() -> io::Result<UnixDatagram> { - let inner = try!(Socket::new_raw(libc::AF_UNIX, libc::SOCK_DGRAM)); + let inner = Socket::new_raw(libc::AF_UNIX, libc::SOCK_DGRAM)?; Ok(UnixDatagram(inner)) } @@ -557,7 +557,7 @@ impl UnixDatagram { /// /// Returns two `UnixDatagrams`s which are connected to each other. pub fn pair() -> io::Result<(UnixDatagram, UnixDatagram)> { - let (i1, i2) = try!(Socket::new_pair(libc::AF_UNIX, libc::SOCK_DGRAM)); + let (i1, i2) = Socket::new_pair(libc::AF_UNIX, libc::SOCK_DGRAM)?; Ok((UnixDatagram(i1), UnixDatagram(i2))) } @@ -568,9 +568,9 @@ impl UnixDatagram { pub fn connect<P: AsRef<Path>>(&self, path: P) -> io::Result<()> { fn inner(d: &UnixDatagram, path: &Path) -> io::Result<()> { unsafe { - let (addr, len) = try!(sockaddr_un(path)); + let (addr, len) = sockaddr_un(path)?; - try!(cvt(libc::connect(*d.0.as_inner(), &addr as *const _ as *const _, len))); + cvt(libc::connect(*d.0.as_inner(), &addr as *const _ as *const _, len))?; Ok(()) } @@ -605,7 +605,7 @@ impl UnixDatagram { /// whence the data came. pub fn recv_from(&self, buf: &mut [u8]) -> io::Result<(usize, SocketAddr)> { let mut count = 0; - let addr = try!(SocketAddr::new(|addr, len| { + let addr = SocketAddr::new(|addr, len| { unsafe { count = libc::recvfrom(*self.0.as_inner(), buf.as_mut_ptr() as *mut _, @@ -621,7 +621,7 @@ impl UnixDatagram { -1 } } - })); + })?; Ok((count as usize, addr)) } @@ -639,14 +639,14 @@ impl UnixDatagram { pub fn send_to<P: AsRef<Path>>(&self, buf: &[u8], path: P) -> io::Result<usize> { fn inner(d: &UnixDatagram, buf: &[u8], path: &Path) -> io::Result<usize> { unsafe { - let (addr, len) = try!(sockaddr_un(path)); - - let count = try!(cvt(libc::sendto(*d.0.as_inner(), - buf.as_ptr() as *const _, - buf.len(), - 0, - &addr as *const _ as *const _, - len))); + let (addr, len) = sockaddr_un(path)?; + + let count = cvt(libc::sendto(*d.0.as_inner(), + buf.as_ptr() as *const _, + buf.len(), + 0, + &addr as *const _ as *const _, + len))?; Ok(count as usize) } } diff --git a/src/libstd/sys/unix/fd.rs b/src/libstd/sys/unix/fd.rs index 8ec073858fd..94c48be02ff 100644 --- a/src/libstd/sys/unix/fd.rs +++ b/src/libstd/sys/unix/fd.rs @@ -39,11 +39,11 @@ impl FileDesc { } pub fn read(&self, buf: &mut [u8]) -> io::Result<usize> { - let ret = try!(cvt(unsafe { + let ret = cvt(unsafe { libc::read(self.fd, buf.as_mut_ptr() as *mut c_void, buf.len() as size_t) - })); + })?; Ok(ret as usize) } @@ -53,11 +53,11 @@ impl FileDesc { } pub fn write(&self, buf: &[u8]) -> io::Result<usize> { - let ret = try!(cvt(unsafe { + let ret = cvt(unsafe { libc::write(self.fd, buf.as_ptr() as *const c_void, buf.len() as size_t) - })); + })?; Ok(ret as usize) } diff --git a/src/libstd/sys/unix/fs.rs b/src/libstd/sys/unix/fs.rs index 3985a07470e..810a34478c5 100644 --- a/src/libstd/sys/unix/fs.rs +++ b/src/libstd/sys/unix/fs.rs @@ -418,18 +418,18 @@ impl OpenOptions { impl File { pub fn open(path: &Path, opts: &OpenOptions) -> io::Result<File> { - let path = try!(cstr(path)); + let path = cstr(path)?; File::open_c(&path, opts) } pub fn open_c(path: &CStr, opts: &OpenOptions) -> io::Result<File> { let flags = libc::O_CLOEXEC | - try!(opts.get_access_mode()) | - try!(opts.get_creation_mode()) | + opts.get_access_mode()? | + opts.get_creation_mode()? | (opts.custom_flags as c_int & !libc::O_ACCMODE); - let fd = try!(cvt_r(|| unsafe { + let fd = cvt_r(|| unsafe { open64(path.as_ptr(), flags, opts.mode as c_int) - })); + })?; let fd = FileDesc::new(fd); // Currently the standard library supports Linux 2.6.18 which did not @@ -448,19 +448,19 @@ impl File { pub fn file_attr(&self) -> io::Result<FileAttr> { let mut stat: stat64 = unsafe { mem::zeroed() }; - try!(cvt(unsafe { + cvt(unsafe { fstat64(self.0.raw(), &mut stat) - })); + })?; Ok(FileAttr { stat: stat }) } pub fn fsync(&self) -> io::Result<()> { - try!(cvt_r(|| unsafe { libc::fsync(self.0.raw()) })); + cvt_r(|| unsafe { libc::fsync(self.0.raw()) })?; Ok(()) } pub fn datasync(&self) -> io::Result<()> { - try!(cvt_r(|| unsafe { os_datasync(self.0.raw()) })); + cvt_r(|| unsafe { os_datasync(self.0.raw()) })?; return Ok(()); #[cfg(any(target_os = "macos", target_os = "ios"))] @@ -476,9 +476,9 @@ impl File { } pub fn truncate(&self, size: u64) -> io::Result<()> { - try!(cvt_r(|| unsafe { + cvt_r(|| unsafe { ftruncate64(self.0.raw(), size as off64_t) - })); + })?; Ok(()) } @@ -502,7 +502,7 @@ impl File { SeekFrom::End(off) => (libc::SEEK_END, off as off64_t), SeekFrom::Current(off) => (libc::SEEK_CUR, off as off64_t), }; - let n = try!(cvt(unsafe { lseek64(self.0.raw(), pos, whence) })); + let n = cvt(unsafe { lseek64(self.0.raw(), pos, whence) })?; Ok(n as u64) } @@ -521,8 +521,8 @@ impl DirBuilder { } pub fn mkdir(&self, p: &Path) -> io::Result<()> { - let p = try!(cstr(p)); - try!(cvt(unsafe { libc::mkdir(p.as_ptr(), self.mode) })); + let p = cstr(p)?; + cvt(unsafe { libc::mkdir(p.as_ptr(), self.mode) })?; Ok(()) } @@ -532,7 +532,7 @@ impl DirBuilder { } fn cstr(path: &Path) -> io::Result<CString> { - Ok(try!(CString::new(path.as_os_str().as_bytes()))) + Ok(CString::new(path.as_os_str().as_bytes())?) } impl FromInner<c_int> for File { @@ -610,7 +610,7 @@ impl fmt::Debug for File { pub fn readdir(p: &Path) -> io::Result<ReadDir> { let root = Arc::new(p.to_path_buf()); - let p = try!(cstr(p)); + let p = cstr(p)?; unsafe { let ptr = libc::opendir(p.as_ptr()); if ptr.is_null() { @@ -622,32 +622,32 @@ pub fn readdir(p: &Path) -> io::Result<ReadDir> { } pub fn unlink(p: &Path) -> io::Result<()> { - let p = try!(cstr(p)); - try!(cvt(unsafe { libc::unlink(p.as_ptr()) })); + let p = cstr(p)?; + cvt(unsafe { libc::unlink(p.as_ptr()) })?; Ok(()) } pub fn rename(old: &Path, new: &Path) -> io::Result<()> { - let old = try!(cstr(old)); - let new = try!(cstr(new)); - try!(cvt(unsafe { libc::rename(old.as_ptr(), new.as_ptr()) })); + let old = cstr(old)?; + let new = cstr(new)?; + cvt(unsafe { libc::rename(old.as_ptr(), new.as_ptr()) })?; Ok(()) } pub fn set_perm(p: &Path, perm: FilePermissions) -> io::Result<()> { - let p = try!(cstr(p)); - try!(cvt_r(|| unsafe { libc::chmod(p.as_ptr(), perm.mode) })); + let p = cstr(p)?; + cvt_r(|| unsafe { libc::chmod(p.as_ptr(), perm.mode) })?; Ok(()) } pub fn rmdir(p: &Path) -> io::Result<()> { - let p = try!(cstr(p)); - try!(cvt(unsafe { libc::rmdir(p.as_ptr()) })); + let p = cstr(p)?; + cvt(unsafe { libc::rmdir(p.as_ptr()) })?; Ok(()) } pub fn remove_dir_all(path: &Path) -> io::Result<()> { - let filetype = try!(lstat(path)).file_type(); + let filetype = lstat(path)?.file_type(); if filetype.is_symlink() { unlink(path) } else { @@ -656,27 +656,27 @@ pub fn remove_dir_all(path: &Path) -> io::Result<()> { } fn remove_dir_all_recursive(path: &Path) -> io::Result<()> { - for child in try!(readdir(path)) { - let child = try!(child); - if try!(child.file_type()).is_dir() { - try!(remove_dir_all_recursive(&child.path())); + for child in readdir(path)? { + let child = child?; + if child.file_type()?.is_dir() { + remove_dir_all_recursive(&child.path())?; } else { - try!(unlink(&child.path())); + unlink(&child.path())?; } } rmdir(path) } pub fn readlink(p: &Path) -> io::Result<PathBuf> { - let c_path = try!(cstr(p)); + let c_path = cstr(p)?; let p = c_path.as_ptr(); let mut buf = Vec::with_capacity(256); loop { - let buf_read = try!(cvt(unsafe { + let buf_read = cvt(unsafe { libc::readlink(p, buf.as_mut_ptr() as *mut _, buf.capacity() as libc::size_t) - })) as usize; + })? as usize; unsafe { buf.set_len(buf_read); } @@ -694,39 +694,39 @@ pub fn readlink(p: &Path) -> io::Result<PathBuf> { } pub fn symlink(src: &Path, dst: &Path) -> io::Result<()> { - let src = try!(cstr(src)); - let dst = try!(cstr(dst)); - try!(cvt(unsafe { libc::symlink(src.as_ptr(), dst.as_ptr()) })); + let src = cstr(src)?; + let dst = cstr(dst)?; + cvt(unsafe { libc::symlink(src.as_ptr(), dst.as_ptr()) })?; Ok(()) } pub fn link(src: &Path, dst: &Path) -> io::Result<()> { - let src = try!(cstr(src)); - let dst = try!(cstr(dst)); - try!(cvt(unsafe { libc::link(src.as_ptr(), dst.as_ptr()) })); + let src = cstr(src)?; + let dst = cstr(dst)?; + cvt(unsafe { libc::link(src.as_ptr(), dst.as_ptr()) })?; Ok(()) } pub fn stat(p: &Path) -> io::Result<FileAttr> { - let p = try!(cstr(p)); + let p = cstr(p)?; let mut stat: stat64 = unsafe { mem::zeroed() }; - try!(cvt(unsafe { + cvt(unsafe { stat64(p.as_ptr(), &mut stat as *mut _ as *mut _) - })); + })?; Ok(FileAttr { stat: stat }) } pub fn lstat(p: &Path) -> io::Result<FileAttr> { - let p = try!(cstr(p)); + let p = cstr(p)?; let mut stat: stat64 = unsafe { mem::zeroed() }; - try!(cvt(unsafe { + cvt(unsafe { lstat64(p.as_ptr(), &mut stat as *mut _ as *mut _) - })); + })?; Ok(FileAttr { stat: stat }) } pub fn canonicalize(p: &Path) -> io::Result<PathBuf> { - let path = try!(CString::new(p.as_os_str().as_bytes())); + let path = CString::new(p.as_os_str().as_bytes())?; let buf; unsafe { let r = libc::realpath(path.as_ptr(), ptr::null_mut()); @@ -746,11 +746,11 @@ pub fn copy(from: &Path, to: &Path) -> io::Result<u64> { "the source path is not an existing regular file")) } - let mut reader = try!(File::open(from)); - let mut writer = try!(File::create(to)); - let perm = try!(reader.metadata()).permissions(); + let mut reader = File::open(from)?; + let mut writer = File::create(to)?; + let perm = reader.metadata()?.permissions(); - let ret = try!(io::copy(&mut reader, &mut writer)); - try!(set_permissions(to, perm)); + let ret = io::copy(&mut reader, &mut writer)?; + set_permissions(to, perm)?; Ok(ret) } diff --git a/src/libstd/sys/unix/net.rs b/src/libstd/sys/unix/net.rs index d7b353c9b2a..830957a7e59 100644 --- a/src/libstd/sys/unix/net.rs +++ b/src/libstd/sys/unix/net.rs @@ -75,7 +75,7 @@ impl Socket { } } - let fd = try!(cvt(libc::socket(fam, ty, 0))); + let fd = cvt(libc::socket(fam, ty, 0))?; let fd = FileDesc::new(fd); fd.set_cloexec(); Ok(Socket(fd)) @@ -97,7 +97,7 @@ impl Socket { } } - try!(cvt(libc::socketpair(fam, ty, 0, fds.as_mut_ptr()))); + cvt(libc::socketpair(fam, ty, 0, fds.as_mut_ptr()))?; let a = FileDesc::new(fds[0]); a.set_cloexec(); let b = FileDesc::new(fds[1]); @@ -128,9 +128,9 @@ impl Socket { } } - let fd = try!(cvt_r(|| unsafe { + let fd = cvt_r(|| unsafe { libc::accept(self.0.raw(), storage, len) - })); + })?; let fd = FileDesc::new(fd); fd.set_cloexec(); Ok(Socket(fd)) @@ -185,7 +185,7 @@ impl Socket { } pub fn timeout(&self, kind: libc::c_int) -> io::Result<Option<Duration>> { - let raw: libc::timeval = try!(getsockopt(self, libc::SOL_SOCKET, kind)); + let raw: libc::timeval = getsockopt(self, libc::SOL_SOCKET, kind)?; if raw.tv_sec == 0 && raw.tv_usec == 0 { Ok(None) } else { @@ -201,7 +201,7 @@ impl Socket { Shutdown::Read => libc::SHUT_RD, Shutdown::Both => libc::SHUT_RDWR, }; - try!(cvt(unsafe { libc::shutdown(self.0.raw(), how) })); + cvt(unsafe { libc::shutdown(self.0.raw(), how) })?; Ok(()) } @@ -210,7 +210,7 @@ impl Socket { } pub fn nodelay(&self) -> io::Result<bool> { - let raw: c_int = try!(getsockopt(self, libc::IPPROTO_TCP, libc::TCP_NODELAY)); + let raw: c_int = getsockopt(self, libc::IPPROTO_TCP, libc::TCP_NODELAY)?; Ok(raw != 0) } @@ -220,7 +220,7 @@ impl Socket { } pub fn take_error(&self) -> io::Result<Option<io::Error>> { - let raw: c_int = try!(getsockopt(self, libc::SOL_SOCKET, libc::SO_ERROR)); + let raw: c_int = getsockopt(self, libc::SOL_SOCKET, libc::SO_ERROR)?; if raw == 0 { Ok(None) } else { diff --git a/src/libstd/sys/unix/os.rs b/src/libstd/sys/unix/os.rs index b6a0bd84409..eed62c9ecfd 100644 --- a/src/libstd/sys/unix/os.rs +++ b/src/libstd/sys/unix/os.rs @@ -110,7 +110,7 @@ pub fn getcwd() -> io::Result<PathBuf> { pub fn chdir(p: &path::Path) -> io::Result<()> { let p: &OsStr = p.as_ref(); - let p = try!(CString::new(p.as_bytes())); + let p = CString::new(p.as_bytes())?; unsafe { match libc::chdir(p.as_ptr()) == (0 as c_int) { true => Ok(()), @@ -180,16 +180,16 @@ pub fn current_exe() -> io::Result<PathBuf> { libc::KERN_PROC_PATHNAME as c_int, -1 as c_int]; let mut sz: libc::size_t = 0; - try!(cvt(libc::sysctl(mib.as_mut_ptr(), mib.len() as ::libc::c_uint, - ptr::null_mut(), &mut sz, ptr::null_mut(), - 0 as libc::size_t))); + cvt(libc::sysctl(mib.as_mut_ptr(), mib.len() as ::libc::c_uint, + ptr::null_mut(), &mut sz, ptr::null_mut(), + 0 as libc::size_t))?; if sz == 0 { return Err(io::Error::last_os_error()) } let mut v: Vec<u8> = Vec::with_capacity(sz as usize); - try!(cvt(libc::sysctl(mib.as_mut_ptr(), mib.len() as ::libc::c_uint, - v.as_mut_ptr() as *mut libc::c_void, &mut sz, - ptr::null_mut(), 0 as libc::size_t))); + cvt(libc::sysctl(mib.as_mut_ptr(), mib.len() as ::libc::c_uint, + v.as_mut_ptr() as *mut libc::c_void, &mut sz, + ptr::null_mut(), 0 as libc::size_t))?; if sz == 0 { return Err(io::Error::last_os_error()); } @@ -217,11 +217,11 @@ pub fn current_exe() -> io::Result<PathBuf> { libc::KERN_PROC_ARGV]; let mib = mib.as_mut_ptr(); let mut argv_len = 0; - try!(cvt(libc::sysctl(mib, 4, 0 as *mut _, &mut argv_len, - 0 as *mut _, 0))); + cvt(libc::sysctl(mib, 4, 0 as *mut _, &mut argv_len, + 0 as *mut _, 0))?; let mut argv = Vec::<*const libc::c_char>::with_capacity(argv_len as usize); - try!(cvt(libc::sysctl(mib, 4, argv.as_mut_ptr() as *mut _, - &mut argv_len, 0 as *mut _, 0))); + cvt(libc::sysctl(mib, 4, argv.as_mut_ptr() as *mut _, + &mut argv_len, 0 as *mut _, 0))?; argv.set_len(argv_len as usize); if argv[0].is_null() { return Err(io::Error::new(io::ErrorKind::Other, @@ -460,7 +460,7 @@ pub fn env() -> Env { pub fn getenv(k: &OsStr) -> io::Result<Option<OsString>> { // environment variables with a nul byte can't be set, so their value is // always None as well - let k = try!(CString::new(k.as_bytes())); + let k = CString::new(k.as_bytes())?; let _g = ENV_LOCK.lock(); Ok(unsafe { let s = libc::getenv(k.as_ptr()) as *const _; @@ -473,8 +473,8 @@ pub fn getenv(k: &OsStr) -> io::Result<Option<OsString>> { } pub fn setenv(k: &OsStr, v: &OsStr) -> io::Result<()> { - let k = try!(CString::new(k.as_bytes())); - let v = try!(CString::new(v.as_bytes())); + let k = CString::new(k.as_bytes())?; + let v = CString::new(v.as_bytes())?; let _g = ENV_LOCK.lock(); cvt(unsafe { libc::setenv(k.as_ptr(), v.as_ptr(), 1) @@ -482,7 +482,7 @@ pub fn setenv(k: &OsStr, v: &OsStr) -> io::Result<()> { } pub fn unsetenv(n: &OsStr) -> io::Result<()> { - let nbuf = try!(CString::new(n.as_bytes())); + let nbuf = CString::new(n.as_bytes())?; let _g = ENV_LOCK.lock(); cvt(unsafe { libc::unsetenv(nbuf.as_ptr()) diff --git a/src/libstd/sys/unix/pipe.rs b/src/libstd/sys/unix/pipe.rs index e5cb3761001..beca2d46753 100644 --- a/src/libstd/sys/unix/pipe.rs +++ b/src/libstd/sys/unix/pipe.rs @@ -87,13 +87,13 @@ pub fn read2(p1: AnonPipe, let max = cmp::max(p1.raw(), p2.raw()); loop { // wait for either pipe to become readable using `select` - try!(cvt_r(|| unsafe { + cvt_r(|| unsafe { let mut read: libc::fd_set = mem::zeroed(); libc::FD_SET(p1.raw(), &mut read); libc::FD_SET(p2.raw(), &mut read); libc::select(max + 1, &mut read, 0 as *mut _, 0 as *mut _, 0 as *mut _) - })); + })?; // Read as much as we can from each pipe, ignoring EWOULDBLOCK or // EAGAIN. If we hit EOF, then this will happen because the underlying @@ -113,11 +113,11 @@ pub fn read2(p1: AnonPipe, } } }; - if try!(read(&p1, v1)) { + if read(&p1, v1)? { p2.set_nonblocking(false); return p2.read_to_end(v2).map(|_| ()); } - if try!(read(&p2, v2)) { + if read(&p2, v2)? { p1.set_nonblocking(false); return p1.read_to_end(v1).map(|_| ()); } diff --git a/src/libstd/sys/unix/process.rs b/src/libstd/sys/unix/process.rs index 47b0ff42f93..6f56f3ade06 100644 --- a/src/libstd/sys/unix/process.rs +++ b/src/libstd/sys/unix/process.rs @@ -225,11 +225,11 @@ impl Command { "nul byte found in provided data")); } - let (ours, theirs) = try!(self.setup_io(default, needs_stdin)); - let (input, output) = try!(sys::pipe::anon_pipe()); + let (ours, theirs) = self.setup_io(default, needs_stdin)?; + let (input, output) = sys::pipe::anon_pipe()?; let pid = unsafe { - match try!(cvt(libc::fork())) { + match cvt(libc::fork())? { 0 => { drop(input); let err = self.do_exec(theirs); @@ -335,7 +335,7 @@ impl Command { // have the drop glue anyway because this code never returns (the // child will either exec() or invoke libc::exit) unsafe fn do_exec(&mut self, stdio: ChildPipes) -> io::Error { - macro_rules! try { + macro_rules! t { ($e:expr) => (match $e { Ok(e) => e, Err(e) => return e, @@ -343,17 +343,17 @@ impl Command { } if let Some(fd) = stdio.stdin.fd() { - try!(cvt_r(|| libc::dup2(fd, libc::STDIN_FILENO))); + t!(cvt_r(|| libc::dup2(fd, libc::STDIN_FILENO))); } if let Some(fd) = stdio.stdout.fd() { - try!(cvt_r(|| libc::dup2(fd, libc::STDOUT_FILENO))); + t!(cvt_r(|| libc::dup2(fd, libc::STDOUT_FILENO))); } if let Some(fd) = stdio.stderr.fd() { - try!(cvt_r(|| libc::dup2(fd, libc::STDERR_FILENO))); + t!(cvt_r(|| libc::dup2(fd, libc::STDERR_FILENO))); } if let Some(u) = self.gid { - try!(cvt(libc::setgid(u as gid_t))); + t!(cvt(libc::setgid(u as gid_t))); } if let Some(u) = self.uid { // When dropping privileges from root, the `setgroups` call @@ -365,7 +365,7 @@ impl Command { // privilege dropping function. let _ = libc::setgroups(0, ptr::null()); - try!(cvt(libc::setuid(u as uid_t))); + t!(cvt(libc::setuid(u as uid_t))); } if self.session_leader { // Don't check the error of setsid because it fails if we're the @@ -374,7 +374,7 @@ impl Command { let _ = libc::setsid(); } if let Some(ref cwd) = self.cwd { - try!(cvt(libc::chdir(cwd.as_ptr()))); + t!(cvt(libc::chdir(cwd.as_ptr()))); } if let Some(ref envp) = self.envp { *sys::os::environ() = envp.as_ptr(); @@ -390,9 +390,9 @@ impl Command { // need to clean things up now to avoid confusing the program // we're about to run. let mut set: libc::sigset_t = mem::uninitialized(); - try!(cvt(libc::sigemptyset(&mut set))); - try!(cvt(libc::pthread_sigmask(libc::SIG_SETMASK, &set, - ptr::null_mut()))); + t!(cvt(libc::sigemptyset(&mut set))); + t!(cvt(libc::pthread_sigmask(libc::SIG_SETMASK, &set, + ptr::null_mut()))); let ret = libc::signal(libc::SIGPIPE, libc::SIG_DFL); if ret == libc::SIG_ERR { return io::Error::last_os_error() @@ -400,7 +400,7 @@ impl Command { } for callback in self.closures.iter_mut() { - try!(callback()); + t!(callback()); } libc::execvp(self.argv[0], self.argv.as_ptr()); @@ -415,9 +415,9 @@ impl Command { let stdin = self.stdin.as_ref().unwrap_or(default_stdin); let stdout = self.stdout.as_ref().unwrap_or(&default); let stderr = self.stderr.as_ref().unwrap_or(&default); - let (their_stdin, our_stdin) = try!(stdin.to_child_stdio(true)); - let (their_stdout, our_stdout) = try!(stdout.to_child_stdio(false)); - let (their_stderr, our_stderr) = try!(stderr.to_child_stdio(false)); + let (their_stdin, our_stdin) = stdin.to_child_stdio(true)?; + let (their_stdout, our_stdout) = stdout.to_child_stdio(false)?; + let (their_stderr, our_stderr) = stderr.to_child_stdio(false)?; let ours = StdioPipes { stdin: our_stdin, stdout: our_stdout, @@ -454,14 +454,14 @@ impl Stdio { // overwritten prematurely. Stdio::Fd(ref fd) => { if fd.raw() >= 0 && fd.raw() <= libc::STDERR_FILENO { - Ok((ChildStdio::Owned(try!(fd.duplicate())), None)) + Ok((ChildStdio::Owned(fd.duplicate()?), None)) } else { Ok((ChildStdio::Explicit(fd.raw()), None)) } } Stdio::MakePipe => { - let (reader, writer) = try!(pipe::anon_pipe()); + let (reader, writer) = pipe::anon_pipe()?; let (ours, theirs) = if readable { (writer, reader) } else { @@ -477,7 +477,7 @@ impl Stdio { let path = unsafe { CStr::from_ptr("/dev/null\0".as_ptr() as *const _) }; - let fd = try!(File::open_c(&path, &opts)); + let fd = File::open_c(&path, &opts)?; Ok((ChildStdio::Owned(fd.into_fd()), None)) } } @@ -508,9 +508,9 @@ fn pair_to_key(key: &OsStr, value: &OsStr, saw_nul: &mut bool) -> CString { impl fmt::Debug for Command { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - try!(write!(f, "{:?}", self.program)); + write!(f, "{:?}", self.program)?; for arg in &self.args { - try!(write!(f, " {:?}", arg)); + write!(f, " {:?}", arg)?; } Ok(()) } @@ -589,7 +589,7 @@ impl Process { return Ok(status) } let mut status = 0 as c_int; - try!(cvt_r(|| unsafe { libc::waitpid(self.pid, &mut status, 0) })); + cvt_r(|| unsafe { libc::waitpid(self.pid, &mut status, 0) })?; self.status = Some(ExitStatus(status)); Ok(ExitStatus(status)) } diff --git a/src/libstd/sys/unix/rand.rs b/src/libstd/sys/unix/rand.rs index fa504ade084..92c3bf8829a 100644 --- a/src/libstd/sys/unix/rand.rs +++ b/src/libstd/sys/unix/rand.rs @@ -138,7 +138,7 @@ mod imp { return Ok(OsRng { inner: OsGetrandomRng }); } - let reader = try!(File::open("/dev/urandom")); + let reader = File::open("/dev/urandom")?; let reader_rng = ReaderRng::new(reader); Ok(OsRng { inner: OsReaderRng(reader_rng) }) diff --git a/src/libstd/sys/windows/backtrace.rs b/src/libstd/sys/windows/backtrace.rs index 3cc3a631b89..0e10a8d8e8d 100644 --- a/src/libstd/sys/windows/backtrace.rs +++ b/src/libstd/sys/windows/backtrace.rs @@ -131,7 +131,7 @@ pub fn write(w: &mut Write) -> io::Result<()> { // Start from -1 to avoid printing this stack frame, which will // always be exactly the same. let mut i = -1; - try!(write!(w, "stack backtrace:\n")); + write!(w, "stack backtrace:\n")?; while StackWalk64(image, process, thread, &mut frame, &mut context, ptr::null_mut(), ptr::null_mut(), @@ -144,7 +144,7 @@ pub fn write(w: &mut Write) -> io::Result<()> { i += 1; if i >= 0 { - try!(printing::print(w, i, addr - 1, process, &dbghelp)); + printing::print(w, i, addr - 1, process, &dbghelp)?; } } diff --git a/src/libstd/sys/windows/dynamic_lib.rs b/src/libstd/sys/windows/dynamic_lib.rs index 84cfbe5e721..dde13ec8364 100644 --- a/src/libstd/sys/windows/dynamic_lib.rs +++ b/src/libstd/sys/windows/dynamic_lib.rs @@ -36,7 +36,7 @@ impl DynamicLibrary { } pub fn symbol(&self, symbol: &str) -> io::Result<usize> { - let symbol = try!(CString::new(symbol)); + let symbol = CString::new(symbol)?; unsafe { match c::GetProcAddress(self.handle, symbol.as_ptr()) as usize { 0 => Err(io::Error::last_os_error()), diff --git a/src/libstd/sys/windows/fs.rs b/src/libstd/sys/windows/fs.rs index 624fef097fc..529e42248f6 100644 --- a/src/libstd/sys/windows/fs.rs +++ b/src/libstd/sys/windows/fs.rs @@ -248,13 +248,13 @@ impl OpenOptions { impl File { pub fn open(path: &Path, opts: &OpenOptions) -> io::Result<File> { - let path = try!(to_u16s(path)); + let path = to_u16s(path)?; let handle = unsafe { c::CreateFileW(path.as_ptr(), - try!(opts.get_access_mode()), + opts.get_access_mode()?, opts.share_mode, opts.security_attributes as *mut _, - try!(opts.get_creation_mode()), + opts.get_creation_mode()?, opts.get_flags_and_attributes(), ptr::null_mut()) }; @@ -266,7 +266,7 @@ impl File { } pub fn fsync(&self) -> io::Result<()> { - try!(cvt(unsafe { c::FlushFileBuffers(self.handle.raw()) })); + cvt(unsafe { c::FlushFileBuffers(self.handle.raw()) })?; Ok(()) } @@ -277,20 +277,20 @@ impl File { EndOfFile: size as c::LARGE_INTEGER, }; let size = mem::size_of_val(&info); - try!(cvt(unsafe { + cvt(unsafe { c::SetFileInformationByHandle(self.handle.raw(), c::FileEndOfFileInfo, &mut info as *mut _ as *mut _, size as c::DWORD) - })); + })?; Ok(()) } pub fn file_attr(&self) -> io::Result<FileAttr> { unsafe { let mut info: c::BY_HANDLE_FILE_INFORMATION = mem::zeroed(); - try!(cvt(c::GetFileInformationByHandle(self.handle.raw(), - &mut info))); + cvt(c::GetFileInformationByHandle(self.handle.raw(), + &mut info))?; let mut attr = FileAttr { attributes: info.dwFileAttributes, creation_time: info.ftCreationTime, @@ -331,16 +331,16 @@ impl File { }; let pos = pos as c::LARGE_INTEGER; let mut newpos = 0; - try!(cvt(unsafe { + cvt(unsafe { c::SetFilePointerEx(self.handle.raw(), pos, &mut newpos, whence) - })); + })?; Ok(newpos as u64) } pub fn duplicate(&self) -> io::Result<File> { Ok(File { - handle: try!(self.handle.duplicate(0, true, c::DUPLICATE_SAME_ACCESS)), + handle: self.handle.duplicate(0, true, c::DUPLICATE_SAME_ACCESS)?, }) } @@ -353,7 +353,7 @@ impl File { -> io::Result<(c::DWORD, &'a c::REPARSE_DATA_BUFFER)> { unsafe { let mut bytes = 0; - try!(cvt({ + cvt({ c::DeviceIoControl(self.handle.raw(), c::FSCTL_GET_REPARSE_POINT, ptr::null_mut(), @@ -362,14 +362,14 @@ impl File { space.len() as c::DWORD, &mut bytes, ptr::null_mut()) - })); + })?; Ok((bytes, &*(space.as_ptr() as *const c::REPARSE_DATA_BUFFER))) } } fn readlink(&self) -> io::Result<PathBuf> { let mut space = [0u8; c::MAXIMUM_REPARSE_DATA_BUFFER_SIZE]; - let (_bytes, buf) = try!(self.reparse_point(&mut space)); + let (_bytes, buf) = self.reparse_point(&mut space)?; unsafe { let (path_buffer, subst_off, subst_len, relative) = match buf.ReparseTag { c::IO_REPARSE_TAG_SYMLINK => { @@ -516,10 +516,10 @@ impl DirBuilder { pub fn new() -> DirBuilder { DirBuilder } pub fn mkdir(&self, p: &Path) -> io::Result<()> { - let p = try!(to_u16s(p)); - try!(cvt(unsafe { + let p = to_u16s(p)?; + cvt(unsafe { c::CreateDirectoryW(p.as_ptr(), ptr::null_mut()) - })); + })?; Ok(()) } } @@ -527,7 +527,7 @@ impl DirBuilder { pub fn readdir(p: &Path) -> io::Result<ReadDir> { let root = p.to_path_buf(); let star = p.join("*"); - let path = try!(to_u16s(&star)); + let path = to_u16s(&star)?; unsafe { let mut wfd = mem::zeroed(); @@ -545,28 +545,28 @@ pub fn readdir(p: &Path) -> io::Result<ReadDir> { } pub fn unlink(p: &Path) -> io::Result<()> { - let p_u16s = try!(to_u16s(p)); - try!(cvt(unsafe { c::DeleteFileW(p_u16s.as_ptr()) })); + let p_u16s = to_u16s(p)?; + cvt(unsafe { c::DeleteFileW(p_u16s.as_ptr()) })?; Ok(()) } pub fn rename(old: &Path, new: &Path) -> io::Result<()> { - let old = try!(to_u16s(old)); - let new = try!(to_u16s(new)); - try!(cvt(unsafe { + let old = to_u16s(old)?; + let new = to_u16s(new)?; + cvt(unsafe { c::MoveFileExW(old.as_ptr(), new.as_ptr(), c::MOVEFILE_REPLACE_EXISTING) - })); + })?; Ok(()) } pub fn rmdir(p: &Path) -> io::Result<()> { - let p = try!(to_u16s(p)); - try!(cvt(unsafe { c::RemoveDirectoryW(p.as_ptr()) })); + let p = to_u16s(p)?; + cvt(unsafe { c::RemoveDirectoryW(p.as_ptr()) })?; Ok(()) } pub fn remove_dir_all(path: &Path) -> io::Result<()> { - let filetype = try!(lstat(path)).file_type(); + let filetype = lstat(path)?.file_type(); if filetype.is_symlink() { // On Windows symlinks to files and directories are removed differently. // rmdir only deletes dir symlinks and junctions, not file symlinks. @@ -577,15 +577,15 @@ pub fn remove_dir_all(path: &Path) -> io::Result<()> { } fn remove_dir_all_recursive(path: &Path) -> io::Result<()> { - for child in try!(readdir(path)) { - let child = try!(child); - let child_type = try!(child.file_type()); + for child in readdir(path)? { + let child = child?; + let child_type = child.file_type()?; if child_type.is_dir() { - try!(remove_dir_all_recursive(&child.path())); + remove_dir_all_recursive(&child.path())?; } else if child_type.is_symlink_dir() { - try!(rmdir(&child.path())); + rmdir(&child.path())?; } else { - try!(unlink(&child.path())); + unlink(&child.path())?; } } rmdir(path) @@ -599,7 +599,7 @@ pub fn readlink(path: &Path) -> io::Result<PathBuf> { opts.access_mode(0); opts.custom_flags(c::FILE_FLAG_OPEN_REPARSE_POINT | c::FILE_FLAG_BACKUP_SEMANTICS); - let file = try!(File::open(&path, &opts)); + let file = File::open(&path, &opts)?; file.readlink() } @@ -608,21 +608,21 @@ pub fn symlink(src: &Path, dst: &Path) -> io::Result<()> { } pub fn symlink_inner(src: &Path, dst: &Path, dir: bool) -> io::Result<()> { - let src = try!(to_u16s(src)); - let dst = try!(to_u16s(dst)); + let src = to_u16s(src)?; + let dst = to_u16s(dst)?; let flags = if dir { c::SYMBOLIC_LINK_FLAG_DIRECTORY } else { 0 }; - try!(cvt(unsafe { + cvt(unsafe { c::CreateSymbolicLinkW(dst.as_ptr(), src.as_ptr(), flags) as c::BOOL - })); + })?; Ok(()) } pub fn link(src: &Path, dst: &Path) -> io::Result<()> { - let src = try!(to_u16s(src)); - let dst = try!(to_u16s(dst)); - try!(cvt(unsafe { + let src = to_u16s(src)?; + let dst = to_u16s(dst)?; + cvt(unsafe { c::CreateHardLinkW(dst.as_ptr(), src.as_ptr(), ptr::null_mut()) - })); + })?; Ok(()) } @@ -632,7 +632,7 @@ pub fn stat(path: &Path) -> io::Result<FileAttr> { opts.access_mode(0); // This flag is so we can open directories too opts.custom_flags(c::FILE_FLAG_BACKUP_SEMANTICS); - let file = try!(File::open(path, &opts)); + let file = File::open(path, &opts)?; file.file_attr() } @@ -641,14 +641,14 @@ pub fn lstat(path: &Path) -> io::Result<FileAttr> { // No read or write permissions are necessary opts.access_mode(0); opts.custom_flags(c::FILE_FLAG_BACKUP_SEMANTICS | c::FILE_FLAG_OPEN_REPARSE_POINT); - let file = try!(File::open(path, &opts)); + let file = File::open(path, &opts)?; file.file_attr() } pub fn set_perm(p: &Path, perm: FilePermissions) -> io::Result<()> { - let p = try!(to_u16s(p)); + let p = to_u16s(p)?; unsafe { - try!(cvt(c::SetFileAttributesW(p.as_ptr(), perm.attrs))); + cvt(c::SetFileAttributesW(p.as_ptr(), perm.attrs))?; Ok(()) } } @@ -668,7 +668,7 @@ pub fn canonicalize(p: &Path) -> io::Result<PathBuf> { opts.access_mode(0); // This flag is so we can open directories too opts.custom_flags(c::FILE_FLAG_BACKUP_SEMANTICS); - let f = try!(File::open(p, &opts)); + let f = File::open(p, &opts)?; get_path(&f) } @@ -687,13 +687,13 @@ pub fn copy(from: &Path, to: &Path) -> io::Result<u64> { *(lpData as *mut i64) = TotalBytesTransferred; c::PROGRESS_CONTINUE } - let pfrom = try!(to_u16s(from)); - let pto = try!(to_u16s(to)); + let pfrom = to_u16s(from)?; + let pto = to_u16s(to)?; let mut size = 0i64; - try!(cvt(unsafe { + cvt(unsafe { c::CopyFileExW(pfrom.as_ptr(), pto.as_ptr(), Some(callback), &mut size as *mut _ as *mut _, ptr::null_mut(), 0) - })); + })?; Ok(size as u64) } @@ -710,13 +710,13 @@ pub fn symlink_junction<P: AsRef<Path>, Q: AsRef<Path>>(src: P, dst: Q) -> io::R #[allow(dead_code)] fn symlink_junction_inner(target: &Path, junction: &Path) -> io::Result<()> { let d = DirBuilder::new(); - try!(d.mkdir(&junction)); + d.mkdir(&junction)?; let mut opts = OpenOptions::new(); opts.write(true); opts.custom_flags(c::FILE_FLAG_OPEN_REPARSE_POINT | c::FILE_FLAG_BACKUP_SEMANTICS); - let f = try!(File::open(junction, &opts)); + let f = File::open(junction, &opts)?; let h = f.handle().raw(); unsafe { diff --git a/src/libstd/sys/windows/handle.rs b/src/libstd/sys/windows/handle.rs index 1396d670902..74546bb893b 100644 --- a/src/libstd/sys/windows/handle.rs +++ b/src/libstd/sys/windows/handle.rs @@ -169,22 +169,22 @@ impl RawHandle { // WriteFile takes a DWORD (u32) for the length so it only supports // writing u32::MAX bytes at a time. let len = cmp::min(buf.len(), u32::MAX as usize) as c::DWORD; - try!(cvt(unsafe { + cvt(unsafe { c::WriteFile(self.0, buf.as_ptr() as c::LPVOID, len, &mut amt, ptr::null_mut()) - })); + })?; Ok(amt as usize) } pub fn duplicate(&self, access: c::DWORD, inherit: bool, options: c::DWORD) -> io::Result<Handle> { let mut ret = 0 as c::HANDLE; - try!(cvt(unsafe { + cvt(unsafe { let cur_proc = c::GetCurrentProcess(); c::DuplicateHandle(cur_proc, self.0, cur_proc, &mut ret, access, inherit as c::BOOL, options) - })); + })?; Ok(Handle::new(ret)) } } diff --git a/src/libstd/sys/windows/net.rs b/src/libstd/sys/windows/net.rs index 3a2f06418cf..ab2d969fe0a 100644 --- a/src/libstd/sys/windows/net.rs +++ b/src/libstd/sys/windows/net.rs @@ -92,35 +92,35 @@ impl Socket { SocketAddr::V4(..) => c::AF_INET, SocketAddr::V6(..) => c::AF_INET6, }; - let socket = try!(unsafe { + let socket = unsafe { match c::WSASocketW(fam, ty, 0, ptr::null_mut(), 0, c::WSA_FLAG_OVERLAPPED) { c::INVALID_SOCKET => Err(last_error()), n => Ok(Socket(n)), } - }); - try!(socket.set_no_inherit()); + }?; + socket.set_no_inherit()?; Ok(socket) } pub fn accept(&self, storage: *mut c::SOCKADDR, len: *mut c_int) -> io::Result<Socket> { - let socket = try!(unsafe { + let socket = unsafe { match c::accept(self.0, storage, len) { c::INVALID_SOCKET => Err(last_error()), n => Ok(Socket(n)), } - }); - try!(socket.set_no_inherit()); + }?; + socket.set_no_inherit()?; Ok(socket) } pub fn duplicate(&self) -> io::Result<Socket> { - let socket = try!(unsafe { + let socket = unsafe { let mut info: c::WSAPROTOCOL_INFO = mem::zeroed(); - try!(cvt(c::WSADuplicateSocketW(self.0, + cvt(c::WSADuplicateSocketW(self.0, c::GetCurrentProcessId(), - &mut info))); + &mut info))?; match c::WSASocketW(info.iAddressFamily, info.iSocketType, info.iProtocol, @@ -129,8 +129,8 @@ impl Socket { c::INVALID_SOCKET => Err(last_error()), n => Ok(Socket(n)), } - }); - try!(socket.set_no_inherit()); + }?; + socket.set_no_inherit()?; Ok(socket) } @@ -169,7 +169,7 @@ impl Socket { } pub fn timeout(&self, kind: c_int) -> io::Result<Option<Duration>> { - let raw: c::DWORD = try!(net::getsockopt(self, c::SOL_SOCKET, kind)); + let raw: c::DWORD = net::getsockopt(self, c::SOL_SOCKET, kind)?; if raw == 0 { Ok(None) } else { @@ -192,7 +192,7 @@ impl Socket { Shutdown::Read => c::SD_RECEIVE, Shutdown::Both => c::SD_BOTH, }; - try!(cvt(unsafe { c::shutdown(self.0, how) })); + cvt(unsafe { c::shutdown(self.0, how) })?; Ok(()) } @@ -211,12 +211,12 @@ impl Socket { } pub fn nodelay(&self) -> io::Result<bool> { - let raw: c::BYTE = try!(net::getsockopt(self, c::IPPROTO_TCP, c::TCP_NODELAY)); + let raw: c::BYTE = net::getsockopt(self, c::IPPROTO_TCP, c::TCP_NODELAY)?; Ok(raw != 0) } pub fn take_error(&self) -> io::Result<Option<io::Error>> { - let raw: c_int = try!(net::getsockopt(self, c::SOL_SOCKET, c::SO_ERROR)); + let raw: c_int = net::getsockopt(self, c::SOL_SOCKET, c::SO_ERROR)?; if raw == 0 { Ok(None) } else { diff --git a/src/libstd/sys/windows/os.rs b/src/libstd/sys/windows/os.rs index 688475a7565..32ca32e76cb 100644 --- a/src/libstd/sys/windows/os.rs +++ b/src/libstd/sys/windows/os.rs @@ -239,7 +239,7 @@ pub fn chdir(p: &path::Path) -> io::Result<()> { } pub fn getenv(k: &OsStr) -> io::Result<Option<OsString>> { - let k = try!(to_u16s(k)); + let k = to_u16s(k)?; let res = super::fill_utf16_buf(|buf, sz| unsafe { c::GetEnvironmentVariableW(k.as_ptr(), buf, sz) }, |buf| { @@ -258,8 +258,8 @@ pub fn getenv(k: &OsStr) -> io::Result<Option<OsString>> { } pub fn setenv(k: &OsStr, v: &OsStr) -> io::Result<()> { - let k = try!(to_u16s(k)); - let v = try!(to_u16s(v)); + let k = to_u16s(k)?; + let v = to_u16s(v)?; cvt(unsafe { c::SetEnvironmentVariableW(k.as_ptr(), v.as_ptr()) @@ -267,7 +267,7 @@ pub fn setenv(k: &OsStr, v: &OsStr) -> io::Result<()> { } pub fn unsetenv(n: &OsStr) -> io::Result<()> { - let v = try!(to_u16s(n)); + let v = to_u16s(n)?; cvt(unsafe { c::SetEnvironmentVariableW(v.as_ptr(), ptr::null()) }).map(|_| ()) diff --git a/src/libstd/sys/windows/pipe.rs b/src/libstd/sys/windows/pipe.rs index fbe38d76e95..8631a63d653 100644 --- a/src/libstd/sys/windows/pipe.rs +++ b/src/libstd/sys/windows/pipe.rs @@ -95,7 +95,7 @@ pub fn anon_pipe() -> io::Result<(AnonPipe, AnonPipe)> { opts.read(false); opts.share_mode(0); opts.attributes(c::FILE_FLAG_OVERLAPPED); - let writer = try!(File::open(Path::new(&name), &opts)); + let writer = File::open(Path::new(&name), &opts)?; let writer = AnonPipe { inner: writer.into_handle() }; Ok((AnonPipe { inner: reader }, AnonPipe { inner: writer.into_handle() })) @@ -126,8 +126,8 @@ pub fn read2(p1: AnonPipe, let p1 = p1.into_handle(); let p2 = p2.into_handle(); - let mut p1 = try!(AsyncPipe::new(p1, v1)); - let mut p2 = try!(AsyncPipe::new(p2, v2)); + let mut p1 = AsyncPipe::new(p1, v1)?; + let mut p2 = AsyncPipe::new(p2, v2)?; let objs = [p1.event.raw(), p2.event.raw()]; // In a loop we wait for either pipe's scheduled read operation to complete. @@ -143,11 +143,11 @@ pub fn read2(p1: AnonPipe, c::WaitForMultipleObjects(2, objs.as_ptr(), c::FALSE, c::INFINITE) }; if res == c::WAIT_OBJECT_0 { - if !try!(p1.result()) || !try!(p1.schedule_read()) { + if !p1.result()? || !p1.schedule_read()? { return p2.finish() } } else if res == c::WAIT_OBJECT_0 + 1 { - if !try!(p2.result()) || !try!(p2.schedule_read()) { + if !p2.result()? || !p2.schedule_read()? { return p1.finish() } } else { @@ -183,7 +183,7 @@ impl<'a> AsyncPipe<'a> { // WaitForMultipleObjects call above for pipes created initially, // and the only time an even will go back to "unset" will be once an // I/O operation is successfully scheduled (what we want). - let event = try!(Handle::new_event(true, true)); + let event = Handle::new_event(true, true)?; let mut overlapped: Box<c::OVERLAPPED> = unsafe { Box::new(mem::zeroed()) }; @@ -207,7 +207,7 @@ impl<'a> AsyncPipe<'a> { assert_eq!(self.state, State::NotReading); let amt = unsafe { let slice = slice_to_end(self.dst); - try!(self.pipe.read_overlapped(slice, &mut *self.overlapped)) + self.pipe.read_overlapped(slice, &mut *self.overlapped)? }; // If this read finished immediately then our overlapped event will @@ -240,7 +240,7 @@ impl<'a> AsyncPipe<'a> { let amt = match self.state { State::NotReading => return Ok(true), State::Reading => { - try!(self.pipe.overlapped_result(&mut *self.overlapped, true)) + self.pipe.overlapped_result(&mut *self.overlapped, true)? } State::Read(amt) => amt, }; @@ -257,7 +257,7 @@ impl<'a> AsyncPipe<'a> { /// Waits for any pending and schedule read, and then calls `read_to_end` /// if necessary to read all the remaining information. fn finish(&mut self) -> io::Result<()> { - while try!(self.result()) && try!(self.schedule_read()) { + while self.result()? && self.schedule_read()? { // ... } Ok(()) diff --git a/src/libstd/sys/windows/printing/msvc.rs b/src/libstd/sys/windows/printing/msvc.rs index 37aaa1f1b0e..9c29ac4082a 100644 --- a/src/libstd/sys/windows/printing/msvc.rs +++ b/src/libstd/sys/windows/printing/msvc.rs @@ -53,7 +53,7 @@ pub fn print(w: &mut Write, None }; - try!(output(w, i, addr as usize as *mut c_void, name)); + output(w, i, addr as usize as *mut c_void, name)?; // Now find out the filename and line number let mut line: c::IMAGEHLP_LINE64 = mem::zeroed(); diff --git a/src/libstd/sys/windows/process.rs b/src/libstd/sys/windows/process.rs index 524c932eed4..f4957297581 100644 --- a/src/libstd/sys/windows/process.rs +++ b/src/libstd/sys/windows/process.rs @@ -151,7 +151,7 @@ impl Command { si.dwFlags = c::STARTF_USESTDHANDLES; let program = program.as_ref().unwrap_or(&self.program); - let mut cmd_str = try!(make_command_line(program, &self.args)); + let mut cmd_str = make_command_line(program, &self.args)?; cmd_str.push(0); // add null terminator // stolen from the libuv code. @@ -160,8 +160,8 @@ impl Command { flags |= c::DETACHED_PROCESS | c::CREATE_NEW_PROCESS_GROUP; } - let (envp, _data) = try!(make_envp(self.env.as_ref())); - let (dirp, _data) = try!(make_dirp(self.cwd.as_ref())); + let (envp, _data) = make_envp(self.env.as_ref())?; + let (dirp, _data) = make_dirp(self.cwd.as_ref())?; let mut pi = zeroed_process_information(); // Prepare all stdio handles to be inherited by the child. This @@ -186,23 +186,23 @@ impl Command { let stdin = self.stdin.as_ref().unwrap_or(default_stdin); let stdout = self.stdout.as_ref().unwrap_or(&default); let stderr = self.stderr.as_ref().unwrap_or(&default); - let stdin = try!(stdin.to_handle(c::STD_INPUT_HANDLE, &mut pipes.stdin)); - let stdout = try!(stdout.to_handle(c::STD_OUTPUT_HANDLE, - &mut pipes.stdout)); - let stderr = try!(stderr.to_handle(c::STD_ERROR_HANDLE, - &mut pipes.stderr)); + let stdin = stdin.to_handle(c::STD_INPUT_HANDLE, &mut pipes.stdin)?; + let stdout = stdout.to_handle(c::STD_OUTPUT_HANDLE, + &mut pipes.stdout)?; + let stderr = stderr.to_handle(c::STD_ERROR_HANDLE, + &mut pipes.stderr)?; si.hStdInput = stdin.raw(); si.hStdOutput = stdout.raw(); si.hStdError = stderr.raw(); - try!(unsafe { + unsafe { cvt(c::CreateProcessW(ptr::null(), cmd_str.as_mut_ptr(), ptr::null_mut(), ptr::null_mut(), c::TRUE, flags, envp, dirp, &mut si, &mut pi)) - }); + }?; // We close the thread handle because we don't care about keeping // the thread id valid, and we aren't keeping the thread handle @@ -216,9 +216,9 @@ impl Command { impl fmt::Debug for Command { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - try!(write!(f, "{:?}", self.program)); + write!(f, "{:?}", self.program)?; for arg in &self.args { - try!(write!(f, " {:?}", arg)); + write!(f, " {:?}", arg)?; } Ok(()) } @@ -240,18 +240,18 @@ impl Stdio { } Stdio::MakePipe => { - let (reader, writer) = try!(pipe::anon_pipe()); + let (reader, writer) = pipe::anon_pipe()?; let (ours, theirs) = if stdio_id == c::STD_INPUT_HANDLE { (writer, reader) } else { (reader, writer) }; *pipe = Some(ours); - try!(cvt(unsafe { + cvt(unsafe { c::SetHandleInformation(theirs.handle().raw(), c::HANDLE_FLAG_INHERIT, c::HANDLE_FLAG_INHERIT) - })); + })?; Ok(theirs.into_handle()) } @@ -296,9 +296,9 @@ pub struct Process { impl Process { pub fn kill(&mut self) -> io::Result<()> { - try!(cvt(unsafe { + cvt(unsafe { c::TerminateProcess(self.handle.raw(), 1) - })); + })?; Ok(()) } @@ -315,7 +315,7 @@ impl Process { return Err(Error::last_os_error()) } let mut status = 0; - try!(cvt(c::GetExitCodeProcess(self.handle.raw(), &mut status))); + cvt(c::GetExitCodeProcess(self.handle.raw(), &mut status))?; Ok(ExitStatus(status)) } } @@ -381,10 +381,10 @@ fn make_command_line(prog: &OsStr, args: &[OsString]) -> io::Result<Vec<u16>> { // Encode the command and arguments in a command line string such // that the spawned process may recover them using CommandLineToArgvW. let mut cmd: Vec<u16> = Vec::new(); - try!(append_arg(&mut cmd, prog)); + append_arg(&mut cmd, prog)?; for arg in args { cmd.push(' ' as u16); - try!(append_arg(&mut cmd, arg)); + append_arg(&mut cmd, arg)?; } return Ok(cmd); @@ -392,7 +392,7 @@ fn make_command_line(prog: &OsStr, args: &[OsString]) -> io::Result<Vec<u16>> { // If an argument has 0 characters then we need to quote it to ensure // that it actually gets passed through on the command line or otherwise // it will be dropped entirely when parsed on the other end. - try!(ensure_no_nuls(arg)); + ensure_no_nuls(arg)?; let arg_bytes = &arg.as_inner().inner.as_inner(); let quote = arg_bytes.iter().any(|c| *c == b' ' || *c == b'\t') || arg_bytes.is_empty(); @@ -438,9 +438,9 @@ fn make_envp(env: Option<&collections::HashMap<OsString, OsString>>) let mut blk = Vec::new(); for pair in env { - blk.extend(try!(ensure_no_nuls(pair.0)).encode_wide()); + blk.extend(ensure_no_nuls(pair.0)?.encode_wide()); blk.push('=' as u16); - blk.extend(try!(ensure_no_nuls(pair.1)).encode_wide()); + blk.extend(ensure_no_nuls(pair.1)?.encode_wide()); blk.push(0); } blk.push(0); @@ -454,7 +454,7 @@ fn make_dirp(d: Option<&OsString>) -> io::Result<(*const u16, Vec<u16>)> { match d { Some(dir) => { - let mut dir_str: Vec<u16> = try!(ensure_no_nuls(dir)).encode_wide().collect(); + let mut dir_str: Vec<u16> = ensure_no_nuls(dir)?.encode_wide().collect(); dir_str.push(0); Ok((dir_str.as_ptr(), dir_str)) }, diff --git a/src/libstd/sys/windows/stdio.rs b/src/libstd/sys/windows/stdio.rs index 0a0851ffac3..fa3cab2191e 100644 --- a/src/libstd/sys/windows/stdio.rs +++ b/src/libstd/sys/windows/stdio.rs @@ -78,13 +78,13 @@ fn write(out: &Output, data: &[u8]) -> io::Result<usize> { }; let utf16 = utf8.encode_utf16().collect::<Vec<u16>>(); let mut written = 0; - try!(cvt(unsafe { + cvt(unsafe { c::WriteConsoleW(handle, utf16.as_ptr() as c::LPCVOID, utf16.len() as u32, &mut written, ptr::null_mut()) - })); + })?; // FIXME if this only partially writes the utf16 buffer then we need to // figure out how many bytes of `data` were actually written @@ -112,13 +112,13 @@ impl Stdin { if utf8.position() as usize == utf8.get_ref().len() { let mut utf16 = vec![0u16; 0x1000]; let mut num = 0; - try!(cvt(unsafe { + cvt(unsafe { c::ReadConsoleW(handle, utf16.as_mut_ptr() as c::LPVOID, utf16.len() as u32, &mut num, ptr::null_mut()) - })); + })?; utf16.truncate(num as usize); // FIXME: what to do about this data that has already been read? let data = match String::from_utf16(&utf16) { diff --git a/src/libstd/thread/mod.rs b/src/libstd/thread/mod.rs index 2cf6c64eab8..f3139aaf98d 100644 --- a/src/libstd/thread/mod.rs +++ b/src/libstd/thread/mod.rs @@ -285,7 +285,7 @@ impl Builder { Ok(JoinHandle(JoinInner { native: unsafe { - Some(try!(imp::Thread::new(stack_size, Box::new(main)))) + Some(imp::Thread::new(stack_size, Box::new(main))?) }, thread: my_thread, packet: Packet(my_packet), |