---

yaml
---
r: 149423
b: refs/heads/try2
c: e2f99b9
h: refs/heads/master
i:
  149421: d124fbc
  149419: 1224b9f
  149415: 4702309
  149407: 07fea0b
v: v3

Author: pnkfelix

[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: c6aaf2c7bd69af2a3fc9a109a8c3a6c3004616f2
+refs/heads/try2: e2f99b93cd0f9bdbaf126ce3eb5b9a8f2be354f4
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/compiletest/runtest.rs

@@ -258,12 +258,15 @@ actual:\n\
 }
 
 fn run_debuginfo_test(config: &config, props: &TestProps, testfile: &Path) {
-    let mut config = config {
-        target_rustcflags: cleanup_debug_info_options(&config.target_rustcflags),
-        host_rustcflags: cleanup_debug_info_options(&config.host_rustcflags),
-        .. config.clone()
-    };
 
+    // do not optimize debuginfo tests
+    let mut config = match config.target_rustcflags {
+        Some(ref flags) => config {
+            target_rustcflags: Some(flags.replace("-O", "")),
+            .. (*config).clone()
+        },
+        None => (*config).clone()
+    };
     let config = &mut config;
     let check_lines = &props.check_lines;
     let mut cmds = props.debugger_cmds.connect("\n");
@@ -433,20 +436,6 @@ fn run_debuginfo_test(config: &config, props: &TestProps, testfile: &Path) {
                                   check_lines[i]), &ProcRes);
         }
     }
