---

yaml
---
r: 152047
b: refs/heads/try2
c: 68455a1
h: refs/heads/master
i:
  152045: b12020f
  152043: b5aba06
  152039: 993354a
  152031: f7b19a1
v: v3

Author: sanrodari

[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: 746d086f9322d24fa7b389dd911e204ca35012ae
+refs/heads/try2: 68455a12db890a6021e77b9746749ebd4557e78d
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/doc/tutorial.md

@@ -57,24 +57,13 @@ they don't contain references to names that aren't actually defined.
 
 # Getting started
 
-There are two ways to install the Rust compiler: by building from source or
-by downloading prebuilt binaries or installers for your platform. The
-[install page][rust-install] contains links to download binaries for both
-the nightly build and the most current Rust major release. For Windows and
-OS X, the install page provides links to native installers. 
+> *Warning:* The tarball and installer links are for the most recent
+> release, not master. To use master, you **must** build from [git].
 
-> *Note:* Windows users should read the detailed
-> [Getting started][wiki-start] notes on the wiki. Even when using
-> the binary installer, the Windows build requires a MinGW installation,
-> the precise details of which are not discussed here.
-
-For Linux and OS X, the install page provides links to binary tarballs.
-To install the Rust compiler from the from a binary tarball, download 
-the binary package, extract it, and execute the `install.sh` script in 
-the root directory of the package.
-
-To build the Rust compiler from source, you will need to obtain the source through
-[Git][git] or by downloading the source package from the [install page][rust-install].
+The Rust compiler currently must be built from a [tarball] or [git], unless
+you are on Windows, in which case using the [installer][win-exe] is
+recommended. There is a list of community-maintained nightly builds and
+packages [on the wiki][wiki-packages].
 
 Since the Rust compiler is written in Rust, it must be built by
 a precompiled "snapshot" version of itself (made in an earlier state
@@ -90,9 +79,13 @@ Snapshot binaries are currently built and tested on several platforms:
 You may find that other platforms work, but these are our "tier 1"
 supported build environments that are most likely to work.
 
+> *Note:* Windows users should read the detailed
+> [Getting started][wiki-start] notes on the wiki. Even when using
+> the binary installer, the Windows build requires a MinGW installation,
+> the precise details of which are not discussed here.
+
 [wiki-start]: https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust
 [git]: https://github.com/mozilla/rust.git
-[rust-install]: http://www.rust-lang.org/install.html
 
 To build from source you will also need the following prerequisite
 packages:
@@ -1106,7 +1099,7 @@ let ys = xs;
 
 xs = Nil;
 
-// `xs` can be used again
+// `xs` can't be used again
 ~~~
 
 A destructor call will only occur for a variable that has not been moved from,

branches/try2/src/libcore/tuple.rs

@@ -9,55 +9,8 @@
 // except according to those terms.
 
 //! Operations on tuples
-//!
-//! To access a single element of a tuple one can use the following
-//! methods:
-//!
-//! * `valN` - returns a value of _N_-th element
-//! * `refN` - returns a reference to _N_-th element
-//! * `mutN` - returns a mutable reference to _N_-th element
-//!
-//! Indexing starts from zero, so `val0` returns first value, `val1`
-//! returns second value, and so on. In general, a tuple with _S_
-//! elements provides aforementioned methods suffixed with numbers
-//! from `0` to `S-1`. Traits which contain these methods are
-//! implemented for tuples with up to 12 elements.
-//!
-//! If every type inside a tuple implements one of the following
-//! traits, then a tuple itself also implements it.
-//!
-//! * `Clone`
-//! * `Eq`
-//! * `TotalEq`
-//! * `Ord`
-//! * `TotalOrd`
-//! * `Default`
-//!
-//! # Examples
-//!
-//! Using methods:
-//!
-//! ```
-//! let pair = ("pi", 3.14);
-//! assert_eq!(pair.val0(), "pi");
-//! assert_eq!(pair.val1(), 3.14);
-//! ```
-//!
-//! Using traits implemented for tuples:
-//!
-//! ```
-//! use std::default::Default;
-//!
-//! let a = (1, 2);
-//! let b = (3, 4);
-//! assert!(a != b);
-//!
-//! let c = b.clone();
-//! assert!(b == c);
-//!
-//! let d : (u32, f32) = Default::default();
-//! assert_eq!(d, (0u32, 0.0f32));
-//! ```
+
+#![allow(missing_doc)]
 
 use clone::Clone;
 #[cfg(not(test))] use cmp::*;
@@ -73,7 +26,6 @@ macro_rules! tuple_impls {
         }
     )+) => {
         $(
-            #[allow(missing_doc)]
             pub trait $Tuple<$($T),+> {
                 $(fn $valN(self) -> $T;)+
                 $(fn $refN<'a>(&'a self) -> &'a $T;)+

branches/try2/src/libregex/lib.rs

@@ -401,7 +401,7 @@ pub mod native {
     // undesirable consequences (such as requiring a dependency on
     // `libsyntax`).
     //
-    // Secondly, the code generated by `regex!` must *also* be able
+    // Secondly, the code generated generated by `regex!` must *also* be able
     // to access various functions in this crate to reduce code duplication
     // and to provide a value with precisely the same `Regex` type in this
     // crate. This, AFAIK, is impossible to mitigate.

branches/try2/src/libregex/re.rs

@@ -100,45 +100,38 @@ pub fn is_match(regex: &str, text: &str) -> Result<bool, parse::Error> {
 /// documentation.
 #[deriving(Clone)]
 #[allow(visible_private_types)]
-pub enum Regex {
-    // The representation of `Regex` is exported to support the `regex!`
-    // syntax extension. Do not rely on it.
-    //
-    // See the comments for the `program` module in `lib.rs` for a more
-    // detailed explanation for what `regex!` requires.
+pub struct Regex {
+    /// The representation of `Regex` is exported to support the `regex!`
+    /// syntax extension. Do not rely on it.
+    ///
+    /// See the comments for the `program` module in `lib.rs` for a more
+    /// detailed explanation for what `regex!` requires.
     #[doc(hidden)]
-    Dynamic(Dynamic),
+    pub original: String,
     #[doc(hidden)]
-    Native(Native),
-}
-
-#[deriving(Clone)]
-#[doc(hidden)]
-pub struct Dynamic {
-    original: String,
-    names: Vec<Option<String>>,
+    pub names: Vec<Option<String>>,
     #[doc(hidden)]
-    pub prog: Program
+    pub p: MaybeNative,
 }
 
-#[doc(hidden)]
-pub struct Native {
-    #[doc(hidden)]
-    pub original: &'static str,
-    #[doc(hidden)]
-    pub names: &'static [Option<&'static str>],
-    #[doc(hidden)]
-    pub prog: fn(MatchKind, &str, uint, uint) -> Vec<Option<uint>>
+impl fmt::Show for Regex {
+    /// Shows the original regular expression.
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}", self.original)
+    }
 }
 
-impl Clone for Native {
-    fn clone(&self) -> Native { *self }
+pub enum MaybeNative {
+    Dynamic(Program),
+    Native(fn(MatchKind, &str, uint, uint) -> Vec<Option<uint>>),
 }
 
-impl fmt::Show for Regex {
-    /// Shows the original regular expression.
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}", self.as_str())
+impl Clone for MaybeNative {
+    fn clone(&self) -> MaybeNative {
+        match *self {
+            Dynamic(ref p) => Dynamic(p.clone()),
+            Native(fp) => Native(fp),
+        }
     }
 }
 
@@ -153,11 +146,10 @@ impl Regex {
     pub fn new(re: &str) -> Result<Regex, parse::Error> {
         let ast = try!(parse::parse(re));
         let (prog, names) = Program::new(ast);
-        Ok(Dynamic(Dynamic {
+        Ok(Regex {
             original: re.to_strbuf(),
-            names: names,
-            prog: prog,
-        }))
+            names: names, p: Dynamic(prog),
+        })
     }
 
     /// Returns true if and only if the regex matches the string given.
@@ -503,46 +495,6 @@ impl Regex {
         }
         new.append(text.slice(last_match, text.len()))
     }
-
-    /// Returns the original string of this regex.
-    pub fn as_str<'a>(&'a self) -> &'a str {
-        match *self {
-            Dynamic(Dynamic { ref original, .. }) => original.as_slice(),
-            Native(Native { ref original, .. }) => original.as_slice(),
-        }
-    }
-
-    #[doc(hidden)]
-    #[allow(visible_private_types)]
-    #[experimental]
-    pub fn names_iter<'a>(&'a self) -> NamesIter<'a> {
-        match *self {
-            Native(ref n) => NamesIterNative(n.names.iter()),
-            Dynamic(ref d) => NamesIterDynamic(d.names.iter())
-        }
-    }
-
-    fn names_len(&self) -> uint {
-        match *self {
-            Native(ref n) => n.names.len(),
-            Dynamic(ref d) => d.names.len()
-        }
-    }
-
-}
-
-enum NamesIter<'a> {
-    NamesIterNative(::std::slice::Items<'a, Option<&'static str>>),
-    NamesIterDynamic(::std::slice::Items<'a, Option<String>>)
-}
-
-impl<'a> Iterator<Option<String>> for NamesIter<'a> {
-    fn next(&mut self) -> Option<Option<String>> {
-        match *self {
-            NamesIterNative(ref mut i) => i.next().map(|x| x.map(|s| s.to_strbuf())),
-            NamesIterDynamic(ref mut i) => i.next().map(|x| x.as_ref().map(|s| s.to_strbuf())),
-        }
-    }
 }
 
 /// NoExpand indicates literal string replacement.
