---

yaml
---
r: 156227
b: refs/heads/snap-stage3
c: 5653b4d
h: refs/heads/master
i:
  156225: 45664e5
  156223: 6703f27
v: v3

Author: TeXitoi

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: c29a7520e7fb4a5b4d4eccfc594e05793ef6688d
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 1add4dedc131d5f98d82feafe80d92ed1f3f6d49
+refs/heads/snap-stage3: 5653b4da17446dd2b4862c03a434b76c3e30946c
 refs/heads/try: 6601b0501e31d08d3892a2d5a7d8a57ab120bf75
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/man/rustc.1

@@ -1,4 +1,4 @@
-.TH RUSTC "1" "March 2014" "rustc 0.13.0" "User Commands"
+.TH RUSTC "1" "March 2014" "rustc 0.12.0" "User Commands"
 .SH NAME
 rustc \- The Rust compiler
 .SH SYNOPSIS
@@ -125,8 +125,8 @@ is invoked.
 Selects a target processor. If the value is 'help', then a list of available
 CPUs is printed.
 .TP
-\fBtarget-feature\fR='+feature1,-feature2'
-A comma-separated list of features to enable or disable for the target. A
+\fBtarget-feature\fR='+feature1 -feature2'
+A space-separated list of features to enable or disable for the target. A
 preceding '+' enables a feature while a preceding '-' disables it. Available
 features can be discovered through target-cpu=help.
 .TP

branches/snap-stage3/man/rustdoc.1

@@ -1,4 +1,4 @@
-.TH RUSTDOC "1" "March 2014" "rustdoc 0.13.0" "User Commands"
+.TH RUSTDOC "1" "March 2014" "rustdoc 0.12.0" "User Commands"
 .SH NAME
 rustdoc \- generate documentation from Rust source code
 .SH SYNOPSIS

branches/snap-stage3/mk/main.mk

@@ -13,7 +13,7 @@
 ######################################################################
 
 # The version number
-CFG_RELEASE_NUM=0.13.0
+CFG_RELEASE_NUM=0.12.0
 
 CFG_FILENAME_EXTRA=4e7c5e5c
 

branches/snap-stage3/src/doc/reference.md

@@ -1383,87 +1383,44 @@ a = Cat { name: "Spotty".to_string(), weight: 2.7 };
 In this example, `Cat` is a _struct-like enum variant_,
 whereas `Dog` is simply called an enum variant.
 
-### Constant items
+### Static items
 
 ```{.ebnf .gram}
-const_item : "const" ident ':' type '=' expr ';' ;
+static_item : "static" ident ':' type '=' expr ';' ;
 ```
 
-A *constant item* is a named _constant value_ which is not associated with a
-specific memory location in the program. Constants are essentially inlined
-wherever they are used, meaning that they are copied directly into the relevant
-context when used. References to the same constant are not necessarily
-guaranteed to refer to the same memory address.
-
-Constant values must not have destructors, and otherwise permit most forms of
-data. Constants may refer to the address of other constants, in which case the
-address will have the `static` lifetime. The compiler is, however, still at
-liberty to translate the constant many times, so the address referred to may not
-be stable.
+A *static item* is a named _constant value_ stored in the global data section
+of a crate. Immutable static items are stored in the read-only data section.
+The constant value bound to a static item is, like all constant values,
+evaluated at compile time. Static items have the `static` lifetime, which
+outlives all other lifetimes in a Rust program. Only values stored in the
+global data section (such as string constants and static items) can have the
+`static` lifetime; dynamically constructed values cannot safely be assigned the
+`static` lifetime. Static items are declared with the `static` keyword. A
+static item must have a _constant expression_ giving its definition.
 
-Constants must be explicitly typed. The type may be `bool`, `char`, a number, or
-a type derived from those primitive types. The derived types are references with
-the `static` lifetime, fixed-size arrays, tuples, enum variants, and structs.
+Static items must be explicitly typed. The type may be `bool`, `char`,
+a number, or a type derived from those primitive types. The derived types are
+references with the `static` lifetime, fixed-size arrays, tuples, and structs.
 
 ```
-const BIT1: uint = 1 << 0;
-const BIT2: uint = 1 << 1;
+static BIT1: uint = 1 << 0;
+static BIT2: uint = 1 << 1;
 
-const BITS: [uint, ..2] = [BIT1, BIT2];
-const STRING: &'static str = "bitstring";
+static BITS: [uint, ..2] = [BIT1, BIT2];
+static STRING: &'static str = "bitstring";
 
 struct BitsNStrings<'a> {
     mybits: [uint, ..2],
     mystring: &'a str
 }
 
-const BITS_N_STRINGS: BitsNStrings<'static> = BitsNStrings {
+static BITS_N_STRINGS: BitsNStrings<'static> = BitsNStrings {
     mybits: BITS,
     mystring: STRING
 };
 ```
 
