---

yaml
---
r: 152239
b: refs/heads/try2
c: 9d39178
h: refs/heads/master
i:
  152237: af3062c
  152235: 1b802dc
  152231: 99a7ecf
  152223: 72ce0db
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: 3eeaa84a50bdbd6c3cc5e33c07a01110b59c7087
+refs/heads/try2: 9d39178f2f60b6076e4bd00e263f2304084f34b4
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

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

@@ -201,6 +201,9 @@ 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/test/tests.rs

@@ -28,6 +28,20 @@ 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");
 }