---

yaml
---
r: 14746
b: refs/heads/try
c: c19ea05
h: refs/heads/master
v: v3

Author: damag

[refs]

@@ -2,5 +2,5 @@
 refs/heads/master: 61b1875c16de39c166b0f4d54bba19f9c6777d1a
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 4a81779abd786ff22d71434c6d9a5917ea4cdfff
-refs/heads/try: e8c7b5347d3b834a2c467677cfa8670316b2c574
+refs/heads/try: c19ea057faed3e4b1abe03c1d760b7741b135e1b
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105

branches/try/src/README.txt

@@ -2,7 +2,7 @@ This is preliminary version of the Rust compiler.
 
 Source layout:
 
-comp/              The self-hosted compiler
+rustc/             The self-hosted compiler
 
 cargo/             The package manager
 

branches/try/src/rustc/driver/driver.rs

@@ -163,8 +163,6 @@ fn compile_upto(sess: session, cfg: ast::crate_cfg,
     let mutbl_map =
         time(time_passes, "mutability checking",
              bind middle::mutbl::check_crate(ty_cx, crate));
-    time(time_passes, "region checking",
-         bind middle::regionck::check_crate(ty_cx, crate));
     let (copy_map, ref_map) =
         time(time_passes, "alias checking",
              bind middle::alias::check_crate(ty_cx, crate));

branches/try/src/rustc/middle/regionck.rs

@@ -45,7 +45,6 @@ mod middle {
     mod capture;
     mod pat_util;
     mod region;
-    mod regionck;
 
     mod tstate {
         mod ck;

branches/try/src/rustc/rustc.rc

@@ -9,8 +9,10 @@ import rustc::syntax::ast;
 import rustc::front::attr;
 import core::tuple;
 
-export crate_attrs, basic_attrs, variant_attrs;
-export parse_crate, parse_basic, parse_variant;
+export crate_attrs, basic_attrs, fn_attrs, arg_attrs,
+       variant_attrs, res_attrs, method_attrs;
+export parse_crate, parse_basic, parse_fn,
+       parse_variant, parse_res, parse_method;
 export parse_hidden;
 
 type crate_attrs = {
@@ -22,10 +24,27 @@ type basic_attrs = {
     desc: option<str>
 };
 
+type fn_attrs = {
+    args: [arg_attrs],
+    return: option<str>,
+    failure: option<str>
+};
+
+type arg_attrs = {
+    name: str,
+    desc: str
+};
+
 type variant_attrs = {
     desc: option<str>
 };
 
+type res_attrs = {
+    args: [arg_attrs]
+};
+
+type method_attrs = fn_attrs;
+
 #[cfg(test)]
 mod test {
 
@@ -212,6 +231,72 @@ fn parse_long_doc<T>(
     }
 }
 
+fn parse_fn(attrs: [ast::attribute]) -> fn_attrs {
+    parse_long_doc(attrs, parse_fn_long_doc)
+}
+
+fn parse_fn_long_doc(items: [@ast::meta_item]) -> fn_attrs {
+    let return = attr::meta_item_value_from_list(items, "return");
+    let failure = attr::meta_item_value_from_list(items, "failure");
+    let args = parse_args(items);
+
+    {
+        args: args,
+        return: return,
+        failure: failure
+    }
+}
+
+fn parse_args(items: [@ast::meta_item]) -> [arg_attrs] {
+    alt attr::meta_item_list_from_list(items, "args") {
+      some(items) {
+        vec::filter_map(items) {|item|
+            option::map(attr::name_value_str_pair(item)) { |pair|
+                {
+                    name: tuple::first(pair),
+                    desc: tuple::second(pair)
+                }
+            }
+        }
+      }
+      none { [] }
+    }
+}
+
+#[test]
+fn parse_fn_should_handle_undocumented_functions() {
+    let source = "";
+    let attrs = test::parse_attributes(source);
+    let attrs = parse_fn(attrs);
+    assert attrs.return == none;
+    assert vec::len(attrs.args) == 0u;
+}
+
+#[test]
+fn parse_fn_should_parse_the_return_value_description() {
+    let source = "#[doc(return = \"return value\")]";
+    let attrs = test::parse_attributes(source);
+    let attrs = parse_fn(attrs);
+    assert attrs.return == some("return value");
+}
+
+#[test]
+fn parse_fn_should_parse_the_argument_descriptions() {
+    let source = "#[doc(args(a = \"arg a\", b = \"arg b\"))]";
+    let attrs = test::parse_attributes(source);
+    let attrs = parse_fn(attrs);
+    assert attrs.args[0] == {name: "a", desc: "arg a"};
+    assert attrs.args[1] == {name: "b", desc: "arg b"};
+}
+
+#[test]
+fn parse_fn_should_parse_failure_conditions() {
+    let source = "#[doc(failure = \"it's the fail\")]";
+    let attrs = test::parse_attributes(source);
+    let attrs = parse_fn(attrs);
+    assert attrs.failure == some("it's the fail");
+}
+
 fn parse_variant(attrs: [ast::attribute]) -> variant_attrs {
     parse_short_doc_or(
         attrs,
@@ -257,6 +342,29 @@ fn should_parse_variant_long_doc() {
     assert attrs.desc == some("a");
 }
 
+fn parse_res(attrs: [ast::attribute]) -> res_attrs {
+    parse_long_doc(attrs, parse_res_long_doc)
+}
+
+fn parse_res_long_doc(items: [@ast::meta_item]) -> res_attrs {
+    {
+        args: parse_args(items)
+    }
+}
+
+#[test]
+fn shoulde_parse_resource_arg() {
+    let source = "#[doc(args(a = \"b\"))]";
+    let attrs = test::parse_attributes(source);
+    let attrs = parse_res(attrs);
+    assert attrs.args[0].name == "a";
+    assert attrs.args[0].desc == "b";
+}
+
+fn parse_method(attrs: [ast::attribute]) -> method_attrs {
+    parse_fn(attrs)
+}
+
 fn parse_hidden(attrs: [ast::attribute]) -> bool {
     parse_short_doc_or(
         attrs,