---

yaml
---
r: 80718
b: refs/heads/try
c: 45c62c0
h: refs/heads/master
v: v3

Author: erickt

[refs]

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

branches/try/src/compiletest/compiletest.rs

@@ -309,7 +309,7 @@ pub fn make_test_name(config: &config, testfile: &Path) -> test::TestName {
         let filename = path.filename();
         let p = path.pop();
         let dir = p.filename();
-        fmt!("%s/%s", dir.unwrap_or_default(""), filename.unwrap_or_default(""))
+        fmt!("%s/%s", dir.unwrap_or(""), filename.unwrap_or(""))
     }
 
     test::DynTestName(fmt!("[%s] %s",

branches/try/src/libextra/glob.rs

@@ -312,7 +312,7 @@ impl Pattern {
         let require_literal = |c| {
             (options.require_literal_separator && is_sep(c)) ||
             (options.require_literal_leading_dot && c == '.'
-             && is_sep(prev_char.unwrap_or_default('/')))
+             && is_sep(prev_char.unwrap_or('/')))
         };
 
         for (ti, token) in self.tokens.slice_from(i).iter().enumerate() {

branches/try/src/librustc/driver/driver.rs

@@ -681,9 +681,9 @@ pub fn build_session_options(binary: @str,
             link::output_type_bitcode
         } else { link::output_type_exe };
     let sysroot_opt = getopts::opt_maybe_str(matches, "sysroot").map_move(|m| @Path(m));
-    let target = getopts::opt_maybe_str(matches, "target").unwrap_or_default(host_triple());
-    let target_cpu = getopts::opt_maybe_str(matches, "target-cpu").unwrap_or_default(~"generic");
-    let target_feature = getopts::opt_maybe_str(matches, "target-feature").unwrap_or_default(~"");
+    let target = getopts::opt_maybe_str(matches, "target").unwrap_or(host_triple());
+    let target_cpu = getopts::opt_maybe_str(matches, "target-cpu").unwrap_or(~"generic");
+    let target_feature = getopts::opt_maybe_str(matches, "target-feature").unwrap_or(~"");
     let save_temps = getopts::opt_present(matches, "save-temps");
     let opt_level = {
         if (debugging_opts & session::no_opt) != 0 {

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

@@ -221,8 +221,7 @@ impl PrivacyVisitor {
         // If the method is a default method, we need to use the def_id of
         // the default implementation.
         // Having to do this this is really unfortunate.
-        let method_id = ty::method(self.tcx, method_id).provided_source
-            .unwrap_or_default(method_id);
+        let method_id = ty::method(self.tcx, method_id).provided_source.unwrap_or(method_id);
 
         if method_id.crate == LOCAL_CRATE {
             let is_private = self.method_is_private(span, method_id.node);

branches/try/src/librustc/middle/typeck/check/_match.rs

@@ -173,7 +173,7 @@ pub fn check_pat_variant(pcx: &pat_ctxt, pat: @ast::Pat, path: &ast::Path,
                     fcx.write_error(pat.id);
                     kind_name = "[error]";
                     arg_types = (*subpats).clone()
-                                          .unwrap_or_default(~[])
+                                          .unwrap_or(~[])
                                           .map(|_| ty::mk_err());
                 }
             }
@@ -222,7 +222,7 @@ pub fn check_pat_variant(pcx: &pat_ctxt, pat: @ast::Pat, path: &ast::Path,
             fcx.write_error(pat.id);
             kind_name = "[error]";
             arg_types = (*subpats).clone()
-                                  .unwrap_or_default(~[])
+                                  .unwrap_or(~[])
                                   .map(|_| ty::mk_err());
         }
     }

branches/try/src/librustdoc/attr_pass.rs

@@ -68,7 +68,7 @@ fn fold_crate(
     doc::CrateDoc {
         topmod: doc::ModDoc {
             item: doc::ItemDoc {
-                name: attrs.name.clone().unwrap_or_default(doc.topmod.name_()),
+                name: attrs.name.clone().unwrap_or(doc.topmod.name_()),
                 .. doc.topmod.item.clone()
             },
             .. doc.topmod.clone()

branches/try/src/librustdoc/config.rs

@@ -142,7 +142,7 @@ fn config_from_opts(
         let output_dir = getopts::opt_maybe_str(matches, opt_output_dir());
         let output_dir = output_dir.map_move(|s| Path(s));
         result::Ok(Config {
-            output_dir: output_dir.unwrap_or_default(config.output_dir.clone()),
+            output_dir: output_dir.unwrap_or(config.output_dir.clone()),
             .. config
         })
     };

branches/try/src/librustpkg/path_util.rs

@@ -55,10 +55,6 @@ pub fn workspace_contains_package_id(pkgid: &PkgId, workspace: &Path) -> bool {
 pub fn workspace_contains_package_id_(pkgid: &PkgId, workspace: &Path,
 // Returns the directory it was actually found in
              workspace_to_src_dir: &fn(&Path) -> Path) -> Option<Path> {
-    if !os::path_is_dir(workspace) {
-        return None;
-    }
-
     let src_dir = workspace_to_src_dir(workspace);
 
     let mut found = None;

branches/try/src/librustpkg/rustpkg.rs

@@ -33,7 +33,7 @@ use rustc::metadata::filesearch::rust_path;
 use extra::{getopts};
 use syntax::{ast, diagnostic};
 use util::*;
-use messages::{error, warn, note};
+use messages::*;
 use path_util::build_pkg_id_in_workspace;
 use path_util::{U_RWX, in_rust_path};
 use path_util::{built_executable_in_workspace, built_library_in_workspace, default_workspace};

branches/try/src/librustpkg/tests.rs

@@ -1581,28 +1581,6 @@ fn pkgid_pointing_to_subdir() {
     assert_executable_exists(&workspace, "testpkg");
 }
 
-fn test_recursive_deps() {
-    let a_id = PkgId::new("a");
-    let b_id = PkgId::new("b");
-    let c_id = PkgId::new("c");
-    let b_workspace = create_local_package_with_dep(&b_id, &c_id);
-    writeFile(&b_workspace.push("src").push("c-0.1").push("lib.rs"),
-               "pub fn g() {}");
-    let a_workspace = create_local_package(&a_id);
-    writeFile(&a_workspace.push("src").push("a-0.1").push("main.rs"),
-               "extern mod b; use b::f; fn main() { f(); }");
-    writeFile(&b_workspace.push("src").push("b-0.1").push("lib.rs"),
-               "extern mod c; use c::g; pub fn f() { g(); }");
-    let environment = Some(~[(~"RUST_PATH", b_workspace.to_str())]);
-    debug!("RUST_PATH=%s", b_workspace.to_str());
-    command_line_test_with_env([~"install", ~"a"],
-                               &a_workspace,
-                               environment);
-    assert_lib_exists(&a_workspace, &Path("a"), NoVersion);
-    assert_lib_exists(&b_workspace, &Path("b"), NoVersion);
-    assert_lib_exists(&b_workspace, &Path("c"), NoVersion);
-}
-
 /// Returns true if p exists and is executable
 fn is_executable(p: &Path) -> bool {
     use std::libc::consts::os::posix88::{S_IXUSR};

branches/try/src/librustpkg/util.rs

@@ -22,9 +22,7 @@ use rustc::driver::session::{lib_crate, bin_crate};
 use context::{in_target, StopBefore, Link, Assemble, BuildContext};
 use package_id::PkgId;
 use package_source::PkgSrc;
-use workspace::pkg_parent_workspaces;
-use path_util::{installed_library_in_workspace, U_RWX, rust_path};
-use messages::error;
+use path_util::{installed_library_in_workspace, U_RWX};
 
 pub use target::{OutputType, Main, Lib, Bench, Test};
 use workcache_support::{digest_file_with_date, digest_only_date};
@@ -245,7 +243,9 @@ pub fn compile_input(context: &BuildContext,
     let mut crate = driver::phase_1_parse_input(sess, cfg.clone(), &input);
     crate = driver::phase_2_configure_and_expand(sess, cfg.clone(), crate);
 
-    find_and_install_dependencies(context, pkg_id, sess, exec, crate,
+    // Not really right. Should search other workspaces too, and the installed
+    // database (which doesn't exist yet)
+    find_and_install_dependencies(context, sess, exec, workspace, crate,
                                   |p| {
                                       debug!("a dependency: %s", p.to_str());
                                       // Pass the directory containing a dependency
@@ -362,15 +362,13 @@ pub fn compile_crate(ctxt: &BuildContext,
 /// Collect all `extern mod` directives in `c`, then
 /// try to install their targets, failing if any target
 /// can't be found.
-pub fn find_and_install_dependencies(context: &BuildContext,
-                                     parent: &PkgId,
+pub fn find_and_install_dependencies(ctxt: &BuildContext,
                                      sess: session::Session,
                                      exec: &mut workcache::Exec,
+                                     workspace: &Path,
                                      c: &ast::Crate,
                                      save: @fn(Path)
                                      ) {
-    use conditions::nonexistent_package::cond;
-
     do c.each_view_item() |vi: &ast::view_item| {
         debug!("A view item!");
         match vi.node {
@@ -381,7 +379,7 @@ pub fn find_and_install_dependencies(context: &BuildContext,
                     None => sess.str_of(lib_ident)
                 };
                 debug!("Finding and installing... %s", lib_name);
-                match installed_library_in_workspace(&Path(lib_name), &context.sysroot()) {
+                match installed_library_in_workspace(&Path(lib_name), &ctxt.sysroot()) {
                     Some(ref installed_path) => {
                         debug!("It exists: %s", installed_path.to_str());
                         // Say that [path for c] has a discovered dependency on
@@ -399,18 +397,8 @@ pub fn find_and_install_dependencies(context: &BuildContext,
                                lib_name.to_str());
                         // Try to install it
                         let pkg_id = PkgId::new(lib_name);
-                        let workspaces = pkg_parent_workspaces(&context.context, &pkg_id);
-                        let dep_workspace = if workspaces.is_empty() {
-                            error(fmt!("Couldn't find package %s, which is needed by %s, \
-                                            in any of the workspaces in the RUST_PATH (%?)",
-                                            lib_name, parent.to_str(), rust_path()));
-                            cond.raise((pkg_id.clone(), ~"Dependency not found"))
-                        }
-                        else {
-                            workspaces[0]
-                        };
                         let (outputs_disc, inputs_disc) =
-                            context.install(PkgSrc::new(dep_workspace.clone(), false, pkg_id));
+                            ctxt.install(PkgSrc::new(workspace.clone(), false, pkg_id));
                         debug!("Installed %s, returned %? dependencies and \
                                %? transitive dependencies",
                                lib_name, outputs_disc.len(), inputs_disc.len());
@@ -435,7 +423,7 @@ pub fn find_and_install_dependencies(context: &BuildContext,
                         // Also, add an additional search path
                         debug!("Adding additional search path: %s", lib_name);
                         let installed_library =
-                            installed_library_in_workspace(&Path(lib_name), &dep_workspace)
+                            installed_library_in_workspace(&Path(lib_name), workspace)
                                 .expect( fmt!("rustpkg failed to install dependency %s",
                                               lib_name));
                         let install_dir = installed_library.pop();

branches/try/src/libstd/at_vec.rs

@@ -45,7 +45,7 @@ pub fn capacity<T>(v: @[T]) -> uint {
 #[inline]
 pub fn build<A>(size: Option<uint>, builder: &fn(push: &fn(v: A))) -> @[A] {
     let mut vec = @[];
-    unsafe { raw::reserve(&mut vec, size.unwrap_or_default(4)); }
+    unsafe { raw::reserve(&mut vec, size.unwrap_or(4)); }
     builder(|x| unsafe { raw::push(&mut vec, x) });
     vec
 }

branches/try/src/libstd/option.rs

@@ -332,7 +332,7 @@ impl<T> Option<T> {
 
     /// Returns the contained value or a default
     #[inline]
-    pub fn unwrap_or_default(self, def: T) -> T {
+    pub fn unwrap_or(self, def: T) -> T {
         match self {
             Some(x) => x,
             None => def

branches/try/src/libstd/os.rs

@@ -611,7 +611,7 @@ pub fn tmpdir() -> Path {
         if cfg!(target_os = "android") {
             Path("/data/tmp")
         } else {
-            getenv_nonempty("TMPDIR").unwrap_or_default(Path("/tmp"))
+            getenv_nonempty("TMPDIR").unwrap_or(Path("/tmp"))
         }
     }
 

branches/try/src/libstd/vec.rs

@@ -205,7 +205,7 @@ pub fn with_capacity<T>(capacity: uint) -> ~[T] {
  */
 #[inline]
 pub fn build<A>(size: Option<uint>, builder: &fn(push: &fn(v: A))) -> ~[A] {
-    let mut vec = with_capacity(size.unwrap_or_default(4));
+    let mut vec = with_capacity(size.unwrap_or(4));
     builder(|x| vec.push(x));
     vec
 }

branches/try/src/libsyntax/parse/parser.rs

@@ -802,7 +802,7 @@ impl Parser {
         */
 
         let opt_abis = self.parse_opt_abis();
-        let abis = opt_abis.unwrap_or_default(AbiSet::Rust());
+        let abis = opt_abis.unwrap_or(AbiSet::Rust());
         let purity = self.parse_unsafety();
         self.expect_keyword(keywords::Fn);
         let (decl, lifetimes) = self.parse_ty_fn_decl();
@@ -3461,7 +3461,7 @@ impl Parser {
         let ident = self.parse_ident();
         let opt_bounds = self.parse_optional_ty_param_bounds();
         // For typarams we don't care about the difference b/w "<T>" and "<T:>".
-        let bounds = opt_bounds.unwrap_or_default(opt_vec::Empty);
+        let bounds = opt_bounds.unwrap_or(opt_vec::Empty);
         ast::TyParam { ident: ident, id: ast::DUMMY_NODE_ID, bounds: bounds }
     }
 
@@ -4363,7 +4363,7 @@ impl Parser {
                 self.obsolete(*self.last_span, ObsoleteExternVisibility);
             }
 
-            let abis = opt_abis.unwrap_or_default(AbiSet::C());
+            let abis = opt_abis.unwrap_or(AbiSet::C());
 
             let (inner, next) = self.parse_inner_attrs_and_next();
             let m = self.parse_foreign_mod_items(sort, abis, next);
@@ -4640,7 +4640,7 @@ impl Parser {
 
             if self.eat_keyword(keywords::Fn) {
                 // EXTERN FUNCTION ITEM
-                let abis = opt_abis.unwrap_or_default(AbiSet::C());
+                let abis = opt_abis.unwrap_or(AbiSet::C());
                 let (ident, item_, extra_attrs) =
                     self.parse_item_fn(extern_fn, abis);
                 return iovi_item(self.mk_item(lo, self.last_span.hi, ident,