---

yaml
---
r: 162725
b: refs/heads/try
c: acad03a
h: refs/heads/master
i:
  162723: 013f1f9
v: v3

Author: bors

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 9146a919b616e39e528e4d7100d16eef52f1f852
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: cafe2966770ff377aad6dd9fd808e68055587c58
-refs/heads/try: 432adc675e2955cbc639cbecf318dc23e053e7e2
+refs/heads/try: acad03a420186ee8f0c28626e59eee55664dd0b4
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596

branches/try/src/doc/complement-lang-faq.md

@@ -108,7 +108,7 @@ The `str` type is UTF-8 because we observe more text in the wild in this encodin
 
 This does mean that indexed access to a Unicode codepoint inside a `str` value is an O(n) operation. On the one hand, this is clearly undesirable; on the other hand, this problem is full of trade-offs and we'd like to point a few important qualifications:
 
-* Scanning a `str` for ASCII-range codepoints can still be done safely octet-at-a-time, with each indexing operation pulling out a `u8` costing only O(1) and producing a value that can be cast and compared to an ASCII-range `char`. So if you're (say) line-breaking on `'\n'`, octet-based treatment still works. UTF8 was well-designed this way.
+* Scanning a `str` for ASCII-range codepoints can still be done safely octet-at-a-time. If you use `.as_bytes()`, pulling out a `u8` costs only O(1) and produces a value that can be cast and compared to an ASCII-range `char`. So if you're (say) line-breaking on `'\n'`, octet-based treatment still works. UTF8 was well-designed this way.
 * Most "character oriented" operations on text only work under very restricted language assumptions sets such as "ASCII-range codepoints only". Outside ASCII-range, you tend to have to use a complex (non-constant-time) algorithm for determining linguistic-unit (glyph, word, paragraph) boundaries anyways. We recommend using an "honest" linguistically-aware, Unicode-approved algorithm.
 * The `char` type is UCS4. If you honestly need to do a codepoint-at-a-time algorithm, it's trivial to write a `type wstr = [char]`, and unpack a `str` into it in a single pass, then work with the `wstr`. In other words: the fact that the language is not "decoding to UCS4 by default" shouldn't stop you from decoding (or re-encoding any other way) if you need to work with that encoding.
 

branches/try/src/doc/guide.md

@@ -922,7 +922,7 @@ or 'breaks up,' the tuple, and assigns the bits to three bindings.
 
 This pattern is very powerful, and we'll see it repeated more later.
 
-There also a few things you can do with a tuple as a whole, without
+There are also a few things you can do with a tuple as a whole, without
 destructuring. You can assign one tuple into another, if they have the same
 arity and contained types.
 

branches/try/src/libcollections/str.rs

@@ -656,6 +656,13 @@ Section: CowString
 /// A clone-on-write string
 pub type CowString<'a> = Cow<'a, String, str>;
 
+impl<'a> Str for CowString<'a> {
+    #[inline]
+    fn as_slice<'b>(&'b self) -> &'b str {
+        (**self).as_slice()
+    }
+}
+
 /*
 Section: Trait implementations
 */

branches/try/src/libgetopts/lib.rs

@@ -92,11 +92,10 @@
 
 #[cfg(test)] #[phase(plugin, link)] extern crate log;
 
-pub use self::Name::*;
-pub use self::HasArg::*;
-pub use self::Occur::*;
-pub use self::Fail_::*;
-pub use self::FailType::*;
+use self::Name::*;
+use self::HasArg::*;
+use self::Occur::*;
+use self::Fail::*;
 use self::Optval::*;
 
 use std::fmt;
