---

yaml
---
r: 6727
b: refs/heads/master
c: 7953a5d
h: refs/heads/master
i:
  6725: 9e84d87
  6723: 9ccfd88
  6719: 9a071d4
v: v3

Author: Elly Jones

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: fd1dd76977f808ec40796d6ca66e4bf98de6de9c
+refs/heads/master: 7953a5dcfcb779a4a127b34e9cc85b0359c45d1a

trunk/src/cargo/cargo.rs

@@ -6,6 +6,7 @@ import rustc::syntax::parse::parser;
 import std::fs;
 import std::generic_os;
 import std::io;
+import std::json;
 import option;
 import option::{none, some};
 import std::os;
@@ -206,6 +207,36 @@ fn install_file(c: cargo, wd: str, _path: str) {
     install_source(c, wd);
 }
 
+fn install_resolved(c: cargo, wd: str, key: str) {
+    fs::remove_dir(wd);
+    let u = "https://rust-package-index.appspot.com/pkg/" + key;
+    let p = run::program_output("curl", [u]);
+    if p.status != 0 {
+        fail #fmt["Fetch of %s failed: %s", u, p.err];
+    }
+    let j = json::from_str(p.out);
+    alt j {
+        some (json::dict(_j)) {
+            alt _j.find("install") {
+                some (json::string(g)) {
+                    log #fmt["Resolved: %s -> %s", key, g];
+                    cmd_install(c, ["cargo", "install", g]);
+                }
+                _ { fail #fmt["Bogus install: '%s'", p.out]; }
+            }
+        }
+        _ { fail #fmt["Bad json: '%s'", p.out]; }
+    }
+}
+
+fn install_uuid(c: cargo, wd: str, uuid: str) {
+    install_resolved(c, wd, "by-uuid/" + uuid);
+}
+
+fn install_named(c: cargo, wd: str, name: str) {
+    install_resolved(c, wd, "by-name/" + name);
+}
+
 fn cmd_install(c: cargo, argv: [str]) {
     // cargo install <pkg>
     if vec::len(argv) < 3u {
@@ -226,6 +257,11 @@ fn cmd_install(c: cargo, argv: [str]) {
     } else if str::starts_with(argv[2], "file:") {
         let path = rest(argv[2], 5u);
         install_file(c, wd, path);
+    } else if str::starts_with(argv[2], "uuid:") {
+        let uuid = rest(argv[2], 5u);
+        install_uuid(c, wd, uuid);
+    } else {
+        install_named(c, wd, argv[2]);
     }
 }
 

trunk/src/comp/metadata/decoder.rs

@@ -244,7 +244,7 @@ fn get_tag_variants(_data: @[u8], def: ast::def_id, tcx: ty::ctxt,
 
           }
         }
-        infos += [@{args: arg_tys, ctor_ty: ctor_ty, id: did}];
+        infos += [{args: arg_tys, ctor_ty: ctor_ty, id: did}];
     }
     ret infos;
 }

trunk/src/comp/middle/check_alt.rs

@@ -149,7 +149,7 @@ fn is_refutable(tcx: ty::ctxt, pat: @pat) -> bool {
       }
       pat_tag(_, args) {
         let vdef = variant_def_ids(tcx.def_map.get(pat.id));
-        if vec::len(*ty::tag_variants(tcx, vdef.tg)) != 1u { ret true; }
+        if vec::len(ty::tag_variants(tcx, vdef.tg)) != 1u { ret true; }
         for p: @pat in args { if is_refutable(tcx, p) { ret true; } }
         false
       }

trunk/src/comp/middle/gc.rs

