---

yaml
---
r: 152241
b: refs/heads/try2
c: 179fc6d
h: refs/heads/master
i:
  152239: 175a2e7
v: v3

Author: BurntSushi

[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: 5a6dc40a102cecdf73ddc9757afe7233e678cfeb
+refs/heads/try2: 179fc6dbfd97eb59e92df84e80fa9354ce5eeea0
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/libregex/lib.rs

@@ -155,15 +155,16 @@
 //! # Unicode
 //!
 //! This implementation executes regular expressions **only** on sequences of
-//! UTF8 codepoints while exposing match locations as byte indices.
+//! Unicode code points while exposing match locations as byte indices into the
+//! search string.
 //!
 //! 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 UTF8 codepoints. This means you can embed Unicode characters directly
-//! into your expression:
+//! of Unicode code points. This means you can use Unicode characters
+//! directly in your expression:
 //!
 //! ```rust
 //! # #![feature(phase)]
@@ -229,10 +230,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 and at most x (greedy)
+//! x{n,m}    at least n x and at most m x (greedy)
 //! x{n,}     at least n x (greedy)
 //! x{n}      exactly n x
-//! x{n,m}?   at least n and at most x (ungreedy)
+//! x{n,m}?   at least n x and at most m x (ungreedy)
 //! x{n,}?    at least n x (ungreedy)
 //! x{n}?     exactly n x
 //! </pre>
@@ -300,7 +301,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 valid UTF8 codepoint
+//! \x{10FFFF} any hex character code corresponding to a Unicode code point
 //! </pre>
 //!
 //! ## Perl character classes (Unicode friendly)
@@ -390,7 +391,7 @@ mod vm;
 #[cfg(test, not(windows))]
 mod test;
 
-/// The `program` module exists to support the `regex!` macro. Do not use.
+/// The `native` 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,8 +18,10 @@ use parse;
 use vm;
 use vm::{CaptureLocs, MatchKind, Exists, Location, Submatches};
 
-/// Escapes all regular expression meta characters in `text` so that it may be
-/// safely used in a regular expression as a literal string.
+/// Escapes all regular expression meta characters in `text`.
+///
+/// The string returned may be safely used as a literal in a regular
+/// expression.
 pub fn quote(text: &str) -> String {
     let mut quoted = String::with_capacity(text.len());
     for c in text.chars() {
@@ -45,17 +47,18 @@ pub fn is_match(regex: &str, text: &str) -> Result<bool, parse::Error> {
     Regex::new(regex).map(|r| r.is_match(text))
 }
 
-/// 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
+/// 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
 /// 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 UTF8 codepoint
+/// indices**. Every byte index is guaranteed to be at a Unicode code point
 /// boundary.
 ///
 /// The lifetimes `'r` and `'t` in this crate correspond to the lifetime of a
@@ -189,7 +192,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
@@ -216,7 +219,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
@@ -577,8 +580,8 @@ impl<'t> Replacer for &'t str {
     }
 }
 
-impl<'a> Replacer for |&Captures|: 'a -> String {
-    fn reg_replace<'r>(&'r mut self, caps: &Captures) -> MaybeOwned<'r> {
+impl<'t> Replacer for |&Captures|: 't -> String {
+    fn reg_replace<'a>(&'a mut self, caps: &Captures) -> MaybeOwned<'a> {
         Owned((*self)(caps))
     }
 }
@@ -823,8 +826,9 @@ 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/librustc/middle/typeck/check/mod.rs

@@ -168,6 +168,15 @@ pub struct Inherited<'a> {
     upvar_borrow_map: RefCell<ty::UpvarBorrowMap>,
 }
 
