---

yaml
---
r: 14747
b: refs/heads/try
c: 4fc5b82
h: refs/heads/master
i:
  14745: e254872
  14743: a54870d
v: v3

Author: brson

[refs]

@@ -2,5 +2,5 @@
 refs/heads/master: 61b1875c16de39c166b0f4d54bba19f9c6777d1a
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 4a81779abd786ff22d71434c6d9a5917ea4cdfff
-refs/heads/try: c19ea057faed3e4b1abe03c1d760b7741b135e1b
+refs/heads/try: 4fc5b822e218301eedf49ec249fdd1a0adf8ebd6
 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:
 
-rustc/             The self-hosted compiler
+comp/              The self-hosted compiler
 
 cargo/             The package manager
 

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

@@ -163,6 +163,8 @@ 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

@@ -0,0 +1,71 @@
+/*
+ * The region checking pass. Ensures that region-annotated pointers never
+ * outlive their referents.
+ */
+
+import driver::session::session;
+import middle::ty;
+import std::map::hashmap;
+import syntax::{ast, visit};
+
+type ctxt = {
+    tcx: ty::ctxt,
+    enclosing_block: option<ast::node_id>
+};
+
+fn check_expr(expr: @ast::expr, cx: ctxt, visitor: visit::vt<ctxt>) {
+    ty::walk_ty(cx.tcx, ty::expr_ty(cx.tcx, expr)) { |t|
+        alt ty::get(t).struct {
+            ty::ty_rptr(region, _) {
+                alt region {
+                    ty::re_named(_) | ty::re_caller(_) { /* ok */ }
+                    ty::re_block(rbi) {
+                        let referent_block_id = rbi;
+                        let enclosing_block_id = alt cx.enclosing_block {
+                            none {
+                                cx.tcx.sess.span_bug(expr.span, "block " +
+                                                     "region type outside " +
+                                                     "a block?!");
+                            }
+                            some(eb) { eb }
+                        };
+
+                        let parent_blocks = cx.tcx.region_map.parent_blocks;
+                        while enclosing_block_id != referent_block_id {
+                            if parent_blocks.contains_key(referent_block_id) {
+                                referent_block_id =
+                                    parent_blocks.get(referent_block_id);
+                            } else {
+                                // TODO: Enable this.
+
+                                //cx.tcx.sess.span_err(expr.span,
+                                //                     "reference escapes " +
+                                //                     "its block");
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+            _ { /* no-op */ }
+        }
+    }
+
+    visit::visit_expr(expr, cx, visitor);
+}
+
+fn check_block(blk: ast::blk, cx: ctxt, visitor: visit::vt<ctxt>) {
+    let new_cx: ctxt = { enclosing_block: some(blk.node.id) with cx };
+    visit::visit_block(blk, new_cx, visitor);
+}
+
+fn check_crate(ty_cx: ty::ctxt, crate: @ast::crate) {
+    let cx: ctxt = {tcx: ty_cx, enclosing_block: none};
+    let visitor = visit::mk_vt(@{
+        visit_expr: check_expr,
+        visit_block: check_block
+        with *visit::default_visitor()
+    });
+    visit::visit_crate(*crate, cx, visitor);
+}
+

branches/try/src/rustc/rustc.rc

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

branches/try/src/rustdoc/attr_parser.rs

@@ -9,10 +9,8 @@ import rustc::syntax::ast;
 import rustc::front::attr;
 import core::tuple;
 
-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 crate_attrs, basic_attrs, variant_attrs;
+export parse_crate, parse_basic, parse_variant;
 export parse_hidden;
 
 type crate_attrs = {
@@ -24,27 +22,10 @@ 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 {
 
@@ -231,72 +212,6 @@ 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,
@@ -342,29 +257,6 @@ 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,