---

yaml
---
r: 152034
b: refs/heads/try2
c: a7ab733
h: refs/heads/master
v: v3

Author: bors

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

branches/try2/src/doc/guide-runtime.md

@@ -45,7 +45,7 @@ The runtime is designed with a few goals in mind:
   support as well.
 
 * The runtime should not enforce separate "modes of compilation" in order to
-  work in multiple circumstances. Is it an explicit goal that you compile a Rust
+  work in multiple circumstances. It is an explicit goal that you compile a Rust
   library once and use it forever (in all environments).
 
 * The runtime should be fast. There should be no architectural design barrier

branches/try2/src/doc/rustdoc.md

@@ -41,6 +41,31 @@ pub fn recalibrate() {
 # }
 ~~~
 
+Documentation can also be controlled via the `doc` attribute on items. This is
+implicitly done by the compiler when using the above form of doc comments
+(converting the slash-based comments to `#[doc]` attributes).
+
+~~~
+#[doc = "
+Calculates the factorial of a number.
+
+Given the input integer `n`, this function will calculate `n!` and return it.
+"]
+pub fn factorial(n: int) -> int { if n < 2 {1} else {n * factorial(n)} }
+# fn main() {}
+~~~
+
+The `doc` attribute can also be used to control how rustdoc emits documentation
+in some cases.
+
+```
+// Rustdoc will inline documentation of a `pub use` into this crate when the
+// `pub use` reaches across crates, but this behavior can also be disabled.
+#[doc(no_inline)]
+pub use std::option::Option;
+# fn main() {}
+```
+
 Doc comments are markdown, and are currently parsed with the
 [sundown][sundown] library. rustdoc does not yet do any fanciness such as
 referencing other items inline, like javadoc's `@see`. One exception to this

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 generated by `regex!` must *also* be able
+    // Secondly, the code 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,38 +100,45 @@ pub fn is_match(regex: &str, text: &str) -> Result<bool, parse::Error> {
 /// documentation.
 #[deriving(Clone)]
 #[allow(visible_private_types)]
-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.
+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.
     #[doc(hidden)]
-    pub original: String,
+    Dynamic(Dynamic),
     #[doc(hidden)]
-    pub names: Vec<Option<String>>,
+    Native(Native),
+}
+
+#[deriving(Clone)]
+#[doc(hidden)]
+pub struct Dynamic {
+    original: String,
+    names: Vec<Option<String>>,
     #[doc(hidden)]
-    pub p: MaybeNative,
+    pub prog: Program
 }
 
-impl fmt::Show for Regex {
-    /// Shows the original regular expression.
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}", self.original)
-    }
+#[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>>
 }
 
