---

yaml
---
r: 80770
b: refs/heads/try
c: 940a86b
h: refs/heads/master
v: v3

Author: lkuper

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 4c6bf4872012c010f84dc7fa2cdfe87522533f89
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: cbd1eefbd350797b783df119fed7956d7e1c74ad
-refs/heads/try: 4ac10f8f6e8e07c70fadb676170c5402442e2243
+refs/heads/try: 940a86b760bc56d9cd54238201a2206a9d55c70c
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/src/libextra/tempfile.rs

@@ -28,6 +28,97 @@ pub fn mkdtemp(tmpdir: &Path, suffix: &str) -> Option<Path> {
     None
 }
 
-// the tests for this module need to change the path using change_dir,
-// and this doesn't play nicely with other tests so these unit tests are located
-// in src/test/run-pass/tempfile.rs
+#[cfg(test)]
+mod tests {
+
+    use tempfile::mkdtemp;
+
+    use std::os;
+
+    #[test]
+    fn test_mkdtemp() {
+        let p = mkdtemp(&Path("."), "foobar").unwrap();
+        os::remove_dir(&p);
+        assert!(p.to_str().ends_with("foobar"));
+    }
+
+    // Ideally these would be in std::os but then core would need
+    // to depend on std
+    #[test]
+    fn recursive_mkdir_rel() {
+        use std::libc::consts::os::posix88::{S_IRUSR, S_IWUSR, S_IXUSR};
+        use std::os;
+        use std::unstable::change_dir_locked;
+
+        let root = mkdtemp(&os::tmpdir(), "recursive_mkdir_rel").
+            expect("recursive_mkdir_rel");
+        assert!(do change_dir_locked(&root) {
+            let path = Path("frob");
+            debug!("recursive_mkdir_rel: Making: %s in cwd %s [%?]", path.to_str(),
+                   os::getcwd().to_str(),
+                   os::path_exists(&path));
+            assert!(os::mkdir_recursive(&path,  (S_IRUSR | S_IWUSR | S_IXUSR) as i32));
+            assert!(os::path_is_dir(&path));
+            assert!(os::mkdir_recursive(&path,  (S_IRUSR | S_IWUSR | S_IXUSR) as i32));
+            assert!(os::path_is_dir(&path));
+        });
+    }
+
+    #[test]
+    fn recursive_mkdir_dot() {
+        use std::libc::consts::os::posix88::{S_IRUSR, S_IWUSR, S_IXUSR};
+        use std::os;
+
+        let dot = Path(".");
+        assert!(os::mkdir_recursive(&dot,  (S_IRUSR | S_IWUSR | S_IXUSR) as i32));
+        let dotdot = Path("..");
+        assert!(os::mkdir_recursive(&dotdot,  (S_IRUSR | S_IWUSR | S_IXUSR) as i32));
+    }
+
+    #[test]
+    fn recursive_mkdir_rel_2() {
+        use std::libc::consts::os::posix88::{S_IRUSR, S_IWUSR, S_IXUSR};
+        use std::os;
+        use std::unstable::change_dir_locked;
+
+        let root = mkdtemp(&os::tmpdir(), "recursive_mkdir_rel_2").
+            expect("recursive_mkdir_rel_2");
+        assert!(do change_dir_locked(&root) {
+            let path = Path("./frob/baz");
+            debug!("recursive_mkdir_rel_2: Making: %s in cwd %s [%?]", path.to_str(),
+                   os::getcwd().to_str(), os::path_exists(&path));
+            assert!(os::mkdir_recursive(&path, (S_IRUSR | S_IWUSR | S_IXUSR) as i32));
+                assert!(os::path_is_dir(&path));
+            assert!(os::path_is_dir(&path.pop()));
+            let path2 = Path("quux/blat");
+            debug!("recursive_mkdir_rel_2: Making: %s in cwd %s", path2.to_str(),
+                   os::getcwd().to_str());
+            assert!(os::mkdir_recursive(&path2, (S_IRUSR | S_IWUSR | S_IXUSR) as i32));
+                assert!(os::path_is_dir(&path2));
+            assert!(os::path_is_dir(&path2.pop()));
+        });
+    }
+
+    // Ideally this would be in core, but needs mkdtemp
+    #[test]
+    pub fn test_rmdir_recursive_ok() {
+        use std::libc::consts::os::posix88::{S_IRUSR, S_IWUSR, S_IXUSR};
+        use std::os;
+
+        let rwx = (S_IRUSR | S_IWUSR | S_IXUSR) as i32;
+
+        let tmpdir = mkdtemp(&os::tmpdir(), "test").expect("test_rmdir_recursive_ok: \
+                                            couldn't create temp dir");
+        let root = tmpdir.push("foo");
+
+        debug!("making %s", root.to_str());
+        assert!(os::make_dir(&root, rwx));
+        assert!(os::make_dir(&root.push("foo"), rwx));
+        assert!(os::make_dir(&root.push("foo").push("bar"), rwx));
+        assert!(os::make_dir(&root.push("foo").push("bar").push("blat"), rwx));
+        assert!(os::remove_dir_recursive(&root));
+        assert!(!os::path_exists(&root));
+        assert!(!os::path_exists(&root.push("bar")));
+        assert!(!os::path_exists(&root.push("bar").push("blat")));
+    }
+}

