---

yaml
---
r: 152247
b: refs/heads/try2
c: 024df5c
h: refs/heads/master
i:
  152245: 4e7a3c0
  152243: 2a1c831
  152239: 175a2e7
v: v3

Author: emberian

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

branches/try2/src/liballoc/rc.rs

@@ -33,7 +33,6 @@ use core::option::{Option, Some, None};
 use core::ptr;
 use core::ptr::RawPtr;
 use core::mem::{min_align_of, size_of};
-use core::fmt;
 
 use heap::deallocate;
 
@@ -179,12 +178,6 @@ impl<T: Ord> Ord for Rc<T> {
     fn cmp(&self, other: &Rc<T>) -> Ordering { (**self).cmp(&**other) }
 }
 
-impl<T: fmt::Show> fmt::Show for Rc<T> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        (**self).fmt(f)
-    }
-}
-
 /// Weak reference to a reference-counted box
 #[unsafe_no_drop_flag]
 pub struct Weak<T> {

branches/try2/src/libregex/lib.rs

@@ -155,16 +155,15 @@
 //! # Unicode
 //!
 //! This implementation executes regular expressions **only** on sequences of
-//! Unicode code points while exposing match locations as byte indices into the
-//! search string.
+//! UTF8 codepoints while exposing match locations as byte indices.
 //!
 //! Currently, only naive case folding is supported. Namely, when matching
 //! case insensitively, the characters are first converted to their uppercase
 //! forms and then compared.
 //!
 //! Regular expressions themselves are also **only** interpreted as a sequence
-//! of Unicode code points. This means you can use Unicode characters
-//! directly in your expression:
+//! of UTF8 codepoints. This means you can embed Unicode characters directly
+//! into your expression:
 //!
 //! ```rust
 //! # #![feature(phase)]
@@ -230,10 +229,10 @@
 //! x*?       zero or more of x (ungreedy)
 //! x+?       one or more of x (ungreedy)
 //! x??       zero or one of x (ungreedy)
-//! x{n,m}    at least n x and at most m x (greedy)
+//! x{n,m}    at least n and at most x (greedy)
 //! x{n,}     at least n x (greedy)
 //! x{n}      exactly n x
-//! x{n,m}?   at least n x and at most m x (ungreedy)
+//! x{n,m}?   at least n and at most x (ungreedy)
 //! x{n,}?    at least n x (ungreedy)
 //! x{n}?     exactly n x
 //! </pre>
@@ -301,7 +300,7 @@
 //! \v         vertical tab (\x0B)
 //! \123       octal character code (up to three digits)
 //! \x7F       hex character code (exactly two digits)
-//! \x{10FFFF} any hex character code corresponding to a Unicode code point
+//! \x{10FFFF} any hex character code corresponding to a valid UTF8 codepoint
 //! </pre>
 //!
 //! ## Perl character classes (Unicode friendly)
@@ -391,7 +390,7 @@ mod vm;
 #[cfg(test, not(windows))]
 mod test;
 
-/// The `native` module exists to support the `regex!` macro. Do not use.
+/// The `program` module exists to support the `regex!` macro. Do not use.
 #[doc(hidden)]
 pub mod native {
     // Exporting this stuff is bad form, but it's necessary for two reasons.

branches/try2/src/libregex/parse/mod.rs

@@ -201,9 +201,6 @@ pub fn parse(s: &str) -> Result<Ast, Error> {
 
 impl<'a> Parser<'a> {
     fn parse(&mut self) -> Result<Ast, Error> {
-        if self.chars.len() == 0 {
-            return Ok(Nothing);
-        }
         loop {
             let c = self.cur();
             match c {

branches/try2/src/libregex/re.rs

@@ -18,10 +18,8 @@ use parse;
 use vm;
 use vm::{CaptureLocs, MatchKind, Exists, Location, Submatches};
 
-/// Escapes all regular expression meta characters in `text`.
-///
-/// The string returned may be safely used as a literal in a regular
-/// expression.
+/// Escapes all regular expression meta characters in `text` so that it may be
+/// safely used in a regular expression as a literal string.
 pub fn quote(text: &str) -> String {
     let mut quoted = String::with_capacity(text.len());
     for c in text.chars() {
@@ -47,18 +45,17 @@ pub fn is_match(regex: &str, text: &str) -> Result<bool, parse::Error> {
     Regex::new(regex).map(|r| r.is_match(text))
 }
 
-/// A compiled regular expression
-///
-/// It is represented as either a sequence of bytecode instructions (dynamic)
-/// or as a specialized Rust function (native). It can be used to search, split
+/// Regex is a compiled regular expression, represented as either a sequence
+/// of bytecode instructions (dynamic) or as a specialized Rust function
+/// (native). It can be used to search, split
 /// or replace text. All searching is done with an implicit `.*?` at the
 /// beginning and end of an expression. To force an expression to match the
 /// whole string (or a prefix or a suffix), you must use an anchor like `^` or
 /// `$` (or `\A` and `\z`).
 ///
 /// While this crate will handle Unicode strings (whether in the regular
 /// expression or in the search text), all positions returned are **byte
-/// indices**. Every byte index is guaranteed to be at a Unicode code point
+/// indices**. Every byte index is guaranteed to be at a UTF8 codepoint
 /// boundary.
 ///
 /// The lifetimes `'r` and `'t` in this crate correspond to the lifetime of a
@@ -192,7 +189,7 @@ impl Regex {
     ///
     /// # Example
     ///
-    /// Find the start and end location of the first word with exactly 13
+    /// Find the start and end location of every word with exactly 13
     /// characters:
     ///
     /// ```rust
@@ -219,7 +216,7 @@ impl Regex {
     ///
     /// # Example
     ///
-    /// Find the start and end location of every word with exactly 13
+    /// Find the start and end location of the first word with exactly 13
     /// characters:
     ///
     /// ```rust
@@ -580,8 +577,8 @@ impl<'t> Replacer for &'t str {
     }
 }
 
-impl<'t> Replacer for |&Captures|: 't -> String {
-    fn reg_replace<'a>(&'a mut self, caps: &Captures) -> MaybeOwned<'a> {
+impl<'a> Replacer for |&Captures|: 'a -> String {
+    fn reg_replace<'r>(&'r mut self, caps: &Captures) -> MaybeOwned<'r> {
         Owned((*self)(caps))
     }
 }
@@ -826,9 +823,8 @@ impl<'t> Iterator<Option<(uint, uint)>> for SubCapturesPos<'t> {
 }
 
 /// An iterator that yields all non-overlapping capture groups matching a
-/// particular regular expression.
-///
-/// The iterator stops when no more matches can be found.
+/// particular regular expression. The iterator stops when no more matches can
+/// be found.
 ///
 /// `'r` is the lifetime of the compiled expression and `'t` is the lifetime
 /// of the matched string.

branches/try2/src/libregex/test/tests.rs

@@ -28,20 +28,6 @@ fn split() {
     assert_eq!(subs, vec!("cauchy", "plato", "tyler", "binx"));
 }
 
-#[test]
-fn empty_regex_empty_match() {
-    let re = regex!("");
-    let ms = re.find_iter("").collect::<Vec<(uint, uint)>>();
-    assert_eq!(ms, vec![(0, 0)]);
-}
-
-#[test]
-fn empty_regex_nonempty_match() {
-    let re = regex!("");
-    let ms = re.find_iter("abc").collect::<Vec<(uint, uint)>>();
-    assert_eq!(ms, vec![(0, 0), (1, 1), (2, 2), (3, 3)]);
-}
-
 macro_rules! replace(
     ($name:ident, $which:ident, $re:expr,
      $search:expr, $replace:expr, $result:expr) => (

branches/try2/src/librustc/back/archive.rs

@@ -110,7 +110,7 @@ impl<'a> Archive<'a> {
                     lto: bool) -> io::IoResult<()> {
         let object = format!("{}.o", name);
         let bytecode = format!("{}.bc.deflate", name);
-        let mut ignore = vec!(bytecode.as_slice(), METADATA_FILENAME);
+        let mut ignore = vec!(METADATA_FILENAME, bytecode.as_slice());
         if lto {
             ignore.push(object.as_slice());
         }

branches/try2/src/librustc/middle/typeck/check/demand.rs

@@ -12,14 +12,11 @@
 use middle::ty;
 use middle::typeck::check::FnCtxt;
 use middle::typeck::infer;
-use middle::typeck::infer::resolve_type;
-use middle::typeck::infer::resolve::try_resolve_tvar_shallow;
 
 use std::result::{Err, Ok};
 use std::result;
 use syntax::ast;
 use syntax::codemap::Span;
-use util::ppaux::Repr;
 
 // Requires that the two types unify, and prints an error message if they
 // don't.
@@ -61,13 +58,6 @@ pub fn eqtype(fcx: &FnCtxt, sp: Span, expected: ty::t, actual: ty::t) {
 // Checks that the type `actual` can be coerced to `expected`.
 pub fn coerce(fcx: &FnCtxt, sp: Span, expected: ty::t, expr: &ast::Expr) {
     let expr_ty = fcx.expr_ty(expr);
-    debug!("demand::coerce(expected = {}, expr_ty = {})",
-           expected.repr(fcx.ccx.tcx),
-           expr_ty.repr(fcx.ccx.tcx));
-    let expected = if ty::type_needs_infer(expected) {
-        resolve_type(fcx.infcx(), expected,
-                     try_resolve_tvar_shallow).unwrap_or(expected)
-    } else { expected };
     match fcx.mk_assignty(expr, expr_ty, expected) {
       result::Ok(()) => { /* ok */ }
       result::Err(ref err) => {

branches/try2/src/libstd/slice.rs

@@ -712,103 +712,13 @@ pub trait MutableOrdVector<T> {
     /// assert!(v == [-5, -3, 1, 2, 4]);
     /// ```
     fn sort(self);
-
-    /// Mutates the slice to the next lexicographic permutation.
-    ///
-    /// Returns `true` if successful, `false` if the slice is at the last-ordered permutation.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// let v = &mut [0, 1, 2];
-    /// v.next_permutation();
-    /// assert_eq!(v, &mut [0, 2, 1]);
-    /// v.next_permutation();
-    /// assert_eq!(v, &mut [1, 0, 2]);
-    /// ```
-    fn next_permutation(self) -> bool;
-
-    /// Mutates the slice to the previous lexicographic permutation.
-    ///
-    /// Returns `true` if successful, `false` if the slice is at the first-ordered permutation.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// let v = &mut [1, 0, 2];
-    /// v.prev_permutation();
-    /// assert_eq!(v, &mut [0, 2, 1]);
-    /// v.prev_permutation();
-    /// assert_eq!(v, &mut [0, 1, 2]);
-    /// ```
-    fn prev_permutation(self) -> bool;
 }
 
 impl<'a, T: Ord> MutableOrdVector<T> for &'a mut [T] {
     #[inline]
     fn sort(self) {
         self.sort_by(|a,b| a.cmp(b))
     }
-
-    fn next_permutation(self) -> bool {
-        // These cases only have 1 permutation each, so we can't do anything.
-        if self.len() < 2 { return false; }
-
-        // Step 1: Identify the longest, rightmost weakly decreasing part of the vector
-        let mut i = self.len() - 1;
-        while i > 0 && self[i-1] >= self[i] {
-            i -= 1;
-        }
-
-        // If that is the entire vector, this is the last-ordered permutation.
-        if i == 0 {
-            return false;
-        }
-
-        // Step 2: Find the rightmost element larger than the pivot (i-1)
-        let mut j = self.len() - 1;
-        while j >= i && self[j] <= self[i-1]  {
-            j -= 1;
-        }
-
-        // Step 3: Swap that element with the pivot
-        self.swap(j, i-1);
-
-        // Step 4: Reverse the (previously) weakly decreasing part
-        self.mut_slice_from(i).reverse();
-
-        true
-    }
-
-    fn prev_permutation(self) -> bool {
-        // These cases only have 1 permutation each, so we can't do anything.
-        if self.len() < 2 { return false; }
-
-        // Step 1: Identify the longest, rightmost weakly increasing part of the vector
-        let mut i = self.len() - 1;
-        while i > 0 && self[i-1] <= self[i] {
-            i -= 1;
-        }
-
-        // If that is the entire vector, this is the first-ordered permutation.
-        if i == 0 {
-            return false;
-        }
-
-        // Step 2: Reverse the weakly increasing part
-        self.mut_slice_from(i).reverse();
-
-        // Step 3: Find the rightmost element equal to or bigger than the pivot (i-1)
-        let mut j = self.len() - 1;
-        while j >= i && self[j-1] < self[i-1]  {
-            j -= 1;
-        }
-
-        // Step 4: Swap that element with the pivot
-        self.swap(i-1, j);
-
-        true
-    }
 }
 
 /// Unsafe operations
@@ -1319,58 +1229,6 @@ mod tests {
         }
     }
 
-    #[test]
-    fn test_lexicographic_permutations() {
-        let v : &mut[int] = &mut[1, 2, 3, 4, 5];
-        assert!(v.prev_permutation() == false);
-        assert!(v.next_permutation());
-        assert_eq!(v, &mut[1, 2, 3, 5, 4]);
-        assert!(v.prev_permutation());
-        assert_eq!(v, &mut[1, 2, 3, 4, 5]);
-        assert!(v.next_permutation());
-        assert!(v.next_permutation());
-        assert_eq!(v, &mut[1, 2, 4, 3, 5]);
-        assert!(v.next_permutation());
-        assert_eq!(v, &mut[1, 2, 4, 5, 3]);
-
-        let v : &mut[int] = &mut[1, 0, 0, 0];
-        assert!(v.next_permutation() == false);
-        assert!(v.prev_permutation());
-        assert_eq!(v, &mut[0, 1, 0, 0]);
-        assert!(v.prev_permutation());
-        assert_eq!(v, &mut[0, 0, 1, 0]);
-        assert!(v.prev_permutation());
-        assert_eq!(v, &mut[0, 0, 0, 1]);
-        assert!(v.prev_permutation() == false);
-    }
-
-    #[test]
-    fn test_lexicographic_permutations_empty_and_short() {
-        let empty : &mut[int] = &mut[];
-        assert!(empty.next_permutation() == false);
-        assert_eq!(empty, &mut[]);
-        assert!(empty.prev_permutation() == false);
-        assert_eq!(empty, &mut[]);
-
-        let one_elem : &mut[int] = &mut[4];
-        assert!(one_elem.prev_permutation() == false);
-        assert_eq!(one_elem, &mut[4]);
-        assert!(one_elem.next_permutation() == false);
-        assert_eq!(one_elem, &mut[4]);
-
-        let two_elem : &mut[int] = &mut[1, 2];
-        assert!(two_elem.prev_permutation() == false);
-        assert_eq!(two_elem, &mut[1, 2]);
-        assert!(two_elem.next_permutation());
-        assert_eq!(two_elem, &mut[2, 1]);
-        assert!(two_elem.next_permutation() == false);
-        assert_eq!(two_elem, &mut[2, 1]);
-        assert!(two_elem.prev_permutation());
-        assert_eq!(two_elem, &mut[1, 2]);
-        assert!(two_elem.prev_permutation() == false);
-        assert_eq!(two_elem, &mut[1, 2]);
-    }
-
     #[test]
     fn test_position_elem() {
         assert!([].position_elem(&1).is_none());