---

yaml
---
r: 147187
b: refs/heads/try2
c: fa36de3
h: refs/heads/master
i:
  147185: 91cdaab
  147183: 5bd00c2
v: v3

Author: DiamondLovesYou

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 6e0b82e07c78c42a735461ba65fc1a15768a0b8c
+refs/heads/try2: fa36de339a75c6c8756262a905049f395e881c39
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/doc/rust.md

@@ -1239,9 +1239,9 @@ static BIT2: uint = 1 << 1;
 static BITS: [uint, ..2] = [BIT1, BIT2];
 static STRING: &'static str = "bitstring";
 
-struct BitsNStrings<'a> {
+struct BitsNStrings<'self> {
     mybits: [uint, ..2],
-    mystring: &'a str
+    mystring: &'self str
 }
 
 static bits_n_strings: BitsNStrings<'static> = BitsNStrings {
@@ -2281,7 +2281,7 @@ The following are examples of structure expressions:
 ~~~~
 # struct Point { x: f64, y: f64 }
 # struct TuplePoint(f64, f64);
-# mod game { pub struct User<'a> { name: &'a str, age: uint, score: uint } }
+# mod game { pub struct User<'self> { name: &'self str, age: uint, score: uint } }
 # struct Cookie; fn some_fn<T>(t: T) {}
 Point {x: 10.0, y: 20.0};
 TuplePoint(10.0, 20.0);
@@ -3055,7 +3055,7 @@ order specified by the tuple type.
 An example of a tuple type and its use:
 
 ~~~~
-type Pair<'a> = (int,&'a str);
+type Pair<'self> = (int,&'self str);
 let p: Pair<'static> = (10,"hello");
 let (a, b) = p;
 assert!(b != "world");
