---

yaml
---
r: 153049
b: refs/heads/try2
c: 94a56a3
h: refs/heads/master
i:
  153047: 3d079ab
v: v3

Author: luqmana

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

branches/try2/src/doc/rust.md

@@ -2155,6 +2155,8 @@ These are functions:
 
 * `str_eq`
   : Compare two strings (`&str`) for equality.
+* `uniq_str_eq`
+  : Compare two owned strings (`String`) for equality.
 * `strdup_uniq`
   : Return a new unique string
     containing a copy of the contents of a unique string.

branches/try2/src/doc/rustdoc.md

@@ -51,7 +51,7 @@ Calculates the factorial of a number.
 
 Given the input integer `n`, this function will calculate `n!` and return it.
 "]
-pub fn factorial(n: int) -> int { if n < 2 {1} else {n * factorial(n - 1)} }
+pub fn factorial(n: int) -> int { if n < 2 {1} else {n * factorial(n)} }
 # fn main() {}
 ~~~
 

branches/try2/src/etc/install.sh

@@ -35,13 +35,6 @@ need_ok() {
     fi
 }
 
-need_cmd() {
-    if command -v $1 >/dev/null 2>&1
-    then msg "found $1"
-    else err "need $1"
-    fi
-}
-
 putvar() {
     local T
     eval T=\$$1
@@ -205,15 +198,6 @@ absolutify() {
     ABSOLUTIFIED="${FILE_PATH}"
 }
 
-msg "looking for install programs"
-need_cmd mkdir
-need_cmd printf
-need_cmd cut
-need_cmd grep
-need_cmd uname
-need_cmd tr
-need_cmd sed
-
 CFG_SRC_DIR="$(cd $(dirname $0) && pwd)/"
 CFG_SELF="$0"
 CFG_ARGS="$@"
@@ -232,65 +216,16 @@ else
     step_msg "processing $CFG_SELF args"
 fi
 
-# Check for mingw or cygwin in order to special case $CFG_LIBDIR_RELATIVE.
-# This logic is duplicated from configure in order to get the correct libdir
-# for Windows installs.
-CFG_OSTYPE=$(uname -s)
-
-case $CFG_OSTYPE in
-
-    MINGW32*)
-        CFG_OSTYPE=pc-mingw32
-        ;;
-
-    MINGW64*)
-        # msys2, MSYSTEM=MINGW64
-        CFG_OSTYPE=w64-mingw32
-        ;;
-
-# Thad's Cygwin identifers below
-
-#   Vista 32 bit
-    CYGWIN_NT-6.0)
-        CFG_OSTYPE=pc-mingw32
-        ;;
-
-#   Vista 64 bit
-    CYGWIN_NT-6.0-WOW64)
-        CFG_OSTYPE=w64-mingw32
-        ;;
-
-#   Win 7 32 bit
-    CYGWIN_NT-6.1)
-        CFG_OSTYPE=pc-mingw32
-        ;;
-
-#   Win 7 64 bit
-    CYGWIN_NT-6.1-WOW64)
-        CFG_OSTYPE=w64-mingw32
-        ;;
-esac
-
 OPTIONS=""
 BOOL_OPTIONS=""
 VAL_OPTIONS=""
 
-# On windows we just store the libraries in the bin directory because
-# there's no rpath. This is where the build system itself puts libraries;
-# --libdir is used to configure the installation directory.
-# FIXME: Thise needs to parameterized over target triples. Do it in platform.mk
-CFG_LIBDIR_RELATIVE=lib
-if [ "$CFG_OSTYPE" = "pc-mingw32" ] || [ "$CFG_OSTYPE" = "w64-mingw32" ]
-then
-    CFG_LIBDIR_RELATIVE=bin
-fi
-
 flag uninstall "only uninstall from the installation prefix"
 opt verify 1 "verify that the installed binaries run correctly"
 valopt prefix "/usr/local" "set installation prefix"
 # NB This isn't quite the same definition as in `configure`.
 # just using 'lib' instead of CFG_LIBDIR_RELATIVE
-valopt libdir "${CFG_PREFIX}/${CFG_LIBDIR_RELATIVE}" "install libraries"
+valopt libdir "${CFG_PREFIX}/lib" "install libraries"
 valopt mandir "${CFG_PREFIX}/share/man" "install man pages in PATH"
 
 if [ $HELP -eq 1 ]
@@ -449,7 +384,7 @@ while read p; do
     need_ok "failed to update manifest"
 
 # The manifest lists all files to install
-done < "${CFG_SRC_DIR}/${CFG_LIBDIR_RELATIVE}/rustlib/manifest.in"
+done < "${CFG_SRC_DIR}/lib/rustlib/manifest.in"
 
 # Sanity check: can we run the installed binaries?
 if [ -z "${CFG_DISABLE_VERIFY}" ]

