---

yaml
---
r: 152030
b: refs/heads/try2
c: 69070ac
h: refs/heads/master
v: v3

Author: lilyball

[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: db2ddb1bba9a78b0791266805bdeca9f3fce89fc
+refs/heads/try2: 69070ac85fcf930b02e2c75bc161a75c5742e138
 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. It is an explicit goal that you compile a Rust
+  work in multiple circumstances. Is it 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,31 +41,6 @@ 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 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.

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

@@ -75,7 +75,6 @@ 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) {
@@ -90,14 +89,14 @@ fn native(cx: &mut ExtCtxt, sp: codemap::Span, tts: &[ast::TokenTree])
             return DummyResult::any(sp)
         }
     };
-    let prog = match re {
-        Dynamic(Dynamic { ref prog, .. }) => prog.clone(),
+    let prog = match re.p {
+        Dynamic(ref prog) => prog.clone(),
         Native(_) => unreachable!(),
     };
 
     let mut gen = NfaGen {
         cx: &*cx, sp: sp, prog: prog,
-        names: re.names_iter().collect(), original: re.as_str().to_strbuf(),
+        names: re.names.clone(), original: re.original.clone(),
     };
     MacExpr::new(gen.code())
 }
@@ -120,7 +119,7 @@ impl<'a> NfaGen<'a> {
             |cx, name| match *name {
                 Some(ref name) => {
                     let name = name.as_slice();
-                    quote_expr!(cx, Some($name))
+                    quote_expr!(cx, Some($name.to_strbuf()))
                 }
                 None => cx.expr_none(self.sp),
             }
@@ -142,11 +141,9 @@ 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,
@@ -313,11 +310,11 @@ fn exec<'t>(which: ::regex::native::MatchKind, input: &'t str,
     }
 }
 
-::regex::native::Native(::regex::native::Native {
-    original: $regex,
-    names: CAP_NAMES,
-    prog: exec,
-})
+::regex::Regex {
+    original: $regex.to_strbuf(),
+    names: vec!$cap_names,
+    p: ::regex::native::Native(exec),
+}
         })
     }
 

branches/try2/src/libregex_macros/lib.rs

@@ -206,9 +206,6 @@ 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/common.rs

@@ -306,10 +306,3 @@ 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/csearch.rs

@@ -1309,18 +1309,3 @@ 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;
-}