---

yaml
---
r: 162724
b: refs/heads/try
c: 432adc6
h: refs/heads/master
v: v3

Author: ftxqxd

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 9146a919b616e39e528e4d7100d16eef52f1f852
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: cafe2966770ff377aad6dd9fd808e68055587c58
-refs/heads/try: 3ee471cab5ed17b14484c636c02d95fa1699e76f
+refs/heads/try: 432adc675e2955cbc639cbecf318dc23e053e7e2
 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. 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.
+* 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.
 * 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 are also a few things you can do with a tuple as a whole, without
+There 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,13 +656,6 @@ 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,10 +92,11 @@
 
 #[cfg(test)] #[phase(plugin, link)] extern crate log;
 
-use self::Name::*;
-use self::HasArg::*;
-use self::Occur::*;
-use self::Fail::*;
+pub use self::Name::*;
+pub use self::HasArg::*;
+pub use self::Occur::*;
+pub use self::Fail_::*;
+pub use self::FailType::*;
 use self::Optval::*;
 
 use std::fmt;
@@ -190,7 +191,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.
@@ -203,8 +204,19 @@ 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 {
@@ -252,7 +264,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)),
@@ -354,12 +366,11 @@ impl Matches {
     pub fn opt_default(&self, nm: &str, def: &str) -> Option<String> {
         let vals = self.opt_vals(nm);
         if vals.is_empty() {
-            None
-        } else {
-            match vals[0] {
-                Val(ref s) => Some((*s).clone()),
-                _ => Some(def.to_string())
-            }
+            return None;
+        }
+        match vals[0] {
+            Val(ref s) => Some((*s).clone()),
+            _ => Some(def.to_string())
         }
     }
 
@@ -523,15 +534,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) => {
@@ -559,7 +570,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();
@@ -670,15 +681,21 @@ pub fn getopts(args: &[String], optgrps: &[OptGroup]) -> Result {
         }
         i += 1;
     }
