---

yaml
---
r: 98149
b: refs/heads/master
c: 421d245
h: refs/heads/master
i:
  98147: 186747b
v: v3

Author: alexcrichton

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 80a3f453db387d02dcb596745731031e7a8c9048
+refs/heads/master: 421d24582d278c510fcaa8a3918d4eeff739f556
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: b6400f998497c3958f40997a71756ead344a776d
 refs/heads/try: c274a6888410ce3e357e014568b43310ed787d36

trunk/Makefile.in

@@ -371,9 +371,6 @@ DRIVER_CRATE := $(S)src/driver/driver.rs
 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
-
 define DEF_LLVM_VARS
 # The configure script defines these variables with the target triples
 # separated by Z. This defines new ones with the expected format.
@@ -421,7 +418,6 @@ export CFG_PREFIX
 export CFG_LIBDIR
 export CFG_RUSTLIBDIR
 export CFG_LIBDIR_RELATIVE
-export CFG_DISABLE_INJECT_STD_VERSION
 
 ######################################################################
 # Subprograms

trunk/configure

@@ -381,7 +381,6 @@ opt clang 0 "prefer clang to gcc for building the runtime"
 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"
 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"
@@ -1043,7 +1042,6 @@ putvar CFG_DISABLE_MANAGE_SUBMODULES
 putvar CFG_ANDROID_CROSS_PATH
 putvar CFG_MINGW32_CROSS_PATH
 putvar CFG_MANDIR
-putvar CFG_DISABLE_INJECT_STD_VERSION
 
 # Avoid spurious warnings from clang by feeding it original source on
 # ccache-miss rather than preprocessed input.

trunk/doc/index.md

@@ -4,54 +4,52 @@
 <style type="text/css">
 #TOC { display: none; }
 .header-section-number { display: none; }
-li {list-style-type: none; }
 </style>
 
-* [The Rust tutorial](tutorial.html)  (* [PDF](tutorial.pdf))
-* [The Rust reference manual](rust.html) (* [PDF](rust.pdf))
+[The Rust tutorial](tutorial.html)  ([PDF](tutorial.pdf))  
+[The Rust reference manual](rust.html) ([PDF](rust.pdf))  
 
 # Guides
 
