---

yaml
---
r: 61423
b: refs/heads/try
c: af54d58
h: refs/heads/master
i:
  61421: 0696f09
  61419: 16468cb
  61415: 33f8c36
  61407: dd7e0ae
v: v3

Author: emberian

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 2d28d645422c1617be58c8ca7ad9a457264ca850
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 2d28d645422c1617be58c8ca7ad9a457264ca850
-refs/heads/try: a289dcd18719018ca7051dc03d4a711993008eb2
+refs/heads/try: af54d58891505a67aaab5365b957679b0c593eb7
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/src/libcore/vec.rs

@@ -1445,6 +1445,46 @@ pub fn reverse<T>(v: &mut [T]) {
     }
 }
 
+/**
+ * Reverse part of a vector in place.
+ *
+ * Reverse the elements in the vector between `start` and `end - 1`.
+ *
+ * If either start or end do not represent valid positions in the vector, the
+ * vector is returned unchanged.
+ *
+ * # Arguments
+ *
+ * * `v` - The mutable vector to be modified
+ *
+ * * `start` - Index of the first element of the slice
+ *
+ * * `end` - Index one past the final element to be reversed.
+ *
+ * # Example
+ *
+ * Assume a mutable vector `v` contains `[1,2,3,4,5]`. After the call:
+ *
+ * ~~~
+ *
+ * reverse_part(v, 1, 4);
+ *
+ * ~~~
+ *
+ * `v` now contains `[1,4,3,2,5]`.
+ */
+pub fn reverse_part<T>(v: &mut [T], start: uint, end : uint) {
+    let sz = v.len();
+    if start >= sz || end > sz { return; }
+    let mut i = start;
+    let mut j = end - 1;
+    while i < j {
+        vec::swap(v, i, j);
+        i += 1;
+        j -= 1;
+    }
+}
+
 /// Returns a vector with the order of elements reversed
 pub fn reversed<T:Copy>(v: &const [T]) -> ~[T] {
     let mut rs: ~[T] = ~[];
@@ -1739,29 +1779,49 @@ pub fn each2_mut<U, T>(v1: &mut [U], v2: &mut [T], f: &fn(u: &mut U, t: &mut T)
  *
  * The total number of permutations produced is `len(v)!`.  If `v` contains
  * repeated elements, then some permutations are repeated.
+ *
+ * See [Algorithms to generate
+ * permutations](http://en.wikipedia.org/wiki/Permutation).
+ *
+ *  # Arguments
+ *
+ *  * `values` - A vector of values from which the permutations are
+ *  chosen
+ *
+ *  * `fun` - The function to iterate over the combinations
  */
-#[cfg(not(stage0))]
-pub fn each_permutation<T:Copy>(v: &[T], put: &fn(ts: &[T]) -> bool) -> bool {
-    let ln = len(v);
-    if ln <= 1 {
-        put(v);
-    } else {
-        // This does not seem like the most efficient implementation.  You
-        // could make far fewer copies if you put your mind to it.
-        let mut i = 0u;
-        while i < ln {
-            let elt = v[i];
-            let mut rest = slice(v, 0u, i).to_vec();
-            rest.push_all(const_slice(v, i+1u, ln));
-            for each_permutation(rest) |permutation| {
-                if !put(append(~[elt], permutation)) {
-                    return false;
-                }
-            }
-            i += 1u;
+pub fn each_permutation<T:Copy>(values: &[T], fun: &fn(perm : &[T]) -> bool) -> bool {
+    let length = values.len();
+    let mut permutation = vec::from_fn(length, |i| values[i]);
+    if length <= 1 {
+        fun(permutation);
+        return true;
+    }
+    let mut indices = vec::from_fn(length, |i| i);
+    loop {
+        if !fun(permutation) { return true; }
+        // find largest k such that indices[k] < indices[k+1]
+        // if no such k exists, all permutations have been generated
+        let mut k = length - 2;
+        while k > 0 && indices[k] >= indices[k+1] {
+            k -= 1;
+        }
+        if k == 0 && indices[0] > indices[1] { return true; }
+        // find largest l such that indices[k] < indices[l]
+        // k+1 is guaranteed to be such
+        let mut l = length - 1;
+        while indices[k] >= indices[l] {
+            l -= 1;
+        }
+        // swap indices[k] and indices[l]; sort indices[k+1..]
+        // (they're just reversed)
+        vec::swap(indices, k, l);
+        reverse_part(indices, k+1, length);
+        // fixup permutation based on indices
+        for uint::range(k, length) |i| {
+            permutation[i] = values[indices[i]];
         }
     }
-    return true;
 }
 
 /**
@@ -4730,6 +4790,53 @@ mod tests {
         }
     }
 
+    #[test]
+    fn test_reverse_part() {
+        let mut values = [1,2,3,4,5];
+        reverse_part(values,1,4);
+        assert_eq!(values, [1,4,3,2,5]);
+    }
+
+    #[test]
+    fn test_permutations0() {
+        let values = [];
+        let mut v : ~[~[int]] = ~[];
+        for each_permutation(values) |p| {
+            v.push(p.to_owned());
+        }
+        assert_eq!(v, ~[~[]]);
+    }
+
+    #[test]
+    fn test_permutations1() {
+        let values = [1];
+        let mut v : ~[~[int]] = ~[];
+        for each_permutation(values) |p| {
+            v.push(p.to_owned());
+        }
+        assert_eq!(v, ~[~[1]]);
+    }
+
+    #[test]
+    fn test_permutations2() {
+        let values = [1,2];
+        let mut v : ~[~[int]] = ~[];
+        for each_permutation(values) |p| {
+            v.push(p.to_owned());
+        }
+        assert_eq!(v, ~[~[1,2],~[2,1]]);
+    }
+
+    #[test]
+    fn test_permutations3() {
+        let values = [1,2,3];
+        let mut v : ~[~[int]] = ~[];
+        for each_permutation(values) |p| {
+            v.push(p.to_owned());
+        }
+        assert_eq!(v, ~[~[1,2,3],~[1,3,2],~[2,1,3],~[2,3,1],~[3,1,2],~[3,2,1]]);
+    }
+
     #[test]
     fn test_each_val() {
         use old_iter::CopyableNonstrictIter;

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

@@ -1566,7 +1566,6 @@ pub mod llvm {
         /* Atomic Operations */
         pub unsafe fn LLVMBuildAtomicLoad(B: BuilderRef,
                                           PointerVal: ValueRef,
-                                          Name: *c_char,
                                           Order: AtomicOrdering)
                                        -> ValueRef;
 

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

@@ -234,13 +234,14 @@ pub fn get_field_type(tcx: ty::ctxt, class_id: ast::def_id,
     }
 }
 
-// Given a def_id for an impl, return the trait it implements,
-// if there is one.
-pub fn get_impl_trait(tcx: ty::ctxt,
-                      def: ast::def_id) -> Option<@ty::TraitRef> {
+// Given a def_id for an impl or class, return the traits it implements,
+// or the empty vector if it's not for an impl or for a class that implements
+// traits
+pub fn get_impl_traits(tcx: ty::ctxt,
+                       def: ast::def_id) -> ~[@ty::TraitRef] {
     let cstore = tcx.cstore;
     let cdata = cstore::get_crate_data(cstore, def.crate);
-    decoder::get_impl_trait(cdata, def.node, tcx)
+    decoder::get_impl_traits(cdata, def.node, tcx)
 }
 
 pub fn get_impl_method(cstore: @mut cstore::CStore,

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

@@ -415,20 +415,19 @@ pub fn get_type_param_count(data: @~[u8], id: ast::node_id) -> uint {
     item_ty_param_count(lookup_item(id, data))
 }
 
-pub fn get_impl_trait(cdata: cmd,
+pub fn get_impl_traits(cdata: cmd,
                        id: ast::node_id,
-                       tcx: ty::ctxt) -> Option<@ty::TraitRef>
+                       tcx: ty::ctxt) -> ~[@ty::TraitRef]
 {
     let item_doc = lookup_item(id, cdata.data);
-    let mut result = None;
+    let mut results = ~[];
     for reader::tagged_docs(item_doc, tag_item_trait_ref) |tp| {
         let trait_ref =
             @parse_trait_ref_data(tp.data, cdata.cnum, tp.start, tcx,
                                   |_, did| translate_def_id(cdata, did));
-        result = Some(trait_ref);
-        break;
+        results.push(trait_ref);
     };
-    result
+    results
 }
 
 pub fn get_impl_method(intr: @ident_interner, cdata: cmd, id: ast::node_id,

branches/try/src/librustc/middle/trans/base.rs

@@ -2228,7 +2228,8 @@ pub fn register_fn_fuller(ccx: @CrateContext,
         mangle_exported_name(ccx, /*bad*/copy path, node_type)
     };
 
-    let llfn: ValueRef = decl_fn(ccx.llmod, ps, cc, llfty);
+    // XXX: Bad copy.
+    let llfn: ValueRef = decl_fn(ccx.llmod, copy ps, cc, llfty);
     ccx.item_symbols.insert(node_id, ps);
 
     // FIXME #4404 android JNI hacks

branches/try/src/librustc/middle/trans/build.rs

@@ -544,7 +544,7 @@ pub fn AtomicLoad(cx: block, PointerVal: ValueRef, order: AtomicOrdering) -> Val
             return llvm::LLVMGetUndef(ccx.int_type);
         }
         count_insn(cx, "load.atomic");
-        return llvm::LLVMBuildAtomicLoad(B(cx), PointerVal, noname(), order);
+        return llvm::LLVMBuildAtomicLoad(B(cx), PointerVal, order);
     }
 }
 

branches/try/src/librustc/middle/trans/datum.rs

@@ -101,6 +101,7 @@ use middle::ty;
 use util::common::indenter;
 use util::ppaux::ty_to_str;
 
+use core::container::Set; // XXX: this should not be necessary
 use core::to_bytes;
 use syntax::ast;
 use syntax::codemap::span;

branches/try/src/librustc/middle/trans/meth.rs

@@ -795,11 +795,8 @@ pub fn make_impl_vtable(ccx: @CrateContext,
     let _icx = ccx.insn_ctxt("impl::make_impl_vtable");
     let tcx = ccx.tcx;
 
-    let trt_id = match ty::impl_trait_ref(tcx, impl_id) {
-        Some(t_id) => t_id.def_id,
-        None       => ccx.sess.bug("make_impl_vtable: don't know how to \
-                                    make a vtable for a type impl!")
-    };
+    // XXX: This should support multiple traits.
+    let trt_id = ty::impl_trait_refs(tcx, impl_id)[0].def_id;
 
     let has_tps =
         !ty::lookup_item_type(ccx.tcx, impl_id).generics.type_param_defs.is_empty();

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

@@ -3883,23 +3883,23 @@ pub fn trait_method_def_ids(cx: ctxt, id: ast::def_id) -> @~[def_id] {
         || @csearch::get_trait_method_def_ids(cx.cstore, id))
 }
 
-pub fn impl_trait_ref(cx: ctxt, id: ast::def_id) -> Option<@TraitRef> {
+pub fn impl_trait_refs(cx: ctxt, id: ast::def_id) -> ~[@TraitRef] {
     if id.crate == ast::local_crate {
-        debug!("(impl_trait_ref) searching for trait impl %?", id);
+        debug!("(impl_traits) searching for trait impl %?", id);
         match cx.items.find(&id.node) {
            Some(&ast_map::node_item(@ast::item {
                         node: ast::item_impl(_, opt_trait, _, _),
                         _},
                     _)) => {
                match opt_trait {
-                   Some(t) => Some(ty::node_id_to_trait_ref(cx, t.ref_id)),
-                   None => None
+                   Some(t) => ~[ty::node_id_to_trait_ref(cx, t.ref_id)],
+                   None => ~[]
                }
            }
-           _ => None
+           _ => ~[]
         }
     } else {
-        csearch::get_impl_trait(cx, id)
+        csearch::get_impl_traits(cx, id)
     }
 }
 

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

@@ -261,14 +261,24 @@ fn lookup_vtable(vcx: &VtableContext,
                         }
                         impls_seen.insert(im.did);
 
-                        // ty::impl_traits gives us the trait im implements,
-                        // if there is one (there's either zero or one).
+                        // ty::impl_traits gives us the list of all
+                        // traits that im implements. Again, usually
+                        // there's just one.
                         //
-                        // If foo implements a trait t, and if t is the
-                        // same trait as trait_ref, we need to
+                        // For example, if im represented the struct
+                        // in:
+                        //
+                        //   struct foo : baz<int>, bar, quux { ... }
+                        //
+                        // then ty::impl_traits would return
+                        //
+                        //   ~[baz<int>, bar, quux]
+                        //
+                        // For each of the traits foo implements, if
+                        // it's the same trait as trait_ref, we need to
                         // unify it with trait_ref in order to get all
                         // the ty vars sorted out.
-                        for ty::impl_trait_ref(tcx, im.did).each |&of_trait_ref|
+                        for ty::impl_trait_refs(tcx, im.did).each |&of_trait_ref|
                         {
                             if of_trait_ref.def_id != trait_ref.def_id { loop; }
 
@@ -446,12 +456,8 @@ fn connect_trait_tps(vcx: &VtableContext,
 {
     let tcx = vcx.tcx();
 
-    let impl_trait_ref = match ty::impl_trait_ref(tcx, impl_did) {
-        Some(t) => t,
-        None => vcx.tcx().sess.span_bug(location_info.span,
-                                  "connect_trait_tps invoked on a type impl")
-    };
-
+    // XXX: This should work for multiple traits.
+    let impl_trait_ref = ty::impl_trait_refs(tcx, impl_did)[0];
     let impl_trait_ref = (*impl_trait_ref).subst(tcx, impl_substs);
     relate_trait_refs(vcx, location_info, &impl_trait_ref, trait_ref);
 }

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

@@ -16,7 +16,7 @@
 
 
 use driver;
-use metadata::csearch::{each_path, get_impl_trait};
+use metadata::csearch::{each_path, get_impl_traits};
 use metadata::csearch::{get_impls_for_mod};
 use metadata::csearch;
 use metadata::cstore::{CStore, iter_crate_data};
@@ -898,13 +898,13 @@ pub impl CoherenceChecker {
 
             let self_type = lookup_item_type(self.crate_context.tcx,
                                              implementation.did);
-            let associated_traits = get_impl_trait(self.crate_context.tcx,
+            let associated_traits = get_impl_traits(self.crate_context.tcx,
                                                     implementation.did);
 
             // Do a sanity check to make sure that inherent methods have base
             // types.
 
-            if associated_traits.is_none() {
+            if associated_traits.len() == 0 {
                 match get_base_type_def_id(self.inference_context,
                                            dummy_sp(),
                                            self_type.ty) {
@@ -940,7 +940,7 @@ pub impl CoherenceChecker {
                 Some(base_type_def_id) => {
                     // inherent methods apply to `impl Type` but not
                     // `impl Trait for Type`:
-                    if associated_traits.is_none() {
+                    if associated_traits.len() == 0 {
                         self.add_inherent_method(base_type_def_id,
                                                  *implementation);
                     }

branches/try/src/rustllvm/RustWrapper.cpp

@@ -553,7 +553,7 @@ extern "C" LLVMValueRef LLVMBuildAtomicLoad(LLVMBuilderRef B,
     li->setVolatile(true);
     li->setAtomic(order);
     li->setAlignment(sizeof(intptr_t));
-    return wrap(unwrap(B)->Insert(li, Name));
+    return wrap(unwrap(B)->Insert(li));
 }
 
 extern "C" LLVMValueRef LLVMBuildAtomicStore(LLVMBuilderRef B,