---

yaml
---
r: 93867
b: refs/heads/try
c: 07e21c3
h: refs/heads/master
i:
  93865: 5c66968
  93863: 7db4fb0
v: v3

Author: thestinger

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 0da105a8b7b6b1e0568e8ff20f6ff4b13cc7ecc2
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: a6d3e57dca68fde4effdda3e4ae2887aa535fcd6
-refs/heads/try: f1bec46e15c245b9e9f5c0cf64bf2ac6a1882066
+refs/heads/try: 07e21c3c8c49918e3909dded55813abbad240c4e
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/mk/docs.mk

@@ -215,12 +215,10 @@ 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) --cfg stage2 $(2)
+	$(Q)$(RUSTDOC) $(2)
 
 DOCS += doc/$(1)/index.html
 endef

branches/try/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}),

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

branches/try/src/librustdoc/lib.rs

@@ -96,7 +96,6 @@ 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",
@@ -195,12 +194,11 @@ 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(), cfgs.take(), &cr)
+        core::run_core(libs.take().move_iter().collect(), &cr)
     }.unwrap();
     info!("finished with rustc");
     local_data::set(analysiskey, analysis);

branches/try/src/librustuv/stream.rs

@@ -69,27 +69,22 @@ 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 => {
-                wait_until_woken_after(&mut rcx.task, || {});
+                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)
+                    }
+                }
                 match rcx.result {
                     n if n < 0 => Err(UvError(n as c_int)),
                     n => Ok(n as uint),

branches/try/src/libstd/hashmap.rs

@@ -13,8 +13,6 @@
 //! The tables use a keyed hash with new random keys generated for each container, so the ordering
 //! of a set of keys in a hash table is randomized.
 
-#[mutable_doc];
-
 use container::{Container, Mutable, Map, MutableMap, Set, MutableSet};
 use clone::Clone;
 use cmp::{Eq, Equiv};