Add unsafe blocks, unsafe functions, and two rudimentary tests

related to them

src/comp/middle/typeck.rs

@@ -1552,10 +1552,12 @@ fn require_pure_call(ccx: @crate_ctxt, caller_purity: ast::purity,
             ccx.tcx.sess.span_fatal
                 (sp, "safe function calls function marked unsafe");
           }
-          //some(ast::def_native_fn(_)) {
+          /* Temporarily disable until unsafe blocks parse!
-          //  ccx.tcx.sess.span_fatal
+          some(ast::def_native_fn(_)) {
-          //  (sp, "native functions can only be invoked from unsafe code");
+            ccx.tcx.sess.span_fatal
-          //}
+                (sp, "native functions can only be invoked from unsafe code");
+          }
+          */
           _ {
           }
         }

src/comp/syntax/parse/parser.rs

@@ -2165,7 +2165,8 @@ fn parse_item(p: parser, attrs: [ast::attribute]) -> option::t<@ast::item> {
         let proto = parse_fn_proto(p);
         ret some(parse_item_fn_or_iter(p, ast::pure_fn, proto, attrs,
                                        ast::il_normal));
-    } else if eat_word(p, "unsafe") {
+    } else if is_word(p, "unsafe") && p.look_ahead(1u) != token::LBRACE {
+        p.bump();
         expect_word(p, "fn");
         ret some(parse_item_fn_or_iter(p, ast::unsafe_fn, ast::proto_fn,
                                        attrs, ast::il_normal));

src/lib/vec.rs

@@ -15,7 +15,9 @@ native "rust" mod rustrt {
 
 /// Reserves space for `n` elements in the given vector.
 fn reserve<@T>(&v: [mutable? T], n: uint) {
-    rustrt::vec_reserve_shared(v, n);
+    //unsafe {
+        rustrt::vec_reserve_shared(v, n);
+    //}
 }
 
 pure fn len<T>(v: [mutable? T]) -> uint { unchecked { rusti::vec_len(v) } }

src/test/compile-fail/unsafe-fn-called-from-safe.rs

@@ -0,0 +1,8 @@
+// -*- rust -*-
+// error-pattern: safe function calls function marked unsafe
+
+unsafe fn f() { ret; }
+
+fn main() {
+    f();
+}

src/test/run-pass/unsafe-fn-called-from-unsafe-blk.rs

@@ -0,0 +1,11 @@
+// -*- rust -*-
+//
+// See also: compile-fail/unsafe-fn-called-from-safe.rs
+
+unsafe fn f() { ret; }
+
+fn main() {
+    unsafe {
+        f();
+    }
+}