---

yaml
---
r: 151498
b: refs/heads/try2
c: fa43727
h: refs/heads/master
v: v3

Author: nikomatsakis

[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: 66f4f558cbe1df6a3ceff6c58ed7d994bed17cd5
+refs/heads/try2: fa43727781833cfbc17e3161dc131b9c243e965f
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/doc/rust.md

@@ -1741,10 +1741,10 @@ import public items from their destination, not private items.
 ## Attributes
 
 ~~~~ {.notrust .ebnf .gram}
-attribute : '#' '!' ? '[' meta_item ']' ;
-meta_item : ident [ '=' literal
-                  | '(' meta_seq ')' ] ? ;
-meta_seq : meta_item [ ',' meta_seq ]* ;
+attribute : '#' '!' ? '[' attr_list ']' ;
+attr_list : attr [ ',' attr_list ]* ;
+attr : ident [ '=' literal
+             | '(' attr_list ')' ] ? ;
 ~~~~
 
 Static entities in Rust — crates, modules and items — may have _attributes_

branches/try2/src/libcore/lib.rs

@@ -106,7 +106,6 @@ mod should_not_exist;
 mod std {
     pub use clone;
     pub use cmp;
-    pub use kinds;
 
     #[cfg(test)] pub use realstd::fmt;    // needed for fail!()
     #[cfg(test)] pub use realstd::rt;     // needed for fail!()

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

@@ -1367,38 +1367,28 @@ fn check_unsafe_block(cx: &Context, e: &ast::Expr) {
     }
 }
 
-fn check_unused_mut_pat(cx: &Context, pats: &[@ast::Pat]) {
-    // collect all mutable pattern and group their NodeIDs by their Identifier to
-    // avoid false warnings in match arms with multiple patterns
-    let mut mutables = HashMap::new();
-    for &p in pats.iter() {
-        pat_util::pat_bindings(&cx.tcx.def_map, p, |mode, id, _, path| {
-            match mode {
-                ast::BindByValue(ast::MutMutable) => {
-                    if path.segments.len() != 1 {
-                        cx.tcx.sess.span_bug(p.span,
-                                             "mutable binding that doesn't consist \
-                                              of exactly one segment");
-                    }
-                    let ident = path.segments.get(0).identifier;
-                    if !token::get_ident(ident).get().starts_with("_") {
-                        mutables.insert_or_update_with(ident.name as uint, vec!(id), |_, old| {
-                            old.push(id);
-                        });
-                    }
-                }
-                _ => {
-                }
-            }
-        });
-    }
+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) => {
+            // `let mut _a = 1;` doesn't need a warning.
+            let initial_underscore = if path.segments.len() == 1 {
+                token::get_ident(path.segments
+                                     .get(0)
+                                     .identifier).get().starts_with("_")
+            } else {
+                cx.tcx.sess.span_bug(p.span,
+                                     "mutable binding that doesn't consist \
+                                      of exactly one segment")
+            };
 
-    let used_mutables = cx.tcx.used_mut_nodes.borrow();
-    for (_, v) in mutables.iter() {
-        if !v.iter().any(|e| used_mutables.contains(e)) {
-            cx.span_lint(UnusedMut, cx.tcx.map.span(*v.get(0)),
-                         "variable does not need to be mutable");
+            if !initial_underscore &&
+               !cx.tcx.used_mut_nodes.borrow().contains(&p.id) {
+                cx.span_lint(UnusedMut, p.span,
+                             "variable does not need to be mutable");
+            }
         }
+        _ => ()
     }
 }
 
@@ -1694,6 +1684,7 @@ impl<'a> Visitor<()> for Context<'a> {
     fn visit_pat(&mut self, p: &ast::Pat, _: ()) {
         check_pat_non_uppercase_statics(self, p);
         check_pat_uppercase_variable(self, p);
+        check_unused_mut_pat(self, p);
 
         visit::walk_pat(self, p, ());
     }
@@ -1709,11 +1700,6 @@ impl<'a> Visitor<()> for Context<'a> {
             ast::ExprParen(expr) => if self.negated_expr_id == e.id {
                 self.negated_expr_id = expr.id
             },
-            ast::ExprMatch(_, ref arms) => {
-                for a in arms.iter() {
-                    check_unused_mut_pat(self, a.pats.as_slice());
-                }
-            },
             _ => ()
         };
 
@@ -1737,18 +1723,6 @@ impl<'a> Visitor<()> for Context<'a> {
         check_unused_result(self, s);
         check_unnecessary_parens_stmt(self, s);
 
-        match s.node {
-            ast::StmtDecl(d, _) => {
-                match d.node {
-                    ast::DeclLocal(l) => {
-                        check_unused_mut_pat(self, &[l.pat]);
-                    },
-                    _ => {}
-                }
-            },
-            _ => {}
-        }
-
         visit::walk_stmt(self, s, ());
     }
 
@@ -1758,10 +1732,6 @@ impl<'a> Visitor<()> for Context<'a> {
             visit::walk_fn(this, fk, decl, body, span, id, ());
         };
 
-        for a in decl.inputs.iter(){
-            check_unused_mut_pat(self, &[a.pat]);
-        }
-
         match *fk {
             visit::FkMethod(_, _, m) => {
                 self.with_lint_attrs(m.attrs.as_slice(), |cx| {

branches/try2/src/librustc/middle/typeck/check/regionck.rs

@@ -299,7 +299,7 @@ pub fn regionck_expr(fcx: &FnCtxt, e: &ast::Expr) {
         // regionck assumes typeck succeeded
         rcx.visit_expr(e, ());
     }
-    fcx.infcx().resolve_regions();
+    fcx.infcx().resolve_regions_and_report_errors();
 }
 
 pub fn regionck_fn(fcx: &FnCtxt, blk: &ast::Block) {
@@ -309,7 +309,7 @@ pub fn regionck_fn(fcx: &FnCtxt, blk: &ast::Block) {
         // regionck assumes typeck succeeded
         rcx.visit_block(blk, ());
     }
-    fcx.infcx().resolve_regions();
+    fcx.infcx().resolve_regions_and_report_errors();
 }
 
 impl<'a> Visitor<()> for Rcx<'a> {

branches/try2/src/librustc/middle/typeck/infer/mod.rs

@@ -644,7 +644,7 @@ impl<'a> InferCtxt<'a> {
         self.region_vars.new_bound(binder_id)
     }
 
-    pub fn resolve_regions(&self) {
+    pub fn resolve_regions_and_report_errors(&self) {
         let errors = self.region_vars.resolve_regions();
         self.report_region_errors(&errors); // see error_reporting.rs
     }

branches/try2/src/libstd/io/net/tcp.rs

@@ -169,7 +169,6 @@ impl TcpStream {
     ///
     /// For clarification on the semantics of interrupting a read and a write,
     /// take a look at `set_read_timeout` and `set_write_timeout`.
-    #[experimental = "the timeout argument may change in type and value"]
     pub fn set_timeout(&mut self, timeout_ms: Option<u64>) {
         self.obj.set_timeout(timeout_ms)
     }
@@ -186,7 +185,6 @@ impl TcpStream {
     /// action is taken. Otherwise, the read operation will be scheduled to
     /// promptly return. If a timeout error is returned, then no data was read
     /// during the timeout period.
-    #[experimental = "the timeout argument may change in type and value"]
     pub fn set_read_timeout(&mut self, timeout_ms: Option<u64>) {
         self.obj.set_read_timeout(timeout_ms)
     }
@@ -213,7 +211,6 @@ impl TcpStream {
     /// does not know how many bytes were written as part of the timeout
     /// operation. It may be the case that bytes continue to be written in an
     /// asynchronous fashion after the call to write returns.
-    #[experimental = "the timeout argument may change in type and value"]
     pub fn set_write_timeout(&mut self, timeout_ms: Option<u64>) {
         self.obj.set_write_timeout(timeout_ms)
     }
@@ -947,26 +944,21 @@ mod test {
 
         // Also make sure that even though the timeout is expired that we will
         // continue to receive any pending connections.
-        //
-        // FIXME: freebsd apparently never sees the pending connection, but
-        //        testing manually always works. Need to investigate this
-        //        flakiness.
-        if !cfg!(target_os = "freebsd") {
-            let (tx, rx) = channel();
-            spawn(proc() {
-                tx.send(TcpStream::connect(addr).unwrap());
-            });
-            let l = rx.recv();
-            for i in range(0, 1001) {
-                match a.accept() {
-                    Ok(..) => break,
-                    Err(ref e) if e.kind == TimedOut => {}
-                    Err(e) => fail!("error: {}", e),
-                }
-                ::task::deschedule();
-                if i == 1000 { fail!("should have a pending connection") }
+        let (tx, rx) = channel();
+        spawn(proc() {
+            tx.send(TcpStream::connect(addr).unwrap());
+        });
+        let l = rx.recv();
+        for i in range(0, 1001) {
+            match a.accept() {
+                Ok(..) => break,
+                Err(ref e) if e.kind == TimedOut => {}
+                Err(e) => fail!("error: {}", e),
             }
+            ::task::deschedule();
+            if i == 1000 { fail!("should have a pending connection") }
         }
+        drop(l);
 
         // Unset the timeout and make sure that this always blocks.
         a.set_timeout(None);

branches/try2/src/libstd/io/net/udp.rs

@@ -147,23 +147,20 @@ impl UdpSocket {
     /// Sets the read/write timeout for this socket.
     ///
     /// For more information, see `TcpStream::set_timeout`
-    #[experimental = "the timeout argument may change in type and value"]
     pub fn set_timeout(&mut self, timeout_ms: Option<u64>) {
         self.obj.set_timeout(timeout_ms)
     }
 
     /// Sets the read timeout for this socket.
     ///
     /// For more information, see `TcpStream::set_timeout`
-    #[experimental = "the timeout argument may change in type and value"]
     pub fn set_read_timeout(&mut self, timeout_ms: Option<u64>) {
         self.obj.set_read_timeout(timeout_ms)
     }
 
     /// Sets the write timeout for this socket.
     ///
     /// For more information, see `TcpStream::set_timeout`
-    #[experimental = "the timeout argument may change in type and value"]
     pub fn set_write_timeout(&mut self, timeout_ms: Option<u64>) {
         self.obj.set_write_timeout(timeout_ms)
     }

branches/try2/src/libstd/io/net/unix.rs

@@ -97,23 +97,20 @@ impl UnixStream {
     /// Sets the read/write timeout for this socket.
     ///
     /// For more information, see `TcpStream::set_timeout`
-    #[experimental = "the timeout argument may change in type and value"]
     pub fn set_timeout(&mut self, timeout_ms: Option<u64>) {
         self.obj.set_timeout(timeout_ms)
     }
 
     /// Sets the read timeout for this socket.
     ///
     /// For more information, see `TcpStream::set_timeout`
-    #[experimental = "the timeout argument may change in type and value"]
     pub fn set_read_timeout(&mut self, timeout_ms: Option<u64>) {
         self.obj.set_read_timeout(timeout_ms)
     }
 
     /// Sets the write timeout for this socket.
     ///
     /// For more information, see `TcpStream::set_timeout`
-    #[experimental = "the timeout argument may change in type and value"]
     pub fn set_write_timeout(&mut self, timeout_ms: Option<u64>) {
         self.obj.set_write_timeout(timeout_ms)
     }

branches/try2/src/libstd/os.rs

@@ -529,9 +529,9 @@ pub fn homedir() -> Option<Path> {
  * Returns the path to a temporary directory.
  *
  * On Unix, returns the value of the 'TMPDIR' environment variable if it is
- * set, otherwise for non-Android it returns '/tmp'. If Android, since there
- * is no global temporary folder (it is usually allocated per-app), we return
- * '/data/local/tmp'.
+ * set and non-empty and '/tmp' otherwise.
+ * On Android, there is no global temporary folder (it is usually allocated
+ * per-app), hence returns '/data/tmp' which is commonly used.
  *
  * On Windows, returns the value of, in order, the 'TMP', 'TEMP',
  * 'USERPROFILE' environment variable  if any are set and not the empty
@@ -554,13 +554,11 @@ pub fn tmpdir() -> Path {
 
     #[cfg(unix)]
     fn lookup() -> Path {
-        let default = if cfg!(target_os = "android") {
-            Path::new("/data/local/tmp")
+        if cfg!(target_os = "android") {
+            Path::new("/data/tmp")
         } else {
-            Path::new("/tmp")
-        };
-
-        getenv_nonempty("TMPDIR").unwrap_or(default)
+            getenv_nonempty("TMPDIR").unwrap_or(Path::new("/tmp"))
+        }
     }
 
     #[cfg(windows)]

branches/try2/src/test/compile-fail/lint-unused-mut-variables.rs

@@ -28,13 +28,6 @@ fn main() {
     match 30 {
         mut x => {} //~ ERROR: variable does not need to be mutable
     }
-    match (30, 2) {
-      (mut x, 1) | //~ ERROR: variable does not need to be mutable
-      (mut x, 2) |
-      (mut x, 3) => {
-      }
-      _ => {}
-    }
 
     let x = |mut y: int| 10; //~ ERROR: variable does not need to be mutable
     fn what(mut foo: int) {} //~ ERROR: variable does not need to be mutable
@@ -57,15 +50,6 @@ fn main() {
         }
     }
 
-    match (30, 2) {
-      (mut x, 1) |
-      (mut x, 2) |
-      (mut x, 3) => {
-        x = 21
-      }
-      _ => {}
-    }
-
     let x = |mut y: int| y = 32;
     fn nothing(mut foo: int) { foo = 37; }