---

yaml
---
r: 90033
b: refs/heads/master
c: 679a2c0
h: refs/heads/master
i:
  90031: 3fc4e4c
v: v3

Author: bors

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 07e21c3c8c49918e3909dded55813abbad240c4e
+refs/heads/master: 679a2c042fb2541f55f1192ca97672907b258337
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: a6d3e57dca68fde4effdda3e4ae2887aa535fcd6
 refs/heads/try: b160761e35efcd1207112b3b782c06633cf441a8

trunk/mk/docs.mk

@@ -215,10 +215,12 @@ RUSTDOC = $(HBIN2_H_$(CFG_BUILD))/rustdoc$(X_$(CFG_BUILD))
 # $(1) - The crate name (std/extra)
 # $(2) - The crate file
 # $(3) - The relevant host build triple (to depend on libstd)
+#
+# Passes --cfg stage2 to rustdoc because it uses the stage2 librustc.
 define libdoc
 doc/$(1)/index.html: $$(RUSTDOC) $$(TLIB2_T_$(3)_H_$(3))/$(CFG_STDLIB_$(3))
 	@$$(call E, rustdoc: $$@)
-	$(Q)$(RUSTDOC) $(2)
+	$(Q)$(RUSTDOC) --cfg stage2 $(2)
 
 DOCS += doc/$(1)/index.html
 endef

trunk/src/libextra/base64.rs

@@ -260,7 +260,7 @@ mod test {
 
     #[test]
     fn test_to_base64_line_break() {
-        assert!(![0u8, 1000].to_base64(Config {line_length: None, ..STANDARD})
+        assert!(![0u8, ..1000].to_base64(Config {line_length: None, ..STANDARD})
                 .contains("\r\n"));
         assert_eq!("foobar".as_bytes().to_base64(Config {line_length: Some(4),
                                                          ..STANDARD}),

trunk/src/librustdoc/core.rs

@@ -37,7 +37,7 @@ pub struct CrateAnalysis {
 
 /// Parses, resolves, and typechecks the given crate
 fn get_ast_and_resolve(cpath: &Path,
-                       libs: HashSet<Path>) -> (DocContext, CrateAnalysis) {
+                       libs: HashSet<Path>, cfgs: ~[~str]) -> (DocContext, CrateAnalysis) {
     use syntax::codemap::dummy_spanned;
     use rustc::driver::driver::{file_input, build_configuration,
                                 phase_1_parse_input,
@@ -66,7 +66,9 @@ fn get_ast_and_resolve(cpath: &Path,
                                               span_diagnostic_handler);
 
     let mut cfg = build_configuration(sess);
-    cfg.push(@dummy_spanned(ast::MetaWord(@"stage2")));
+    for cfg_ in cfgs.move_iter() {
+        cfg.push(@dummy_spanned(ast::MetaWord(cfg_.to_managed())));
+    }
 
     let mut crate = phase_1_parse_input(sess, cfg.clone(), &input);
     crate = phase_2_configure_and_expand(sess, cfg, crate);
@@ -79,8 +81,8 @@ fn get_ast_and_resolve(cpath: &Path,
             CrateAnalysis { exported_items: exported_items });
 }
 
-pub fn run_core (libs: HashSet<Path>, path: &Path) -> (clean::Crate, CrateAnalysis) {
-    let (ctxt, analysis) = get_ast_and_resolve(path, libs);
+pub fn run_core (libs: HashSet<Path>, cfgs: ~[~str], path: &Path) -> (clean::Crate, CrateAnalysis) {
+    let (ctxt, analysis) = get_ast_and_resolve(path, libs, cfgs);
     let ctxt = @ctxt;
     debug!("defmap:");
     for (k, v) in ctxt.tycx.def_map.iter() {

trunk/src/librustdoc/lib.rs

@@ -96,6 +96,7 @@ pub fn opts() -> ~[groups::OptGroup] {
         optopt("o", "output", "where to place the output", "PATH"),
         optmulti("L", "library-path", "directory to add to crate search path",
                  "DIR"),
+        optmulti("", "cfg", "pass a --cfg to rustc", ""),
         optmulti("", "plugin-path", "directory to load plugins from", "DIR"),
         optmulti("", "passes", "space separated list of passes to also run, a \
                                 value of `list` will print available passes",
@@ -194,11 +195,12 @@ fn rust_input(cratefile: &str, matches: &getopts::Matches) -> Output {
 
     // First, parse the crate and extract all relevant information.
     let libs = Cell::new(matches.opt_strs("L").map(|s| Path::new(s.as_slice())));
+    let cfgs = Cell::new(matches.opt_strs("cfg"));
     let cr = Cell::new(Path::new(cratefile));
     info!("starting to run rustc");
     let (crate, analysis) = do std::task::try {
         let cr = cr.take();
-        core::run_core(libs.take().move_iter().collect(), &cr)
+        core::run_core(libs.take().move_iter().collect(), cfgs.take(), &cr)
     }.unwrap();
     info!("finished with rustc");
     local_data::set(analysiskey, analysis);

trunk/src/librustuv/stream.rs

@@ -69,22 +69,27 @@ impl StreamWatcher {
         // uv_read_stop function
         let _f = ForbidUnwind::new("stream read");
 
+        let mut rcx = ReadContext {
+            buf: Some(slice_to_uv_buf(buf)),
+            result: 0,
+            task: None,
+        };
+        // When reading a TTY stream on windows, libuv will invoke alloc_cb
+        // immediately as part of the call to alloc_cb. What this means is that
+        // we must be ready for this to happen (by setting the data in the uv
+        // handle). In theory this otherwise doesn't need to happen until after
+        // the read is succesfully started.
+        unsafe {
+            uvll::set_data_for_uv_handle(self.handle, &rcx)
+        }
+
         // Send off the read request, but don't block until we're sure that the
         // read request is queued.
         match unsafe {
             uvll::uv_read_start(self.handle, alloc_cb, read_cb)
         } {
             0 => {
-                let mut rcx = ReadContext {
-                    buf: Some(slice_to_uv_buf(buf)),
-                    result: 0,
-                    task: None,
-                };
-                do wait_until_woken_after(&mut rcx.task) {
-                    unsafe {
-                        uvll::set_data_for_uv_handle(self.handle, &rcx)
-                    }
-                }
+                wait_until_woken_after(&mut rcx.task, || {});
                 match rcx.result {
                     n if n < 0 => Err(UvError(n as c_int)),
                     n => Ok(n as uint),