---

yaml
---
r: 149690
b: refs/heads/try2
c: 997ff7a
h: refs/heads/master
v: v3

Author: alexcrichton

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: c81b3fb21a560f9eaacc06ceeabcd5b4339e54d0
+refs/heads/try2: 997ff7abd4f3b803575a7bfa4af3fb05569b1f75
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/etc/vim/syntax/rust.vim

@@ -163,12 +163,11 @@ syn region rustGenericLifetimeCandidate display start=/\%(<\|,\s*\)\@<='/ end=/[
 syn match     rustLifetime    display "\'\%([^[:cntrl:][:space:][:punct:][:digit:]]\|_\)\%([^[:cntrl:][:punct:][:space:]]\|_\)*"
 syn match   rustCharacter   /'\([^'\\]\|\\\(.\|x\x\{2}\|u\x\{4}\|U\x\{8}\)\)'/ contains=rustSpecial,rustSpecialError
 
-syn region rustCommentLine                                        start="//"                      end="$"   contains=rustTodo,@Spell
-syn region rustCommentLineDoc                                     start="//\%(//\@!\|!\)"         end="$"   contains=rustTodo,@Spell
-syn region rustCommentBlock    matchgroup=rustCommentBlock        start="/\*\%(!\|\*[*/]\@!\)\@!" end="\*/" contains=rustTodo,rustCommentBlockNest,@Spell
-syn region rustCommentBlockDoc matchgroup=rustCommentBlockDoc     start="/\*\%(!\|\*[*/]\@!\)"    end="\*/" contains=rustTodo,rustCommentBlockDocNest,@Spell
-syn region rustCommentBlockNest matchgroup=rustCommentBlock       start="/\*"                     end="\*/" contains=rustTodo,rustCommentBlockNest,@Spell contained transparent
-syn region rustCommentBlockDocNest matchgroup=rustCommentBlockDoc start="/\*"                     end="\*/" contains=rustTodo,rustCommentBlockDocNest,@Spell contained transparent
+syn cluster rustComment contains=rustCommentLine,rustCommentLineDoc,rustCommentBlock,rustCommentBlockDoc
+syn region rustCommentLine                                    start="//"                      end="$"   contains=rustTodo,@Spell
+syn region rustCommentLineDoc                                 start="//\%(//\@!\|!\)"         end="$"   contains=rustTodo,@Spell
+syn region rustCommentBlock    matchgroup=rustCommentBlock    start="/\*\%(!\|\*[*/]\@!\)\@!" end="\*/" contains=rustTodo,@rustComment,@Spell keepend extend
+syn region rustCommentBlockDoc matchgroup=rustCommentBlockDoc start="/\*\%(!\|\*[*/]\@!\)"    end="\*/" contains=rustTodo,@rustComment,@Spell keepend extend
 " FIXME: this is a really ugly and not fully correct implementation. Most
 " importantly, a case like ``/* */*`` should have the final ``*`` not being in
 " a comment, but in practice at present it leaves comments open two levels

branches/try2/src/librustc/lib.rs

