---

yaml
---
r: 54141
b: refs/heads/dist-snap
c: 74fb263
h: refs/heads/master
i:
  54139: 07be3dd
v: v3

Author: bors

[refs]

@@ -7,7 +7,7 @@ refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
 refs/heads/incoming: 44d4d6de762f3f9aae1fedcf454c66b79b3ad58d
-refs/heads/dist-snap: e1dccf9a7362d0537b92f6c642a00e3c716c7b60
+refs/heads/dist-snap: 74fb263f7a8d385635e0861593ce6d72d0e5ec10
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/RELEASES.txt

@@ -41,6 +41,9 @@ Version 0.6 (March 2013)
       * Pattern matching over vectors improved and expanded
       * `const` renamed to `static` to correspond to lifetime name,
         and make room for future `static mut` unsafe mutable globals.
+      * Replaced `#[deriving_eq]` with `#[deriving(Eq)]`
+      * `Clone` implementations can be automatically generated with
+        `#[deriving(Clone)]`
 
    * Semantic changes
       * Types with owned pointers or custom destructors move by default,

branches/dist-snap/doc/rust.md

@@ -1671,10 +1671,6 @@ vec_elems : [expr [',' expr]*] | [expr ',' ".." expr]
 A [_vector_](#vector-types) _expression_ is written by enclosing zero or
 more comma-separated expressions of uniform type in square brackets.
 
-In the `[expr ',' ".." expr]` form, the expression after the `".."`
-must be a constant expression that can be evaluated at compile time, such
-as a [literal](#literals) or a [static item](#static-items).
-
 ~~~~
 [1, 2, 3, 4];
 ["a", "b", "c", "d"];
@@ -2160,19 +2156,6 @@ do f |j| {
 }
 ~~~~
 
-In this example, both calls to the (binary) function `k` are equivalent:
-
-~~~~
-# fn k(x:int, f: &fn(int)) { }
-# fn l(i: int) { }
-
-k(3, |j| l(j));
-
-do k(3) |j| {
-   l(j);
-}
-~~~~
-
 
 ### For expressions
 
@@ -2201,7 +2184,7 @@ and early boolean-valued returns from the `block` function,
 such that the meaning of `break` and `loop` is preserved in a primitive loop
 when rewritten as a `for` loop controlled by a higher order function.
 
-An example of a for loop over the contents of a vector:
+An example a for loop:
 
 ~~~~
 # type foo = int;
@@ -2215,14 +2198,6 @@ for v.each |e| {
 }
 ~~~~
 
-An example of a for loop over a series of integers:
-
-~~~~
-# fn bar(b:uint) { }
-for uint::range(0, 256) |i| {
-    bar(i);
-}
-~~~~
 
 ### If expressions
 
@@ -2499,7 +2474,6 @@ fail_unless!(b != "world");
 
 The vector type constructor represents a homogeneous array of values of a given type.
 A vector has a fixed size.
-(Operations like `vec::push` operate solely on owned vectors.)
 A vector type can be annotated with a _definite_ size,
 written with a trailing asterisk and integer literal, such as `[int * 10]`.
 Such a definite-sized vector type is a first-class type, since its size is known statically.
@@ -2510,10 +2484,6 @@ such as `&[T]`, `@[T]` or `~[T]`.
 The kind of a vector type depends on the kind of its element type,
 as with other simple structural types.
 
-Expressions producing vectors of definite size cannot be evaluated in a
-context expecting a vector of indefinite size; one must copy the
-definite-sized vector contents into a distinct vector of indefinite size.
-
 An example of a vector type and its use:
 
 ~~~~

branches/dist-snap/src/libcore/iter.rs

@@ -284,8 +284,7 @@ pub fn build_sized_opt<A,B: Buildable<A>>(size: Option<uint>,
 
 // Functions that combine iteration and building
 
-/// Applies a function to each element of an iterable and returns the results
-/// in a sequence built via `BU`.  See also `map_to_vec`.
+/// Applies a function to each element of an iterable and returns the results.
 #[inline(always)]
 pub fn map<T,IT: BaseIter<T>,U,BU: Buildable<U>>(v: &IT, f: &fn(&T) -> U)
     -> BU {

branches/dist-snap/src/libcore/vec.rs

@@ -172,12 +172,12 @@ pub fn with_capacity<T>(capacity: uint) -> ~[T] {
 /**
  * Builds a vector by calling a provided function with an argument
  * function that pushes an element to the back of a vector.
- * This version takes an initial capacity for the vector.
+ * This version takes an initial size for the vector.
  *
  * # Arguments
  *
  * * size - An initial size of the vector to reserve
- * * builder - A function that will construct the vector. It receives
+ * * builder - A function that will construct the vector. It recieves
  *             as an argument a function that will push an element
  *             onto the vector being constructed.
  */
@@ -194,7 +194,7 @@ pub fn build_sized<A>(size: uint, builder: &fn(push: &fn(v: A))) -> ~[A] {
  *
  * # Arguments
  *
- * * builder - A function that will construct the vector. It receives
+ * * builder - A function that will construct the vector. It recieves
  *             as an argument a function that will push an element
  *             onto the vector being constructed.
  */

branches/dist-snap/src/librustc/README.txt

@@ -32,8 +32,8 @@ lib/      - bindings to LLVM
 The files concerned purely with syntax -- that is, the AST, parser,
 pretty-printer, lexer, macro expander, and utilities for traversing
 ASTs -- are in a separate crate called "syntax", whose files are in
-./../libsyntax, where . is the current directory (that is, the parent
-directory of front/, middle/, back/, and so on).
+./../libsyntax if the parent directory of front/, middle/, back/, and
+so on is . .
 
 The entry-point for the compiler is main() in driver/rustc.rs, and
 this file sequences the various parts together.

branches/dist-snap/src/librustc/middle/borrowck/gather_loans.rs

@@ -145,7 +145,7 @@ fn req_loans_in_expr(ex: @ast::expr,
 
         // make sure that the thing we are pointing out stays valid
         // for the lifetime `scope_r` of the resulting ptr:
-        let scope_r = ty_region(tcx.ty(ex));
+        let scope_r = ty_region(tcx, ex.span, tcx.ty(ex));
         self.guarantee_valid(base_cmt, mutbl, scope_r);
         visit::visit_expr(ex, self, vt);
       }
@@ -599,7 +599,8 @@ pub impl GatherLoanCtxt {
                     // find the region of the resulting pointer (note that
                     // the type of such a pattern will *always* be a
                     // region pointer)
-                    let scope_r = ty_region(self.tcx().ty(pat));
+                    let scope_r = ty_region(self.tcx(), pat.span,
+                                            self.tcx().ty(pat));
 
                     // if the scope of the region ptr turns out to be
                     // specific to this arm, wrap the categorization with

branches/dist-snap/src/librustc/middle/ty.rs

@@ -2794,13 +2794,18 @@ pub fn ty_vstore(ty: t) -> vstore {
     }
 }
 
-pub fn ty_region(ty: t) -> Region {
+pub fn ty_region(tcx: ctxt,
+                 span: span,
+                 ty: t) -> Region {
     match get(ty).sty {
-      ty_rptr(r, _) => r,
-      ty_evec(_, vstore_slice(r)) => r,
-      ty_estr(vstore_slice(r)) => r,
-      ref s => fail!(fmt!("ty_region() invoked on in appropriate ty: %?",
-          (*s)))
+        ty_rptr(r, _) => r,
+        ty_evec(_, vstore_slice(r)) => r,
+        ty_estr(vstore_slice(r)) => r,
+        ref s => {
+            tcx.sess.span_bug(
+                span,
+                fmt!("ty_region() invoked on in appropriate ty: %?", s));
+        }
     }
 }
 

branches/dist-snap/src/librustc/middle/typeck/check/regionck.rs

@@ -616,8 +616,9 @@ pub mod guarantor {
         // mk_subr should never fail.
         let rptr_ty = rcx.resolve_node_type(id);
         if !ty::type_is_error(rptr_ty) {
-            debug!("rptr_ty=%s", ty_to_str(rcx.fcx.ccx.tcx, rptr_ty));
-            let r = ty::ty_region(rptr_ty);
+            let tcx = rcx.fcx.ccx.tcx;
+            debug!("rptr_ty=%s", ty_to_str(tcx, rptr_ty));
+            let r = ty::ty_region(tcx, span, rptr_ty);
             infallibly_mk_subr(rcx, true, span, r, bound);
         }
     }
@@ -890,7 +891,7 @@ pub mod guarantor {
             ast::pat_region(p) => {
                 let rptr_ty = rcx.resolve_node_type(pat.id);
                 if !ty::type_is_error(rptr_ty) {
-                    let r = ty::ty_region(rptr_ty);
+                    let r = ty::ty_region(rcx.fcx.tcx(), pat.span, rptr_ty);
                     link_ref_bindings_in_pat(rcx, p, Some(r));
                 }
             }