---

yaml
---
r: 51663
b: refs/heads/incoming
c: 043150b
h: refs/heads/master
i:
  51661: ce4b65f
  51659: f11d4e4
  51655: c3e2889
  51647: 6b707ad
v: v3

Author: brson

[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: de7d5589441d4f0fe8c4f083b6fa9dbfac451398
+refs/heads/incoming: 043150b9ab29e46d0dbee36e53737915a09163b7
 refs/heads/dist-snap: 8b98e5a296d95c5e832db0756828e5bec31c6f50
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/incoming/RELEASES.txt

@@ -1,7 +1,7 @@
 Version 0.6 (March 2013)
 ---------------------------
 
-   * ~2000 changes, numerous bugfixes
+   * ~??? changes, numerous bugfixes
 
    * TODO:
       * Ord/Cmp
@@ -39,11 +39,6 @@ Version 0.6 (March 2013)
       * Newtype enums removed. Used tuple-structs.
       * Trait implementations no longer support visibility modifiers
       * 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,
@@ -57,9 +52,8 @@ Version 0.6 (March 2013)
       * Name resolution continues to be tweaked
       * Method visibility is inherited from the implementation declaration
       * Structural records have been removed
-      * Many more types can be used in static items, including enums
-        'static-lifetime pointers and vectors
-      * Pattern matching over vectors improved and expanded
+      * Many more types can be used in constants, including enums,
+        `static lifetime pointers and vectors
       * Typechecking of closure types has been overhauled to
         improve inference and eliminate unsoundness
 
@@ -91,7 +85,6 @@ Version 0.6 (March 2013)
       * Improved foreign function ABI implementation for x86, x86_64
       * Various memory usage improvements
       * Rust code may be embedded in foreign code under limited circumstances
-      * Inline assembler supported by new asm!() syntax extension.
 
 Version 0.5 (December 2012)
 ---------------------------

branches/incoming/configure

@@ -444,13 +444,12 @@ fi
 
 if [ ! -z "$CFG_PANDOC" ]
 then
-    PV_MAJOR_MINOR=$(pandoc --version | grep '^pandoc ' |
-        # extract the first 2 version fields, ignore everything else
-        sed 's/pandoc \([0-9]*\)\.\([0-9]*\).*/\1 \2/')
-
-    # these patterns are shell globs, *not* regexps
-    PV_MAJOR=${PV_MAJOR_MINOR% *}
-    PV_MINOR=${PV_MAJOR_MINOR#* }
+    PANDOC_VER_LINE=$(pandoc --version | grep '^pandoc ')
+    PANDOC_VER=${PANDOC_VER_LINE#pandoc }
+    PV_MAJOR_MINOR=${PANDOC_VER%.[0-9]*}
+    PV_MAJOR=${PV_MAJOR_MINOR%%[.][0-9]*}
+    PV_MINOR=${PV_MAJOR_MINOR#[0-9]*[.]}
+    PV_MINOR=${PV_MINOR%%[.][0-9]*}
     if [ "$PV_MAJOR" -lt "1" ] || [ "$PV_MINOR" -lt "8" ]
     then
 		step_msg "pandoc $PV_MAJOR.$PV_MINOR is too old. disabling"
@@ -575,7 +574,6 @@ fi
 CFG_PREFIX=${CFG_PREFIX%/}
 CFG_HOST_TRIPLES="$(echo $CFG_HOST_TRIPLES | tr ',' ' ')"
 CFG_TARGET_TRIPLES="$(echo $CFG_TARGET_TRIPLES | tr ',' ' ')"
-CFG_SUPPORTED_TARGET_TRIPLES="$(grep ^CC_*=* $CFG_SRC_DIR/mk/platform.mk | sed 's,^[^_]*_,,' | sed 's/\([^=]*\).*/\1/' | xargs)"
 
 # copy host-triples to target-triples so that hosts are a subset of targets
 V_TEMP=""
@@ -588,22 +586,8 @@ CFG_TARGET_TRIPLES=$V_TEMP
 # check target-specific tool-chains
 for i in $CFG_TARGET_TRIPLES
 do
-    L_CHECK=false
-    for j in $CFG_SUPPORTED_TARGET_TRIPLES
-    do
-        if [ $i = $j ]
-        then
-            L_CHECK=true
-        fi
-    done
-
-    if [ $L_CHECK = false ]
-    then
-        err "unsupported target triples \"$i\" found"
-    fi
-
     case $i in
-        arm-linux-androideabi)
+        arm-unknown-android)
 
             if [ ! -f $CFG_ANDROID_CROSS_PATH/bin/arm-linux-androideabi-gcc ]
             then

branches/incoming/doc/rust.md

@@ -617,8 +617,8 @@ each of which may have some number of [attributes](#attributes) attached to it.
 ## Items
 
 ~~~~~~~~ {.ebnf .gram}
-item : mod_item | fn_item | type_item | struct_item | enum_item
-     | static_item | trait_item | impl_item | foreign_mod_item ;
+item : mod_item | fn_item | type_item | enum_item
+     | const_item | trait_item | impl_item | foreign_mod_item ;
 ~~~~~~~~
 
 An _item_ is a component of a crate; some module items can be defined in crate
@@ -627,7 +627,7 @@ crate by a nested set of [modules](#modules). Every crate has a single
 "outermost" anonymous module; all further items within the crate have
 [paths](#paths) within the module tree of the crate.
 
-Items are entirely determined at compile-time, generally remain fixed during
+Items are entirely determined at compile-time, remain constant during
 execution, and may reside in read-only memory.
 
 There are several kinds of item:
@@ -637,7 +637,7 @@ There are several kinds of item:
   * [type definitions](#type-definitions)
   * [structures](#structures)
   * [enumerations](#enumerations)
-  * [static items](#static-items)
+  * [constants](#constants)
   * [traits](#traits)
   * [implementations](#implementations)
 
@@ -1091,23 +1091,21 @@ a = Cat{ name: ~"Spotty", weight: 2.7 };
 In this example, `Cat` is a _struct-like enum variant_,
 whereas `Dog` is simply called an enum variant.
 
-### Static items
+### Constants
 
 ~~~~~~~~ {.ebnf .gram}
-static_item : "static" ident ':' type '=' expr ';' ;
+const_item : "const" ident ':' type '=' expr ';' ;
 ~~~~~~~~
 
-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.
-Static items are declared with the `static` keyword.
-A static item must have a _constant expression_ giving its definition.
+A *constant* is a named value stored in read-only memory in a crate.
+The value bound to a constant is evaluated at compile time.
+Constants are declared with the `static` keyword.
+A constant item must have an expression giving its definition.
+The definition expression of a constant is limited to expression forms that can be evaluated at compile time.
 
-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 borrowed pointers with the `'static` lifetime,
-fixed-size arrays, tuples, and structs.
+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 borrowed pointers, static arrays, tuples, and structs.
+Borrowed pointers must be have the `'static` lifetime.
 
 ~~~~
 static bit1: uint = 1 << 0;
@@ -1458,7 +1456,7 @@ The declared names may denote new slots or new items.
 
 An _item declaration statement_ has a syntactic form identical to an
 [item](#items) declaration within a module. Declaring an item -- a function,
-enumeration, structure, type, static, trait, implementation or module -- locally
+enumeration, type, constant, trait, implementation or module -- locally
 within a statement block is simply a way of restricting its scope to a narrow
 region containing all of its uses; it is otherwise identical in meaning to
 declaring the item outside the statement block.
@@ -1671,10 +1669,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 +2154,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 +2182,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 +2196,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 +2472,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 +2482,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/incoming/doc/tutorial-borrowed-ptr.md

@@ -468,10 +468,11 @@ overwritten for the duration of the borrow.  In fact, the compiler
 would accept the example we gave earlier. The example is safe because
 the shape pointer has type `&Shape`, which means "borrowed pointer to
 immutable memory containing a `shape`". If, however, the type of that
-pointer were `&mut Shape`, then the ref binding would be ill-typed.
-Just as with unique boxes, the compiler will permit `ref` bindings
-into data owned by the stack frame even if the data are mutable,
-but otherwise it requires that the data reside in immutable memory.
+pointer were `&const Shape` or `&mut Shape`, then the ref binding
+would be ill-typed. Just as with unique boxes, the compiler will
+permit `ref` bindings into data owned by the stack frame even if the
+data are mutable, but otherwise it requires that the data reside in
+immutable memory.
 
 # Returning borrowed pointers
 

branches/incoming/doc/tutorial.md

@@ -234,7 +234,7 @@ while count < 10 {
 
 Although Rust can almost always infer the types of local variables, you
 can specify a variable's type by following it with a colon, then the type
-name. Static items, on the other hand, always require a type annotation.
+name. Constants, on the other hand, always require a type annotation.
 
 ~~~~
 static monster_factor: float = 57.8;

branches/incoming/src/etc/kate/rust.xml

@@ -18,6 +18,7 @@
 	<list name="keywords">
 		<item> as </item>
 		<item> break </item>
+		<item> const </item>
 		<item> copy </item>
 		<item> do </item>
 		<item> drop </item>
@@ -28,17 +29,18 @@
 		<item> if </item>
 		<item> impl </item>
 		<item> let </item>
+		<item> log </item>
 		<item> loop </item>
 		<item> match </item>
 		<item> mod </item>
 		<item> mut </item>
 		<item> priv </item>
 		<item> pub </item>
+		<item> pure </item>
 		<item> ref </item>
 		<item> return </item>
 		<item> static </item>
 		<item> struct </item>
-		<item> super </item>
 		<item> trait </item>
 		<item> unsafe </item>
 		<item> use </item>

branches/incoming/src/libcore/container.rs

@@ -38,12 +38,9 @@ pub trait Map<K, V>: Mutable {
     /// Iterate over the map and mutate the contained values
     fn mutate_values(&mut self, f: &fn(&K, &mut V) -> bool);
 
-    /// Return a reference to the value corresponding to the key
+    /// Return the value corresponding to the key in the map
     fn find(&self, key: &K) -> Option<&'self V>;
 
-    /// Return a mutable reference to the value corresponding to the key
-    fn find_mut(&mut self, key: &K) -> Option<&'self mut V>;
-
     /// Insert a key-value pair into the map. An existing value for a
     /// key is replaced by the new value. Return true if the key did
     /// not already exist in the map.

branches/incoming/src/libcore/core.rc

@@ -51,6 +51,7 @@ Implicitly, all crates behave as if they included the following prologue:
 #[warn(vecs_implicitly_copyable)];
 #[deny(non_camel_case_types)];
 #[allow(deprecated_mutable_fields)];
+#[deny(deprecated_self)];
 #[allow(deprecated_drop)];
 
 // On Linux, link to the runtime with -lrt.
@@ -230,7 +231,6 @@ pub mod rt;
 // can be resolved within libcore.
 #[doc(hidden)]
 pub mod core {
-    pub use clone;
     pub use cmp;
     pub use condition;
     pub use option;

branches/incoming/src/libcore/either.rs

@@ -17,7 +17,7 @@ use result;
 use vec;
 
 /// The either type
-#[deriving(Clone, Eq)]
+#[deriving(Eq)]
 pub enum Either<T, U> {
     Left(T),
     Right(U)