@@ -297,7 +297,8 @@ pub fn run_compiler(args: &[~str]) {
         match input {
           d::FileInput(ref ifile) => {
             let mut stdout = io::stdout();
-            d::list_metadata(sess, &(*ifile), &mut stdout).unwrap();
+            d::list_metadata(sess, &(*ifile),
+                             &mut stdout as &mut io::Writer).unwrap();
           }
           d::StrInput(_) => {
             d::early_error("can not list metadata for stdin");

branches/try2/src/librustc/metadata/decoder.rs

@@ -1145,12 +1145,26 @@ fn list_crate_deps(data: &[u8], out: &mut io::Writer) -> io::IoResult<()> {
     Ok(())
 }
 
+pub fn maybe_get_crate_hash(data: &[u8]) -> Option<Svh> {
+    let cratedoc = reader::Doc(data);
+    reader::maybe_get_doc(cratedoc, tag_crate_hash).map(|doc| {
+        Svh::new(doc.as_str_slice())
+    })
+}
+
 pub fn get_crate_hash(data: &[u8]) -> Svh {
     let cratedoc = reader::Doc(data);
     let hashdoc = reader::get_doc(cratedoc, tag_crate_hash);
     Svh::new(hashdoc.as_str_slice())
 }
 
+pub fn maybe_get_crate_id(data: &[u8]) -> Option<CrateId> {
+    let cratedoc = reader::Doc(data);
+    reader::maybe_get_doc(cratedoc, tag_crate_crateid).map(|doc| {
+        from_str(doc.as_str_slice()).unwrap()
+    })
+}
+
 pub fn get_crate_id(data: &[u8]) -> CrateId {
     let cratedoc = reader::Doc(data);
     let hashdoc = reader::get_doc(cratedoc, tag_crate_crateid);

branches/try2/src/librustc/metadata/loader.rs

@@ -318,12 +318,17 @@ impl<'a> Context<'a> {
     }
 
     fn crate_matches(&mut self, crate_data: &[u8]) -> bool {
-        let other_id = decoder::get_crate_id(crate_data);
-        if !self.crate_id.matches(&other_id) { return false }
+        match decoder::maybe_get_crate_id(crate_data) {
+            Some(ref id) if self.crate_id.matches(id) => {}
+            _ => return false
+        }
+        let hash = match decoder::maybe_get_crate_hash(crate_data) {
+            Some(hash) => hash, None => return false
+        };
         match self.hash {
             None => true,
-            Some(hash) => {
-                if *hash != decoder::get_crate_hash(crate_data) {
+            Some(myhash) => {
+                if *myhash != hash {
                     self.rejected_via_hash = true;
                     false
                 } else {

branches/try2/src/librustc/middle/trans/_match.rs

@@ -1188,7 +1188,7 @@ impl<'a> DynamicFailureHandler<'a> {
 
         let fcx = self.bcx.fcx;
         let fail_cx = fcx.new_block(false, "case_fallthrough", None);
-        controlflow::trans_fail(fail_cx, self.sp, self.msg.clone());
+        controlflow::trans_fail(fail_cx, Some(self.sp), self.msg.clone());
         self.finished.set(Some(fail_cx.llbb));
         fail_cx.llbb
     }

branches/try2/src/librustc/middle/trans/base.rs

@@ -864,7 +864,7 @@ pub fn fail_if_zero<'a>(
       }
     };
     with_cond(cx, is_zero, |bcx| {
-        controlflow::trans_fail(bcx, span, InternedString::new(text))
+        controlflow::trans_fail(bcx, Some(span), InternedString::new(text))
     })
 }
 

branches/try2/src/librustc/middle/trans/controlflow.rs

@@ -18,6 +18,8 @@ use middle::trans::debuginfo;
 use middle::trans::cleanup;
 use middle::trans::cleanup::CleanupMethods;
 use middle::trans::expr;
+use middle::ty;
+use util::ppaux;
 use util::ppaux::Repr;
 
 use middle::trans::type_::Type;
@@ -325,23 +327,67 @@ pub fn trans_ret<'a>(bcx: &'a Block<'a>,
     return bcx;
 }
 
+pub fn trans_fail_expr<'a>(
+                       bcx: &'a Block<'a>,
+                       sp_opt: Option<Span>,
+                       fail_expr: Option<@ast::Expr>)
+                       -> &'a Block<'a> {
+    let _icx = push_ctxt("trans_fail_expr");
+    let mut bcx = bcx;
+    match fail_expr {
+        Some(arg_expr) => {
+            let ccx = bcx.ccx();
+            let tcx = ccx.tcx;
+            let arg_datum =
+                unpack_datum!(bcx, expr::trans_to_lvalue(bcx, arg_expr, "fail"));
+
+            if ty::type_is_str(arg_datum.ty) {
+                let (lldata, _) = arg_datum.get_vec_base_and_len(bcx);
+                return trans_fail_value(bcx, sp_opt, lldata);
+            } else if bcx.unreachable.get() || ty::type_is_bot(arg_datum.ty) {
+                return bcx;
+            } else {
+                bcx.sess().span_bug(
+                    arg_expr.span, ~"fail called with unsupported type " +
+                    ppaux::ty_to_str(tcx, arg_datum.ty));
+            }
+        }
+        _ => trans_fail(bcx, sp_opt, InternedString::new("explicit failure"))
+    }
+}
+
 pub fn trans_fail<'a>(
                   bcx: &'a Block<'a>,
-                  sp: Span,
+                  sp_opt: Option<Span>,
                   fail_str: InternedString)
                   -> &'a Block<'a> {
+    let _icx = push_ctxt("trans_fail");
     let V_fail_str = C_cstr(bcx.ccx(), fail_str);
+    return trans_fail_value(bcx, sp_opt, V_fail_str);
+}
+
+fn trans_fail_value<'a>(
+                    bcx: &'a Block<'a>,
+                    sp_opt: Option<Span>,
+                    V_fail_str: ValueRef)
+                    -> &'a Block<'a> {
     let _icx = push_ctxt("trans_fail_value");
     let ccx = bcx.ccx();
-    let sess = bcx.sess();
-    let loc = sess.parse_sess.cm.lookup_char_pos(sp.lo);
-    let V_filename = C_cstr(bcx.ccx(),
-                            token::intern_and_get_ident(loc.file.name));
-    let V_line = loc.line as int;
+    let (V_filename, V_line) = match sp_opt {
+      Some(sp) => {
+        let sess = bcx.sess();
+        let loc = sess.parse_sess.cm.lookup_char_pos(sp.lo);
+        (C_cstr(bcx.ccx(), token::intern_and_get_ident(loc.file.name)),
+         loc.line as int)
+      }
+      None => {
+        (C_cstr(bcx.ccx(), InternedString::new("<runtime>")), 0)
+      }
+    };
     let V_str = PointerCast(bcx, V_fail_str, Type::i8p());
     let V_filename = PointerCast(bcx, V_filename, Type::i8p());
     let args = ~[V_str, V_filename, C_int(ccx, V_line)];
-    let did = langcall(bcx, Some(sp), "", FailFnLangItem);
+    let did = langcall(bcx, sp_opt, "", FailFnLangItem);
     let bcx = callee::trans_lang_call(bcx, did, args, Some(expr::Ignore)).bcx;
     Unreachable(bcx);
     return bcx;

branches/try2/src/libstd/fmt/mod.rs

@@ -654,8 +654,8 @@ uniform_fn_call_workaround! {
 /// use std::fmt;
 /// use std::io;
 ///
-/// let mut w = io::stdout();
-/// format_args!(|args| { fmt::write(&mut w, args); }, "Hello, {}!", "world");
+/// let w = &mut io::stdout() as &mut io::Writer;
+/// format_args!(|args| { fmt::write(w, args); }, "Hello, {}!", "world");
 /// ```
 pub fn write(output: &mut io::Writer, args: &Arguments) -> Result {
     unsafe { write_unsafe(output, args.fmt, args.args) }

branches/try2/src/libstd/io/buffered.rs

@@ -14,8 +14,7 @@ use cmp;
 use container::Container;
 use io::{Reader, Writer, Stream, Buffer, DEFAULT_BUF_SIZE, IoResult};
 use iter::ExactSize;
-use ops::Drop;
-use option::{Some, None, Option};
+use option::{Some, None};
 use result::{Ok, Err};
 use vec::{OwnedVector, ImmutableVector, MutableVector};
 use vec;
@@ -116,7 +115,7 @@ impl<R: Reader> Reader for BufferedReader<R> {
 
 /// Wraps a Writer and buffers output to it
 ///
-/// This writer will be flushed when it is dropped.
+/// Note that `BufferedWriter` will NOT flush its buffer when dropped.
 ///
 /// # Example
 ///
@@ -131,7 +130,7 @@ impl<R: Reader> Reader for BufferedReader<R> {
 /// writer.flush();
 /// ```
 pub struct BufferedWriter<W> {
-    priv inner: Option<W>,
+    priv inner: W,
     priv buf: ~[u8],
     priv pos: uint
 }
@@ -143,7 +142,7 @@ impl<W: Writer> BufferedWriter<W> {
         let mut buf = vec::with_capacity(cap);
         unsafe { buf.set_len(cap); }
         BufferedWriter {
-            inner: Some(inner),
+            inner: inner,
             buf: buf,
             pos: 0
         }
@@ -156,7 +155,7 @@ impl<W: Writer> BufferedWriter<W> {
 
     fn flush_buf(&mut self) -> IoResult<()> {
         if self.pos != 0 {
-            let ret = self.inner.get_mut_ref().write(self.buf.slice_to(self.pos));
+            let ret = self.inner.write(self.buf.slice_to(self.pos));
             self.pos = 0;
             ret
         } else {
@@ -168,15 +167,15 @@ impl<W: Writer> BufferedWriter<W> {
     ///
     /// This type does not expose the ability to get a mutable reference to the
     /// underlying reader because that could possibly corrupt the buffer.
-    pub fn get_ref<'a>(&'a self) -> &'a W { self.inner.get_ref() }
+    pub fn get_ref<'a>(&'a self) -> &'a W { &self.inner }
 
     /// Unwraps this buffer, returning the underlying writer.
     ///
     /// The buffer is flushed before returning the writer.
     pub fn unwrap(mut self) -> W {
-        // FIXME(#12628): is failing the right thing to do if flushing fails?
+        // FIXME: is failing the right thing to do if flushing fails?
         self.flush_buf().unwrap();
-        self.inner.take_unwrap()
+        self.inner
     }
 }
 
@@ -187,7 +186,7 @@ impl<W: Writer> Writer for BufferedWriter<W> {
         }
 
         if buf.len() > self.buf.len() {
-            self.inner.get_mut_ref().write(buf)
+            self.inner.write(buf)
         } else {
             let dst = self.buf.mut_slice_from(self.pos);
             vec::bytes::copy_memory(dst, buf);
@@ -197,24 +196,14 @@ impl<W: Writer> Writer for BufferedWriter<W> {
     }
 
     fn flush(&mut self) -> IoResult<()> {
-        self.flush_buf().and_then(|()| self.inner.get_mut_ref().flush())
-    }
-}
-
-#[unsafe_destructor]
-impl<W: Writer> Drop for BufferedWriter<W> {
-    fn drop(&mut self) {
-        if self.inner.is_some() {
-            // FIXME(#12628): should this error be ignored?
-            let _ = self.flush_buf();
-        }
+        self.flush_buf().and_then(|()| self.inner.flush())
     }
 }
 
 /// Wraps a Writer and buffers output to it, flushing whenever a newline (`0x0a`,
 /// `'\n'`) is detected.
 ///
-/// This writer will be flushed when it is dropped.
+/// Note that this structure does NOT flush the output when dropped.
 pub struct LineBufferedWriter<W> {
     priv inner: BufferedWriter<W>,
 }
@@ -267,13 +256,13 @@ impl<W> InternalBufferedWriter<W> {
 
 impl<W: Reader> Reader for InternalBufferedWriter<W> {
     fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> {
-        self.get_mut_ref().inner.get_mut_ref().read(buf)
+        self.get_mut_ref().inner.read(buf)
     }
 }
 
-/// Wraps a Stream and buffers input and output to and from it.
+/// Wraps a Stream and buffers input and output to and from it
 ///
-/// The output half will be flushed when this stream is dropped.
+/// Note that `BufferedStream` will NOT flush its output buffer when dropped.
 ///
 /// # Example
 ///

branches/try2/src/libstd/io/stdio.rs

@@ -90,12 +90,6 @@ fn src<T>(fd: libc::c_int, readable: bool, f: |StdSource| -> T) -> T {
 /// buffered access is not desired, the `stdin_raw` function is provided to
 /// provided unbuffered access to stdin.
 ///
-/// Care should be taken when creating multiple handles to the stdin of a
-/// process. Beause this is a buffered reader by default, it's possible for
-/// pending input to be unconsumed in one reader and unavailable to other
-/// readers. It is recommended that only one handle at a time is created for the
-/// stdin of a process.
-///
 /// See `stdout()` for more notes about this function.
 pub fn stdin() -> BufferedReader<StdReader> {
     BufferedReader::new(stdin_raw())
@@ -110,38 +104,20 @@ pub fn stdin_raw() -> StdReader {
     src(libc::STDIN_FILENO, true, |src| StdReader { inner: src })
 }
 
-/// Creates a line-buffered handle to the stdout of the current process.
+/// Creates a new non-blocking handle to the stdout of the current process.
 ///
 /// Note that this is a fairly expensive operation in that at least one memory
 /// allocation is performed. Additionally, this must be called from a runtime
 /// task context because the stream returned will be a non-blocking object using
 /// the local scheduler to perform the I/O.
-///
-/// Care should be taken when creating multiple handles to an output stream for
-/// a single process. While usage is still safe, the output may be surprising if
-/// no synchronization is performed to ensure a sane output.
-pub fn stdout() -> LineBufferedWriter<StdWriter> {
-    LineBufferedWriter::new(stdout_raw())
-}
-
-/// Creates an unbuffered handle to the stdout of the current process
-///
-/// See notes in `stdout()` for more information.
-pub fn stdout_raw() -> StdWriter {
+pub fn stdout() -> StdWriter {
     src(libc::STDOUT_FILENO, false, |src| StdWriter { inner: src })
 }
 
-/// Creates a line-buffered handle to the stderr of the current process.
+/// Creates a new non-blocking handle to the stderr of the current process.
 ///
 /// See `stdout()` for notes about this function.
-pub fn stderr() -> LineBufferedWriter<StdWriter> {
-    LineBufferedWriter::new(stderr_raw())
-}
-
-/// Creates an unbuffered handle to the stderr of the current process
-///
-/// See notes in `stdout()` for more information.
-pub fn stderr_raw() -> StdWriter {
+pub fn stderr() -> StdWriter {
     src(libc::STDERR_FILENO, false, |src| StdWriter { inner: src })
 }
 
@@ -206,7 +182,7 @@ fn with_task_stdout(f: |&mut Writer| -> IoResult<()> ) {
             Local::put(task);
 
             if my_stdout.is_none() {
-                my_stdout = Some(~stdout() as ~Writer);
+                my_stdout = Some(~LineBufferedWriter::new(stdout()) as ~Writer);
             }
             let ret = f(*my_stdout.get_mut_ref());
 

branches/try2/src/libstd/logging.rs

@@ -166,7 +166,9 @@ pub fn log(level: u32, args: &fmt::Arguments) {
     };
 
     if logger.is_none() {
-        logger = Some(~DefaultLogger { handle: io::stderr(), } as ~Logger);
+        logger = Some(~DefaultLogger {
+            handle: LineBufferedWriter::new(io::stderr()),
+        } as ~Logger);
     }
     logger.get_mut_ref().log(level, args);