-### Static items
-
-```{.ebnf .gram}
-static_item : "static" ident ':' type '=' expr ';' ;
-```
-
-A *static item* is similar to a *constant*, except that it represents a precise
-memory location in the program. A static is never "inlined" at the usage site,
-and all references to it refer to the same memory location. Static items have
-the `static` lifetime, which outlives all other lifetimes in a Rust program.
-Static items may be placed in read-only memory if they do not contain any
-interior mutability.
-
-Statics may contain interior mutability through the `UnsafeCell` language item.
-All access to a static is safe, but there are a number of restrictions on
-statics:
-
-* Statics may not contain any destructors.
-* The types of static values must ascribe to `Sync` to allow threadsafe access.
-* Statics may not refer to other statics by value, only by reference.
-* Constants cannot refer to statics.
-
-Constants should in general be preferred over statics, unless large amounts of
-data are being stored, or single-address and mutability properties are required.
-
-```
-use std::sync::atomic;
-
-// Note that INIT_ATOMIC_UINT is a *const*, but it may be used to initialize a
-// static. This static can be modified, so it is not placed in read-only memory.
-static COUNTER: atomic::AtomicUint = atomic::INIT_ATOMIC_UINT;
-
-// This table is a candidate to be placed in read-only memory.
-static TABLE: &'static [uint] = &[1, 2, 3, /* ... */];
-
-for slot in TABLE.iter() {
-    println!("{}", slot);
-}
-COUNTER.fetch_add(1, atomic::SeqCst);
-```
-
 #### Mutable statics
 
 If a static item is declared with the `mut` keyword, then it is allowed to
