---

yaml
---
r: 51579
b: refs/heads/incoming
c: d049bf2
h: refs/heads/master
i:
  51577: 79cb15b
  51575: 41ccfc2
v: v3

Author: catamorphism

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: 8eb2bab100b42f0ba751552d8eff00eb2134c55a
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/incoming: b6f9aa1fd75f0e9468b3bb9ee10a95d18c40b567
+refs/heads/incoming: d049bf249253230b6312400b8a919af0c14204c4
 refs/heads/dist-snap: 8b98e5a296d95c5e832db0756828e5bec31c6f50
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/incoming/RELEASES.txt

@@ -6,15 +6,16 @@ Version 0.6 (March 2013)
    * TODO:
       * Ord/Cmp
       * Lifetime changes
-      * Implicit self
       * Remove `static` keyword
       * Static method syntax
       * `as Trait`
       * `copy` removed, replaced with `Clone`?
-      * `std::map` removed, replaced with `core::hashmap`
+      * More details for "Name resolution continues to be tweaked"?
 
    * Syntax changes
       * The self type parameter in traits is now spelled `Self`
+      * The `self` parameter in trait and impl methods must now be explicitly
+        named (for example: `fn f(&self) { }`). Implicit self is deprecated.
       * Replaced the `Durable` trait with the `'static` lifetime
       * The old closure type syntax with the trailing sigil has been
         removed in favor of the more consistent leading sigil
@@ -23,7 +24,7 @@ Version 0.6 (March 2013)
       * Traits are implemented with `impl Trait for Type`
         instead of `impl Type: Trait`
       * The `export` keyword has finally been removed
-      * The `move` keyword has been removed (linear types move by default)
+      * The `move` keyword has been removed (see "Semantic changes")
       * The interior mutability qualifier on vectors, `[mut T]`, has been
         removed. Use `&mut [T]`, etc.
       * `mut` is no longer valid in `~mut T`. Use inherited mutability
@@ -37,6 +38,7 @@ Version 0.6 (March 2013)
         function modules. Use extern blocks: `extern { ... }`
       * Newtype enums removed. Used tuple-structs.
       * Trait implementations no longer support visibility modifiers
+      * Pattern matching over vectors improved and expanded
 
    * Semantic changes
       * Types with owned pointers or custom destructors move by default,
@@ -49,12 +51,9 @@ Version 0.6 (March 2013)
       * The default type of an inferred closure is &fn instead of @fn
       * Name resolution continues to be tweaked
       * Method visibility is inherited from the implementation declaration
-
-   * Other language changes
       * Structural records have been removed
-      * Many more types can be used in constants, including enums
+      * Many more types can be used in constants, including enums,
         `static lifetime pointers and vectors
-      * Pattern matching over vectors improved and expanded
       * Typechecking of closure types has been overhauled to
         improve inference and eliminate unsoundness
 
@@ -68,6 +67,7 @@ Version 0.6 (March 2013)
       * Containers reorganized around traits in `core::container`
       * `core::dvec` removed, `~[T]` is a drop-in replacement
       * `core::send_map` renamed to `core::hashmap`
+      * `std::map` removed; replaced with `core::hashmap`
       * `std::treemap` reimplemented as an owned balanced tree
       * `std::deque` and `std::smallintmap` reimplemented as owned containers
       * `core::trie` added as a fast ordered map for integer keys
@@ -76,14 +76,14 @@ Version 0.6 (March 2013)
    * Tools
       * Replaced the 'cargo' package manager with 'rustpkg'
       * Added all-purpose 'rust' tool
-      * `rustc --test` now supports a benchmarks with the `#[bench]` attribute
+      * `rustc --test` now supports benchmarks with the `#[bench]` attribute
       * rustc now attempts to offer spelling suggestions
 
    * Misc
       * Improved support for ARM and Android
       * Preliminary MIPS backend
       * Improved foreign function ABI implementation for x86, x86_64
-      * Various and memory usage improvements
+      * Various memory usage improvements
       * Rust code may be embedded in foreign code under limited circumstances
 
 Version 0.5 (December 2012)

branches/incoming/src/librustc/middle/kind.rs