-* [Pointers](guide-pointers.html)
-* [References and Lifetimes](guide-lifetimes.html)
-* [Containers and Iterators](guide-container.html)
-* [Tasks and Communication](guide-tasks.html)
-* [Foreign Function Interface](guide-ffi.html)
-* [Macros](guide-macros.html)
-* [Packaging](guide-rustpkg.html)
-* [Testing](guide-testing.html)
-* [Conditions](guide-conditions.html)
-* [Rust's Runtime](guide-runtime.html)
+[Pointers](guide-pointers.html)  
+[References and Lifetimes](guide-lifetimes.html)  
+[Containers and Iterators](guide-container.html)  
+[Tasks and Communication](guide-tasks.html)  
+[Foreign Function Interface](guide-ffi.html)  
+[Macros](guide-macros.html)  
+[Packaging](guide-rustpkg.html)  
+[Testing](guide-testing.html)  
+[Conditions](guide-conditions.html)
+[Rust's Runtime](guide-runtime.html)
 
 # Libraries
 
-* [The standard library, `libstd`](std/index.html)
-* [The extra library, `libextra`](extra/index.html)
+[The standard library, `libstd`](std/index.html)  
+[The extra library, `libextra`](extra/index.html)
 
-* [The M:N runtime library, `libgreen`](green/index.html)
-* [The 1:1 runtime library, `libnative`](native/index.html)
+[The M:N runtime library, `libgreen`](green/index.html)  
+[The 1:1 runtime library, `libnative`](native/index.html)
 
-* [The Rust libuv library, `librustuv`](rustuv/index.html)
-* [The Rust packaging library, `librustpkg`](rustpkg/index.html)
+[The Rust libuv library, `librustuv`](rustuv/index.html)  
+[The Rust packaging library, `librustpkg`](rustpkg/index.html)
 
-* [The Rust parser, `libsyntax`](syntax/index.html)
-* [The Rust compiler, `librustc`](rustc/index.html)
+[The Rust parser, `libsyntax`](syntax/index.html)  
+[The Rust compiler, `librustc`](rustc/index.html)
 
 # Tooling
 
-* [The `rustdoc` manual](rustdoc.html)
-* [The `rustpkg` manual](rustpkg.html)
+[The `rustpkg` manual](rustpkg.html)
 
 # FAQs
 
-* [Language FAQ](complement-lang-faq.html)
-* [Project FAQ](complement-project-faq.html)
-* [Usage FAQ](complement-usage-faq.html)
-* [Code cheatsheet](complement-cheatsheet.html) - "How do I do X?"  
-* [How to submit a bug report](complement-bugreport.html)
+[Language FAQ](complement-lang-faq.html)  
+[Project FAQ](complement-project-faq.html)  
+[Usage FAQ](complement-usage-faq.html)  
+[Code cheatsheet](complement-cheatsheet.html) - "How do I do X?"  
+[How to submit a bug report](complement-bugreport.html)
 
 # External resources
 
-* The Rust [IRC channel](http://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust) - `#rust` on irc.mozilla.org  
-* The Rust community on [Reddit](http://reddit.com/r/rust)
-* The Rust [wiki](http://github.com/mozilla/rust/wiki)
+The Rust [IRC channel](http://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust) - `#rust` on irc.mozilla.org  
+The Rust community on [Reddit](http://reddit.com/r/rust)  
+The Rust [wiki](http://github.com/mozilla/rust/wiki)

trunk/doc/rust.md

@@ -806,7 +806,9 @@ path_glob : ident [ "::" path_glob ] ?
 
 A _use declaration_ creates one or more local name bindings synonymous
 with some other [path](#paths).
-Usually a `use` declaration is used to shorten the path required to refer to a module item.
+Usually a `use` declaration is used to shorten the path required to refer to a
+module item. These declarations may appear at the top of [modules](#modules) and
+[blocks](#blocks).
 
 *Note*: Unlike in many languages,
 `use` declarations in Rust do *not* declare linkage dependency with external crates.
@@ -2318,14 +2320,24 @@ let base = Point3d {x: 1, y: 2, z: 3};
 Point3d {y: 0, z: 10, .. base};
 ~~~~
 
-### Record expressions
+### Block expressions
 
 ~~~~ {.ebnf .gram}
-rec_expr : '{' ident ':' expr
-               [ ',' ident ':' expr ] *
-               [ ".." expr ] '}'
+block_expr : '{' [ view_item ] *
+                 [ stmt ';' | item ] *
+                 [ expr ] '}'
 ~~~~
 
+A _block expression_ is similar to a module in terms of the declarations that
+are possible. Each block conceptually introduces a new namespace scope. View
+items can bring new names into scopes and declared items are in scope for only
+the block itself.
+
+A block will execute each statement sequentially, and then execute the
+expression (if given). If the final expression is omitted, the type and return
+value of the block are `()`, but if it is provided, the type and return value
+of the block are that of the expression itself.
+
 ### Method-call expressions
 
 ~~~~ {.ebnf .gram}

trunk/mk/llvm.mk

@@ -28,7 +28,7 @@ LLVM_STAMP_$(1) = $$(CFG_LLVM_BUILD_DIR_$(1))/llvm-auto-clean-stamp
 
 $$(LLVM_CONFIG_$(1)): $$(LLVM_DEPS) $$(LLVM_STAMP_$(1))
 	@$$(call E, make: llvm)
-	$$(Q)$$(MAKE) -C $$(CFG_LLVM_BUILD_DIR_$(1)) $$(CFG_LLVM_BUILD_ENV_$(1)) ONLY_TOOLS="$$(LLVM_TOOLS)"
+	$$(Q)$$(MAKE) -C $$(CFG_LLVM_BUILD_DIR_$(1)) $$(CFG_LLVM_BUILD_ENV_$(1))
 	$$(Q)touch $$(LLVM_CONFIG_$(1))
 endif
 

trunk/src/compiletest/header.rs

@@ -90,14 +90,10 @@ pub fn is_test_ignored(config: &config, testfile: &Path) -> bool {
     fn xfail_target(config: &config) -> ~str {
         ~"xfail-" + util::get_os(config.target)
     }
-    fn xfail_stage(config: &config) -> ~str {
-        ~"xfail-" + config.stage_id.split('-').next().unwrap()
-    }
 
     let val = iter_header(testfile, |ln| {
         if parse_name_directive(ln, "xfail-test") { false }
         else if parse_name_directive(ln, xfail_target(config)) { false }
-        else if parse_name_directive(ln, xfail_stage(config)) { false }
         else if config.mode == common::mode_pretty &&
             parse_name_directive(ln, "xfail-pretty") { false }
         else { true }

trunk/src/etc/vim/syntax/rust.vim

@@ -83,7 +83,8 @@ syn keyword rustTrait OrdIterator MutableDoubleEndedIterator ExactSize
 syn keyword rustTrait Times
 
 syn keyword rustTrait Algebraic Trigonometric Exponential Hyperbolic
-syn keyword rustTrait Bitwise Bounded Integer Fractional Real RealExt
+syn keyword rustTrait Bitwise BitCount Bounded
+syn keyword rustTrait Integer Fractional Real RealExt
 syn keyword rustTrait Num NumCast CheckedAdd CheckedSub CheckedMul
 syn keyword rustTrait Orderable Signed Unsigned Round
 syn keyword rustTrait Primitive Int Float ToStrRadix ToPrimitive FromPrimitive

trunk/src/libextra/base64.rs

@@ -154,25 +154,7 @@ impl<'a> ToBase64 for &'a [u8] {
 pub trait FromBase64 {
     /// Converts the value of `self`, interpreted as base64 encoded data, into
     /// an owned vector of bytes, returning the vector.
-    fn from_base64(&self) -> Result<~[u8], FromBase64Error>;
-}
-
-/// Errors that can occur when decoding a base64 encoded string
-pub enum FromBase64Error {
-    /// The input contained a character not part of the base64 format
-    InvalidBase64Character(char, uint),
-    /// The input had an invalid length
-    InvalidBase64Length,
-}
-
-impl ToStr for FromBase64Error {
-    fn to_str(&self) -> ~str {
-        match *self {
-            InvalidBase64Character(ch, idx) =>
-                format!("Invalid character '{}' at position {}", ch, idx),
-            InvalidBase64Length => ~"Invalid length",
-        }
-    }
+    fn from_base64(&self) -> Result<~[u8], ~str>;
 }
 
 impl<'a> FromBase64 for &'a str {
@@ -206,7 +188,7 @@ impl<'a> FromBase64 for &'a str {
      * }
      * ```
      */
-    fn from_base64(&self) -> Result<~[u8], FromBase64Error> {
+    fn from_base64(&self) -> Result<~[u8], ~str> {
         let mut r = ~[];
         let mut buf: u32 = 0;
         let mut modulus = 0;
@@ -223,7 +205,8 @@ impl<'a> FromBase64 for &'a str {
                 '/'|'_' => buf |= 0x3F,
                 '\r'|'\n' => continue,
                 '=' => break,
-                _ => return Err(InvalidBase64Character(self.char_at(idx), idx)),
+                _ => return Err(format!("Invalid character '{}' at position {}",
+                                     self.char_at(idx), idx))
             }
 
             buf <<= 6;
@@ -238,7 +221,8 @@ impl<'a> FromBase64 for &'a str {
 
         for (idx, byte) in it {
             if (byte as char) != '=' {
-                return Err(InvalidBase64Character(self.char_at(idx), idx));
+                return Err(format!("Invalid character '{}' at position {}",
+                                self.char_at(idx), idx));
             }
         }
 
@@ -251,7 +235,7 @@ impl<'a> FromBase64 for &'a str {
                 r.push((buf >> 8 ) as u8);
             }
             0 => (),
-            _ => return Err(InvalidBase64Length),
+            _ => return Err(~"Invalid Base64 length")
         }
 
         Ok(r)

trunk/src/libextra/comm.rs

@@ -16,8 +16,6 @@ Higher level communication abstractions.
 
 #[allow(missing_doc)];
 
-use std::comm;
-
 /// An extension of `pipes::stream` that allows both sending and receiving.
 pub struct DuplexStream<T, U> {
     priv chan: Chan<T>,
@@ -42,7 +40,7 @@ impl<T:Send,U:Send> DuplexStream<T, U> {
     pub fn recv(&self) -> U {
         self.port.recv()
     }
-    pub fn try_recv(&self) -> comm::TryRecvResult<U> {
+    pub fn try_recv(&self) -> Option<U> {
         self.port.try_recv()
     }
     pub fn recv_opt(&self) -> Option<U> {
@@ -79,11 +77,11 @@ impl<T: Send> SyncPort<T> {
         })
     }
 
-    pub fn try_recv(&self) -> comm::TryRecvResult<T> {
-        match self.duplex_stream.try_recv() {
-            comm::Data(t) => { self.duplex_stream.try_send(()); comm::Data(t) }
-            state => state,
-        }
+    pub fn try_recv(&self) -> Option<T> {
+        self.duplex_stream.try_recv().map(|val| {
+            self.duplex_stream.try_send(());
+            val
+        })
     }
 }
 
@@ -127,9 +125,9 @@ mod test {
         // Rendezvous streams should be able to handle any number of messages being sent
         let (port, chan) = rendezvous();
         do spawn {
-            10000.times(|| { chan.send(()) })
+            1000000.times(|| { chan.send(()) })
         }
-        10000.times(|| { port.recv() })
+        1000000.times(|| { port.recv() })
     }
 
     #[test]

trunk/src/libextra/enum_set.rs

@@ -13,8 +13,6 @@
 //! This module defines a container which uses an efficient bit mask
 //! representation to hold C-like enum variants.
 
-use std::num::Bitwise;
-
 #[deriving(Clone, Eq, IterBytes, ToStr, Encodable, Decodable)]
 /// A specialized Set implementation to use enum types.
 pub struct EnumSet<E> {

trunk/src/libextra/hex.rs

@@ -53,25 +53,7 @@ impl<'a> ToHex for &'a [u8] {
 pub trait FromHex {
     /// Converts the value of `self`, interpreted as hexadecimal encoded data,
     /// into an owned vector of bytes, returning the vector.
-    fn from_hex(&self) -> Result<~[u8], FromHexError>;
-}
-
-/// Errors that can occur when decoding a hex encoded string
-pub enum FromHexError {
-    /// The input contained a character not part of the hex format
-    InvalidHexCharacter(char, uint),
-    /// The input had a invalid length
-    InvalidHexLength,
-}
-
-impl ToStr for FromHexError {
-    fn to_str(&self) -> ~str {
-        match *self {
-            InvalidHexCharacter(ch, idx) =>
-                format!("Invalid character '{}' at position {}", ch, idx),
-            InvalidHexLength => ~"Invalid input length",
-        }
-    }
+    fn from_hex(&self) -> Result<~[u8], ~str>;
 }
 
 impl<'a> FromHex for &'a str {
@@ -101,7 +83,7 @@ impl<'a> FromHex for &'a str {
      * }
      * ```
      */
-    fn from_hex(&self) -> Result<~[u8], FromHexError> {
+    fn from_hex(&self) -> Result<~[u8], ~str> {
         // This may be an overestimate if there is any whitespace
         let mut b = vec::with_capacity(self.len() / 2);
         let mut modulus = 0;
@@ -118,7 +100,8 @@ impl<'a> FromHex for &'a str {
                     buf >>= 4;
                     continue
                 }
-                _ => return Err(InvalidHexCharacter(self.char_at(idx), idx)),
+                _ => return Err(format!("Invalid character '{}' at position {}",
+                                        self.char_at(idx), idx))
             }
 
             modulus += 1;
@@ -130,7 +113,7 @@ impl<'a> FromHex for &'a str {
 
         match modulus {
             0 => Ok(b),
-            _ => Err(InvalidHexLength),
+            _ => Err(~"Invalid input length")
         }
     }
 }

trunk/src/libextra/lib.rs

@@ -20,8 +20,7 @@ Rust extras are part of the standard Rust distribution.
 
 */
 
-// NOTE: upgrade to 0.10-pre after the next snapshot
-#[crate_id = "extra#0.9"];
+#[crate_id = "extra#0.10-pre"];
 #[comment = "Rust extras"];
 #[license = "MIT/ASL2"];
 #[crate_type = "rlib"];

trunk/src/libextra/num/bigint.rs

@@ -22,7 +22,7 @@ A `BigInt` is a combination of `BigUint` and `Sign`.
 use std::cmp::{Eq, Ord, TotalEq, TotalOrd, Ordering, Less, Equal, Greater};
 use std::num;
 use std::num::{Zero, One, ToStrRadix, FromStrRadix, Orderable};
-use std::num::{Bitwise, ToPrimitive, FromPrimitive};
+use std::num::{ToPrimitive, FromPrimitive};
 use std::rand::Rng;
 use std::str;
 use std::uint;