@@ -660,23 +612,22 @@ pub struct Captures<'t> {
 }
 
 impl<'t> Captures<'t> {
-    #[allow(experimental)]
     fn new(re: &Regex, search: &'t str, locs: CaptureLocs)
           -> Option<Captures<'t>> {
         if !has_match(&locs) {
             return None
         }
 
         let named =
-            if re.names_len() == 0 {
+            if re.names.len() == 0 {
                 None
             } else {
                 let mut named = HashMap::new();
-                for (i, name) in re.names_iter().enumerate() {
+                for (i, name) in re.names.iter().enumerate() {
                     match name {
-                        None => {},
-                        Some(name) => {
-                            named.insert(name, i);
+                        &None => {},
+                        &Some(ref name) => {
+                            named.insert(name.to_strbuf(), i);
                         }
                     }
                 }
@@ -911,9 +862,9 @@ fn exec(re: &Regex, which: MatchKind, input: &str) -> CaptureLocs {
 
 fn exec_slice(re: &Regex, which: MatchKind,
               input: &str, s: uint, e: uint) -> CaptureLocs {
-    match *re {
-        Dynamic(Dynamic { ref prog, .. }) => vm::run(which, prog, input, s, e),
-        Native(Native { prog, .. }) => prog(which, input, s, e),
+    match re.p {
+        Dynamic(ref prog) => vm::run(which, prog, input, s, e),
+        Native(exec) => exec(which, input, s, e),
     }
 }
 

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

@@ -20,9 +20,6 @@ mod native_bench;
 #[path = "tests.rs"]
 mod native_tests;
 
-#[cfg(not(stage1))]
-mod native_static;
-
 // Due to macro scoping rules, this definition only applies for the modules
 // defined below. Effectively, it allows us to use the same tests for both
 // native and dynamic regexes.