-    for i in range(0u, n_opts) {
+    i = 0u;
+    while i < n_opts {
         let n = vals[i].len();
         let occ = opts[i].occur;
-        if occ == Req && n == 0 {
-            return Err(OptionMissing(opts[i].name.to_string()));
+        if occ == Req {
+            if n == 0 {
+                return Err(OptionMissing(opts[i].name.to_string()));
+            }
         }
-        if occ != Multi && n > 1 {
-            return Err(OptionDuplicated(opts[i].name.to_string()));
+        if occ != Multi {
+            if n > 1 {
+                return Err(OptionDuplicated(opts[i].name.to_string()));
+            }
         }
+        i += 1;
     }
     Ok(Matches {
         opts: opts,
@@ -949,11 +966,20 @@ 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() {
@@ -987,7 +1013,7 @@ mod tests {
         let opts = vec!(reqopt("t", "test", "testing", "TEST"));
         let rs = getopts(args.as_slice(), opts.as_slice());
         match rs {
-          Err(OptionMissing(_)) => {},
+          Err(f) => check_fail_type(f, OptionMissing_),
           _ => panic!()
         }
     }
@@ -998,12 +1024,12 @@ mod tests {
         let opts = vec!(reqopt("t", "test", "testing", "TEST"));
         let rs = getopts(long_args.as_slice(), opts.as_slice());
         match rs {
-          Err(ArgumentMissing(_)) => {},
+          Err(f) => check_fail_type(f, ArgumentMissing_),
           _ => panic!()
         }
         let short_args = vec!("-t".to_string());
         match getopts(short_args.as_slice(), opts.as_slice()) {
-          Err(ArgumentMissing(_)) => {},
+          Err(f) => check_fail_type(f, ArgumentMissing_),
           _ => panic!()
         }
     }
@@ -1014,7 +1040,7 @@ mod tests {
         let opts = vec!(reqopt("t", "test", "testing", "TEST"));
         let rs = getopts(args.as_slice(), opts.as_slice());
         match rs {
-          Err(OptionDuplicated(_)) => {},
+          Err(f) => check_fail_type(f, OptionDuplicated_),
           _ => panic!()
         }
     }
@@ -1066,12 +1092,12 @@ mod tests {
         let opts = vec!(optopt("t", "test", "testing", "TEST"));
         let rs = getopts(long_args.as_slice(), opts.as_slice());
         match rs {
-          Err(ArgumentMissing(_)) => {},
+          Err(f) => check_fail_type(f, ArgumentMissing_),
           _ => panic!()
         }
         let short_args = vec!("-t".to_string());
         match getopts(short_args.as_slice(), opts.as_slice()) {
-          Err(ArgumentMissing(_)) => {},
+          Err(f) => check_fail_type(f, ArgumentMissing_),
           _ => panic!()
         }
     }
@@ -1082,7 +1108,7 @@ mod tests {
         let opts = vec!(optopt("t", "test", "testing", "TEST"));
         let rs = getopts(args.as_slice(), opts.as_slice());
         match rs {
-          Err(OptionDuplicated(_)) => {},
+          Err(f) => check_fail_type(f, OptionDuplicated_),
           _ => panic!()
         }
     }
@@ -1130,7 +1156,9 @@ mod tests {
         let opts = vec!(optflag("t", "test", "testing"));
         let rs = getopts(args.as_slice(), opts.as_slice());
         match rs {
-          Err(UnexpectedArgument(_)) => {},
+          Err(f) => {
+            check_fail_type(f, UnexpectedArgument_);
+          }
           _ => panic!()
         }
     }
@@ -1141,7 +1169,7 @@ mod tests {
         let opts = vec!(optflag("t", "test", "testing"));
         let rs = getopts(args.as_slice(), opts.as_slice());
         match rs {
-          Err(OptionDuplicated(_)) => {},
+          Err(f) => check_fail_type(f, OptionDuplicated_),
           _ => panic!()
         }
     }
@@ -1289,12 +1317,12 @@ mod tests {
         let opts = vec!(optmulti("t", "test", "testing", "TEST"));
         let rs = getopts(long_args.as_slice(), opts.as_slice());
         match rs {
-          Err(ArgumentMissing(_)) => {},
+          Err(f) => check_fail_type(f, ArgumentMissing_),
           _ => panic!()
         }
         let short_args = vec!("-t".to_string());
         match getopts(short_args.as_slice(), opts.as_slice()) {
-          Err(ArgumentMissing(_)) => {},
+          Err(f) => check_fail_type(f, ArgumentMissing_),
           _ => panic!()
         }
     }
@@ -1324,12 +1352,12 @@ mod tests {
         let opts = vec!(optmulti("t", "test", "testing", "TEST"));
         let rs = getopts(long_args.as_slice(), opts.as_slice());
         match rs {
-          Err(UnrecognizedOption(_)) => {},
+          Err(f) => check_fail_type(f, UnrecognizedOption_),
           _ => panic!()
         }
         let short_args = vec!("-u".to_string());
         match getopts(short_args.as_slice(), opts.as_slice()) {
-          Err(UnrecognizedOption(_)) => {},
+          Err(f) => check_fail_type(f, UnrecognizedOption_),
           _ => panic!()
         }
     }
@@ -1465,14 +1493,14 @@ mod tests {
     #[test]
     fn test_long_to_short() {
         let mut short = Opt {
-            name: Name::Long("banana".to_string()),
-            hasarg: HasArg::Yes,
-            occur: Occur::Req,
+            name: Long("banana".to_string()),
+            hasarg: Yes,
+            occur: Req,
             aliases: Vec::new(),
         };
-        short.aliases = vec!(Opt { name: Name::Short('b'),
-                                hasarg: HasArg::Yes,
-                                occur: Occur::Req,
+        short.aliases = vec!(Opt { name: Short('b'),
+                                hasarg: Yes,
+                                occur: Req,
                                 aliases: Vec::new() });
         let verbose = reqopt("b", "banana", "some bananas", "VAL");
 

branches/try/src/librustc/middle/resolve.rs

@@ -3239,7 +3239,7 @@ impl<'a> Resolver<'a> {
                                             segment_name),
                         }
                     } else {
-                        format!("Could not find `{}` in `{}`.",
+                        format!("Could not find `{}` in `{}`",
                                 segment_name,
                                 module_name)
                     };
@@ -4744,7 +4744,7 @@ impl<'a> Resolver<'a> {
                         Some(&DefMod(_)) => {
                             self.resolve_error(path.span, "inherent implementations are not \
                                                            allowed for types not defined in \
-                                                           the current module.");
+                                                           the current module");
                         }
                         _ => {}
                     }
@@ -5843,12 +5843,12 @@ impl<'a> Resolver<'a> {
                                     };
 
                                     if msg.len() > 0 {
-                                        msg = format!(" Did you mean {}?", msg)
+                                        msg = format!(". Did you mean {}?", msg)
                                     }
 
                                     self.resolve_error(
                                         expr.span,
-                                        format!("unresolved name `{}`.{}",
+                                        format!("unresolved name `{}`{}",
                                                 wrong_name,
                                                 msg).as_slice());
                                 }

branches/try/src/librustc/middle/typeck/collect.rs

@@ -184,7 +184,7 @@ impl<'a, 'tcx> AstConv<'tcx> for CrateCtxt<'a, 'tcx> {
 
     fn ty_infer(&self, span: Span) -> Ty<'tcx> {
         span_err!(self.tcx.sess, span, E0121,
-                  "the type placeholder `_` is not allowed within types on item signatures.");
+                  "the type placeholder `_` is not allowed within types on item signatures");
         ty::mk_err()
     }
 
@@ -1715,7 +1715,7 @@ fn add_unsized_bound<'tcx,AC>(this: &AC,
                                                        the given bound is not \
                                                        a default. \
                                                        Only `Sized?` is \
-                                                       supported.",
+                                                       supported",
                                                       desc).as_slice());
                     ty::try_add_builtin_trait(this.tcx(),
                                               kind_id,

branches/try/src/librustc/middle/typeck/infer/error_reporting.rs

@@ -1648,15 +1648,15 @@ impl<'a, 'tcx> ErrorReportingHelpers<'tcx> for InferCtxt<'a, 'tcx> {
                 self.tcx.sess.span_note(
                     span,
                     format!("...so that the type `{}` \
-                             will meet the declared lifetime bounds.",
+                             will meet the declared lifetime bounds",
                             self.ty_to_string(t)).as_slice());
             }
             infer::RelateDefaultParamBound(span, t) => {
                 self.tcx.sess.span_note(
                     span,
                     format!("...so that type parameter \
                              instantiated with `{}`, \
-                             will meet its declared lifetime bounds.",
+                             will meet its declared lifetime bounds",
                             self.ty_to_string(t)).as_slice());
             }
             infer::RelateRegionParamBound(span) => {