branches/try/src/librustpkg/tests.rs

@@ -819,25 +819,26 @@ fn rust_path_test() {
 }
 
 #[test]
-#[ignore] // FIXME(#9184) tests can't change the cwd (other tests are sad then)
 fn rust_path_contents() {
+    use std::unstable::change_dir_locked;
+
     let dir = mkdtemp(&os::tmpdir(), "rust_path").expect("rust_path_contents failed");
     let abc = &dir.push("A").push("B").push("C");
     assert!(os::mkdir_recursive(&abc.push(".rust"), U_RWX));
     assert!(os::mkdir_recursive(&abc.pop().push(".rust"), U_RWX));
     assert!(os::mkdir_recursive(&abc.pop().pop().push(".rust"), U_RWX));
-    assert!(os::change_dir(abc));
-
-    let p = rust_path();
-    let cwd = os::getcwd().push(".rust");
-    let parent = cwd.pop().pop().push(".rust");
-    let grandparent = cwd.pop().pop().pop().push(".rust");
-    assert!(p.contains(&cwd));
-    assert!(p.contains(&parent));
-    assert!(p.contains(&grandparent));
-    for a_path in p.iter() {
-        assert!(!a_path.components.is_empty());
-    }
+    assert!(do change_dir_locked(&dir.push("A").push("B").push("C")) {
+        let p = rust_path();
+        let cwd = os::getcwd().push(".rust");
+        let parent = cwd.pop().pop().push(".rust");
+        let grandparent = cwd.pop().pop().pop().push(".rust");
+        assert!(p.contains(&cwd));
+        assert!(p.contains(&parent));
+        assert!(p.contains(&grandparent));
+        for a_path in p.iter() {
+            assert!(!a_path.components.is_empty());
+        }
+    });
 }
 
 #[test]

branches/try/src/libstd/unstable/mod.rs

@@ -68,6 +68,59 @@ fn test_run_in_bare_thread_exchange() {
     }
 }
 