@@ -3220,7 +3220,7 @@ fn add(x: int, y: int) -> int {
 
 let mut x = add(5,7);
 
-type Binop<'a> = 'a |int,int| -> int;
+type Binop<'self> = 'self |int,int| -> int;
 let bo: Binop = add;
 x = bo(5,7);
 ~~~~

branches/try2/mk/platform.mk

@@ -350,7 +350,7 @@ CFG_GCCISH_DEF_FLAG_arm-unknown-linux-gnueabi := -Wl,--export-dynamic,--dynamic-
 CFG_GCCISH_PRE_LIB_FLAGS_arm-unknown-linux-gnueabi := -Wl,-whole-archive
 CFG_GCCISH_POST_LIB_FLAGS_arm-unknown-linux-gnueabi := -Wl,-no-whole-archive
 CFG_DEF_SUFFIX_arm-unknown-linux-gnueabi := .linux.def
-CFG_INSTALL_NAME_ar,-unknown-linux-gnueabi =
+CFG_INSTALL_NAME_arm-unknown-linux-gnueabi =
 CFG_LIBUV_LINK_FLAGS_arm-unknown-linux-gnueabi =
 CFG_EXE_SUFFIX_arm-unknown-linux-gnueabi :=
 CFG_WINDOWSY_arm-unknown-linux-gnueabi :=

branches/try2/mk/tests.mk

@@ -394,8 +394,7 @@ $(3)/stage$(1)/test/rustdoctest-$(2)$$(X_$(2)):					\
 		$$(RUSTDOC_LIB) $$(RUSTDOC_INPUTS)		\
 		$$(SREQ$(1)_T_$(2)_H_$(3)) \
 		$$(TLIB$(1)_T_$(2)_H_$(3))/$$(CFG_LIBSYNTAX_$(2)) \
-		$$(TLIB$(1)_T_$(2)_H_$(3))/$$(CFG_LIBRUSTC_$(2)) \
-		$$(SUNDOWN_LIB_$(2))
+		$$(TLIB$(1)_T_$(2)_H_$(3))/$$(CFG_LIBRUSTC_$(2))
 	@$$(call E, compile_and_link: $$@)
 	$$(STAGE$(1)_T_$(2)_H_$(3)) -o $$@ $$< --test \
 		-L $$(SUNDOWN_DIR_$(2))

branches/try2/src/compiletest/compiletest.rs

@@ -325,17 +325,19 @@ pub fn make_test_name(config: &config, testfile: &Path) -> test::TestName {
 }
 
 pub fn make_test_closure(config: &config, testfile: &Path) -> test::TestFn {
-    let config = (*config).clone();
+    use std::cell::Cell;
+    let config = Cell::new((*config).clone());
     // FIXME (#9639): This needs to handle non-utf8 paths
-    let testfile = testfile.as_str().unwrap().to_owned();
-    test::DynTestFn(proc() { runtest::run(config, testfile) })
+    let testfile = Cell::new(testfile.as_str().unwrap().to_owned());
+    test::DynTestFn(proc() { runtest::run(config.take(), testfile.take()) })
 }
 
 pub fn make_metrics_test_closure(config: &config, testfile: &Path) -> test::TestFn {
-    let config = (*config).clone();
+    use std::cell::Cell;
+    let config = Cell::new((*config).clone());
     // FIXME (#9639): This needs to handle non-utf8 paths
-    let testfile = testfile.as_str().unwrap().to_owned();
+    let testfile = Cell::new(testfile.as_str().unwrap().to_owned());
     test::DynMetricFn(proc(mm) {
-        runtest::run_metrics(config, testfile, mm)
+        runtest::run_metrics(config.take(), testfile.take(), mm)
     })
 }

branches/try2/src/compiletest/errors.rs

@@ -19,7 +19,10 @@ pub fn load_errors(testfile: &Path) -> ~[ExpectedError] {
     let mut error_patterns = ~[];
     let mut rdr = BufferedReader::new(File::open(testfile).unwrap());
     let mut line_num = 1u;
-    for ln in rdr.lines() {
+    loop {
+        let ln = match rdr.read_line() {
+            Some(ln) => ln, None => break,
+        };
         error_patterns.push_all_move(parse_expected(line_num, ln));
         line_num += 1u;
     }

branches/try2/src/compiletest/header.rs

@@ -107,7 +107,11 @@ fn iter_header(testfile: &Path, it: |&str| -> bool) -> bool {
     use std::io::File;
 
     let mut rdr = BufferedReader::new(File::open(testfile).unwrap());
-    for ln in rdr.lines() {
+    loop {
+        let ln = match rdr.read_line() {
+            Some(ln) => ln, None => break
+        };
+
         // Assume that any directives will be found before the first
         // module or function. This doesn't seem to be an optimization
         // with a warm page cache. Maybe with a cold one.

branches/try2/src/driver/driver.rs

@@ -9,15 +9,15 @@
 // except according to those terms.
 
 #[cfg(rustpkg)]
-extern mod this = "rustpkg";
+extern mod this(name = "rustpkg");
 
 #[cfg(rustdoc)]
-extern mod this = "rustdoc";
+extern mod this(name = "rustdoc");
 
 #[cfg(rustc)]
-extern mod this = "rustc";
+extern mod this(name = "rustc");
 
 #[cfg(rustdoc_ng)]
-extern mod this = "rustdoc_ng";
+extern mod this(name = "rustdoc_ng");
 
 fn main() { this::main() }

branches/try2/src/etc/combine-tests.py

@@ -42,7 +42,6 @@ def scrub(b):
 c = open("tmp/run_pass_stage2.rc", "w")
 i = 0
 c.write("// AUTO-GENERATED FILE: DO NOT EDIT\n")
-c.write("#[pkgid=\"run_pass_stage2#0.1\"];\n")
 c.write("#[link(name=\"run_pass_stage2\", vers=\"0.1\")];\n")
 c.write("#[feature(globs, macro_rules, struct_variant, managed_boxes)];\n")
 c.write("#[allow(attribute_usage)];\n")

branches/try2/src/etc/vim/syntax/rust.vim

@@ -3,7 +3,7 @@
 " Maintainer:   Patrick Walton <[email protected]>
 " Maintainer:   Ben Blum <[email protected]>
 " Maintainer:   Chris Morgan <[email protected]>
-" Last Change:  2013 Dec 10
+" Last Change:  2013 Dec 04
 
 if version < 600
   syntax clear
@@ -19,23 +19,23 @@ syn keyword   rustOperator    as
 syn match     rustAssert      "\<assert\(\w\)*!" contained
 syn match     rustFail        "\<fail\(\w\)*!" contained
 syn keyword   rustKeyword     break continue do extern
-syn keyword   rustKeyword     for in if impl let
-syn keyword   rustKeyword     loop once priv pub
+syn keyword   rustKeyword     in if impl let log
+syn keyword   rustKeyword     for impl let log
+syn keyword   rustKeyword     loop mod once priv pub
 syn keyword   rustKeyword     return
 syn keyword   rustKeyword     unsafe while
 syn keyword   rustKeyword     use nextgroup=rustModPath skipwhite
 " FIXME: Scoped impl's name is also fallen in this category
 syn keyword   rustKeyword     mod trait struct enum type nextgroup=rustIdentifier skipwhite
 syn keyword   rustKeyword     fn nextgroup=rustFuncName skipwhite
 syn keyword   rustKeyword     proc
-syn keyword   rustStorage     mut ref static
-syn keyword   rustObsoleteStorage const
+syn keyword   rustStorage     const mut ref static
 
 syn match     rustIdentifier  contains=rustIdentifierPrime "\%([^[:cntrl:][:space:][:punct:][:digit:]]\|_\)\%([^[:cntrl:][:punct:][:space:]]\|_\)*" display contained
 syn match     rustFuncName    "\%([^[:cntrl:][:space:][:punct:][:digit:]]\|_\)\%([^[:cntrl:][:punct:][:space:]]\|_\)*" display contained
 
 " Reserved (but not yet used) keywords {{{2
-syn keyword   rustReservedKeyword alignof be offsetof pure sizeof typeof yield
+syn keyword   rustKeyword     alignof be offsetof pure sizeof typeof yield
 
 " Built-in types {{{2
 syn keyword   rustType        int uint float char bool u8 u16 u32 u64 f32
@@ -160,15 +160,14 @@ syn match     rustHexNumber   display "\<0x[a-fA-F0-9_]\+\%([iu]\%(8\|16\|32\|64
 syn match     rustOctNumber   display "\<0o[0-7_]\+\%([iu]\%(8\|16\|32\|64\)\=\)\="
 syn match     rustBinNumber   display "\<0b[01_]\+\%([iu]\%(8\|16\|32\|64\)\=\)\="
 
-" Special case for numbers of the form "1." which are float literals, unless followed by
-" an identifier, which makes them integer literals with a method call or field access.
-" (This must go first so the others take precedence.)
-syn match     rustFloat       display "\<[0-9][0-9_]*\.\%([^[:cntrl:][:space:][:punct:][:digit:]]\|_\)\@!"
-" To mark a number as a normal float, it must have at least one of the three things integral values don't have:
+" To mark it as a float, it must have at least one of the three things integral values don't have:
 " a decimal point and more numbers; an exponent; and a type suffix.
 syn match     rustFloat       display "\<[0-9][0-9_]*\%(\.[0-9][0-9_]*\)\%([eE][+-]\=[0-9_]\+\)\=\(f32\|f64\)\="
 syn match     rustFloat       display "\<[0-9][0-9_]*\%(\.[0-9][0-9_]*\)\=\%([eE][+-]\=[0-9_]\+\)\(f32\|f64\)\="
 syn match     rustFloat       display "\<[0-9][0-9_]*\%(\.[0-9][0-9_]*\)\=\%([eE][+-]\=[0-9_]\+\)\=\(f32\|f64\)"
+" Special case for numbers of the form "1." which are float literals, unless followed by
+" an identifier, which makes them integer literals with a method call or field access.
+syn match     rustFloat       display "\<[0-9][0-9_]*\.\%([^[:cntrl:][:space:][:punct:][:digit:]]\|_\)\@!"
 
 " For the benefit of delimitMate
 syn region rustLifetimeCandidate display start=/&'\%(\([^'\\]\|\\\(['nrt0\\\"]\|x\x\{2}\|u\x\{4}\|U\x\{8}\)\)'\)\@!/ end=/[[:cntrl:][:space:][:punct:]]\@=\|$/ contains=rustSigil,rustLifetime
@@ -228,7 +227,6 @@ hi def link rustSelf          Constant
 hi def link rustFloat         Float
 hi def link rustOperator      Operator
 hi def link rustKeyword       Keyword
-hi def link rustReservedKeyword Error
 hi def link rustConditional   Conditional
 hi def link rustIdentifier    Identifier
 hi def link rustCapsIdent     rustIdentifier
@@ -249,7 +247,6 @@ hi def link rustTodo          Todo
 hi def link rustAttribute     PreProc
 hi def link rustDeriving      PreProc
 hi def link rustStorage       StorageClass
-hi def link rustObsoleteStorage Error
 hi def link rustLifetime      Special
 
 " Other Suggestions:

branches/try2/src/libextra/arc.rs

@@ -49,13 +49,13 @@ use std::task;
 use std::borrow;
 
 /// As sync::condvar, a mechanism for unlock-and-descheduling and signaling.
-pub struct Condvar<'a> {
+pub struct Condvar<'self> {
     priv is_mutex: bool,
-    priv failed: &'a mut bool,
-    priv cond: &'a sync::Condvar<'a>
+    priv failed: &'self mut bool,
+    priv cond: &'self sync::Condvar<'self>
 }
 
-impl<'a> Condvar<'a> {
+impl<'self> Condvar<'self> {
     /// Atomically exit the associated Arc and block until a signal is sent.
     #[inline]
     pub fn wait(&self) { self.wait_on(0) }
@@ -523,19 +523,19 @@ fn borrow_rwlock<T:Freeze + Send>(state: *mut RWArcInner<T>) -> *RWLock {
 }
 
 /// The "write permission" token used for RWArc.write_downgrade().
-pub struct RWWriteMode<'a, T> {
-    priv data: &'a mut T,
-    priv token: sync::RWLockWriteMode<'a>,
+pub struct RWWriteMode<'self, T> {
+    priv data: &'self mut T,
+    priv token: sync::RWLockWriteMode<'self>,
     priv poison: PoisonOnFail,
 }
 
 /// The "read permission" token used for RWArc.write_downgrade().
-pub struct RWReadMode<'a, T> {
-    priv data: &'a T,
-    priv token: sync::RWLockReadMode<'a>,
+pub struct RWReadMode<'self, T> {
+    priv data: &'self T,
+    priv token: sync::RWLockReadMode<'self>,
 }
 
-impl<'a, T:Freeze + Send> RWWriteMode<'a, T> {
+impl<'self, T:Freeze + Send> RWWriteMode<'self, T> {
     /// Access the pre-downgrade RWArc in write mode.
     pub fn write<U>(&mut self, blk: |x: &mut T| -> U) -> U {
         match *self {
@@ -574,7 +574,7 @@ impl<'a, T:Freeze + Send> RWWriteMode<'a, T> {
     }
 }
 
-impl<'a, T:Freeze + Send> RWReadMode<'a, T> {
+impl<'self, T:Freeze + Send> RWReadMode<'self, T> {
     /// Access the post-downgrade rwlock in read mode.
     pub fn read<U>(&self, blk: |x: &T| -> U) -> U {
         match *self {
@@ -597,6 +597,7 @@ mod tests {
 
     use arc::*;
 
+    use std::cell::Cell;
     use std::comm;
     use std::task;
 
@@ -627,18 +628,18 @@ mod tests {
         let arc = ~MutexArc::new(false);
         let arc2 = ~arc.clone();
         let (p,c) = comm::oneshot();
-        do task::spawn {
+        let (c,p) = (Cell::new(c), Cell::new(p));
+        do task::spawn || {
             // wait until parent gets in
-            p.recv();
+            p.take().recv();
             arc2.access_cond(|state, cond| {
                 *state = true;
                 cond.signal();
             })
         }
 
-        let mut c = Some(c);
         arc.access_cond(|state, cond| {
-            c.take_unwrap().send(());
+            c.take().send(());
             assert!(!*state);
             while !*state {
                 cond.wait();

branches/try2/src/libextra/base64.rs

@@ -56,7 +56,7 @@ pub trait ToBase64 {
     fn to_base64(&self, config: Config) -> ~str;
 }
 
-impl<'a> ToBase64 for &'a [u8] {
+impl<'self> ToBase64 for &'self [u8] {
     /**
      * Turn a vector of `u8` bytes into a base64 string.
      *
@@ -157,7 +157,7 @@ pub trait FromBase64 {
     fn from_base64(&self) -> Result<~[u8], ~str>;
 }
 
-impl<'a> FromBase64 for &'a str {
+impl<'self> FromBase64 for &'self str {
     /**
      * Convert any base64 encoded string (literal, `@`, `&`, or `~`)
      * to the byte values it encodes.

branches/try2/src/libextra/bitv.rs

@@ -578,13 +578,13 @@ fn iterate_bits(base: uint, bits: uint, f: |uint| -> bool) -> bool {
 }
 
 /// An iterator for `Bitv`.
-pub struct BitvIterator<'a> {
-    priv bitv: &'a Bitv,
+pub struct BitvIterator<'self> {
+    priv bitv: &'self Bitv,
     priv next_idx: uint,
     priv end_idx: uint,
 }
 
-impl<'a> Iterator<bool> for BitvIterator<'a> {
+impl<'self> Iterator<bool> for BitvIterator<'self> {
     #[inline]
     fn next(&mut self) -> Option<bool> {
         if self.next_idx != self.end_idx {
@@ -602,7 +602,7 @@ impl<'a> Iterator<bool> for BitvIterator<'a> {
     }
 }
 
-impl<'a> DoubleEndedIterator<bool> for BitvIterator<'a> {
+impl<'self> DoubleEndedIterator<bool> for BitvIterator<'self> {
     #[inline]
     fn next_back(&mut self) -> Option<bool> {
         if self.next_idx != self.end_idx {
@@ -614,9 +614,9 @@ impl<'a> DoubleEndedIterator<bool> for BitvIterator<'a> {
     }
 }
 
-impl<'a> ExactSize<bool> for BitvIterator<'a> {}
+impl<'self> ExactSize<bool> for BitvIterator<'self> {}
 
-impl<'a> RandomAccessIterator<bool> for BitvIterator<'a> {
+impl<'self> RandomAccessIterator<bool> for BitvIterator<'self> {
     #[inline]
     fn indexable(&self) -> uint {
         self.end_idx - self.next_idx
@@ -903,12 +903,12 @@ impl BitvSet {
     }
 }
 
-pub struct BitvSetIterator<'a> {
-    priv set: &'a BitvSet,
+pub struct BitvSetIterator<'self> {
+    priv set: &'self BitvSet,
     priv next_idx: uint
 }
 
-impl<'a> Iterator<uint> for BitvSetIterator<'a> {
+impl<'self> Iterator<uint> for BitvSetIterator<'self> {
     #[inline]
     fn next(&mut self) -> Option<uint> {
         while self.next_idx < self.set.capacity() {