@@ -191,7 +190,7 @@ pub struct Matches {
 /// expected format. Use the `Show` implementation to output detailed
 /// information.
 #[deriving(Clone, PartialEq, Eq)]
-pub enum Fail_ {
+pub enum Fail {
     /// The option requires an argument but none was passed.
     ArgumentMissing(String),
     /// The passed option is not declared among the possible options.
@@ -204,19 +203,8 @@ pub enum Fail_ {
     UnexpectedArgument(String),
 }
 
-/// The type of failure that occurred.
-#[deriving(PartialEq, Eq)]
-#[allow(missing_docs)]
-pub enum FailType {
-    ArgumentMissing_,
-    UnrecognizedOption_,
-    OptionMissing_,
-    OptionDuplicated_,
-    UnexpectedArgument_,
-}
-
 /// The result of parsing a command line with a set of options.
-pub type Result = result::Result<Matches, Fail_>;
+pub type Result = result::Result<Matches, Fail>;
 
 impl Name {
     fn from_str(nm: &str) -> Name {
@@ -264,7 +252,7 @@ impl OptGroup {
             (1,_) => Opt {
                 name: Long((long_name)),
                 hasarg: hasarg,
-                occur:  occur,
+                occur: occur,
                 aliases: vec!(
                     Opt {
                         name: Short(short_name.as_slice().char_at(0)),
@@ -366,11 +354,12 @@ impl Matches {
     pub fn opt_default(&self, nm: &str, def: &str) -> Option<String> {
         let vals = self.opt_vals(nm);
         if vals.is_empty() {
-            return None;
-        }
-        match vals[0] {
-            Val(ref s) => Some((*s).clone()),
-            _ => Some(def.to_string())
+            None
+        } else {
+            match vals[0] {
+                Val(ref s) => Some((*s).clone()),
+                _ => Some(def.to_string())
+            }
         }
     }
 
@@ -534,15 +523,15 @@ pub fn opt(short_name: &str,
     }
 }
 
-impl Fail_ {
-    /// Convert a `Fail_` enum into an error string.
+impl Fail {
+    /// Convert a `Fail` enum into an error string.
     #[deprecated="use `Show` (`{}` format specifier)"]
     pub fn to_err_msg(self) -> String {
         self.to_string()
     }
 }
 
-impl fmt::Show for Fail_ {
+impl fmt::Show for Fail {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
             ArgumentMissing(ref nm) => {
@@ -570,7 +559,7 @@ impl fmt::Show for Fail_ {
 /// `opt_str`, etc. to interrogate results.
 /// # Panics
 ///
-/// Returns `Err(Fail_)` on failure: use the `Show` implementation of `Fail_` to display
+/// Returns `Err(Fail)` on failure: use the `Show` implementation of `Fail` to display
 /// information about it.
 pub fn getopts(args: &[String], optgrps: &[OptGroup]) -> Result {
     let opts: Vec<Opt> = optgrps.iter().map(|x| x.long_to_short()).collect();
@@ -681,21 +670,15 @@ pub fn getopts(args: &[String], optgrps: &[OptGroup]) -> Result {
         }
         i += 1;
     }
-    i = 0u;
-    while i < n_opts {
+    for i in range(0u, n_opts) {
         let n = vals[i].len();
         let occ = opts[i].occur;
-        if occ == Req {
-            if n == 0 {
-                return Err(OptionMissing(opts[i].name.to_string()));
-            }
+        if occ == Req && n == 0 {
+            return Err(OptionMissing(opts[i].name.to_string()));
         }
-        if occ != Multi {
-            if n > 1 {
-                return Err(OptionDuplicated(opts[i].name.to_string()));
-            }
+        if occ != Multi && n > 1 {
+            return Err(OptionDuplicated(opts[i].name.to_string()));
         }
-        i += 1;
     }
     Ok(Matches {
         opts: opts,
@@ -966,20 +949,11 @@ fn test_split_within() {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use super::Fail::*;
 
     use std::result::{Err, Ok};
     use std::result;
 
-    fn check_fail_type(f: Fail_, ft: FailType) {
-        match f {
-          ArgumentMissing(_) => assert!(ft == ArgumentMissing_),
-          UnrecognizedOption(_) => assert!(ft == UnrecognizedOption_),
-          OptionMissing(_) => assert!(ft == OptionMissing_),
-          OptionDuplicated(_) => assert!(ft == OptionDuplicated_),
-          UnexpectedArgument(_) => assert!(ft == UnexpectedArgument_)
-        }
-    }
-
     // Tests for reqopt
     #[test]
     fn test_reqopt() {
@@ -1013,7 +987,7 @@ mod tests {
         let opts = vec!(reqopt("t", "test", "testing", "TEST"));
         let rs = getopts(args.as_slice(), opts.as_slice());
         match rs {
-          Err(f) => check_fail_type(f, OptionMissing_),
+          Err(OptionMissing(_)) => {},
           _ => panic!()
         }
     }
@@ -1024,12 +998,12 @@ mod tests {
         let opts = vec!(reqopt("t", "test", "testing", "TEST"));
         let rs = getopts(long_args.as_slice(), opts.as_slice());
         match rs {
-          Err(f) => check_fail_type(f, ArgumentMissing_),
+          Err(ArgumentMissing(_)) => {},
           _ => panic!()
         }
         let short_args = vec!("-t".to_string());
         match getopts(short_args.as_slice(), opts.as_slice()) {
-          Err(f) => check_fail_type(f, ArgumentMissing_),
+          Err(ArgumentMissing(_)) => {},
           _ => panic!()
         }
     }
@@ -1040,7 +1014,7 @@ mod tests {
         let opts = vec!(reqopt("t", "test", "testing", "TEST"));
         let rs = getopts(args.as_slice(), opts.as_slice());
         match rs {
-          Err(f) => check_fail_type(f, OptionDuplicated_),
+          Err(OptionDuplicated(_)) => {},
           _ => panic!()
         }
     }
@@ -1092,12 +1066,12 @@ mod tests {
         let opts = vec!(optopt("t", "test", "testing", "TEST"));
         let rs = getopts(long_args.as_slice(), opts.as_slice());
         match rs {
-          Err(f) => check_fail_type(f, ArgumentMissing_),
+          Err(ArgumentMissing(_)) => {},
           _ => panic!()
         }
         let short_args = vec!("-t".to_string());
         match getopts(short_args.as_slice(), opts.as_slice()) {
-          Err(f) => check_fail_type(f, ArgumentMissing_),
+          Err(ArgumentMissing(_)) => {},
           _ => panic!()
         }
     }
@@ -1108,7 +1082,7 @@ mod tests {
         let opts = vec!(optopt("t", "test", "testing", "TEST"));
         let rs = getopts(args.as_slice(), opts.as_slice());
         match rs {
-          Err(f) => check_fail_type(f, OptionDuplicated_),
+          Err(OptionDuplicated(_)) => {},
           _ => panic!()
         }
     }
@@ -1156,9 +1130,7 @@ mod tests {
         let opts = vec!(optflag("t", "test", "testing"));
         let rs = getopts(args.as_slice(), opts.as_slice());
         match rs {
-          Err(f) => {
-            check_fail_type(f, UnexpectedArgument_);
-          }
+          Err(UnexpectedArgument(_)) => {},
           _ => panic!()
         }
     }
@@ -1169,7 +1141,7 @@ mod tests {
         let opts = vec!(optflag("t", "test", "testing"));
         let rs = getopts(args.as_slice(), opts.as_slice());
         match rs {
-          Err(f) => check_fail_type(f, OptionDuplicated_),
+          Err(OptionDuplicated(_)) => {},
           _ => panic!()
         }
     }
@@ -1317,12 +1289,12 @@ mod tests {
         let opts = vec!(optmulti("t", "test", "testing", "TEST"));
         let rs = getopts(long_args.as_slice(), opts.as_slice());
         match rs {
-          Err(f) => check_fail_type(f, ArgumentMissing_),
+          Err(ArgumentMissing(_)) => {},
           _ => panic!()
         }
         let short_args = vec!("-t".to_string());
         match getopts(short_args.as_slice(), opts.as_slice()) {
-          Err(f) => check_fail_type(f, ArgumentMissing_),
+          Err(ArgumentMissing(_)) => {},
           _ => panic!()
         }
     }
@@ -1352,12 +1324,12 @@ mod tests {
         let opts = vec!(optmulti("t", "test", "testing", "TEST"));
         let rs = getopts(long_args.as_slice(), opts.as_slice());
         match rs {
-          Err(f) => check_fail_type(f, UnrecognizedOption_),
+          Err(UnrecognizedOption(_)) => {},
           _ => panic!()
         }
         let short_args = vec!("-u".to_string());
         match getopts(short_args.as_slice(), opts.as_slice()) {
-          Err(f) => check_fail_type(f, UnrecognizedOption_),
+          Err(UnrecognizedOption(_)) => {},
           _ => panic!()
         }
     }
@@ -1493,14 +1465,14 @@ mod tests {
     #[test]
     fn test_long_to_short() {
         let mut short = Opt {
-            name: Long("banana".to_string()),
-            hasarg: Yes,
-            occur: Req,
+            name: Name::Long("banana".to_string()),
+            hasarg: HasArg::Yes,
+            occur: Occur::Req,
             aliases: Vec::new(),
         };
-        short.aliases = vec!(Opt { name: Short('b'),
-                                hasarg: Yes,
-                                occur: Req,
+        short.aliases = vec!(Opt { name: Name::Short('b'),
+                                hasarg: HasArg::Yes,
+                                occur: Occur::Req,
                                 aliases: Vec::new() });
         let verbose = reqopt("b", "banana", "some bananas", "VAL");
 

branches/try/src/librustc_trans/driver/driver.rs

@@ -51,6 +51,12 @@ pub fn compile_input(sess: Session,
                      outdir: &Option<Path>,
                      output: &Option<Path>,
                      addl_plugins: Option<Plugins>) {
+    // These may be left in an incoherent state after a previous compile.
+    // `clear_tables` and `get_ident_interner().clear()` can be used to free
+    // memory, but they do not restore the initial state.
+    syntax::ext::mtwt::reset_tables();
+    token::reset_ident_interner();
+
     // We need nested scopes here, because the intermediate results can keep
     // large chunks of memory alive and we want to free them as soon as
     // possible to keep the peak memory usage low

branches/try/src/librustc_trans/trans/asm.rs

@@ -77,19 +77,22 @@ pub fn trans_inline_asm<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, ia: &ast::InlineAsm)
     // no failure occurred preparing operands, no need to cleanup
     fcx.pop_custom_cleanup_scope(temp_scope);
 
-    let mut constraints =
-        String::from_str(constraints.iter()
-                                    .map(|s| s.get().to_string())
-                                    .chain(ext_constraints.into_iter())
-                                    .collect::<Vec<String>>()
-                                    .connect(",")
-                                    .as_slice());
-
-    let mut clobbers = get_clobbers();
-    if !ia.clobbers.get().is_empty() && !clobbers.is_empty() {
-        clobbers = format!("{},{}", ia.clobbers.get(), clobbers);
-    } else {
-        clobbers.push_str(ia.clobbers.get());
+    let mut constraints = constraints.iter()
+                                     .map(|s| s.get().to_string())
+                                     .chain(ext_constraints.into_iter())
+                                     .collect::<Vec<String>>()
+                                     .connect(",");
+
+    let mut clobbers = ia.clobbers.iter()
+                                  .map(|s| format!("~{{{}}}", s.get()))
+                                  .collect::<Vec<String>>()
+                                  .connect(",");
+    let more_clobbers = get_clobbers();
+    if !more_clobbers.is_empty() {
+        if !clobbers.is_empty() {
+            clobbers.push(',');
+        }
+        clobbers.push_str(more_clobbers.as_slice());
     }
 
     // Add the clobbers to our constraints list