---

yaml
---
r: 107647
b: refs/heads/dist-snap
c: 35e26e9
h: refs/heads/master
i:
  107645: 98f03b6
  107643: 83864a7
  107639: 61d66e8
  107631: d611af8
  107615: a90d962
  107583: 18d954d
  107519: 2d9a72c
v: v3

Author: alexcrichton

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: f64fdf524a434f0e5cd0bc91d09c144723f3c90d
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: 6516b303b5f35e81350cccdf6629766e2b0a027e
+refs/heads/dist-snap: 35e26e94d8a13ef3f24a66374aff815e370f8843
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/Makefile.in

@@ -124,12 +124,6 @@ endif
 ifdef TRACE
   CFG_RUSTC_FLAGS += -Z trace
 endif
-ifdef DISABLE_RPATH
-# NOTE: make this CFG_RUSTC_FLAGS after stage0 snapshot
-RUSTFLAGS_STAGE1 += --no-rpath
-RUSTFLAGS_STAGE2 += --no-rpath
-RUSTFLAGS_STAGE3 += --no-rpath
-endif
 
 # The executables crated during this compilation process have no need to include
 # static copies of libstd and libextra. We also generate dynamic versions of all
@@ -373,7 +367,7 @@ LLVM_COMPONENTS=x86 arm mips ipo bitreader bitwriter linker asmparser jit mcjit
                 interpreter instrumentation
 
 # Only build these LLVM tools
-LLVM_TOOLS=bugpoint llc llvm-ar llvm-as llvm-dis llvm-mc opt llvm-extract
+LLVM_TOOLS=bugpoint llc llvm-ar llvm-as llvm-dis llvm-mc opt
 
 define DEF_LLVM_VARS
 # The configure script defines these variables with the target triples
@@ -547,21 +541,8 @@ CFGFLAG$(1)_T_$(2)_H_$(3) = stage1
 endif
 endif
 
-ifdef CFG_DISABLE_RPATH
-ifeq ($$(OSTYPE_$(3)),apple-darwin)
-  RPATH_VAR$(1)_T_$(2)_H_$(3) := \
-      DYLD_LIBRARY_PATH="$$$$DYLD_LIBRARY_PATH:$$(HLIB$(1)_H_$(3))"
-else
-  RPATH_VAR$(1)_T_$(2)_H_$(3) := \
-      LD_LIBRARY_PATH="$$$$LD_LIBRARY_PATH:$$(HLIB$(1)_H_$(3))"
-endif
-else
-    RPATH_VAR$(1)_T_$(2)_H_$(3) :=
-endif
-
 STAGE$(1)_T_$(2)_H_$(3) := 						\