branches/try2/src/libcore/num/mod.rs

@@ -586,14 +586,14 @@ macro_rules! int_impl {
             fn rotate_left(self, n: uint) -> $T {
                 // Protect against undefined behaviour for over-long bit shifts
                 let n = n % $BITS;
-                (self << n) | (self >> (($BITS - n) % $BITS))
+                (self << n) | (self >> ($BITS - n))
             }
 
             #[inline]
             fn rotate_right(self, n: uint) -> $T {
                 // Protect against undefined behaviour for over-long bit shifts
                 let n = n % $BITS;
-                (self >> n) | (self << (($BITS - n) % $BITS))
+                (self >> n) | (self << ($BITS - n))
             }
 
             #[inline]

branches/try2/src/libcoretest/num/int_macros.rs

@@ -114,15 +114,6 @@ mod tests {
         assert_eq!(_1.rotate_left(124), _1);
         assert_eq!(_0.rotate_right(124), _0);
         assert_eq!(_1.rotate_right(124), _1);
-
-        // Rotating by 0 should have no effect
-        assert_eq!(A.rotate_left(0), A);
-        assert_eq!(B.rotate_left(0), B);
-        assert_eq!(C.rotate_left(0), C);
-        // Rotating by a multiple of word size should also have no effect
-        assert_eq!(A.rotate_left(64), A);
-        assert_eq!(B.rotate_left(64), B);
-        assert_eq!(C.rotate_left(64), C);
     }
 
     #[test]

branches/try2/src/libcoretest/num/uint_macros.rs

@@ -74,15 +74,6 @@ mod tests {
         assert_eq!(_1.rotate_left(124), _1);
         assert_eq!(_0.rotate_right(124), _0);
         assert_eq!(_1.rotate_right(124), _1);
-
-        // Rotating by 0 should have no effect
-        assert_eq!(A.rotate_left(0), A);
-        assert_eq!(B.rotate_left(0), B);
-        assert_eq!(C.rotate_left(0), C);
-        // Rotating by a multiple of word size should also have no effect
-        assert_eq!(A.rotate_left(64), A);
-        assert_eq!(B.rotate_left(64), B);
-        assert_eq!(C.rotate_left(64), C);
     }
 
     #[test]

branches/try2/src/libnum/rational.rs

@@ -274,17 +274,12 @@ impl<T: Clone + Integer + PartialOrd>
     Num for Ratio<T> {}
 
 /* String conversions */
-impl<T: fmt::Show + Eq + One> fmt::Show for Ratio<T> {
-    /// Renders as `numer/denom`. If denom=1, renders as numer.
+impl<T: fmt::Show> fmt::Show for Ratio<T> {
+    /// Renders as `numer/denom`.
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        if self.denom == One::one() {
-            write!(f, "{}", self.numer)
-        } else {
-            write!(f, "{}/{}", self.numer, self.denom)
-        }
+        write!(f, "{}/{}", self.numer, self.denom)
     }
 }
-
 impl<T: ToStrRadix> ToStrRadix for Ratio<T> {
     /// Renders as `numer/denom` where the numbers are in base `radix`.
     fn to_str_radix(&self, radix: uint) -> String {
@@ -296,20 +291,21 @@ impl<T: ToStrRadix> ToStrRadix for Ratio<T> {
 
 impl<T: FromStr + Clone + Integer + PartialOrd>
     FromStr for Ratio<T> {
-    /// Parses `numer/denom` or just `numer`
+    /// Parses `numer/denom`.
     fn from_str(s: &str) -> Option<Ratio<T>> {
-        let mut split = s.splitn('/', 1);
-
-        let num = split.next().and_then(|n| FromStr::from_str(n));
-        let den = split.next().or(Some("1")).and_then(|d| FromStr::from_str(d));
-
-        match (num, den) {
-            (Some(n), Some(d)) => Some(Ratio::new(n, d)),
-            _ => None
+        let split: Vec<&str> = s.splitn('/', 1).collect();
+        if split.len() < 2 {
+            return None
         }
+        let a_option: Option<T> = FromStr::from_str(*split.get(0));
+        a_option.and_then(|a| {
+            let b_option: Option<T> = FromStr::from_str(*split.get(1));
+            b_option.and_then(|b| {
+                Some(Ratio::new(a.clone(), b.clone()))
+            })
+        })
     }
 }
-
 impl<T: FromStrRadix + Clone + Integer + PartialOrd>
     FromStrRadix for Ratio<T> {
     /// Parses `numer/denom` where the numbers are in base `radix`.
@@ -433,13 +429,6 @@ mod test {
         assert!(!_neg1_2.is_integer());
     }
 
-    #[test]
-    fn test_show() {
-        assert_eq!(format!("{}", _2), "2".to_string());
-        assert_eq!(format!("{}", _1_2), "1/2".to_string());
-        assert_eq!(format!("{}", _0), "0".to_string());
-        assert_eq!(format!("{}", Ratio::from_integer(-2i)), "-2".to_string());
-    }
 
     mod arith {
         use super::{_0, _1, _2, _1_2, _3_2, _neg1_2, to_big};
@@ -573,11 +562,11 @@ mod test {
             assert_eq!(FromStr::from_str(s.as_slice()), Some(r));
             assert_eq!(r.to_str(), s);
         }
-        test(_1, "1".to_string());
-        test(_0, "0".to_string());
+        test(_1, "1/1".to_string());
+        test(_0, "0/1".to_string());
         test(_1_2, "1/2".to_string());
         test(_3_2, "3/2".to_string());
-        test(_2, "2".to_string());
+        test(_2, "2/1".to_string());
         test(_neg1_2, "-1/2".to_string());
     }
     #[test]

branches/try2/src/librustc/middle/check_match.rs

@@ -74,12 +74,12 @@ impl fmt::Show for Matrix {
     }
 }
 
-pub struct MatchCheckCtxt<'a> {
-    pub tcx: &'a ty::ctxt
+struct MatchCheckCtxt<'a> {
+    tcx: &'a ty::ctxt
 }
 
 #[deriving(Clone, PartialEq)]
-pub enum Constructor {
+enum Constructor {
     /// The constructor of all patterns that don't vary by constructor,
     /// e.g. struct patterns and fixed-length arrays.
     Single,
@@ -492,9 +492,9 @@ fn is_useful_specialized(cx: &MatchCheckCtxt, &Matrix(ref m): &Matrix, v: &[Gc<P
                          ctor: Constructor, lty: ty::t, witness: WitnessPreference) -> Usefulness {
     let arity = constructor_arity(cx, &ctor, lty);
     let matrix = Matrix(m.iter().filter_map(|r| {
-        specialize(cx, r.as_slice(), &ctor, 0u, arity)
+        specialize(cx, r.as_slice(), &ctor, arity)
     }).collect());
-    match specialize(cx, v, &ctor, 0u, arity) {
+    match specialize(cx, v, &ctor, arity) {
         Some(v) => is_useful(cx, &matrix, v.as_slice(), witness),
         None => NotUseful
     }
@@ -580,7 +580,7 @@ fn is_wild(cx: &MatchCheckCtxt, p: Gc<Pat>) -> bool {
 ///
 /// For instance, a tuple pattern (_, 42u, Some([])) has the arity of 3.
 /// A struct pattern's arity is the number of fields it contains, etc.
-pub fn constructor_arity(cx: &MatchCheckCtxt, ctor: &Constructor, ty: ty::t) -> uint {
+fn constructor_arity(cx: &MatchCheckCtxt, ctor: &Constructor, ty: ty::t) -> uint {
     match ty::get(ty).sty {
         ty::ty_tup(ref fs) => fs.len(),
         ty::ty_box(_) | ty::ty_uniq(_) => 1u,
@@ -628,11 +628,11 @@ fn range_covered_by_constructor(ctor: &Constructor,
 /// different patterns.
 /// Structure patterns with a partial wild pattern (Foo { a: 42, .. }) have their missing
 /// fields filled with wild patterns.
-pub fn specialize(cx: &MatchCheckCtxt, r: &[Gc<Pat>],
-                  constructor: &Constructor, col: uint, arity: uint) -> Option<Vec<Gc<Pat>>> {
+fn specialize(cx: &MatchCheckCtxt, r: &[Gc<Pat>],
+              constructor: &Constructor, arity: uint) -> Option<Vec<Gc<Pat>>> {
     let &Pat {
         id: pat_id, node: ref node, span: pat_span
-    } = &(*raw_pat(r[col]));
+    } = &(*raw_pat(r[0]));
     let head: Option<Vec<Gc<Pat>>> = match node {
         &PatWild =>
             Some(Vec::from_elem(arity, wild())),
@@ -776,7 +776,7 @@ pub fn specialize(cx: &MatchCheckCtxt, r: &[Gc<Pat>],
             None
         }
     };
-    head.map(|head| head.append(r.slice_to(col)).append(r.slice_from(col + 1)))
+    head.map(|head| head.append(r.tail()))
 }
 
 fn default(cx: &MatchCheckCtxt, r: &[Gc<Pat>]) -> Option<Vec<Gc<Pat>>> {

branches/try2/src/librustc/middle/lang_items.rs

@@ -248,6 +248,7 @@ lets_do_this! {
     OrdTraitLangItem,                "ord",                     ord_trait;
 
     StrEqFnLangItem,                 "str_eq",                  str_eq_fn;
+    UniqStrEqFnLangItem,             "uniq_str_eq",             uniq_str_eq_fn;
 
     // A number of failure-related lang items. The `fail_` item corresponds to
     // divide-by-zero and various failure cases with `match`. The