@@ -128,7 +128,7 @@ fn type_is_gc_relevant(cx: ty::ctxt, ty: ty::t) -> bool {
 
       ty::ty_tag(did, tps) {
         let variants = ty::tag_variants(cx, did);
-        for variant in *variants {
+        for variant in variants {
             for aty in variant.args {
                 let arg_ty = ty::substitute_type_params(cx, tps, aty);
                 if type_is_gc_relevant(cx, arg_ty) { ret true; }

trunk/src/comp/middle/mut.rs

@@ -32,7 +32,7 @@ fn expr_root(tcx: ty::ctxt, ex: @expr, autoderef: bool) ->
               }
               ty::ty_tag(did, tps) {
                 let variants = ty::tag_variants(tcx, did);
-                if vec::len(*variants) != 1u ||
+                if vec::len(variants) != 1u ||
                        vec::len(variants[0].args) != 1u {
                     break;
                 }

trunk/src/comp/middle/shape.rs

@@ -106,7 +106,7 @@ fn largest_variants(ccx: @crate_ctxt, tag_id: ast::def_id) -> [uint] {
     // just T.
     let ranges = [];
     let variants = ty::tag_variants(ccx.tcx, tag_id);
-    for variant: ty::variant_info in *variants {
+    for variant: ty::variant_info in variants {
         let bounded = true;
         let {a: min_size, b: min_align} = {a: 0u, b: 0u};
         for elem_t: ty::t in variant.args {
@@ -134,7 +134,7 @@ fn largest_variants(ccx: @crate_ctxt, tag_id: ast::def_id) -> [uint] {
 
     // Initialize the candidate set to contain all variants.
     let candidates = [mutable];
-    for variant in *variants { candidates += [mutable true]; }
+    for variant in variants { candidates += [mutable true]; }
 
     // Do a pairwise comparison among all variants still in the candidate set.
     // Throw out any variant that we know has size and alignment at least as
@@ -214,7 +214,7 @@ fn compute_static_tag_size(ccx: @crate_ctxt, largest_variants: [uint],
     // Add space for the tag if applicable.
     // FIXME (issue #792): This is wrong. If the tag starts with an 8 byte
     // aligned quantity, we don't align it.
-    if vec::len(*variants) > 1u {
+    if vec::len(variants) > 1u {
         let variant_t = T_tag_variant(ccx);
         max_size += trans::llsize_of_real(ccx, variant_t) as u16;
         let align = trans::llalign_of_real(ccx, variant_t) as u8;
@@ -228,11 +228,11 @@ tag tag_kind { tk_unit; tk_enum; tk_complex; }
 
 fn tag_kind(ccx: @crate_ctxt, did: ast::def_id) -> tag_kind {
     let variants = ty::tag_variants(ccx.tcx, did);
-    if vec::len(*variants) == 0u { ret tk_complex; }
-    for v: ty::variant_info in *variants {
+    if vec::len(variants) == 0u { ret tk_complex; }
+    for v: ty::variant_info in variants {
         if vec::len(v.args) > 0u { ret tk_complex; }
     }
-    if vec::len(*variants) == 1u { ret tk_unit; }
+    if vec::len(variants) == 1u { ret tk_unit; }
     ret tk_enum;
 }
 
@@ -452,7 +452,7 @@ fn gen_tag_shapes(ccx: @crate_ctxt) -> ValueRef {
         let item_tyt = ty::lookup_item_type(ccx.tcx, did);
         let ty_param_count = vec::len(item_tyt.kinds);
 
-        for v: ty::variant_info in *variants {
+        for v: ty::variant_info in variants {
             offsets += [vec::len(data) as u16];
 
             let variant_shape = shape_of_variant(ccx, v, ty_param_count);
@@ -476,7 +476,7 @@ fn gen_tag_shapes(ccx: @crate_ctxt) -> ValueRef {
         let did = did_; // Satisfy alias checker.
         let variants = ty::tag_variants(ccx.tcx, did);
         add_u16(header, header_sz + info_sz);
-        info_sz += 2u16 * ((vec::len(*variants) as u16) + 2u16) + 3u16;
+        info_sz += 2u16 * ((vec::len(variants) as u16) + 2u16) + 3u16;
     }
 
     // Construct the info tables, which contain offsets to the shape of each
@@ -488,7 +488,7 @@ fn gen_tag_shapes(ccx: @crate_ctxt) -> ValueRef {
     for did_: ast::def_id in ccx.shape_cx.tag_order {
         let did = did_; // Satisfy alias checker.
         let variants = ty::tag_variants(ccx.tcx, did);
-        add_u16(info, vec::len(*variants) as u16);
+        add_u16(info, vec::len(variants) as u16);
 
         // Construct the largest-variants table.
         add_u16(info,
@@ -500,7 +500,7 @@ fn gen_tag_shapes(ccx: @crate_ctxt) -> ValueRef {
 
         // Determine whether the tag has dynamic size.
         let dynamic = false;
-        for variant: ty::variant_info in *variants {
+        for variant: ty::variant_info in variants {
             for typ: ty::t in variant.args {
                 if ty::type_has_dynamic_size(ccx.tcx, typ) { dynamic = true; }
             }
@@ -516,7 +516,7 @@ fn gen_tag_shapes(ccx: @crate_ctxt) -> ValueRef {
         info += [size_align.align];
 
         // Now write in the offset of each variant.
-        for v: ty::variant_info in *variants {
+        for v: ty::variant_info in variants {
             add_u16(info, header_sz + info_sz + offsets[i]);
             i += 1u;
         }

trunk/src/comp/middle/trans.rs

@@ -211,7 +211,7 @@ fn type_of_inner(cx: @crate_ctxt, sp: span, t: ty::t)
 
 fn type_of_tag(cx: @crate_ctxt, sp: span, did: ast::def_id, t: ty::t)
     -> TypeRef {
-    let degen = vec::len(*ty::tag_variants(cx.tcx, did)) == 1u;
+    let degen = vec::len(ty::tag_variants(cx.tcx, did)) == 1u;
     if check type_has_static_size(cx, t) {
         let size = static_size_of_tag(cx, sp, t);
         if !degen { T_tag(cx, size) }
@@ -511,7 +511,7 @@ fn static_size_of_tag(cx: @crate_ctxt, sp: span, t: ty::t)
 
         let max_size = 0u;
         let variants = ty::tag_variants(cx.tcx, tid);
-        for variant: ty::variant_info in *variants {
+        for variant: ty::variant_info in variants {
             let tup_ty = simplify_type(cx, ty::mk_tup(cx.tcx, variant.args));
             // Perform any type parameter substitutions.
 
@@ -592,7 +592,7 @@ fn dynamic_size_of(cx: @block_ctxt, t: ty::t, mode: align_mode) -> result {
         let max_size: ValueRef = alloca(bcx, ccx.int_type);
         Store(bcx, C_int(ccx, 0), max_size);
         let variants = ty::tag_variants(bcx_tcx(bcx), tid);
-        for variant: ty::variant_info in *variants {
+        for variant: ty::variant_info in variants {
             // Perform type substitution on the raw argument types.
 
             let raw_tys: [ty::t] = variant.args;
@@ -609,7 +609,7 @@ fn dynamic_size_of(cx: @block_ctxt, t: ty::t, mode: align_mode) -> result {
         }
         let max_size_val = Load(bcx, max_size);
         let total_size =
-            if vec::len(*variants) != 1u {
+            if vec::len(variants) != 1u {
                 Add(bcx, max_size_val, llsize_of(ccx, ccx.int_type))
             } else { max_size_val };
         ret rslt(bcx, total_size);
@@ -1693,7 +1693,7 @@ fn iter_structural_ty(cx: @block_ctxt, av: ValueRef, t: ty::t,
       }
       ty::ty_tag(tid, tps) {
         let variants = ty::tag_variants(bcx_tcx(cx), tid);
-        let n_variants = vec::len(*variants);
+        let n_variants = vec::len(variants);
 
         // Cast the tags to types we can GEP into.
         if n_variants == 1u {
@@ -1715,7 +1715,7 @@ fn iter_structural_ty(cx: @block_ctxt, av: ValueRef, t: ty::t,
         let llswitch = Switch(cx, lldiscrim_a, unr_cx.llbb, n_variants);
         let next_cx = new_sub_block_ctxt(cx, "tag-iter-next");
         let i = 0u;
-        for variant: ty::variant_info in *variants {
+        for variant: ty::variant_info in variants {
             let variant_cx =
                 new_sub_block_ctxt(cx,
                                    "tag-iter-variant-" +
@@ -2340,7 +2340,7 @@ fn autoderef(cx: @block_ctxt, v: ValueRef, t: ty::t) -> result_t {
           }
           ty::ty_tag(did, tps) {
             let variants = ty::tag_variants(ccx.tcx, did);
-            if vec::len(*variants) != 1u ||
+            if vec::len(variants) != 1u ||
                    vec::len(variants[0].args) != 1u {
                 break;
             }
@@ -2714,7 +2714,7 @@ fn trans_var(cx: @block_ctxt, sp: span, def: ast::def, id: ast::node_id)
             let bcx = alloc_result.bcx;
             let lltagptr = PointerCast(bcx, lltagblob, T_ptr(lltagty));
             let lldiscrimptr = GEPi(bcx, lltagptr, [0, 0]);
-            let d = if vec::len(*ty::tag_variants(ccx.tcx, tid)) != 1u {
+            let d = if vec::len(ty::tag_variants(ccx.tcx, tid)) != 1u {
                 let lldiscrim_gv = lookup_discriminant(bcx.fcx.lcx, vid);
                 let lldiscrim = Load(bcx, lldiscrim_gv);
                 lldiscrim

trunk/src/comp/middle/trans_alt.rs

@@ -65,7 +65,7 @@ fn variant_opt(ccx: @crate_ctxt, pat_id: ast::node_id) -> opt {
     let vdef = ast_util::variant_def_ids(ccx.tcx.def_map.get(pat_id));
     let variants = ty::tag_variants(ccx.tcx, vdef.tg);
     let i = 0u;
-    for v: ty::variant_info in *variants {
+    for v: ty::variant_info in variants {
         if vdef.var == v.id { ret var(i, vdef); }
         i += 1u;
     }
@@ -265,7 +265,7 @@ fn extract_variant_args(bcx: @block_ctxt, pat_id: ast::node_id,
     let args = [];
     let size =
         vec::len(ty::tag_variant_with_id(ccx.tcx, vdefs.tg, vdefs.var).args);
-    if size > 0u && vec::len(*variants) != 1u {
+    if size > 0u && vec::len(variants) != 1u {
         let tagptr =
             PointerCast(bcx, val, trans_common::T_opaque_tag_ptr(ccx));
         blobptr = GEPi(bcx, tagptr, [0, 1]);
@@ -470,7 +470,7 @@ fn compile_submatch(bcx: @block_ctxt, m: match, vals: [ValueRef], f: mk_fail,
     if vec::len(opts) > 0u {
         alt opts[0] {
           var(_, vdef) {
-            if vec::len(*ty::tag_variants(ccx.tcx, vdef.tg)) == 1u {
+            if vec::len(ty::tag_variants(ccx.tcx, vdef.tg)) == 1u {
                 kind = single;
             } else {
                 let tagptr =