-pub enum MaybeNative {
-    Dynamic(Program),
-    Native(fn(MatchKind, &str, uint, uint) -> Vec<Option<uint>>),
+impl Clone for Native {
+    fn clone(&self) -> Native { *self }
 }
 
-impl Clone for MaybeNative {
-    fn clone(&self) -> MaybeNative {
-        match *self {
-            Dynamic(ref p) => Dynamic(p.clone()),
-            Native(fp) => Native(fp),
-        }
+impl fmt::Show for Regex {
+    /// Shows the original regular expression.
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}", self.as_str())
     }
 }
 
@@ -146,10 +153,11 @@ impl Regex {
     pub fn new(re: &str) -> Result<Regex, parse::Error> {
         let ast = try!(parse::parse(re));
         let (prog, names) = Program::new(ast);
-        Ok(Regex {
+        Ok(Dynamic(Dynamic {
             original: re.to_strbuf(),
-            names: names, p: Dynamic(prog),
-        })
+            names: names,
+            prog: prog,
+        }))
     }
 
     /// Returns true if and only if the regex matches the string given.
@@ -495,6 +503,46 @@ 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.
@@ -612,22 +660,23 @@ 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(ref name) => {
-                            named.insert(name.to_strbuf(), i);
+                        None => {},
+                        Some(name) => {
+                            named.insert(name, i);
                         }
                     }
                 }
@@ -862,9 +911,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.p {
-        Dynamic(ref prog) => vm::run(which, prog, input, s, e),
-        Native(exec) => exec(which, input, s, e),
+    match *re {
+        Dynamic(Dynamic { ref prog, .. }) => vm::run(which, prog, input, s, e),
+        Native(Native { prog, .. }) => prog(which, input, s, e),
     }
 }
 

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

@@ -20,6 +20,9 @@ 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.

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

@@ -0,0 +1,26 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use regex::Regex;
+static RE: Regex = regex!(r"\d+");
+
+#[test]
+fn static_splitn() {
+    let text = "cauchy123plato456tyler789binx";
+    let subs: Vec<&str> = RE.splitn(text, 2).collect();
+    assert_eq!(subs, vec!("cauchy", "plato456tyler789binx"));
+}
+
+#[test]
+fn static_split() {
+    let text = "cauchy123plato456tyler789binx";
+    let subs: Vec<&str> = RE.split(text).collect();
+    assert_eq!(subs, vec!("cauchy", "plato", "tyler", "binx"));
+}

branches/try2/src/libregex_macros/lib.rs

@@ -75,6 +75,7 @@ pub fn macro_registrar(register: |ast::Name, SyntaxExtension|) {
 /// It is strongly recommended to read the dynamic implementation in vm.rs
 /// first before trying to understand the code generator. The implementation
 /// strategy is identical and vm.rs has comments and will be easier to follow.
+#[allow(experimental)]
 fn native(cx: &mut ExtCtxt, sp: codemap::Span, tts: &[ast::TokenTree])
           -> Box<MacResult> {
     let regex = match parse(cx, tts) {
@@ -89,14 +90,14 @@ fn native(cx: &mut ExtCtxt, sp: codemap::Span, tts: &[ast::TokenTree])
             return DummyResult::any(sp)
         }
     };
-    let prog = match re.p {
-        Dynamic(ref prog) => prog.clone(),
+    let prog = match re {
+        Dynamic(Dynamic { ref prog, .. }) => prog.clone(),
         Native(_) => unreachable!(),
     };
 
     let mut gen = NfaGen {
         cx: &*cx, sp: sp, prog: prog,
-        names: re.names.clone(), original: re.original.clone(),
+        names: re.names_iter().collect(), original: re.as_str().to_strbuf(),
     };
     MacExpr::new(gen.code())
 }
@@ -119,7 +120,7 @@ impl<'a> NfaGen<'a> {
             |cx, name| match *name {
                 Some(ref name) => {
                     let name = name.as_slice();
-                    quote_expr!(cx, Some($name.to_strbuf()))
+                    quote_expr!(cx, Some($name))
                 }
                 None => cx.expr_none(self.sp),
             }
@@ -141,9 +142,11 @@ impl<'a> NfaGen<'a> {
         let regex = self.original.as_slice();
 
         quote_expr!(self.cx, {
+static CAP_NAMES: &'static [Option<&'static str>] = &$cap_names;
 fn exec<'t>(which: ::regex::native::MatchKind, input: &'t str,
             start: uint, end: uint) -> Vec<Option<uint>> {
     #![allow(unused_imports)]
+    #![allow(unused_mut)]
     use regex::native::{
         MatchKind, Exists, Location, Submatches,
         StepState, StepMatchEarlyReturn, StepMatch, StepContinue,
@@ -310,11 +313,11 @@ fn exec<'t>(which: ::regex::native::MatchKind, input: &'t str,
     }
 }
 
-::regex::Regex {
-    original: $regex.to_strbuf(),
-    names: vec!$cap_names,
-    p: ::regex::native::Native(exec),
-}
+::regex::native::Native(::regex::native::Native {
+    original: $regex,
+    names: CAP_NAMES,
+    prog: exec,
+})
         })
     }
 

branches/try2/src/librustc/metadata/common.rs

@@ -206,6 +206,9 @@ pub static tag_crate_triple: uint = 0x66;
 
 pub static tag_dylib_dependency_formats: uint = 0x67;
 
+pub static tag_method_argument_names: uint = 0x8e;
+pub static tag_method_argument_name: uint = 0x8f;
+
 #[deriving(Clone, Show)]
 pub struct LinkMeta {
     pub crateid: CrateId,

branches/try2/src/librustc/metadata/csearch.rs

@@ -306,3 +306,10 @@ pub fn get_missing_lang_items(cstore: &cstore::CStore, cnum: ast::CrateNum)
     let cdata = cstore.get_crate_data(cnum);
     decoder::get_missing_lang_items(&*cdata)
 }
+
+pub fn get_method_arg_names(cstore: &cstore::CStore, did: ast::DefId)
+    -> Vec<String>
+{
+    let cdata = cstore.get_crate_data(did.krate);
+    decoder::get_method_arg_names(&*cdata, did.node)
+}

branches/try2/src/librustc/metadata/decoder.rs

@@ -1309,3 +1309,18 @@ pub fn get_missing_lang_items(cdata: Cmd)
     });
     return result;
 }
+
+pub fn get_method_arg_names(cdata: Cmd, id: ast::NodeId) -> Vec<String> {
+    let mut ret = Vec::new();
+    let method_doc = lookup_item(id, cdata.data());
+    match reader::maybe_get_doc(method_doc, tag_method_argument_names) {
+        Some(args_doc) => {
+            reader::tagged_docs(args_doc, tag_method_argument_name, |name_doc| {
+                ret.push(name_doc.as_str_slice().to_strbuf());
+                true
+            });
+        }
+        None => {}
+    }
+    return ret;
+}