---

yaml
---
r: 162734
b: refs/heads/try
c: 232ffa0
h: refs/heads/master
v: v3

Author: jfager

[refs]

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

branches/try/mk/target.mk

@@ -79,7 +79,7 @@ $$(TLIB$(1)_T_$(2)_H_$(3))/stamp.$(4): \
 	    $$(dir $$@)$$(call CFG_LIB_GLOB_$(2),$(4)))
 	$$(call REMOVE_ALL_OLD_GLOB_MATCHES, \
 	    $$(dir $$@)$$(call CFG_RLIB_GLOB,$(4)))
-	$(Q)CFG_LLVM_LINKAGE_FILE=$$(LLVM_LINKAGE_PATH_$(3)) \
+	$(Q)CFG_LLVM_LINKAGE_FILE=$$(LLVM_LINKAGE_PATH_$(2)) \
 	    $$(subst @,,$$(STAGE$(1)_T_$(2)_H_$(3))) \
 		$$(RUST_LIB_FLAGS_ST$(1)) \
 		-L "$$(RT_OUTPUT_DIR_$(2))" \

branches/try/mk/tests.mk

@@ -412,7 +412,7 @@ $(3)/stage$(1)/test/$(4)test-$(2)$$(X_$(2)): \
 		$$(CRATEFILE_$(4)) \
 		$$(TESTDEP_$(1)_$(2)_$(3)_$(4))
 	@$$(call E, rustc: $$@)
-	$(Q)CFG_LLVM_LINKAGE_FILE=$$(LLVM_LINKAGE_PATH_$(3)) \
+	$(Q)CFG_LLVM_LINKAGE_FILE=$$(LLVM_LINKAGE_PATH_$(2)) \
 	    $$(subst @,,$$(STAGE$(1)_T_$(2)_H_$(3))) -o $$@ $$< --test \
 		-L "$$(RT_OUTPUT_DIR_$(2))" \
 		-L "$$(LLVM_LIBDIR_$(2))" \
@@ -598,7 +598,7 @@ CTEST_DISABLE_debuginfo-lldb = "lldb tests are only run on darwin"
 endif
 
 ifeq ($(CFG_OSTYPE),apple-darwin)
-CTEST_DISABLE_debuginfo-gdb = "gdb on darwin needs root"
+CTEST_DISABLE_debuginfo-gdb = "gdb on darwing needs root"
 endif
 
 # CTEST_DISABLE_NONSELFHOST_$(TEST_GROUP), if set, will cause that
@@ -891,7 +891,7 @@ endif
 ifeq ($(2),$$(CFG_BUILD))
 $$(call TEST_OK_FILE,$(1),$(2),$(3),doc-crate-$(4)): $$(CRATEDOCTESTDEP_$(1)_$(2)_$(3)_$(4))
 	@$$(call E, run doc-crate-$(4) [$(2)])
-	$$(Q)CFG_LLVM_LINKAGE_FILE=$$(LLVM_LINKAGE_PATH_$(3)) \
+	$$(Q)CFG_LLVM_LINKAGE_FILE=$$(LLVM_LINKAGE_PATH_$(2)) \
 	    $$(RUSTDOC_$(1)_T_$(2)_H_$(3)) --test --cfg dox \
 	    	$$(CRATEFILE_$(4)) --test-args "$$(TESTARGS)" && touch $$@
 else

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");