---

yaml
---
r: 140905
b: refs/heads/try2
c: c2baaa8
h: refs/heads/master
i:
  140903: 4622018
v: v3

Author: emberian

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 77c98f081509733af957af6ed7b0b277e5f57871
+refs/heads/try2: c2baaa8d8432c8d7320e928e7ad706f225430bb3
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/libcore/iter.rs

@@ -43,8 +43,6 @@ much easier to implement.
 #[cfg(not(stage0))] use cmp::Ord;
 #[cfg(not(stage0))] use option::{Option, Some, None};
 #[cfg(not(stage0))] use vec::OwnedVector;
-#[cfg(not(stage0))] use num::{One, Zero};
-#[cfg(not(stage0))] use ops::{Add, Mul};
 
 #[cfg(stage0)]
 pub trait Times {
@@ -214,81 +212,6 @@ pub fn min<T: Ord>(iter: &fn(f: &fn(T) -> bool) -> bool) -> Option<T> {
     result
 }
 
-/**
- * Reduce an iterator to an accumulated value.
- *
- * # Example:
- *
- * ~~~~
- * assert_eq!(fold(0i, |f| int::range(1, 5, f), |a, x| *a += x), 10);
- * ~~~~
- */
-#[cfg(not(stage0))]
-#[inline]
-pub fn fold<T, U>(start: T, iter: &fn(f: &fn(U) -> bool) -> bool, f: &fn(&mut T, U)) -> T {
-    let mut result = start;
-    for iter |x| {
-        f(&mut result, x);
-    }
-    result
-}
-
-/**
- * Reduce an iterator to an accumulated value.
- *
- * `fold_ref` is usable in some generic functions where `fold` is too lenient to type-check, but it
- * forces the iterator to yield borrowed pointers.
- *
- * # Example:
- *
- * ~~~~
- * fn product<T: One + Mul<T, T>>(iter: &fn(f: &fn(&T) -> bool) -> bool) -> T {
- *     fold_ref(One::one::<T>(), iter, |a, x| *a = a.mul(x))
- * }
- * ~~~~
- */
-#[cfg(not(stage0))]
-#[inline]
-pub fn fold_ref<T, U>(start: T, iter: &fn(f: &fn(&U) -> bool) -> bool, f: &fn(&mut T, &U)) -> T {
-    let mut result = start;
-    for iter |x| {
-        f(&mut result, x);
-    }
-    result
-}
-
-/**
- * Return the sum of the items yielding by an iterator.
- *
- * # Example:
- *
- * ~~~~
- * let xs: ~[int] = ~[1, 2, 3, 4];
- * assert_eq!(do sum |f| { xs.each(f) }, 10);
- * ~~~~
- */
-#[cfg(not(stage0))]
-#[inline(always)]
-pub fn sum<T: Zero + Add<T, T>>(iter: &fn(f: &fn(&T) -> bool) -> bool) -> T {
-    fold_ref(Zero::zero::<T>(), iter, |a, x| *a = a.add(x))
-}
-
-/**
- * Return the product of the items yielded by an iterator.
- *
- * # Example:
- *
- * ~~~~
- * let xs: ~[int] = ~[1, 2, 3, 4];
- * assert_eq!(do product |f| { xs.each(f) }, 24);
- * ~~~~
- */
-#[cfg(not(stage0))]
-#[inline(always)]
-pub fn product<T: One + Mul<T, T>>(iter: &fn(f: &fn(&T) -> bool) -> bool) -> T {
-    fold_ref(One::one::<T>(), iter, |a, x| *a = a.mul(x))
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -331,33 +254,4 @@ mod tests {
         let xs = ~[8, 2, 3, 1, -5, 9, 11, 15];
         assert_eq!(min(|f| xs.each(f)).unwrap(), &-5);
     }
-
-    #[test]
-    fn test_fold() {
-        assert_eq!(fold(0i, |f| int::range(1, 5, f), |a, x| *a += x), 10);
-    }
-
-    #[test]
-    fn test_sum() {
-        let xs: ~[int] = ~[1, 2, 3, 4];
-        assert_eq!(do sum |f| { xs.each(f) }, 10);
-    }
-
-    #[test]
-    fn test_empty_sum() {
-        let xs: ~[int] = ~[];
-        assert_eq!(do sum |f| { xs.each(f) }, 0);
-    }
-
-    #[test]
-    fn test_product() {
-        let xs: ~[int] = ~[1, 2, 3, 4];
-        assert_eq!(do product |f| { xs.each(f) }, 24);
-    }
-
-    #[test]
-    fn test_empty_product() {
-        let xs: ~[int] = ~[];
-        assert_eq!(do product |f| { xs.each(f) }, 1);
-    }
 }

branches/try2/src/libcore/rt/stack.rs

@@ -31,9 +31,7 @@ pub impl StackSegment {
 
     /// Point one word beyond the high end of the allocated stack
     fn end(&self) -> *uint {
-        unsafe {
-            vec::raw::to_ptr(self.buf).offset(self.buf.len()) as *uint
-        }
+        vec::raw::to_ptr(self.buf).offset(self.buf.len()) as *uint
     }
 }
 

branches/try2/src/libcore/rt/uv/mod.rs

@@ -362,7 +362,7 @@ pub type Buf = uvll::uv_buf_t;
 
 /// Borrow a slice to a Buf
 pub fn slice_to_uv_buf(v: &[u8]) -> Buf {
-    let data = unsafe { vec::raw::to_ptr(v) };
+    let data = vec::raw::to_ptr(v);
     unsafe { uvll::buf_init(data, v.len()) }
 }
 

branches/try2/src/libcore/vec.rs

@@ -1445,46 +1445,6 @@ 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] = ~[];
@@ -1779,49 +1739,29 @@ 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
  */
-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]];
+#[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;
         }
     }
+    return true;
 }
 
 /**
@@ -4790,53 +4730,6 @@ 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/try2/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/try2/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/try2/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/try2/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;