+
+/// Changes the current working directory to the specified
+/// path while acquiring a global lock, then calls `action`.
+/// If the change is successful, releases the lock and restores the
+/// CWD to what it was before, returning true.
+/// Returns false if the directory doesn't exist or if the directory change
+/// is otherwise unsuccessful.
+///
+/// This is used by test cases to avoid cwd races.
+///
+/// # Safety Note
+///
+/// This uses a pthread mutex so descheduling in the action callback
+/// can lead to deadlock. Calling change_dir_locked recursively will
+/// also deadlock.
+pub fn change_dir_locked(p: &Path, action: &fn()) -> bool {
+    #[fixed_stack_segment]; #[inline(never)];
+
+    use os;
+    use os::change_dir;
+    use unstable::sync::atomically;
+    use unstable::finally::Finally;
+
+    unsafe {
+        // This is really sketchy. Using a pthread mutex so descheduling
+        // in the `action` callback can cause deadlock. Doing it in
+        // `task::atomically` to try to avoid that, but ... I don't know
+        // this is all bogus.
+        return do atomically {
+            rust_take_change_dir_lock();
+
+            do (||{
+                let old_dir = os::getcwd();
+                if change_dir(p) {
+                    action();
+                    change_dir(&old_dir)
+                }
+                else {
+                    false
+                }
+            }).finally {
+                rust_drop_change_dir_lock();
+            }
+        }
+    }
+
+    extern {
+        fn rust_take_change_dir_lock();
+        fn rust_drop_change_dir_lock();
+    }
+}
+
+
 /// Dynamically inquire about whether we're running under V.
 /// You should usually not use this unless your test definitely
 /// can't run correctly un-altered. Valgrind is there to help

branches/try/src/libsyntax/ast_util.rs

@@ -1,4 +1,4 @@
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -15,7 +15,7 @@ use codemap::{Span, dummy_sp};
 use fold;
 use opt_vec;
 use parse::token;
-use visit::{SimpleVisitor, Visitor};
+use visit::Visitor;
 use visit;
 
 use std::hashmap::HashMap;

branches/try/src/libsyntax/visit.rs

@@ -1,4 +1,4 @@
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -668,144 +668,3 @@ pub fn walk_arm<E:Clone, V:Visitor<E>>(visitor: &mut V, arm: &Arm, env: E) {
     walk_expr_opt(visitor, arm.guard, env.clone());
     visitor.visit_block(&arm.body, env)
 }