-
-    fn cleanup_debug_info_options(options: &Option<~str>) -> Option<~str> {
-        if options.is_none() {
-            return None;
-        }
-
-        // Remove options that are either unwanted (-O) or may lead to duplicates due to RUSTFLAGS.
-        let options_to_remove = [~"-O", ~"-g", ~"--debuginfo"];
-        let new_options = split_maybe_args(options).move_iter()
-                                                   .filter(|x| !options_to_remove.contains(x))
-                                                   .to_owned_vec()
-                                                   .connect(" ");
-        Some(new_options)
-    }
 }
 
 fn check_error_patterns(props: &TestProps,

branches/try2/src/doc/guide-macros.md

@@ -11,17 +11,17 @@ which both pattern-match on their input and both return early in one case,
 doing nothing otherwise:
 
 ~~~~
-# enum T { SpecialA(uint), SpecialB(uint) };
+# enum t { special_a(uint), special_b(uint) };
 # fn f() -> uint {
-# let input_1 = SpecialA(0);
-# let input_2 = SpecialA(0);
+# let input_1 = special_a(0);
+# let input_2 = special_a(0);
 match input_1 {
-    SpecialA(x) => { return x; }
+    special_a(x) => { return x; }
     _ => {}
 }
 // ...
 match input_2 {
-    SpecialB(x) => { return x; }
+    special_b(x) => { return x; }
     _ => {}
 }
 # return 0u;
@@ -37,22 +37,22 @@ lightweight custom syntax extensions, themselves defined using the
 the pattern in the above code:
 
 ~~~~
-# enum T { SpecialA(uint), SpecialB(uint) };
+# enum t { special_a(uint), special_b(uint) };
 # fn f() -> uint {
-# let input_1 = SpecialA(0);
-# let input_2 = SpecialA(0);
+# let input_1 = special_a(0);
+# let input_2 = special_a(0);
 macro_rules! early_return(
-    ($inp:expr $sp:ident) => ( // invoke it like `(input_5 SpecialE)`
+    ($inp:expr $sp:ident) => ( // invoke it like `(input_5 special_e)`
         match $inp {
             $sp(x) => { return x; }
             _ => {}
         }
     );
 )
 // ...
-early_return!(input_1 SpecialA);
+early_return!(input_1 special_a);
 // ...
-early_return!(input_2 SpecialB);
+early_return!(input_2 special_b);
 # return 0;
 # }
 ~~~~
@@ -155,10 +155,10 @@ separator token (a comma-separated list could be written `$(...),*`), and `+`
 instead of `*` to mean "at least one".
 
 ~~~~
-# enum T { SpecialA(uint),SpecialB(uint),SpecialC(uint),SpecialD(uint)};
+# enum t { special_a(uint),special_b(uint),special_c(uint),special_d(uint)};
 # fn f() -> uint {
-# let input_1 = SpecialA(0);
-# let input_2 = SpecialA(0);
+# let input_1 = special_a(0);
+# let input_2 = special_a(0);
 macro_rules! early_return(
     ($inp:expr, [ $($sp:ident)|+ ]) => (
         match $inp {
@@ -170,9 +170,9 @@ macro_rules! early_return(
     );
 )
 // ...
-early_return!(input_1, [SpecialA|SpecialC|SpecialD]);
+early_return!(input_1, [special_a|special_c|special_d]);
 // ...
-early_return!(input_2, [SpecialB]);
+early_return!(input_2, [special_b]);
 # return 0;
 # }
 ~~~~
@@ -215,14 +215,14 @@ solves the problem.
 Now consider code like the following:
 
 ~~~~
-# enum T1 { Good1(T2, uint), Bad1};
-# struct T2 { body: T3 }
-# enum T3 { Good2(uint), Bad2};
-# fn f(x: T1) -> uint {
+# enum t1 { good_1(t2, uint), bad_1 };
+# struct t2 { body: t3 }
+# enum t3 { good_2(uint), bad_2};
+# fn f(x: t1) -> uint {
 match x {
-    Good1(g1, val) => {
+    good_1(g1, val) => {
         match g1.body {
-            Good2(result) => {
+            good_2(result) => {
                 // complicated stuff goes here
                 return result + val;
             },
@@ -261,13 +261,13 @@ macro_rules! biased_match (
     )
 )
 
-# enum T1 { Good1(T2, uint), Bad1};
-# struct T2 { body: T3 }
-# enum T3 { Good2(uint), Bad2};
-# fn f(x: T1) -> uint {
-biased_match!((x)       ~ (Good1(g1, val)) else { return 0 };
+# enum t1 { good_1(t2, uint), bad_1 };
+# struct t2 { body: t3 }
+# enum t3 { good_2(uint), bad_2};
+# fn f(x: t1) -> uint {
+biased_match!((x)       ~ (good_1(g1, val)) else { return 0 };
               binds g1, val )
-biased_match!((g1.body) ~ (Good2(result) )
+biased_match!((g1.body) ~ (good_2(result) )
                   else { fail!("Didn't get good_2") };
               binds result )
 // complicated stuff goes here
@@ -365,13 +365,13 @@ macro_rules! biased_match (
 )
 
 
-# enum T1 { Good1(T2, uint), Bad1};
-# struct T2 { body: T3 }
-# enum T3 { Good2(uint), Bad2};
-# fn f(x: T1) -> uint {
+# enum t1 { good_1(t2, uint), bad_1 };
+# struct t2 { body: t3 }
+# enum t3 { good_2(uint), bad_2};
+# fn f(x: t1) -> uint {
 biased_match!(
-    (x)       ~ (Good1(g1, val)) else { return 0 };
-    (g1.body) ~ (Good2(result) ) else { fail!("Didn't get Good2") };
+    (x)       ~ (good_1(g1, val)) else { return 0 };
+    (g1.body) ~ (good_2(result) ) else { fail!("Didn't get good_2") };
     binds val, result )
 // complicated stuff goes here
 return result + val;

branches/try2/src/doc/rust.md

@@ -470,7 +470,7 @@ Two examples of paths with type arguments:
 # use std::hashmap::HashMap;
 # fn f() {
 # fn id<T>(t: T) -> T { t }
-type T = HashMap<int,~str>;  // Type arguments used in a type expression
+type t = HashMap<int,~str>;  // Type arguments used in a type expression
 let x = id::<int>(10);         // Type arguments used in a call expression
 # }
 ~~~~
@@ -701,7 +701,7 @@ An example of a module:
 
 ~~~~
 mod math {
-    type Complex = (f64, f64);
+    type complex = (f64, f64);
     fn sin(f: f64) -> f64 {
         ...
 # fail!();
@@ -2824,13 +2824,13 @@ provided by an implementation of `std::iter::Iterator`.
 An example of a for loop over the contents of a vector:
 
 ~~~~
-# type Foo = int;
-# fn bar(f: Foo) { }
+# type foo = int;
+# fn bar(f: foo) { }
 # let a = 0;
 # let b = 0;
 # let c = 0;
 
-let v: &[Foo] = &[a, b, c];
+let v: &[foo] = &[a, b, c];
 
 for e in v.iter() {
     bar(*e);

branches/try2/src/doc/tutorial.md

@@ -582,32 +582,6 @@ loop {
 This code prints out a weird sequence of numbers and stops as soon as
 it finds one that can be divided by five.
 
-There is also a for-loop that can be used to iterate over a range of numbers:
-
-~~~~
-for n in range(0, 5) {
-    println!("{}", n);
-}
-~~~~
-
-The snippet above prints integer numbers under 5 starting at 0.
-
-More generally, a for loop works with anything implementing the `Iterator` trait.
-Data structures can provide one or more methods that return iterators over
-their contents. For example, strings support iteration over their contents in
-various ways:
-
-~~~~
-let s = "Hello";
-for c in s.chars() {
-    println!("{}", c);
-}
-~~~~
-
-The snippet above prints the characters in "Hello" vertically, adding a new
-line after each character.
-
-
 # Data structures
 
 ## Structs

branches/try2/src/libcollections/lib.rs

@@ -26,7 +26,6 @@ pub use bitv::Bitv;
 pub use btree::BTree;
 pub use deque::Deque;
 pub use dlist::DList;
-pub use enum_set::EnumSet;
 pub use list::List;
 pub use lru_cache::LruCache;
 pub use priority_queue::PriorityQueue;
@@ -38,7 +37,6 @@ pub mod bitv;
 pub mod btree;
 pub mod deque;
 pub mod dlist;
-pub mod enum_set;
 pub mod list;
 pub mod lru_cache;
 pub mod priority_queue;

branches/try2/src/libcollections/enum_set.rs renamed to branches/try2/src/libextra/enum_set.rs

@@ -139,7 +139,7 @@ mod test {
 
     use std::cast;
 
-    use enum_set::{EnumSet, CLike};
+    use enum_set::*;
 
     #[deriving(Eq)]
     #[repr(uint)]