---

yaml
---
r: 150685
b: refs/heads/try2
c: 767ed1a
h: refs/heads/master
i:
  150683: 637fac2
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: e2c84a78b4a3e95ea0def29172022ef4cf695958
+refs/heads/try2: 767ed1a71f07e869e07bde138845e16b320908ec
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/libglob/lib.rs

@@ -1,4 +1,4 @@
-// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -43,7 +43,6 @@ use std::path::is_sep;
 pub struct Paths {
     root: Path,
     dir_patterns: Vec<Pattern>,
-    require_dir: bool,
     options: MatchOptions,
     todo: Vec<(Path,uint)>,
 }
@@ -52,7 +51,7 @@ pub struct Paths {
 /// Return an iterator that produces all the Paths that match the given pattern,
 /// which may be absolute or relative to the current working directory.
 ///
-/// This method uses the default match options and is equivalent to calling
+/// is method uses the default match options and is equivalent to calling
 /// `glob_with(pattern, MatchOptions::new())`. Use `glob_with` directly if you
 /// want to use non-default match options.
 ///
@@ -107,7 +106,6 @@ pub fn glob_with(pattern: &str, options: MatchOptions) -> Paths {
             return Paths {
                 root: root,
                 dir_patterns: Vec::new(),
-                require_dir: false,
                 options: options,
                 todo: Vec::new(),
             };
@@ -119,21 +117,13 @@ pub fn glob_with(pattern: &str, options: MatchOptions) -> Paths {
     let dir_patterns = pattern.slice_from(cmp::min(root_len, pattern.len()))
                        .split_terminator(is_sep)
                        .map(|s| Pattern::new(s))
-                       .collect::<Vec<Pattern>>();
-    let require_dir = pattern.chars().next_back().map(is_sep) == Some(true);
+                       .collect();
 
-    let mut todo = Vec::new();
-    if dir_patterns.len() > 0 {
-        // Shouldn't happen, but we're using -1 as a special index.
-        assert!(dir_patterns.len() < -1 as uint);
-
-        fill_todo(&mut todo, dir_patterns.as_slice(), 0, &root, options);
-    }
+    let todo = list_dir_sorted(&root).move_iter().map(|x|(x,0u)).collect();
 
     Paths {
         root: root,
         dir_patterns: dir_patterns,
-        require_dir: require_dir,
         options: options,
         todo: todo,
     }
@@ -148,12 +138,6 @@ impl Iterator<Path> for Paths {
             }
 
             let (path,idx) = self.todo.pop().unwrap();
-            // idx -1: was already checked by fill_todo, maybe path was '.' or
-            // '..' that we can't match here because of normalization.
-            if idx == -1 as uint {
-                if self.require_dir && !path.is_dir() { continue; }
-                return Some(path);
-            }
             let ref pattern = *self.dir_patterns.get(idx);
 
             if pattern.matches_with(match path.filename_str() {
@@ -168,27 +152,23 @@ impl Iterator<Path> for Paths {
                 if idx == self.dir_patterns.len() - 1 {
                     // it is not possible for a pattern to match a directory *AND* its children
                     // so we don't need to check the children
-
-                    if !self.require_dir || path.is_dir() {
-                        return Some(path);
-                    }
+                    return Some(path);
                 } else {
-                    fill_todo(&mut self.todo, self.dir_patterns.as_slice(),
-                              idx + 1, &path, self.options);
+                    self.todo.extend(list_dir_sorted(&path).move_iter().map(|x|(x,idx+1)));
                 }
             }
         }
     }
 
 }
 
-fn list_dir_sorted(path: &Path) -> Option<Vec<Path>> {
+fn list_dir_sorted(path: &Path) -> Vec<Path> {
     match fs::readdir(path) {
         Ok(mut children) => {
             children.sort_by(|p1, p2| p2.filename().cmp(&p1.filename()));
-            Some(children.move_iter().collect())
+            children.move_iter().collect()
         }
-        Err(..) => None
+        Err(..) => Vec::new()
     }
 }
 
@@ -455,72 +435,6 @@ impl Pattern {
 
 }
 
-// Fills `todo` with paths under `path` to be matched by `patterns[idx]`,
-// special-casing patterns to match `.` and `..`, and avoiding `readdir()`
-// calls when there are no metacharacters in the pattern.
-fn fill_todo(todo: &mut Vec<(Path, uint)>, patterns: &[Pattern], idx: uint, path: &Path,
-             options: MatchOptions) {
-    // convert a pattern that's just many Char(_) to a string
-    fn pattern_as_str(pattern: &Pattern) -> Option<~str> {
-        let mut s = ~"";
-        for token in pattern.tokens.iter() {
-            match *token {
-                Char(c) => s.push_char(c),
-                _ => return None
-            }
-        }
-        return Some(s);
-    }
-
-    let add = |todo: &mut Vec<_>, next_path: Path| {
-        if idx + 1 == patterns.len() {
-            // We know it's good, so don't make the iterator match this path
-            // against the pattern again. In particular, it can't match
-            // . or .. globs since these never show up as path components.
-            todo.push((next_path, -1 as uint));
-        } else {
-            fill_todo(todo, patterns, idx + 1, &next_path, options);
-        }
-    };
-
-    let pattern = &patterns[idx];
-
-    match pattern_as_str(pattern) {
-        Some(s) => {
-            // This pattern component doesn't have any metacharacters, so we
-            // don't need to read the current directory to know where to
-            // continue. So instead of passing control back to the iterator,
-            // we can just check for that one entry and potentially recurse
-            // right away.
-            let special = "." == s || ".." == s;
-            let next_path = path.join(s);
-            if (special && path.is_dir()) || (!special && next_path.exists()) {
-                add(todo, next_path);
-            }
-        },
-        None => {
-            match list_dir_sorted(path) {
-                Some(entries) => {
-                    todo.extend(entries.move_iter().map(|x|(x, idx)));
-
-                    // Matching the special directory entries . and .. that refer to
-                    // the current and parent directory respectively requires that
-                    // the pattern has a leading dot, even if the `MatchOptions` field
-                    // `require_literal_leading_dot` is not set.
-                    if pattern.tokens.len() > 0 && pattern.tokens.get(0) == &Char('.') {
-                        for &special in [".", ".."].iter() {
-                            if pattern.matches_with(special, options) {
-                                add(todo, path.join(special));
-                            }
-                        }
-                    }
-                }
-                None => {}
-            }
-        }
-    }
-}
-
 fn parse_char_specifiers(s: &[char]) -> Vec<CharSpecifier> {
     let mut cs = Vec::new();
     let mut i = 0;
@@ -653,7 +567,7 @@ mod test {
     fn test_absolute_pattern() {
         // assume that the filesystem is not empty!
         assert!(glob("/*").next().is_some());
-        assert!(glob("//").next().is_some());
+        assert!(glob("//").next().is_none());
 
         // check windows absolute paths with host/device components
         let root_with_device = os::getcwd().root_path().unwrap().join("*");

branches/try2/src/librustc/middle/borrowck/mod.rs

@@ -274,12 +274,13 @@ pub fn opt_loan_path(cmt: mc::cmt) -> Option<@LoanPath> {
     match cmt.cat {
         mc::cat_rvalue(..) |
         mc::cat_static_item |
-        mc::cat_copied_upvar(_) => {
+        mc::cat_copied_upvar(mc::CopiedUpvar { onceness: ast::Many, .. }) => {
             None
         }
 
         mc::cat_local(id) |
         mc::cat_arg(id) |
+        mc::cat_copied_upvar(mc::CopiedUpvar { upvar_id: id, .. }) |
         mc::cat_upvar(ty::UpvarId {var_id: id, ..}, _) => {
             Some(@LpVar(id))
         }

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

@@ -237,7 +237,7 @@ impl<'a> BufWriter<'a> {
 
 impl<'a> Writer for BufWriter<'a> {
     fn write(&mut self, buf: &[u8]) -> IoResult<()> {
-        // return an error if the entire write does not fit in the buffer
+        // raises a condition if the entire write does not fit in the buffer
         let max_size = self.buf.len();
         if self.pos >= max_size || (self.pos + buf.len()) > max_size {
             return Err(IoError {

branches/try2/src/test/compile-fail/issue-10398.rs

@@ -0,0 +1,19 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+fn main() {
+    let x = ~1;
+    let f: proc() = proc() {
+        let _a = x;
+        drop(x);
+        //~^ ERROR: use of moved value: `x`
+    };
+    f();
+}

branches/try2/src/test/compile-fail/issue-11925.rs

@@ -11,7 +11,7 @@
 fn main() {
     let r = {
         let x = ~42;
-        let f = proc() &x; //~ ERROR: borrowed value does not live long enough
+        let f = proc() &x; //~ ERROR: `x` does not live long enough
         f()
     };
 

branches/try2/src/test/compile-fail/issue-12041.rs

@@ -0,0 +1,21 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+fn main() {
+    let (tx, rx) = channel();
+    spawn(proc() {
+        loop {
+            let tx = tx;
+            //~^ ERROR: use of moved value: `tx`
+            tx.send(1);
+        }
+    });
+}
+

branches/try2/src/test/compile-fail/issue-12127.rs

@@ -0,0 +1,18 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+fn main() {
+    let f = proc() {};
+    (proc() {
+        f();
+        f();
+        //~^ ERROR: use of moved value: `f`
+    })()
+}

branches/try2/src/test/run-pass/glob-std.rs

@@ -10,12 +10,13 @@
 
 // ignore-win32 TempDir may cause IoError on windows: #10462
 
-#![feature(macro_rules)]
+#[feature(macro_rules)];
 
 extern crate glob;
 
 use glob::glob;
-use std::os;
+use std::unstable::finally::Finally;
+use std::{os, unstable};
 use std::io;
 use std::io::TempDir;
 
@@ -28,9 +29,9 @@ macro_rules! assert_eq ( ($e1:expr, $e2:expr) => (
 pub fn main() {
     fn mk_file(path: &str, directory: bool) {
         if directory {
-            io::fs::mkdir(&Path::new(path), io::UserRWX).unwrap();
+            io::fs::mkdir(&Path::new(path), io::UserRWX);
         } else {
-            io::File::create(&Path::new(path)).unwrap();
+            io::File::create(&Path::new(path));
         }
     }
 
@@ -71,8 +72,8 @@ pub fn main() {
     mk_file("xyz/z", false);
 
     assert_eq!(glob_vec(""), Vec::new());
-    assert_eq!(glob_vec("."), vec!(os::getcwd()));
-    assert_eq!(glob_vec(".."), vec!(os::getcwd().join("..")));
+    assert_eq!(glob_vec("."), Vec::new());
+    assert_eq!(glob_vec(".."), Vec::new());
 
     assert_eq!(glob_vec("aaa"), vec!(abs_path("aaa")));
     assert_eq!(glob_vec("aaa/"), vec!(abs_path("aaa")));
@@ -130,15 +131,6 @@ pub fn main() {
         abs_path("aaa/tomato/tomato.txt"),
         abs_path("aaa/tomato/tomoto.txt")));
 
-    assert_eq!(glob_vec("./aaa"), vec!(abs_path("aaa")));
-    assert_eq!(glob_vec("./*"), glob_vec("*"));
-    assert_eq!(glob_vec("*/..").pop().unwrap(), abs_path("."));
-    assert_eq!(glob_vec("aaa/../bbb"), vec!(abs_path("bbb")));
-    assert_eq!(glob_vec("nonexistent/../bbb"), Vec::new());
-    assert_eq!(glob_vec("aaa/tomato/tomato.txt/.."), Vec::new());
-
-    assert_eq!(glob_vec("aaa/tomato/tomato.txt/"), Vec::new());
-
     assert_eq!(glob_vec("aa[a]"), vec!(abs_path("aaa")));
     assert_eq!(glob_vec("aa[abc]"), vec!(abs_path("aaa")));
     assert_eq!(glob_vec("a[bca]a"), vec!(abs_path("aaa")));