---

yaml
---
r: 98165
b: refs/heads/master
c: 419ac4a
h: refs/heads/master
i:
  98163: ed55e10
v: v3

Author: nikomatsakis

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 1e1871f35eb83ae6a63952a145e5132deffded2c
+refs/heads/master: 419ac4a1b899ba88fb360b4c71c08f3610564cd4
 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.

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,9 +806,7 @@ 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. These declarations may appear at the top of [modules](#modules) and
-[blocks](#blocks).
+Usually a `use` declaration is used to shorten the path required to refer to a module item.
 
 *Note*: Unlike in many languages,
 `use` declarations in Rust do *not* declare linkage dependency with external crates.
@@ -2320,24 +2318,14 @@ let base = Point3d {x: 1, y: 2, z: 3};
 Point3d {y: 0, z: 10, .. base};
 ~~~~
 
-### Block expressions
+### Record expressions
 
 ~~~~ {.ebnf .gram}
-block_expr : '{' [ view_item ] *
-                 [ stmt ';' | item ] *
-                 [ expr ] '}'
+rec_expr : '{' ident ':' expr
+               [ ',' ident ':' expr ] *
+               [ ".." 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/check-summary.py

@@ -7,30 +7,22 @@
     summaries = []
     def summarise(fname):
         summary = {}
-        with open(fname) as fd:
-            for line in fd:
-                splitline = line.strip().split(' ')
-                if len(splitline) == 1:
-                    continue
-                status = splitline[0]
-                test = splitline[-1]
-                # track bench runs
-                if splitline[1] == 'ns/iter':
-                    status = 'bench'
-                if not summary.has_key(status):
-                    summary[status] = []
-                summary[status].append(test)
-            summaries.append((fname, summary))
+        fd = open(fname)
+        for line in fd:
+            status, test = line.strip().split(' ', 1)
+            if not summary.has_key(status):
+                summary[status] = []
+            summary[status].append(test)
+        summaries.append((fname, summary))
     def count(t):
         return sum(map(lambda (f, s): len(s.get(t, [])), summaries))
     logfiles = sys.argv[1:]
     map(summarise, logfiles)
     ok = count('ok')
     failed = count('failed')
     ignored = count('ignored')
-    measured = count('bench')
-    print "summary of %d test runs: %d passed; %d failed; %d ignored; %d measured" % \
-            (len(logfiles), ok, failed, ignored, measured)
+    print "summary of %d test runs: %d passed; %d failed; %d ignored" % \
+            (len(logfiles), ok, failed, ignored)
     print ""
     if failed > 0:
         print "failed tests:"

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

@@ -127,9 +127,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]