---

yaml
---
r: 152245
b: refs/heads/try2
c: 3b5d6fd
h: refs/heads/master
i:
  152243: 2a1c831
v: v3

Author: exscape

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

branches/try2/src/README.md

@@ -5,37 +5,26 @@ Source layout:
 | Path                | Description                                               |
 | ------------------- | --------------------------------------------------------- |
 | `librustc/`         | The self-hosted compiler                                  |
-| `liballoc/`         | Rust's core allocation library                            |
-| `libcore/`          | The Rust core library                                     |
-| `libdebug/`         | Debugging utilities                                       |
 | `libstd/`           | The standard library (imported and linked by default)     |
+| `libextra/`         | The "extras" library (slightly more peripheral code)      |
 | `libgreen/`         | The M:N runtime library                                   |
 | `libnative/`        | The 1:1 runtime library                                   |
 | `libsyntax/`        | The Rust parser and pretty-printer                        |
+| `libcollections/`   | A collection of useful data structures and containers     |
+| `libnum/`           | Extended number support library (complex, rational, etc)  |
 | `libtest/`          | Rust's test-runner code                                   |
 | ------------------- | --------------------------------------------------------- |
 | `libarena/`         | The arena (a fast but limited) memory allocator           |
-| `libbacktrace/`     | The libbacktrace library                                  |
-| `libcollections/`   | A collection of useful data structures and containers     |
 | `libflate/`         | Simple compression library                                |
-| `libfmt_macros/`    | Macro support for format strings                          |
 | `libfourcc/`        | Data format identifier library                            |
 | `libgetopts/`       | Get command-line-options library                          |
 | `libglob/`          | Unix glob patterns library                                |
-| `libgraphviz/`      | Generating files for Graphviz                             |
-| `libhexfloat/`      | Hexadecimal floating-point literals                       |
-| `liblibc/`          | Bindings for the C standard library                       |
-| `liblog/`           | Utilities for program-wide and customizable logging       |
-| `libnum/`           | Extended number support library (complex, rational, etc)  |
-| `librand/`          | Random numbers and distributions                          |
 | `libregex/`         | Regular expressions                                       |
-| `libregex_macros/`  | The regex! syntax extension                               |
 | `libsemver/`        | Rust's semantic versioning library                        |
 | `libserialize/`     | Encode-Decode types library                               |
 | `libsync/`          | Concurrency mechanisms and primitives                     |
 | `libterm/`          | ANSI color library for terminals                          |
 | `libtime/`          | Time operations library                                   |
-| `liburl/`           | URL handling lirary                                       |
 | `libuuid/`          | UUID's handling code                                      |
 | ------------------- | --------------------------------------------------------- |
 | `rt/`               | The runtime system                                        |

branches/try2/src/doc/intro.md

@@ -18,7 +18,7 @@ and its implications on a task that programmers usually find very difficult: con
 
 Ownership is central to Rust,
 and is the feature from which many of Rust's powerful capabilities are derived.
-"Ownership" refers to which parts of your code are allowed to read,
+"Ownership" refers to which parts of your code are allowed read,
 write, and ultimately release, memory.
 Let's start by looking at some C++ code:
 

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/libregex_macros/lib.rs

@@ -20,6 +20,7 @@
        html_root_url = "http://doc.rust-lang.org/")]
 
 #![feature(macro_registrar, managed_boxes, quote)]
+#![allow(unused_imports)] // `quote_expr!` adds some `use` globs which may be unused
 
 extern crate regex;
 extern crate syntax;

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) => {