---

yaml
---
r: 50171
b: refs/heads/auto
c: 441313f
h: refs/heads/master
i:
  50169: 4d56a3b
  50167: 2b76acb
v: v3

Author: luqmana

[refs]

@@ -14,5 +14,5 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: a919e5ede5465cfab27cdc7cae59f2c015735753
+refs/heads/auto: 441313fc0ca635be18d1175e7dc265ab9ffa9d7d
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167

branches/auto/src/librustc/metadata/cstore.rs

@@ -141,28 +141,24 @@ pub fn find_extern_mod_stmt_cnum(cstore: @mut CStore,
     extern_mod_crate_map.find(&emod_id)
 }
 
-// returns hashes of crates directly used by this crate. Hashes are sorted by
-// (crate name, crate version, crate hash) in lexicographic order (not semver)
+// returns hashes of crates directly used by this crate. Hashes are
+// sorted by crate name.
 pub fn get_dep_hashes(cstore: @mut CStore) -> ~[~str] {
-    struct crate_hash { name: @~str, vers: @~str, hash: @~str }
+    struct crate_hash { name: @~str, hash: @~str }
     let mut result = ~[];
 
     let extern_mod_crate_map = cstore.extern_mod_crate_map;
     for extern_mod_crate_map.each_value |&cnum| {
         let cdata = cstore::get_crate_data(cstore, cnum);
         let hash = decoder::get_crate_hash(cdata.data);
-        let vers = decoder::get_crate_vers(cdata.data);
-        debug!("Add hash[%s]: %s %s", *cdata.name, *vers, *hash);
+        debug!("Add hash[%s]: %s", *cdata.name, *hash);
         result.push(crate_hash {
             name: cdata.name,
-            vers: vers,
             hash: hash
         });
     }
 
-    let sorted = do std::sort::merge_sort(result) |a, b| {
-        (a.name, a.vers, a.hash) <= (b.name, b.vers, b.hash)
-    };
+    let sorted = std::sort::merge_sort(result, |a, b| a.name <= b.name);
 
     debug!("sorted:");
     for sorted.each |x| {

branches/auto/src/librustc/middle/resolve.rs

@@ -4741,8 +4741,8 @@ pub impl Resolver {
         let mut j = this.value_ribs.len();
         while j != 0 {
             j -= 1;
-            for this.value_ribs[j].bindings.each_key |&k| {
-                vec::push(&mut maybes, copy *this.session.str_of(k));
+            for this.value_ribs[j].bindings.each_entry |e| {
+                vec::push(&mut maybes, copy *this.session.str_of(e.key));
                 vec::push(&mut values, uint::max_value);
             }
         }

branches/auto/src/librustc/middle/trans/tvec.rs

@@ -27,6 +27,7 @@ use middle::ty;
 use util::common::indenter;
 use util::ppaux::ty_to_str;
 
+use core::option::None;
 use core::uint;
 use core::vec;
 use syntax::ast;
@@ -413,30 +414,54 @@ pub fn write_content(bcx: block,
                         return bcx;
                     }
 
-                    let tmpdatum = unpack_datum!(bcx, {
+                    let elem = unpack_datum!(bcx, {
                         expr::trans_to_datum(bcx, element)
                     });
 
-                    let mut temp_cleanups = ~[];
+                    let next_bcx = sub_block(bcx, ~"expr_repeat: while next");
+                    let loop_bcx = loop_scope_block(bcx, next_bcx, None, ~"expr_repeat", None);
+                    let cond_bcx = scope_block(loop_bcx, None, ~"expr_repeat: loop cond");
+                    let set_bcx = scope_block(loop_bcx, None, ~"expr_repeat: body: set");
+                    let inc_bcx = scope_block(loop_bcx, None, ~"expr_repeat: body: inc");
+                    Br(bcx, loop_bcx.llbb);
 
-                    for uint::range(0, count) |i| {
-                        let lleltptr = GEPi(bcx, lldest, [i]);
-                        if i < count - 1 {
-                            // Copy all but the last one in.
-                            bcx = tmpdatum.copy_to(bcx, INIT, lleltptr);
-                        } else {
-                            // Move the last one in.
-                            bcx = tmpdatum.move_to(bcx, INIT, lleltptr);
-                        }
-                        add_clean_temp_mem(bcx, lleltptr, vt.unit_ty);
-                        temp_cleanups.push(lleltptr);
+                    let loop_counter = {
+                        // i = 0
+                        let i = alloca(loop_bcx, T_i64());
+                        Store(loop_bcx, C_i64(0), i);
+
+                        Br(loop_bcx, cond_bcx.llbb);
+                        i
+                    };
+
+                    { // i < count
+                        let lhs = Load(cond_bcx, loop_counter);
+                        let rhs = C_integral(T_i64(), count as u64, lib::llvm::False);
+                        let cmp_lr = ICmp(cond_bcx, lib::llvm::IntULT, lhs, rhs);
+                        let zext = ZExt(cond_bcx, cmp_lr, T_i8());
+                        let cond_val = ICmp(cond_bcx, lib::llvm::IntNE, zext, C_u8(0));
+
+                        CondBr(cond_bcx, cond_val, set_bcx.llbb, next_bcx.llbb);
                     }
 
-                    for vec::each(temp_cleanups) |cleanup| {
-                        revoke_clean(bcx, *cleanup);
+                    { // v[i] = elem
+                        let i = Load(set_bcx, loop_counter);
+                        let lleltptr = InBoundsGEP(set_bcx, lldest, [i]);
+                        let set_bcx = elem.copy_to(set_bcx, INIT, lleltptr);
+
+                        Br(set_bcx, inc_bcx.llbb);
                     }
 
-                    return bcx;
+                    { // i += 1
+                        let i = Load(inc_bcx, loop_counter);
+                        let plusone = Add(inc_bcx, i, C_i64(1));
+                        Store(inc_bcx, plusone, loop_counter);
+
+                        Br(inc_bcx, cond_bcx.llbb);
+                    }
+
+                    return next_bcx;
+
                 }
             }
         }

branches/auto/src/librustc/middle/typeck/coherence.rs

@@ -104,6 +104,32 @@ pub fn get_base_type(inference_context: @mut InferCtxt,
     }
 }
 
+pub fn type_is_defined_in_local_crate(original_type: t) -> bool {
+    /*!
+     *
+     * For coherence, when we have `impl Trait for Type`, we need to
+     * guarantee that `Type` is "local" to the
+     * crate.  For our purposes, this means that it must contain
+     * some nominal type defined in this crate.
+     */
+
+    let mut found_nominal = false;
+    do ty::walk_ty(original_type) |t| {
+        match get(t).sty {
+            ty_enum(def_id, _) |
+            ty_trait(def_id, _, _) |
+            ty_struct(def_id, _) => {
+                if def_id.crate == ast::local_crate {
+                    found_nominal = true;
+                }
+            }
+
+            _ => { }
+        }
+    }
+    return found_nominal;
+}
+
 // Returns the def ID of the base type, if there is one.
 pub fn get_base_type_def_id(inference_context: @mut InferCtxt,
                             span: span,
@@ -161,8 +187,7 @@ pub fn CoherenceChecker(crate_context: @mut CrateCtxt) -> CoherenceChecker {
         crate_context: crate_context,
         inference_context: new_infer_ctxt(crate_context.tcx),
 
-        base_type_def_ids: HashMap(),
-        privileged_implementations: HashMap()
+        base_type_def_ids: HashMap()
     }
 }
 
@@ -174,11 +199,6 @@ pub struct CoherenceChecker {
     // definition ID.
 
     base_type_def_ids: HashMap<def_id,def_id>,
-
-    // A set of implementations in privileged scopes; i.e. those
-    // implementations that are defined in the same scope as their base types.
-
-    privileged_implementations: HashMap<node_id,()>,
 }
 
 pub impl CoherenceChecker {
@@ -615,27 +635,11 @@ pub impl CoherenceChecker {
                         visit_mod(module_, item.span, item.id, (), visitor);
                     }
                     item_impl(_, opt_trait, _, _) => {
-                        let mut ok = false;
-                        match self.base_type_def_ids.find(
-                            &local_def(item.id)) {
-
-                            None => {
-                                // Nothing to do.
-                            }
-                            Some(base_type_def_id) => {
-                                // Check to see whether the implementation is
-                                // in the same crate as its base type.
-
-                                if base_type_def_id.crate == local_crate {
-                                    // Record that this implementation is OK.
-                                    self.privileged_implementations.insert
-                                        (item.id, ());
-                                    ok = true;
-                                }
-                            }
-                        }
-
-                        if !ok {
+                        // `for_ty` is `Type` in `impl Trait for Type`
+                        let for_ty =
+                            ty::node_id_to_type(self.crate_context.tcx,
+                                                item.id);
+                        if !type_is_defined_in_local_crate(for_ty) {
                             // This implementation is not in scope of its base
                             // type. This still might be OK if the trait is
                             // defined in the same crate.
@@ -655,25 +659,24 @@ pub impl CoherenceChecker {
                                                       implement a trait or \
                                                       new type instead");
                                 }
-                                _ => ()
-                          }
 
-                          for opt_trait.each |trait_ref| {
-                                // This is OK if and only if the trait was
-                                // defined in this crate.
-
-                                let trait_def_id =
-                                    self.trait_ref_to_trait_def_id(
-                                        *trait_ref);
-
-                                if trait_def_id.crate != local_crate {
-                                    let session = self.crate_context.tcx.sess;
-                                    session.span_err(item.span,
-                                                     ~"cannot provide an \
-                                                       extension \
-                                                       implementation for a \
-                                                       trait not defined in \
-                                                       this crate");
+                                Some(trait_ref) => {
+                                    // This is OK if and only if the trait was
+                                    // defined in this crate.
+
+                                    let trait_def_id =
+                                        self.trait_ref_to_trait_def_id(
+                                            trait_ref);
+
+                                    if trait_def_id.crate != local_crate {
+                                        let session = self.crate_context.tcx.sess;
+                                        session.span_err(item.span,
+                                                         ~"cannot provide an \
+                                                           extension \
+                                                           implementation for a \
+                                                           trait not defined in \
+                                                           this crate");
+                                    }
                                 }
                             }
                         }