@@ -1498,9 +1455,6 @@ unsafe fn bump_levels_unsafe2() -> uint {
 }
 ```
 
-Mutable statics have the same restrictions as normal statics, except that the
-type of the value is not required to ascribe to `Sync`.
-
 ### Traits
 
 A _trait_ describes a set of method types.

branches/snap-stage3/src/etc/kate/rust.xml

@@ -7,7 +7,7 @@
 	<!ENTITY rustIdent "[a-zA-Z_][a-zA-Z_0-9]*">
 	<!ENTITY rustIntSuf "([iu](8|16|32|64)?)?">
 ]>
-<language name="Rust" version="0.13.0" kateversion="2.4" section="Sources" extensions="*.rs" mimetype="text/x-rust" priority="15">
+<language name="Rust" version="0.12.0" kateversion="2.4" section="Sources" extensions="*.rs" mimetype="text/x-rust" priority="15">
 <highlighting>
 	<list name="fn">
 		<item> fn </item>

branches/snap-stage3/src/etc/unicode.py

@@ -333,14 +333,14 @@ def emit_property_module(f, mod, tbl, emit_fn):
 def emit_regex_module(f, cats, w_data):
     f.write("pub mod regex {\n")
     regex_class = "&'static [(char, char)]"
-    class_table = "&'static [(&'static str, &'static %s)]" % regex_class
+    class_table = "&'static [(&'static str, %s)]" % regex_class
 
     emit_table(f, "UNICODE_CLASSES", cats, class_table,
-        pfun=lambda x: "(\"%s\",&super::%s::%s_table)" % (x[0], x[1], x[0]))
+        pfun=lambda x: "(\"%s\",super::%s::%s_table)" % (x[0], x[1], x[0]))
 
-    f.write("    pub static PERLD: &'static %s = &super::general_category::Nd_table;\n\n"
+    f.write("    pub static PERLD: %s = super::general_category::Nd_table;\n\n"
             % regex_class)
-    f.write("    pub static PERLS: &'static %s = &super::property::White_Space_table;\n\n"
+    f.write("    pub static PERLS: %s = super::property::White_Space_table;\n\n"
             % regex_class)
 
     emit_table(f, "PERLW", w_data, regex_class)

branches/snap-stage3/src/liballoc/heap.rs

@@ -85,7 +85,7 @@ pub fn stats_print() {
 ///
 /// This preserves the non-null invariant for types like `Box<T>`. The address may overlap with
 /// non-zero-size memory allocations.
-pub const EMPTY: *mut () = 0x1 as *mut ();
+pub static EMPTY: *mut () = 0x1 as *mut ();
 
 /// The allocator for unique pointers.
 #[cfg(not(test))]

branches/snap-stage3/src/liballoc/lib.rs

@@ -66,7 +66,7 @@
 #![crate_type = "rlib"]
 #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
        html_favicon_url = "http://www.rust-lang.org/favicon.ico",
-       html_root_url = "http://doc.rust-lang.org/nightly/")]
+       html_root_url = "http://doc.rust-lang.org/")]
 
 #![no_std]
 #![feature(lang_items, phase, unsafe_destructor)]

branches/snap-stage3/src/libarena/lib.rs

@@ -26,7 +26,7 @@
 #![license = "MIT/ASL2"]
 #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
        html_favicon_url = "http://www.rust-lang.org/favicon.ico",
-       html_root_url = "http://doc.rust-lang.org/nightly/")]
+       html_root_url = "http://doc.rust-lang.org/0.12.0/")]
 
 #![feature(unsafe_destructor)]
 #![allow(missing_doc)]

branches/snap-stage3/src/libcollections/lib.rs

@@ -19,7 +19,7 @@
 #![license = "MIT/ASL2"]
 #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
        html_favicon_url = "http://www.rust-lang.org/favicon.ico",
-       html_root_url = "http://doc.rust-lang.org/nightly/",
+       html_root_url = "http://doc.rust-lang.org/0.12.0/",
        html_playground_url = "http://play.rust-lang.org/")]
 
 #![allow(unknown_features)]

branches/snap-stage3/src/libcollections/slice.rs

@@ -87,7 +87,6 @@
 
 #![doc(primitive = "slice")]
 
-use alloc::boxed::Box;
 use core::cmp;
 use core::mem::size_of;
 use core::mem;
@@ -299,23 +298,6 @@ impl<'a, T: Clone> CloneableVector<T> for &'a [T] {
     fn into_vec(self) -> Vec<T> { self.to_vec() }
 }
 
-#[experimental]
-pub trait BoxedSlice<T> {
-    /// Convert `self` into a vector without clones or allocation.
-    fn into_vec(self) -> Vec<T>;
-}
-
-impl<T> BoxedSlice<T> for Box<[T]> {
-    #[experimental]
-    fn into_vec(mut self) -> Vec<T> {
-        unsafe {
-            let xs = Vec::from_raw_parts(self.len(), self.len(), self.as_mut_ptr());
-            mem::forget(self);
-            xs
-        }
-    }
-}
-
 /// Extension methods for vectors containing `Clone` elements.
 pub trait ImmutableCloneableVector<T> {
     /// Partitions the vector into two vectors `(a, b)`, where all
@@ -2326,13 +2308,6 @@ mod tests {
         let y: &mut [int] = [];
         assert!(y.last_mut().is_none());
     }
-
-    #[test]
-    fn test_into_vec() {
-        let xs = box [1u, 2, 3];
-        let ys = xs.into_vec();
-        assert_eq!(ys.as_slice(), [1u, 2, 3].as_slice());
-    }
 }
 
 #[cfg(test)]

branches/snap-stage3/src/libcollections/trie.rs

@@ -34,10 +34,10 @@ use slice::{Items, MutItems};
 use slice;
 
 // FIXME: #5244: need to manually update the TrieNode constructor
-const SHIFT: uint = 4;
-const SIZE: uint = 1 << SHIFT;
-const MASK: uint = SIZE - 1;
-const NUM_CHUNKS: uint = uint::BITS / SHIFT;
+static SHIFT: uint = 4;
+static SIZE: uint = 1 << SHIFT;
+static MASK: uint = SIZE - 1;
+static NUM_CHUNKS: uint = uint::BITS / SHIFT;
 
 #[deriving(Clone)]
 enum Child<T> {

branches/snap-stage3/src/libcollections/vec.rs

@@ -14,7 +14,6 @@
 
 use core::prelude::*;
 
-use alloc::boxed::Box;
 use alloc::heap::{EMPTY, allocate, reallocate, deallocate};
 use core::cmp::max;
 use core::default::Default;
@@ -758,20 +757,6 @@ impl<T> Vec<T> {
         }
     }
 
-    /// Convert the vector into Box<[T]>.
-    ///
-    /// Note that this will drop any excess capacity. Calling this and converting back to a vector
-    /// with `into_vec()` is equivalent to calling `shrink_to_fit()`.
-    #[experimental]
-    pub fn into_boxed_slice(mut self) -> Box<[T]> {
-        self.shrink_to_fit();
-        unsafe {
-            let xs: Box<[T]> = mem::transmute(self.as_mut_slice());
-            mem::forget(self);
-            xs
-        }
-    }
-
     /// Deprecated, call `push` instead
     #[inline]
     #[deprecated = "call .push() instead"]
@@ -1749,7 +1734,7 @@ impl<T> MutableSeq<T> for Vec<T> {
             let size = max(old_size, 2 * mem::size_of::<T>()) * 2;
             if old_size > size { fail!("capacity overflow") }
             unsafe {
-                self.ptr = alloc_or_realloc(self.ptr, old_size, size);
+                self.ptr = alloc_or_realloc(self.ptr, self.cap * mem::size_of::<T>(), size);
             }
             self.cap = max(self.cap, 2) * 2;
         }
@@ -1773,6 +1758,7 @@ impl<T> MutableSeq<T> for Vec<T> {
             }
         }
     }
+
 }
 
 /// An iterator that moves out of a vector.
@@ -2646,13 +2632,6 @@ mod tests {
         assert!(vec2 == vec!((), (), ()));
     }
 
-    #[test]
-    fn test_into_boxed_slice() {
-        let xs = vec![1u, 2, 3];
-        let ys = xs.into_boxed_slice();
-        assert_eq!(ys.as_slice(), [1u, 2, 3].as_slice());
-    }
-
     #[bench]
     fn bench_new(b: &mut Bencher) {
         b.iter(|| {

branches/snap-stage3/src/libcore/atomic.rs

@@ -77,19 +77,19 @@ pub enum Ordering {
 
 /// An `AtomicBool` initialized to `false`
 #[unstable = "may be renamed, pending conventions for static initalizers"]
-pub const INIT_ATOMIC_BOOL: AtomicBool =
+pub static INIT_ATOMIC_BOOL: AtomicBool =
         AtomicBool { v: UnsafeCell { value: 0 }, nocopy: marker::NoCopy };
 /// An `AtomicInt` initialized to `0`
 #[unstable = "may be renamed, pending conventions for static initalizers"]
-pub const INIT_ATOMIC_INT: AtomicInt =
+pub static INIT_ATOMIC_INT: AtomicInt =
         AtomicInt { v: UnsafeCell { value: 0 }, nocopy: marker::NoCopy };
 /// An `AtomicUint` initialized to `0`
 #[unstable = "may be renamed, pending conventions for static initalizers"]
-pub const INIT_ATOMIC_UINT: AtomicUint =
+pub static INIT_ATOMIC_UINT: AtomicUint =
         AtomicUint { v: UnsafeCell { value: 0, }, nocopy: marker::NoCopy };
 
 // NB: Needs to be -1 (0b11111111...) to make fetch_nand work correctly
-const UINT_TRUE: uint = -1;
+static UINT_TRUE: uint = -1;
 
 #[stable]
 impl AtomicBool {

branches/snap-stage3/src/libcore/cell.rs

@@ -219,8 +219,8 @@ pub struct RefCell<T> {
 // Values [1, MAX-1] represent the number of `Ref` active
 // (will not outgrow its range since `uint` is the size of the address space)
 type BorrowFlag = uint;
-const UNUSED: BorrowFlag = 0;
-const WRITING: BorrowFlag = -1;
+static UNUSED: BorrowFlag = 0;
+static WRITING: BorrowFlag = -1;
 
 impl<T> RefCell<T> {
     /// Create a new `RefCell` containing `value`

branches/snap-stage3/src/libcore/char.rs

@@ -63,7 +63,7 @@ static MAX_THREE_B: u32 =  0x10000u32;
 */
 
 /// The highest valid code point
-pub const MAX: char = '\U0010ffff';
+pub static MAX: char = '\U0010ffff';
 
 /// Converts from `u32` to a `char`
 #[inline]

branches/snap-stage3/src/libcore/lib.rs

@@ -53,7 +53,7 @@
 #![crate_type = "rlib"]
 #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
        html_favicon_url = "http://www.rust-lang.org/favicon.ico",
-       html_root_url = "http://doc.rust-lang.org/nightly/",
+       html_root_url = "http://doc.rust-lang.org/0.12.0/",
        html_playground_url = "http://play.rust-lang.org/")]
 
 #![no_std]