-	$$(Q)$$(RPATH_VAR$(1)_T_$(2)_H_$(3))                            \
-		$$(call CFG_RUN_TARG_$(3),$(1),				\
+	$$(Q)$$(call CFG_RUN_TARG_$(3),$(1),				\
 		$$(CFG_VALGRIND_COMPILE$(1)) 			\
 		$$(HBIN$(1)_H_$(3))/rustc$$(X_$(3))			\
 		--cfg $$(CFGFLAG$(1)_T_$(2)_H_$(3))			\

branches/dist-snap/configure

@@ -382,7 +382,6 @@ opt ccache 0 "invoke gcc/clang via ccache to reuse object files between builds"
 opt local-rust 0 "use an installed rustc rather than downloading a snapshot"
 opt pax-flags 0 "apply PaX flags to rustc binaries (required for GRSecurity/PaX-patched kernels)"
 opt inject-std-version 1 "inject the current compiler version of libstd into programs"
-opt rpath 1 "build rpaths into rustc itself"
 valopt prefix "/usr/local" "set installation prefix"
 valopt local-rust-root "/usr/local" "set prefix for local rust binary"
 valopt llvm-root "" "set LLVM root"

branches/dist-snap/doc/guide-container.md

@@ -336,8 +336,8 @@ The `DoubleEndedIterator` trait represents an iterator able to yield elements
 from either end of a range. It inherits from the `Iterator` trait and extends
 it with the `next_back` function.
 
-A `DoubleEndedIterator` can have its direction changed with the `rev` adaptor,
-returning another `DoubleEndedIterator` with `next` and `next_back` exchanged.
+A `DoubleEndedIterator` can be flipped with the `invert` adaptor, returning
+another `DoubleEndedIterator` with `next` and `next_back` exchanged.
 
 ~~~
 let xs = [1, 2, 3, 4, 5, 6];
@@ -347,7 +347,7 @@ println!("{:?}", it.next()); // prints `Some(&2)`
 println!("{:?}", it.next_back()); // prints `Some(&6)`
 
 // prints `5`, `4` and `3`
-for &x in it.rev() {
+for &x in it.invert() {
     println!("{}", x)
 }
 ~~~
@@ -366,7 +366,7 @@ let mut it = xs.iter().chain(ys.iter()).map(|&x| x * 2);
 println!("{:?}", it.next()); // prints `Some(2)`
 
 // prints `16`, `14`, `12`, `10`, `8`, `6`, `4`
-for x in it.rev() {
+for x in it.invert() {
     println!("{}", x);
 }
 ~~~

branches/dist-snap/doc/guide-runtime.md

@@ -202,7 +202,7 @@ Some benefits of using libgreen are:
 
 M:N threading is built upon the concept of a pool of M OS threads (which
 libgreen refers to as schedulers), able to run N Rust tasks. This abstraction is
-encompassed in libgreen's [`SchedPool`](green/struct.SchedPool.html) type. This type allows for
+encompassed in libgreen's [`SchedPool`][schedpool] type. This type allows for
 fine-grained control over the pool of schedulers which will be used to run Rust
 tasks.
 

branches/dist-snap/doc/rust.md

@@ -2865,7 +2865,7 @@ match_pat : pat [ ".." pat ] ? [ "if" expr ] ;
 A `match` expression branches on a *pattern*. The exact form of matching that
 occurs depends on the pattern. Patterns consist of some combination of
 literals, destructured enum constructors, structures, records and tuples, variable binding
-specifications, wildcards (`..`), and placeholders (`_`). A `match` expression has a *head
+specifications, wildcards (`*`), and placeholders (`_`). A `match` expression has a *head
 expression*, which is the value to compare to the patterns. The type of the
 patterns must equal the type of the head expression.
 
@@ -2887,7 +2887,7 @@ match x {
 
 The first pattern matches lists constructed by applying `Cons` to any head value, and a
 tail value of `~Nil`. The second pattern matches _any_ list constructed with `Cons`,
-ignoring the values of its arguments. The difference between `_` and `..` is that the pattern
+ignoring the values of its arguments. The difference between `_` and `*` is that the pattern
 `C(_)` is only type-correct if `C` has exactly one argument, while the pattern `C(..)` is
 type-correct for any enum variant `C`, regardless of how many arguments `C` has.
 
@@ -2939,27 +2939,6 @@ This can be changed to bind to a reference by
 using the `ref` keyword,
 or to a mutable reference using `ref mut`.
 
-Subpatterns can also be bound to variables by the use of the syntax
-`variable @ pattern`.
-For example:
-
-~~~~
-enum List { Nil, Cons(uint, ~List) }
-
-fn is_sorted(list: &List) -> bool {
-    match *list {
-        Nil | Cons(_, ~Nil) => true,
-        Cons(x, ref r @ ~Cons(y, _)) => (x <= y) && is_sorted(*r)
-    }
-}
-
-fn main() {
-    let a = Cons(6, ~Cons(7, ~Cons(42, ~Nil)));
-    assert!(is_sorted(&a));
-}
-
-~~~~
-
 Patterns can also dereference pointers by using the `&`,
 `~` or `@` symbols, as appropriate. For example, these two matches
 on `x: &int` are equivalent:

branches/dist-snap/doc/tutorial.md

@@ -520,16 +520,6 @@ to the value of the matched value inside of the arm's action. Thus, `(0.0,
 y)` matches any tuple whose first element is zero, and binds `y` to
 the second element. `(x, y)` matches any two-element tuple, and binds both
 elements to variables.
-A subpattern can also be bound to a variable, using `variable @ pattern`. For
-example:
-
-~~~~
-# let age = 23;
-match age {
-    a @ 0..20 => println!("{} years old", a),
-    _ => println!("older than 21")
-}
-~~~~
 
 Any `match` arm can have a guard clause (written `if EXPR`), called a
 *pattern guard*, which is an expression of type `bool` that
@@ -1106,7 +1096,7 @@ let y = x.clone();
 
 let z = x;
 
-// and now, it can no longer be used since it has been moved
+// and now, it can no longer be used since it has been moved from
 ~~~
 
 The mutability of a value may be changed by moving it to a new owner:

branches/dist-snap/src/etc/check-summary.py

@@ -1,7 +1,6 @@
 #!/usr/bin/env python
 # xfail-license
 
-import glob
 import sys
 
 if __name__ == '__main__':
@@ -25,8 +24,7 @@ def summarise(fname):
     def count(t):
         return sum(map(lambda (f, s): len(s.get(t, [])), summaries))
     logfiles = sys.argv[1:]
-    for files in map(glob.glob, logfiles):
-        map(summarise, files)
+    map(summarise, logfiles)
     ok = count('ok')
     failed = count('failed')
     ignored = count('ignored')

branches/dist-snap/src/libextra/bitv.rs

@@ -13,7 +13,7 @@
 
 use std::cmp;
 use std::iter::RandomAccessIterator;
-use std::iter::{Rev, Enumerate, Repeat, Map, Zip};
+use std::iter::{Invert, Enumerate, Repeat, Map, Zip};
 use std::num;
 use std::ops;
 use std::uint;
@@ -387,7 +387,7 @@ impl Bitv {
         }
     }
 
-    /// Flip all bits
+    /// Invert all bits
     #[inline]
     pub fn negate(&mut self) {
         match self.rep {
@@ -428,8 +428,8 @@ impl Bitv {
     }
 
     #[inline]
-    pub fn rev_iter<'a>(&'a self) -> Rev<Bits<'a>> {
-        self.iter().rev()
+    pub fn rev_iter<'a>(&'a self) -> Invert<Bits<'a>> {
+        self.iter().invert()
     }
 
     /// Returns `true` if all bits are 0

branches/dist-snap/src/libextra/dlist.rs

@@ -25,7 +25,7 @@
 use std::cast;
 use std::ptr;
 use std::util;
-use std::iter::Rev;
+use std::iter::Invert;
 use std::iter;
 
 use container::Deque;
@@ -368,8 +368,8 @@ impl<T> DList<T> {
 
     /// Provide a reverse iterator
     #[inline]
-    pub fn rev_iter<'a>(&'a self) -> Rev<Items<'a, T>> {
-        self.iter().rev()
+    pub fn rev_iter<'a>(&'a self) -> Invert<Items<'a, T>> {
+        self.iter().invert()
     }
 
     /// Provide a forward iterator with mutable references
@@ -388,8 +388,8 @@ impl<T> DList<T> {
     }
     /// Provide a reverse iterator with mutable references
     #[inline]
-    pub fn mut_rev_iter<'a>(&'a mut self) -> Rev<MutItems<'a, T>> {
-        self.mut_iter().rev()
+    pub fn mut_rev_iter<'a>(&'a mut self) -> Invert<MutItems<'a, T>> {
+        self.mut_iter().invert()
     }
 
 
@@ -401,8 +401,8 @@ impl<T> DList<T> {
 
     /// Consume the list into an iterator yielding elements by value, in reverse
     #[inline]
-    pub fn move_rev_iter(self) -> Rev<MoveItems<T>> {
-        self.move_iter().rev()
+    pub fn move_rev_iter(self) -> Invert<MoveItems<T>> {
+        self.move_iter().invert()
     }
 }
 

branches/dist-snap/src/libextra/ringbuf.rs

@@ -15,7 +15,7 @@
 
 use std::num;
 use std::vec;
-use std::iter::{Rev, RandomAccessIterator};
+use std::iter::{Invert, RandomAccessIterator};
 
 use container::Deque;
 
@@ -192,8 +192,8 @@ impl<T> RingBuf<T> {
     }
 
     /// Back-to-front iterator.
-    pub fn rev_iter<'a>(&'a self) -> Rev<Items<'a, T>> {
-        self.iter().rev()
+    pub fn rev_iter<'a>(&'a self) -> Invert<Items<'a, T>> {
+        self.iter().invert()
     }
 
     /// Front-to-back iterator which returns mutable values.
@@ -223,8 +223,8 @@ impl<T> RingBuf<T> {
     }
 
     /// Back-to-front iterator which returns mutable values.
-    pub fn mut_rev_iter<'a>(&'a mut self) -> Rev<MutItems<'a, T>> {
-        self.mut_iter().rev()
+    pub fn mut_rev_iter<'a>(&'a mut self) -> Invert<MutItems<'a, T>> {
+        self.mut_iter().invert()
     }
 }
 

branches/dist-snap/src/libextra/smallintmap.rs

@@ -15,7 +15,7 @@
 
 #[allow(missing_doc)];
 
-use std::iter::{Enumerate, FilterMap, Rev};
+use std::iter::{Enumerate, FilterMap, Invert};
 use std::util::replace;
 use std::vec;
 
@@ -140,14 +140,14 @@ impl<V> SmallIntMap<V> {
     /// An iterator visiting all key-value pairs in descending order by the keys.
     /// Iterator element type is (uint, &'r V)
     pub fn rev_iter<'r>(&'r self) -> RevEntries<'r, V> {
-        self.iter().rev()
+        self.iter().invert()
     }
 
     /// An iterator visiting all key-value pairs in descending order by the keys,
     /// with mutable references to the values
     /// Iterator element type is (uint, &'r mut V)
     pub fn mut_rev_iter<'r>(&'r mut self) -> RevMutEntries <'r, V> {
-        self.mut_iter().rev()
+        self.mut_iter().invert()
     }
 
     /// Empties the hash map, moving all values into the specified closure
@@ -241,7 +241,7 @@ pub struct Entries<'a, T> {
 
 iterator!(impl Entries -> (uint, &'a T), get_ref)
 double_ended_iterator!(impl Entries -> (uint, &'a T), get_ref)
-pub type RevEntries<'a, T> = Rev<Entries<'a, T>>;
+pub type RevEntries<'a, T> = Invert<Entries<'a, T>>;
 
 pub struct MutEntries<'a, T> {
     priv front: uint,
@@ -251,7 +251,7 @@ pub struct MutEntries<'a, T> {
 
 iterator!(impl MutEntries -> (uint, &'a mut T), get_mut_ref)
 double_ended_iterator!(impl MutEntries -> (uint, &'a mut T), get_mut_ref)
-pub type RevMutEntries<'a, T> = Rev<MutEntries<'a, T>>;
+pub type RevMutEntries<'a, T> = Invert<MutEntries<'a, T>>;
 
 #[cfg(test)]
 mod test_map {