---

yaml
---
r: 14143
b: refs/heads/try
c: a422cd7
h: refs/heads/master
i:
  14141: 2b798f3
  14139: 23541c0
  14135: 9f96fa6
  14127: 6103c15
  14111: 1041880
  14079: 959e38f
v: v3

Author: Magnus Auvinen

[refs]

@@ -2,5 +2,5 @@
 refs/heads/master: 61b1875c16de39c166b0f4d54bba19f9c6777d1a
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 4a81779abd786ff22d71434c6d9a5917ea4cdfff
-refs/heads/try: d846169b1598fc9953a2ecc3fb2f0a557ba5a014
+refs/heads/try: a422cd7ddba45cc943416851c4abc8ae915c4fe9
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105

branches/try/src/cargo/cargo.rs

@@ -5,8 +5,7 @@ use std;
 
 import rustc::syntax::{ast, codemap};
 import rustc::syntax::parse::parser;
-import rustc::util::filesearch::{get_cargo_root, get_cargo_root_nearest,
-                                 get_cargo_sysroot};
+import rustc::util::filesearch::get_cargo_root;
 import rustc::driver::diagnostic;
 
 import std::fs;
@@ -20,8 +19,6 @@ import std::run;
 import str;
 import std::tempfile;
 import vec;
-import std::getopts;
-import getopts::{optflag, optopt, opt_present};
 
 enum _src {
     /* Break cycles in package <-> source */
@@ -56,7 +53,7 @@ type cargo = {
     workdir: str,
     sourcedir: str,
     sources: map::hashmap<str, source>,
-    opts: options
+    mutable test: bool
 };
 
 type pkg = {
@@ -68,18 +65,6 @@ type pkg = {
     crate_type: option<str>
 };
 
-type options = {
-    test: bool,
-    mode: mode,
-    free: [str],
-};
-
-enum mode { system_mode, user_mode, local_mode }
-
-fn opts() -> [getopts::opt] {
-    [optflag("g"), optflag("G"), optopt("mode"), optflag("test")]
-}
-
 fn info(msg: str) {
     io::stdout().write_line("info: " + msg);
 }
@@ -337,49 +322,10 @@ fn load_source_packages(&c: cargo, &src: source) {
     };
 }
 
-fn build_cargo_options(argv: [str]) -> options {
-    let match = alt getopts::getopts(argv, opts()) {
-        result::ok(m) { m }
-        result::err(f) {
-            fail #fmt["%s", getopts::fail_str(f)];
-        }
-    };
-
-    let test = opt_present(match, "test");
-    let mode = if opt_present(match, "G") {
-        if opt_present(match, "mode") { fail "--mode and -G both provided"; }
-        if opt_present(match, "g") { fail "-G and -g both provided"; }
-        system_mode
-    } else if opt_present(match, "g") {
-        if opt_present(match, "mode") { fail "--mode and -g both provided"; }
-        if opt_present(match, "G") { fail "-G and -g both provided"; }
-        user_mode
-    } else if opt_present(match, "mode") {
-        alt getopts::opt_str(match, "mode") {
-            "system" { system_mode }
-            "user" { user_mode }
-            "local" { local_mode }
-            _ { fail "argument to `mode` must be one of `system`" +
-                ", `user`, or `normal`";
-            }
-        }
-    } else {
-        local_mode
-    };
-
-    {test: test, mode: mode, free: match.free}
-}
-
-fn configure(opts: options) -> cargo {
-    let get_cargo_dir = alt opts.mode {
-        system_mode { get_cargo_sysroot }
-        user_mode { get_cargo_root }
-        local_mode { get_cargo_root_nearest }
-    };
-
-    let p = alt get_cargo_dir() {
-        result::ok(p) { p }
-        result::err(e) { fail e }
+fn configure() -> cargo {
+    let p = alt get_cargo_root() {
+      result::ok(p) { p }
+      result::err(e) { fail e }
     };
 
     let sources = map::new_str_hash::<source>();
@@ -393,7 +339,7 @@ fn configure(opts: options) -> cargo {
         workdir: fs::connect(p, "work"),
         sourcedir: fs::connect(p, "sources"),
         sources: sources,
-        opts: opts
+        mutable test: false
     };
 
     need_dir(c.root);
@@ -484,7 +430,7 @@ fn install_source(c: cargo, path: str) {
         alt p {
             none { cont; }
             some(_p) {
-                if c.opts.test {
+                if c.test {
                     test_one_crate(c, path, cf, _p);
                 }
                 install_one_crate(c, path, cf, _p);
@@ -627,14 +573,19 @@ fn install_named_specific(c: cargo, wd: str, src: str, name: str) {
     error("Can't find package " + src + "/" + name);
 }
 
-fn cmd_install(c: cargo) unsafe {
+fn cmd_install(c: cargo, argv: [str]) unsafe {
     // cargo install <pkg>
-    if vec::len(c.opts.free) < 3u {
+    if vec::len(argv) < 3u {
         cmd_usage();
         ret;
     }
 
-    let target = c.opts.free[2];
+    let target = argv[2];
+    // TODO: getopts
+    if vec::len(argv) > 3u && argv[2] == "--test" {
+        c.test = true;
+        target = argv[3];
+    }
 
     let wd = alt tempfile::mkdtemp(c.workdir + fs::path_sep(), "") {
         some(_wd) { _wd }
@@ -720,9 +671,9 @@ fn sync_one(c: cargo, name: str, src: source) {
     run::run_program("cp", [pkgfile, destpkgfile]);
 }
 
-fn cmd_sync(c: cargo) {
-    if vec::len(c.opts.free) == 3u {
-        sync_one(c, c.opts.free[2], c.sources.get(c.opts.free[2]));
+fn cmd_sync(c: cargo, argv: [str]) {
+    if vec::len(argv) == 3u {
+        sync_one(c, argv[2], c.sources.get(argv[2]));
     } else {
         cargo_suggestion(c, true, { || } );
         c.sources.items { |k, v|
@@ -758,8 +709,6 @@ fn cmd_init(c: cargo) {
     }
     info(#fmt["signature ok for sources.json"]);
     run::run_program("cp", [srcfile, destsrcfile]);
-
-    info(#fmt["Initialized .cargo in %s", c.root]);
 }
 
 fn print_pkg(s: source, p: package) {
@@ -772,22 +721,22 @@ fn print_pkg(s: source, p: package) {
         print("   >> " + p.description + "\n")
     }
 }
-fn cmd_list(c: cargo) {
+fn cmd_list(c: cargo, argv: [str]) {
     for_each_package(c, { |s, p|
-        if vec::len(c.opts.free) <= 2u || c.opts.free[2] == s.name {
+        if vec::len(argv) <= 2u || argv[2] == s.name {
             print_pkg(s, p);
         }
     });
 }
 
-fn cmd_search(c: cargo) {
-    if vec::len(c.opts.free) < 3u {
+fn cmd_search(c: cargo, argv: [str]) {
+    if vec::len(argv) < 3u {
         cmd_usage();
         ret;
     }
     let n = 0;
-    let name = c.opts.free[2];
-    let tags = vec::slice(c.opts.free, 3u, vec::len(c.opts.free));
+    let name = argv[2];
+    let tags = vec::slice(argv, 3u, vec::len(argv));
     for_each_package(c, { |s, p|
         if (str::contains(p.name, name) || name == "*") &&
             vec::all(tags, { |t| vec::member(t, p.tags) }) {
@@ -799,46 +748,28 @@ fn cmd_search(c: cargo) {
 }
 
 fn cmd_usage() {
-    print("Usage: cargo <verb> [options] [args...]" +
-          "
-
-    init                                          Set up .cargo
-    install [--test] [source/]package-name        Install by name
-    install [--test] uuid:[source/]package-uuid   Install by uuid
-    list [source]                                 List packages
-    search <name | '*'> [tags...]                 Search packages
-    sync                                          Sync all sources
-    usage                                         This
-
-Options:
-
-    --mode=[system,user,local]   change mode as (system/user/local)
-    -g                           equivalent to --mode=user
-    -G                           equivalent to --mode=system
-
-NOTE:
-This command creates/uses local-level .cargo by default.
-To create/use user-level .cargo, use option -g/--mode=user.
-To create/use system-level .cargo, use option -G/--mode=system.
-");
+    print("Usage: cargo <verb> [args...]");
+    print("  init                                          Set up ~/.cargo");
+    print("  install [--test] [source/]package-name        Install by name");
+    print("  install [--test] uuid:[source/]package-uuid   Install by uuid");
+    print("  list [source]                                 List packages");
+    print("  search <name | '*'> [tags...]                 Search packages");
+    print("  sync                                          Sync all sources");
+    print("  usage                                         This");
 }
 
 fn main(argv: [str]) {
-    let o = build_cargo_options(argv);
-
-    if vec::len(o.free) < 2u {
+    if vec::len(argv) < 2u {
         cmd_usage();
         ret;
     }
-
-    let c = configure(o);
-
-    alt o.free[1] {
+    let c = configure();
+    alt argv[1] {
         "init" { cmd_init(c); }
-        "install" { cmd_install(c); }
-        "list" { cmd_list(c); }
-        "search" { cmd_search(c); }
-        "sync" { cmd_sync(c); }
+        "install" { cmd_install(c, argv); }
+        "list" { cmd_list(c, argv); }
+        "search" { cmd_search(c, argv); }
+        "sync" { cmd_sync(c, argv); }
         "usage" { cmd_usage(); }
         _ { cmd_usage(); }
     }

branches/try/src/comp/back/link.rs

@@ -1,13 +1,18 @@
-import ctypes::{c_int, c_uint};
+import core::ctypes::{c_int, c_uint};
 import driver::session;
 import session::session;
 import lib::llvm::llvm;
 import front::attr;
 import middle::ty;
 import metadata::{encoder, cstore};
 import middle::trans::common::crate_ctxt;
+import str;
 import std::fs;
+import vec;
+import option;
 import std::run;
+import option::some;
+import option::none;
 import std::sha1::sha1;
 import syntax::ast;
 import syntax::print::pprust;

branches/try/src/comp/back/rpath.rs

@@ -1,4 +1,10 @@
-import std::{os, fs, os_fs, map};
+import std::os;
+import std::fs;
+import std::os_fs;
+import vec;
+import std::map;
+import str;
+import uint;
 import metadata::cstore;
 import driver::session;
 import util::filesearch;

branches/try/src/comp/driver/driver.rs

@@ -10,9 +10,11 @@ import middle::{trans, resolve, freevars, kind, ty, typeck, fn_usage,
 import syntax::print::{pp, pprust};
 import util::{ppaux, filesearch};
 import back::link;
+import core::{option, str, int, result};
 import result::{ok, err};
 import std::{fs, io, getopts};
 import io::{reader_util, writer_util};
+import option::{some, none};
 import getopts::{optopt, optmulti, optflag, optflagopt, opt_present};
 import back::{x86, x86_64};
 

branches/try/src/comp/driver/rustc.rs

@@ -2,9 +2,11 @@ use std;
 use rustc;
 
 // -*- rust -*-
+import core::{option, str, vec, result};
 import result::{ok, err};
 import std::{io, getopts};
 import io::writer_util;
+import option::{some, none};
 import getopts::{opt_present};
 import rustc::driver::driver::*;
 import rustc::syntax::codemap;

branches/try/src/comp/driver/session.rs

@@ -3,6 +3,8 @@ import syntax::{ast, codemap};
 import syntax::ast::node_id;
 import codemap::span;
 import syntax::ast::{int_ty, uint_ty, float_ty};
+import option;
+import option::{some, none};
 import syntax::parse::parser::parse_sess;
 import util::filesearch;
 import back::target_strs;

branches/try/src/comp/front/attr.rs

@@ -1,5 +1,6 @@
 // Functions dealing with attributes and meta_items
 
+import core::{either, vec, option};
 import std::map;
 import syntax::{ast, ast_util};
 import driver::session::session;

branches/try/src/comp/front/config.rs

@@ -1,4 +1,6 @@
+import core::{vec, option};
 import syntax::{ast, fold};
+import attr;
 
 export strip_unconfigured_items;
 export metas_in_cfg;

branches/try/src/comp/front/test.rs

@@ -1,5 +1,6 @@
 // Code that generates a test runner to run all the tests in a crate
 
+import core::{option, vec};
 import syntax::{ast, ast_util};
 import syntax::ast_util::*;
 //import syntax::ast_util::dummy_sp;

branches/try/src/comp/lib/llvm.rs

@@ -1,3 +1,4 @@
+import core::{vec, str, option};
 import str::sbuf;
 
 import ctypes::{c_int, c_uint, unsigned, longlong, ulonglong};

branches/try/src/comp/metadata/common.rs

@@ -1,5 +1,7 @@
 // EBML enum definitions and utils shared by the encoder and decoder
 
+import str;
+
 const tag_paths: uint = 0x01u;
 
 const tag_items: uint = 0x02u;

branches/try/src/comp/metadata/creader.rs

@@ -10,6 +10,7 @@ import syntax::codemap::span;
 import util::{filesearch};
 import std::{io, fs};
 import io::writer_util;
+import option::{none, some};
 import std::map::{hashmap, new_int_hash};
 import syntax::print::pprust;
 import common::*;

branches/try/src/comp/metadata/csearch.rs

@@ -3,6 +3,7 @@
 import syntax::ast;
 import syntax::ast_util;
 import middle::ty;
+import option::{some, none};
 import driver::session;
 
 export get_symbol;

branches/try/src/comp/metadata/cstore.rs

@@ -1,6 +1,7 @@
 // The crate store - a central repo for information collected about external
 // crates and libraries
 
+import core::{vec, str};
 import std::map;
 import syntax::ast;
 import util::common::*;

branches/try/src/comp/metadata/decoder.rs

@@ -286,7 +286,7 @@ fn get_impls_for_mod(cdata: cmd, m_id: ast::node_id,
         let did = translate_def_id(cdata, parse_def_id(ebml::doc_data(doc)));
         let item = lookup_item(did.node, data), nm = item_name(item);
         if alt name { some(n) { n == nm } none { true } } {
-            let base_tps = item_ty_param_count(item);
+            let base_tps = item_ty_param_count(doc);
             result += [@{did: did, ident: nm,
                          methods: item_impl_methods(cdata, item, base_tps)}];
         }