+#[deriving(Clone)]
+pub enum FnKind {
+    // A do-closure.
+    DoBlock,
+
+    // A normal closure or fn item.
+    Vanilla
+}
+
 #[deriving(Clone)]
 pub struct FnStyleState {
     pub def: ast::NodeId,
@@ -240,6 +249,11 @@ pub struct FnCtxt<'a> {
     // can actually be made to live as long as it needs to live.
     region_lb: Cell<ast::NodeId>,
 
+    // Says whether we're inside a for loop, in a do block
+    // or neither. Helps with error messages involving the
+    // function return type.
+    fn_kind: FnKind,
+
     inh: &'a Inherited<'a>,
 
     ccx: &'a CrateCtxt<'a>,
@@ -275,6 +289,7 @@ fn blank_fn_ctxt<'a>(ccx: &'a CrateCtxt<'a>,
         ret_ty: rty,
         ps: RefCell::new(FnStyleState::function(ast::NormalFn, 0)),
         region_lb: Cell::new(region_bnd),
+        fn_kind: Vanilla,
         inh: inh,
         ccx: ccx
     }
@@ -341,7 +356,7 @@ fn check_bare_fn(ccx: &CrateCtxt,
         ty::ty_bare_fn(ref fn_ty) => {
             let inh = Inherited::new(ccx.tcx, param_env);
             let fcx = check_fn(ccx, fn_ty.fn_style, &fn_ty.sig,
-                               decl, id, body, &inh);
+                               decl, id, body, Vanilla, &inh);
 
             vtable::resolve_in_block(&fcx, body);
             regionck::regionck_fn(&fcx, body);
@@ -425,6 +440,7 @@ fn check_fn<'a>(ccx: &'a CrateCtxt<'a>,
                 decl: &ast::FnDecl,
                 id: ast::NodeId,
                 body: &ast::Block,
+                fn_kind: FnKind,
                 inherited: &'a Inherited<'a>) -> FnCtxt<'a>
 {
     /*!
@@ -463,6 +479,7 @@ fn check_fn<'a>(ccx: &'a CrateCtxt<'a>,
         ret_ty: ret_ty,
         ps: RefCell::new(FnStyleState::function(fn_style, id)),
         region_lb: Cell::new(body.id),
+        fn_kind: fn_kind,
         inh: inherited,
         ccx: ccx
     };
@@ -2278,6 +2295,7 @@ fn check_expr_with_unifier(fcx: &FnCtxt,
                      store: ty::TraitStore,
                      decl: &ast::FnDecl,
                      body: ast::P<ast::Block>,
+                     fn_kind: FnKind,
                      expected: Option<ty::t>) {
         let tcx = fcx.ccx.tcx;
 
@@ -2355,7 +2373,7 @@ fn check_expr_with_unifier(fcx: &FnCtxt,
         };
 
         check_fn(fcx.ccx, inherited_style, &fty_sig,
-                 decl, id, body, fcx.inh);
+                 decl, id, body, fn_kind, fcx.inh);
     }
 
 
@@ -3026,6 +3044,7 @@ fn check_expr_with_unifier(fcx: &FnCtxt,
                       ty::RegionTraitStore(region, ast::MutMutable),
                       decl,
                       body,
+                      Vanilla,
                       expected);
       }
       ast::ExprProc(decl, body) => {
@@ -3034,6 +3053,7 @@ fn check_expr_with_unifier(fcx: &FnCtxt,
                       ty::UniqTraitStore,
                       decl,
                       body,
+                      Vanilla,
                       expected);
       }
       ast::ExprBlock(b) => {

branches/try2/src/test/compile-fail/issue-7573.rs

@@ -24,11 +24,9 @@ impl CrateId {
 }
 
 pub fn remove_package_from_database() {
-    let mut lines_to_use: Vec<&CrateId> = Vec::new();
+    let mut lines_to_use: Vec<&CrateId> = Vec::new(); //~ ERROR cannot infer an appropriate lifetime
     let push_id = |installed_id: &CrateId| {
         lines_to_use.push(installed_id);
-        //~^ ERROR cannot infer an appropriate lifetime for automatic coercion due to
-        // conflicting requirements
     };
     list_database(push_id);
 

branches/try2/src/test/run-pass/issue-14589.rs

@@ -13,9 +13,9 @@ use std::io::println;
 pub fn main() {
     let (tx, rx) = channel();
 
-    tx.send("hello, world");
-
     spawn(proc() {
         println(rx.recv());
     });
+
+    tx.send("hello, world");
 }