-
-// Simpler, non-context passing interface. Always walks the whole tree, simply
-// calls the given functions on the nodes.
-
-pub trait SimpleVisitor {
-    fn visit_mod(&mut self, &_mod, Span, NodeId);
-    fn visit_view_item(&mut self, &view_item);
-    fn visit_foreign_item(&mut self, @foreign_item);
-    fn visit_item(&mut self, @item);
-    fn visit_local(&mut self, @Local);
-    fn visit_block(&mut self, &Block);
-    fn visit_stmt(&mut self, @Stmt);
-    fn visit_arm(&mut self, &Arm);
-    fn visit_pat(&mut self, @Pat);
-    fn visit_decl(&mut self, @Decl);
-    fn visit_expr(&mut self, @Expr);
-    fn visit_expr_post(&mut self, @Expr);
-    fn visit_ty(&mut self, &Ty);
-    fn visit_generics(&mut self, &Generics);
-    fn visit_fn(&mut self, &fn_kind, &fn_decl, &Block, Span, NodeId);
-    fn visit_ty_method(&mut self, &TypeMethod);
-    fn visit_trait_method(&mut self, &trait_method);
-    fn visit_struct_def(&mut self, @struct_def, Ident, &Generics, NodeId);
-    fn visit_struct_field(&mut self, @struct_field);
-    fn visit_struct_method(&mut self, @method);
-}
-
-pub struct SimpleVisitorVisitor {
-    simple_visitor: @mut SimpleVisitor,
-}
-
-impl Visitor<()> for SimpleVisitorVisitor {
-    fn visit_mod(&mut self,
-                 module: &_mod,
-                 span: Span,
-                 node_id: NodeId,
-                 env: ()) {
-        self.simple_visitor.visit_mod(module, span, node_id);
-        walk_mod(self, module, env)
-    }
-    fn visit_view_item(&mut self, view_item: &view_item, env: ()) {
-        self.simple_visitor.visit_view_item(view_item);
-        walk_view_item(self, view_item, env)
-    }
-    fn visit_foreign_item(&mut self, foreign_item: @foreign_item, env: ()) {
-        self.simple_visitor.visit_foreign_item(foreign_item);
-        walk_foreign_item(self, foreign_item, env)
-    }
-    fn visit_item(&mut self, item: @item, env: ()) {
-        self.simple_visitor.visit_item(item);
-        walk_item(self, item, env)
-    }
-    fn visit_local(&mut self, local: @Local, env: ()) {
-        self.simple_visitor.visit_local(local);
-        walk_local(self, local, env)
-    }
-    fn visit_block(&mut self, block: &Block, env: ()) {
-        self.simple_visitor.visit_block(block);
-        walk_block(self, block, env)
-    }
-    fn visit_stmt(&mut self, statement: @Stmt, env: ()) {
-        self.simple_visitor.visit_stmt(statement);
-        walk_stmt(self, statement, env)
-    }
-    fn visit_arm(&mut self, arm: &Arm, env: ()) {
-        self.simple_visitor.visit_arm(arm);
-        walk_arm(self, arm, env)
-    }
-    fn visit_pat(&mut self, pattern: @Pat, env: ()) {
-        self.simple_visitor.visit_pat(pattern);
-        walk_pat(self, pattern, env)
-    }
-    fn visit_decl(&mut self, declaration: @Decl, env: ()) {
-        self.simple_visitor.visit_decl(declaration);
-        walk_decl(self, declaration, env)
-    }
-    fn visit_expr(&mut self, expression: @Expr, env: ()) {
-        self.simple_visitor.visit_expr(expression);
-        walk_expr(self, expression, env)
-    }
-    fn visit_expr_post(&mut self, expression: @Expr, _: ()) {
-        self.simple_visitor.visit_expr_post(expression)
-    }
-    fn visit_ty(&mut self, typ: &Ty, env: ()) {
-        self.simple_visitor.visit_ty(typ);
-        walk_ty(self, typ, env)
-    }
-    fn visit_generics(&mut self, generics: &Generics, env: ()) {
-        self.simple_visitor.visit_generics(generics);
-        walk_generics(self, generics, env)
-    }
-    fn visit_fn(&mut self,
-                function_kind: &fn_kind,
-                function_declaration: &fn_decl,
-                block: &Block,
-                span: Span,
-                node_id: NodeId,
-                env: ()) {
-        self.simple_visitor.visit_fn(function_kind,
-                                     function_declaration,
-                                     block,
-                                     span,
-                                     node_id);
-        walk_fn(self,
-                 function_kind,
-                 function_declaration,
-                 block,
-                 span,
-                 node_id,
-                 env)
-    }
-    fn visit_ty_method(&mut self, method_type: &TypeMethod, env: ()) {
-        self.simple_visitor.visit_ty_method(method_type);
-        walk_ty_method(self, method_type, env)
-    }
-    fn visit_trait_method(&mut self, trait_method: &trait_method, env: ()) {
-        self.simple_visitor.visit_trait_method(trait_method);
-        walk_trait_method(self, trait_method, env)
-    }
-    fn visit_struct_def(&mut self,
-                        struct_definition: @struct_def,
-                        identifier: Ident,
-                        generics: &Generics,
-                        node_id: NodeId,
-                        env: ()) {
-        self.simple_visitor.visit_struct_def(struct_definition,
-                                             identifier,
-                                             generics,
-                                             node_id);
-        walk_struct_def(self,
-                         struct_definition,
-                         identifier,
-                         generics,
-                         node_id,
-                         env)
-    }
-    fn visit_struct_field(&mut self, struct_field: @struct_field, env: ()) {
-        self.simple_visitor.visit_struct_field(struct_field);
-        walk_struct_field(self, struct_field, env)
-    }
-}

branches/try/src/rt/rust_builtin.cpp

@@ -603,6 +603,18 @@ rust_get_global_args_ptr() {
     return &global_args_ptr;
 }
 
+static lock_and_signal change_dir_lock;
+
+extern "C" CDECL void
+rust_take_change_dir_lock() {
+    change_dir_lock.lock();
+}
+
+extern "C" CDECL void
+rust_drop_change_dir_lock() {
+    change_dir_lock.unlock();
+}
+
 // Used by i386 __morestack
 extern "C" CDECL uintptr_t
 rust_get_task() {