---

yaml
---
r: 91898
b: refs/heads/auto
c: 20233b9
h: refs/heads/master
v: v3

Author: andreasots

[refs]

@@ -13,7 +13,7 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: e632c440f88b3e252bf8c0942fc7be21d9e946d3
+refs/heads/auto: 20233b984855fa72adc07761a6c657ea191c1eb9
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/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/auto/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/auto/src/libextra/serialize.rs

@@ -20,7 +20,6 @@ Core encoding and decoding interfaces.
 
 use std::at_vec;
 use std::hashmap::{HashMap, HashSet};
-use std::rc::Rc;
 use std::trie::{TrieMap, TrieSet};
 use std::vec;
 use ringbuf::RingBuf;
@@ -406,20 +405,6 @@ impl<S:Encoder,T:Encodable<S>> Encodable<S> for @T {
     }
 }
 
-impl<S:Encoder,T:Encodable<S> + Freeze> Encodable<S> for Rc<T> {
-    #[inline]
-    fn encode(&self, s: &mut S) {
-        self.borrow().encode(s)
-    }
-}
-
-impl<D:Decoder,T:Decodable<D> + Freeze> Decodable<D> for Rc<T> {
-    #[inline]
-    fn decode(d: &mut D) -> Rc<T> {
-        Rc::new(Decodable::decode(d))
-    }
-}
-
 impl<D:Decoder,T:Decodable<D> + 'static> Decodable<D> for @T {
     fn decode(d: &mut D) -> @T {
         @Decodable::decode(d)

branches/auto/src/librustc/middle/borrowck/check_loans.rs

@@ -51,7 +51,7 @@ impl<'self> Visitor<()> for CheckLoanCtxt<'self> {
     fn visit_block(&mut self, b:&ast::Block, _:()) {
         check_loans_in_block(self, b);
     }
-    fn visit_pat(&mut self, p:&ast::Pat, _:()) {
+    fn visit_pat(&mut self, p:@ast::Pat, _:()) {
         check_loans_in_pat(self, p);
     }
     fn visit_fn(&mut self, fk:&visit::fn_kind, fd:&ast::fn_decl,
@@ -847,7 +847,7 @@ fn check_loans_in_expr<'a>(this: &mut CheckLoanCtxt<'a>,
 }
 
 fn check_loans_in_pat<'a>(this: &mut CheckLoanCtxt<'a>,
-                          pat: &ast::Pat)
+                          pat: @ast::Pat)
 {
     this.check_for_conflicting_loans(pat.id);
     this.check_move_out_from_id(pat.id, pat.span);

branches/auto/src/librustc/middle/borrowck/gather_loans/mod.rs

@@ -87,7 +87,7 @@ impl<'self> visit::Visitor<()> for GatherLoanCtxt<'self> {
     fn visit_stmt(&mut self, s:@Stmt, _:()) {
         add_stmt_to_map(self, s);
     }
-    fn visit_pat(&mut self, p:&Pat, _:()) {
+    fn visit_pat(&mut self, p:@Pat, _:()) {
         add_pat_to_id_range(self, p);
     }
     fn visit_local(&mut self, l:@Local, _:()) {
@@ -119,7 +119,7 @@ pub fn gather_loans(bccx: &BorrowckCtxt,
 }
 
 fn add_pat_to_id_range(this: &mut GatherLoanCtxt,
-                       p: &ast::Pat) {
+                       p: @ast::Pat) {
     // NB: This visitor function just adds the pat ids into the id
     // range. We gather loans that occur in patterns using the
     // `gather_pat()` method below. Eventually these two should be

branches/auto/src/librustc/middle/check_const.rs

@@ -33,7 +33,7 @@ impl Visitor<bool> for CheckCrateVisitor {
     fn visit_item(&mut self, i:@item, env:bool) {
         check_item(self, self.sess, self.ast_map, self.def_map, i, env);
     }
-    fn visit_pat(&mut self, p:&Pat, env:bool) {
+    fn visit_pat(&mut self, p:@Pat, env:bool) {
         check_pat(self, p, env);
     }
     fn visit_expr(&mut self, ex:@Expr, env:bool) {
@@ -81,7 +81,7 @@ pub fn check_item(v: &mut CheckCrateVisitor,
     }
 }
 
-pub fn check_pat(v: &mut CheckCrateVisitor, p: &Pat, _is_const: bool) {
+pub fn check_pat(v: &mut CheckCrateVisitor, p: @Pat, _is_const: bool) {
     fn is_str(e: @Expr) -> bool {
         match e.node {
             ExprVstore(

branches/auto/src/librustc/middle/lint.rs

@@ -900,7 +900,7 @@ fn check_unsafe_block(cx: &Context, e: &ast::Expr) {
     }
 }
 
-fn check_unused_mut_pat(cx: &Context, p: &ast::Pat) {
+fn check_unused_mut_pat(cx: &Context, p: @ast::Pat) {
     match p.node {
         ast::PatIdent(ast::BindByValue(ast::MutMutable),
                       ref path, _) if pat_util::pat_is_binding(cx.tcx.def_map, p)=> {
@@ -1119,7 +1119,7 @@ impl<'self> Visitor<()> for Context<'self> {
         }
     }
 
-    fn visit_pat(&mut self, p: &ast::Pat, _: ()) {
+    fn visit_pat(&mut self, p: @ast::Pat, _: ()) {
         check_pat_non_uppercase_statics(self, p);
         check_unused_mut_pat(self, p);
 

branches/auto/src/librustc/middle/moves.rs

@@ -459,6 +459,8 @@ impl VisitContext {
             }
 
             ExprMatch(discr, ref arms) => {
+                // We must do this first so that `arms_have_by_move_bindings`
+                // below knows which bindings are moves.
                 for arm in arms.iter() {
                     self.consume_arm(arm);
                 }
@@ -655,6 +657,27 @@ impl VisitContext {
         self.consume_expr(arg_expr)
     }
 
+    pub fn arms_have_by_move_bindings(&mut self,
+                                      moves_map: MovesMap,
+                                      arms: &[Arm])
+                                      -> Option<@Pat> {
+        let mut ret = None;
+        for arm in arms.iter() {
+            for &pat in arm.pats.iter() {
+                let cont = do ast_util::walk_pat(pat) |p| {
+                    if moves_map.contains(&p.id) {
+                        ret = Some(p);
+                        false
+                    } else {
+                        true
+                    }
+                };
+                if !cont { return ret }
+            }
+        }
+        ret
+    }
+
     pub fn compute_captures(&mut self, fn_expr_id: NodeId) -> @[CaptureVar] {
         debug!("compute_capture_vars(fn_expr_id={:?})", fn_expr_id);
         let _indenter = indenter();

branches/auto/src/librustc/middle/pat_util.rs

@@ -20,7 +20,7 @@ pub type PatIdMap = HashMap<Ident, NodeId>;
 
 // This is used because same-named variables in alternative patterns need to
 // use the NodeId of their namesake in the first pattern.
-pub fn pat_id_map(dm: resolve::DefMap, pat: &Pat) -> PatIdMap {
+pub fn pat_id_map(dm: resolve::DefMap, pat: @Pat) -> PatIdMap {
     let mut map = HashMap::new();
     do pat_bindings(dm, pat) |_bm, p_id, _s, n| {
       map.insert(path_to_ident(n), p_id);
@@ -52,7 +52,7 @@ pub fn pat_is_const(dm: resolve::DefMap, pat: &Pat) -> bool {
     }
 }
 
-pub fn pat_is_binding(dm: resolve::DefMap, pat: &Pat) -> bool {
+pub fn pat_is_binding(dm: resolve::DefMap, pat: @Pat) -> bool {
     match pat.node {
         PatIdent(*) => {
             !pat_is_variant_or_struct(dm, pat) &&
@@ -62,7 +62,7 @@ pub fn pat_is_binding(dm: resolve::DefMap, pat: &Pat) -> bool {
     }
 }
 
-pub fn pat_is_binding_or_wild(dm: resolve::DefMap, pat: &Pat) -> bool {
+pub fn pat_is_binding_or_wild(dm: resolve::DefMap, pat: @Pat) -> bool {
     match pat.node {
         PatIdent(*) => pat_is_binding(dm, pat),
         PatWild | PatWildMulti => true,
@@ -73,7 +73,7 @@ pub fn pat_is_binding_or_wild(dm: resolve::DefMap, pat: &Pat) -> bool {
 /// Call `it` on every "binding" in a pattern, e.g., on `a` in
 /// `match foo() { Some(a) => (), None => () }`
 pub fn pat_bindings(dm: resolve::DefMap,
-                    pat: &Pat,
+                    pat: @Pat,
                     it: |BindingMode, NodeId, Span, &Path|) {
     do walk_pat(pat) |p| {
         match p.node {
@@ -86,15 +86,15 @@ pub fn pat_bindings(dm: resolve::DefMap,
     };
 }
 
-pub fn pat_binding_ids(dm: resolve::DefMap, pat: &Pat) -> ~[NodeId] {
+pub fn pat_binding_ids(dm: resolve::DefMap, pat: @Pat) -> ~[NodeId] {
     let mut found = ~[];
     pat_bindings(dm, pat, |_bm, b_id, _sp, _pt| found.push(b_id) );
     return found;
 }
 
 /// Checks if the pattern contains any patterns that bind something to
 /// an ident, e.g. `foo`, or `Foo(foo)` or `foo @ Bar(*)`.
-pub fn pat_contains_bindings(dm: resolve::DefMap, pat: &Pat) -> bool {
+pub fn pat_contains_bindings(dm: resolve::DefMap, pat: @Pat) -> bool {
     let mut contains_bindings = false;
     do walk_pat(pat) |p| {
         if pat_is_binding(dm, p) {

branches/auto/src/librustc/middle/privacy.rs

@@ -739,7 +739,7 @@ impl<'self> Visitor<()> for PrivacyVisitor<'self> {
         }
     }
 
-    fn visit_pat(&mut self, pattern: &ast::Pat, _: ()) {
+    fn visit_pat(&mut self, pattern: @ast::Pat, _: ()) {
         match pattern.node {
             ast::PatStruct(_, ref fields, _) => {
                 match ty::get(ty::pat_ty(self.tcx, pattern)).sty {

branches/auto/src/librustc/middle/region.rs

@@ -340,7 +340,7 @@ fn resolve_arm(visitor: &mut RegionResolutionVisitor,
 }
 
 fn resolve_pat(visitor: &mut RegionResolutionVisitor,
-               pat: &ast::Pat,
+               pat: @ast::Pat,
                cx: Context) {
     assert_eq!(cx.var_parent, cx.parent);
     parent_to_expr(visitor, cx, pat.id, pat.span);
@@ -480,7 +480,7 @@ impl Visitor<Context> for RegionResolutionVisitor {
     fn visit_arm(&mut self, a:&Arm, cx:Context) {
         resolve_arm(self, a, cx);
     }
-    fn visit_pat(&mut self, p:&Pat, cx:Context) {
+    fn visit_pat(&mut self, p:@Pat, cx:Context) {
         resolve_pat(self, p, cx);
     }
     fn visit_stmt(&mut self, s:@Stmt, cx:Context) {

branches/auto/src/librustc/middle/typeck/check/mod.rs

@@ -375,7 +375,7 @@ impl Visitor<()> for GatherLocalsVisitor {
 
     }
         // Add pattern bindings.
-    fn visit_pat(&mut self, p:&ast::Pat, _:()) {
+    fn visit_pat(&mut self, p:@ast::Pat, _:()) {
             match p.node {
               ast::PatIdent(_, ref path, _)
                   if pat_util::pat_is_binding(self.fcx.ccx.tcx.def_map, p) => {

branches/auto/src/librustc/middle/typeck/check/writeback.rs

@@ -278,7 +278,7 @@ fn visit_block(b: &ast::Block, wbcx: &mut WbCtxt) {
     visit::walk_block(wbcx, b, ());
 }
 
-fn visit_pat(p: &ast::Pat, wbcx: &mut WbCtxt) {
+fn visit_pat(p: @ast::Pat, wbcx: &mut WbCtxt) {
     if !wbcx.success {
         return;
     }
@@ -323,7 +323,7 @@ impl Visitor<()> for WbCtxt {
     fn visit_stmt(&mut self, s:@ast::Stmt, _:()) { visit_stmt(s, self); }
     fn visit_expr(&mut self, ex:@ast::Expr, _:()) { visit_expr(ex, self); }
     fn visit_block(&mut self, b:&ast::Block, _:()) { visit_block(b, self); }
-    fn visit_pat(&mut self, p:&ast::Pat, _:()) { visit_pat(p, self); }
+    fn visit_pat(&mut self, p:@ast::Pat, _:()) { visit_pat(p, self); }
     fn visit_local(&mut self, l:@ast::Local, _:()) { visit_local(l, self); }
 }
 

branches/auto/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/auto/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/auto/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/auto/src/libstd/hashmap.rs

@@ -13,6 +13,8 @@
 //! 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};

branches/auto/src/libstd/io/net/ip.rs

@@ -41,7 +41,7 @@ impl ToStr for IpAddr {
             }
 
             Ipv6Addr(a, b, c, d, e, f, g, h) =>
-                format!("{}:{}:{}:{}:{}:{}:{}:{}", a, b, c, d, e, f, g, h)
+                format!("{:x}:{:x}:{:x}:{:x}:{:x}:{:x}:{:x}:{:x}", a, b, c, d, e, f, g, h)
         }
     }
 }
@@ -449,6 +449,7 @@ mod test {
     fn ipv6_addr_to_str() {
         let a1 = Ipv6Addr(0, 0, 0, 0, 0, 0xffff, 0xc000, 0x280);
         assert!(a1.to_str() == ~"::ffff:192.0.2.128" || a1.to_str() == ~"::FFFF:192.0.2.128");
+        assert_eq!(Ipv6Addr(8, 9, 10, 11, 12, 13, 14, 15).to_str(), ~"8:9:a:b:c:d:e:f");
     }
 
 }