@@ -376,7 +376,7 @@ pub fn check_bounds(cx: Context,
 
             ty::bound_durable => {
                 if !kind.is_durable(cx.tcx) {
-                    missing.push("'static");
+                    missing.push("&static");
                 }
             }
 
@@ -467,7 +467,7 @@ pub fn check_durable(tcx: ty::ctxt, ty: ty::t, sp: span) -> bool {
         match ty::get(ty).sty {
           ty::ty_param(*) => {
             tcx.sess.span_err(sp, ~"value may contain borrowed \
-                                    pointers; use `'static` bound");
+                                    pointers; use `&static` bound");
           }
           _ => {
             tcx.sess.span_err(sp, ~"value may contain borrowed \

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

@@ -1404,7 +1404,7 @@ pub fn substs_to_str(cx: ctxt, substs: &substs) -> ~str {
 pub fn param_bound_to_str(cx: ctxt, pb: &param_bound) -> ~str {
     match *pb {
         bound_copy => ~"copy",
-        bound_durable => ~"'static",
+        bound_durable => ~"&static",
         bound_owned => ~"owned",
         bound_const => ~"const",
         bound_trait(t) => ::util::ppaux::ty_to_str(cx, t)

branches/incoming/src/libsyntax/parse/parser.rs

@@ -2704,52 +2704,49 @@ pub impl Parser {
 
         let mut result = opt_vec::Empty;
         loop {
-            match *self.token {
-                token::LIFETIME(lifetime) => {
-                    if str::eq_slice(*self.id_to_str(lifetime), "static") {
-                        result.push(RegionTyParamBound);
-                    } else {
-                        self.span_err(*self.span,
-                                      ~"`'static` is the only permissible \
-                                        region bound here");
-                    }
-                    self.bump();
+            if self.eat(&token::BINOP(token::AND)) {
+                if self.eat_keyword(&~"static") {
+                    result.push(RegionTyParamBound);
+                } else {
+                    self.span_err(*self.span,
+                                  ~"`&static` is the only permissible \
+                                    region bound here");
                 }
-                token::IDENT(*) => {
-                    let maybe_bound = match *self.token {
-                        token::IDENT(copy sid, _) => {
-                            match *self.id_to_str(sid) {
-                                ~"send" |
-                                ~"copy" |
-                                ~"const" |
-                                ~"owned" => {
-                                    self.obsolete(
-                                        *self.span,
-                                        ObsoleteLowerCaseKindBounds);
-
-                                    // Bogus value, but doesn't matter, since
-                                    // is an error
-                                    Some(TraitTyParamBound(
-                                        self.mk_ty_path(sid)))
-                                }
-                                _ => None
+            } else if is_ident(&*self.token) {
+                let maybe_bound = match *self.token {
+                    token::IDENT(copy sid, _) => {
+                        match *self.id_to_str(sid) {
+                            ~"send" |
+                            ~"copy" |
+                            ~"const" |
+                            ~"owned" => {
+                                self.obsolete(
+                                    *self.span,
+                                    ObsoleteLowerCaseKindBounds);
+
+                                // Bogus value, but doesn't matter, since
+                                // is an error
+                                Some(TraitTyParamBound(
+                                    self.mk_ty_path(sid)))
                             }
+                            _ => None
                         }
-                        _ => fail!()
-                    };
+                    }
+                    _ => fail!()
+                };
 
-                    match maybe_bound {
-                        Some(bound) => {
-                            self.bump();
-                            result.push(bound);
-                        }
-                        None => {
-                            let ty = self.parse_ty(false);
-                            result.push(TraitTyParamBound(ty));
-                        }
+                match maybe_bound {
+                    Some(bound) => {
+                        self.bump();
+                        result.push(bound);
+                    }
+                    None => {
+                        let ty = self.parse_ty(false);
+                        result.push(TraitTyParamBound(ty));
                     }
                 }
-                _ => break,
+            } else {
+                break;
             }
 
             if self.eat(&token::BINOP(token::PLUS)) {

branches/incoming/src/libsyntax/print/pprust.rs

@@ -1755,7 +1755,7 @@ pub fn print_bounds(s: @ps, bounds: @OptVec<ast::TyParamBound>) {
 
             match *bound {
                 TraitTyParamBound(ty) => print_type(s, ty),
-                RegionTyParamBound => word(s.s, ~"'static"),
+                RegionTyParamBound => word(s.s, ~"&static"),
             }
         }
     }

branches/incoming/src/test/compile-fail/kindck-owned-trait-scoped.rs

@@ -37,10 +37,10 @@ fn to_foo_2<T:Copy>(t: T) -> @foo {
     // Not OK---T may contain borrowed ptrs and it is going to escape
     // as part of the returned foo value
     struct F<T> { f: T }
-    @F {f:t} as @foo //~ ERROR value may contain borrowed pointers; use `'static` bound
+    @F {f:t} as @foo //~ ERROR value may contain borrowed pointers; use `&static` bound
 }
 
-fn to_foo_3<T:Copy + 'static>(t: T) -> @foo {
+fn to_foo_3<T:Copy + &static>(t: T) -> @foo {
     // OK---T may escape as part of the returned foo value, but it is
     // owned and hence does not contain borrowed ptrs
     struct F<T> { f: T }

branches/incoming/src/test/compile-fail/kindck-owned-trait.rs

@@ -11,10 +11,10 @@
 trait foo { fn foo(&self); }
 
 fn to_foo<T:Copy + foo>(t: T) -> @foo {
-    @t as @foo //~ ERROR value may contain borrowed pointers; use `'static` bound
+    @t as @foo //~ ERROR value may contain borrowed pointers; use `&static` bound
 }
 
-fn to_foo2<T:Copy + foo + 'static>(t: T) -> @foo {
+fn to_foo2<T:Copy + foo + &static>(t: T) -> @foo {
     @t as @foo
 }
 

branches/incoming/src/test/compile-fail/kindck-owned.rs

@@ -13,22 +13,22 @@ fn copy1<T:Copy>(t: T) -> @fn() -> T {
     result
 }
 
-fn copy2<T:Copy + 'static>(t: T) -> @fn() -> T {
+fn copy2<T:Copy + &static>(t: T) -> @fn() -> T {
     let result: @fn() -> T = || t;
     result
 }
 
 fn main() {
     let x = &3;
-    copy2(&x); //~ ERROR does not fulfill `'static`
+    copy2(&x); //~ ERROR does not fulfill `&static`
 
     copy2(@3);
-    copy2(@&x); //~ ERROR does not fulfill `'static`
+    copy2(@&x); //~ ERROR does not fulfill `&static`
 
     let boxed: @fn() = || {};
     copy2(boxed);
     let owned: ~fn() = || {};
     copy2(owned);    //~ ERROR does not fulfill `Copy`
     let borrowed: &fn() = || {};
-    copy2(borrowed); //~ ERROR does not fulfill `'static`
+    copy2(borrowed); //~ ERROR does not fulfill `&static`
 }

branches/incoming/src/test/compile-fail/static-region-bound.rs

@@ -1,4 +1,4 @@
-fn f<T:'static>(_: T) {}
+fn f<T:&static>(_: T) {}
 
 fn main() {
     let x = @3;

branches/incoming/src/test/run-pass/alignment-gep-tup-like-1.rs

@@ -12,7 +12,7 @@ struct pair<A,B> {
     a: A, b: B
 }
 
-fn f<A:Copy + 'static>(a: A, b: u16) -> @fn() -> (A, u16) {
+fn f<A:Copy + &static>(a: A, b: u16) -> @fn() -> (A, u16) {
     let result: @fn() -> (A, u16) = || (a, b);
     result
 }

branches/incoming/src/test/run-pass/close-over-big-then-small-data.rs

@@ -16,7 +16,7 @@ struct Pair<A,B> {
     a: A, b: B
 }
 
-fn f<A:Copy + 'static>(a: A, b: u16) -> @fn() -> (A, u16) {
+fn f<A:Copy + &static>(a: A, b: u16) -> @fn() -> (A, u16) {
     let result: @fn() -> (A, u16) = || (a, b);
     result
 }

branches/incoming/src/test/run-pass/fixed-point-bind-unique.rs

@@ -10,11 +10,11 @@
 
 // xfail-fast
 
-fn fix_help<A:'static,B:Owned>(f: extern fn(@fn(A) -> B, A) -> B, x: A) -> B {
+fn fix_help<A:&static,B:Owned>(f: extern fn(@fn(A) -> B, A) -> B, x: A) -> B {
     return f(|a| fix_help(f, a), x);
 }
 
-fn fix<A:'static,B:Owned>(f: extern fn(@fn(A) -> B, A) -> B) -> @fn(A) -> B {
+fn fix<A:&static,B:Owned>(f: extern fn(@fn(A) -> B, A) -> B) -> @fn(A) -> B {
     return |a| fix_help(f, a);
 }
 

branches/incoming/src/test/run-pass/issue-2734.rs

@@ -11,7 +11,7 @@
 trait hax { } 
 impl<A> hax for A { } 
 
-fn perform_hax<T:'static>(x: @T) -> @hax {
+fn perform_hax<T:&static>(x: @T) -> @hax {
     @x as @hax
 }
 

branches/incoming/src/test/run-pass/issue-2735.rs

@@ -11,7 +11,7 @@
 trait hax { }
 impl<A> hax for A { }
 
-fn perform_hax<T:'static>(x: @T) -> @hax {
+fn perform_hax<T:&static>(x: @T) -> @hax {
     @x as @hax
 }
 

branches/incoming/src/test/run-pass/issue-2904.rs

@@ -59,7 +59,7 @@ fn square_from_char(c: char) -> square {
     }
 }
 
-fn read_board_grid<rdr:'static + io::Reader>(+in: rdr) -> ~[~[square]] {
+fn read_board_grid<rdr: &static + io::Reader>(+in: rdr) -> ~[~[square]] {
     let in = @in as @io::Reader;
     let mut grid = ~[];
     for in.each_line |line| {