---

yaml
---
r: 16107
b: refs/heads/try
c: 653a1f8
h: refs/heads/master
i:
  16105: f1cefa1
  16103: 1f8c991
v: v3

Author: nikomatsakis

[refs]

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

branches/try/src/librustsyntax/parse/parser.rs

@@ -136,7 +136,18 @@ class parser {
     }
     fn get_id() -> node_id { next_node_id(self.sess) }
 
-    fn parse_ty_fn() -> fn_decl {
+    fn parse_ty_fn(purity: ast::purity) -> ty_ {
+        let proto = if self.eat_keyword("native") {
+            self.expect_keyword("fn");
+            ast::proto_bare
+        } else {
+            self.expect_keyword("fn");
+            self.parse_fn_ty_proto()
+        };
+        ty_fn(proto, self.parse_ty_fn_decl(purity))
+    }
+
+    fn parse_ty_fn_decl(purity: ast::purity) -> fn_decl {
         let inputs =
             self.parse_seq(token::LPAREN, token::RPAREN,
                            seq_sep(token::COMMA)) { |p|
@@ -159,7 +170,7 @@ class parser {
         let constrs: [@constr] = [];
         let (ret_style, ret_ty) = self.parse_ret_ty();
         ret {inputs: inputs.node, output: ret_ty,
-             purity: impure_fn, cf: ret_style,
+             purity: purity, cf: ret_style,
              constraints: constrs};
     }
 
@@ -170,7 +181,7 @@ class parser {
             let pur = p.parse_fn_purity();
             let ident = p.parse_method_name();
             let tps = p.parse_ty_params();
-            let d = p.parse_ty_fn(), fhi = p.last_span.hi;
+            let d = p.parse_ty_fn_decl(pur), fhi = p.last_span.hi;
             self.expect(token::SEMI);
             {ident: ident, attrs: attrs, decl: {purity: pur with d}, tps: tps,
              span: mk_sp(flo, fhi)}
@@ -384,16 +395,15 @@ class parser {
             let region = self.parse_region_dot();
             let mt = self.parse_mt();
             ty_rptr(region, mt)
-        } else if self.eat_keyword("fn") {
-            let proto = self.parse_fn_ty_proto();
-            alt proto {
-              proto_bare { self.warn("fn is deprecated, use native fn"); }
-              _ { /* fallthrough */ }
-            }
-            ty_fn(proto, self.parse_ty_fn())
+        } else if self.eat_keyword("pure") {
+            self.parse_ty_fn(ast::pure_fn)
+        } else if self.eat_keyword("unsafe") {
+            self.parse_ty_fn(ast::unsafe_fn)
+        } else if self.is_keyword("fn") {
+            self.parse_ty_fn(ast::impure_fn)
         } else if self.eat_keyword("native") {
             self.expect_keyword("fn");
-            ty_fn(proto_bare, self.parse_ty_fn())
+            ty_fn(proto_bare, self.parse_ty_fn_decl(ast::impure_fn))
         } else if self.token == token::MOD_SEP || is_ident(self.token) {
             let path = self.parse_path_with_tps(colons_before_params);
             ty_path(path, self.get_id())

branches/try/src/librustsyntax/print/pprust.rs

@@ -1029,6 +1029,7 @@ fn print_expr(s: ps, &&expr: @ast::expr) {
         cbox(s, indent_unit);
         // head-box, will be closed by print-block at start
         ibox(s, 0u);
+        print_purity(s, decl.purity);
         word(s.s, proto_to_str(proto));
         print_fn_args_and_ret(s, decl, *cap_clause);
         space(s.s);
@@ -1322,10 +1323,8 @@ fn print_pat(s: ps, &&pat: @ast::pat) {
 fn print_fn(s: ps, decl: ast::fn_decl, name: ast::ident,
             typarams: [ast::ty_param]) {
     alt decl.purity {
-      ast::impure_fn { head(s, "fn"); }
-      ast::unsafe_fn { head(s, "unsafe fn"); }
-      ast::pure_fn { head(s, "pure fn"); }
-      ast::crust_fn { head(s, "crust fn"); }
+      ast::impure_fn { head(s, "fn") }
+      _ { head(s, purity_to_str(decl.purity) + " fn") }
     }
     word(s.s, name);
     print_type_params(s, typarams);
@@ -1825,6 +1824,22 @@ fn opt_proto_to_str(opt_p: option<ast::proto>) -> str {
     }
 }
 
+fn purity_to_str(p: ast::purity) -> str {
+    alt p {
+      ast::impure_fn {"impure"}
+      ast::unsafe_fn {"unsafe"}
+      ast::pure_fn {"pure"}
+      ast::crust_fn {"crust"}
+    }
+}
+
+fn print_purity(s: ps, p: ast::purity) {
+    alt p {
+      ast::impure_fn {}
+      _ { word_nbsp(s, purity_to_str(p)) }
+    }
+}
+
 fn proto_to_str(p: ast::proto) -> str {
     ret alt p {
       ast::proto_bare { "native fn" }

branches/try/src/rustc/metadata/tydecode.rs

@@ -159,8 +159,8 @@ fn parse_constr<T: copy>(st: @pstate, conv: conv_did,
     ret @respan(sp, {path: pth, args: args, id: def});
 }
 
-fn parse_ty_rust_fn(st: @pstate, conv: conv_did, p: ast::proto) -> ty::t {
-    ret ty::mk_fn(st.tcx, {proto: p with parse_ty_fn(st, conv)});
+fn parse_ty_rust_fn(st: @pstate, conv: conv_did) -> ty::t {
+    ret ty::mk_fn(st.tcx, parse_ty_fn(st, conv));
 }
 
 fn parse_proto(c: char) -> ast::proto {
@@ -335,8 +335,7 @@ fn parse_ty(st: @pstate, conv: conv_did) -> ty::t {
         ret ty::mk_tup(st.tcx, params);
       }
       'f' {
-        let proto = parse_proto(next(st));
-        parse_ty_rust_fn(st, conv, proto)
+        parse_ty_rust_fn(st, conv)
       }
       'r' {
         assert next(st) == '[';
@@ -441,7 +440,18 @@ fn parse_hex(st: @pstate) -> uint {
     };
 }
 
+fn parse_purity(c: char) -> purity {
+    alt check c {
+      'u' {unsafe_fn}
+      'p' {pure_fn}
+      'i' {impure_fn}
+      'c' {crust_fn}
+    }
+}
+
 fn parse_ty_fn(st: @pstate, conv: conv_did) -> ty::fn_ty {
+    let proto = parse_proto(next(st));
+    let purity = parse_purity(next(st));
     assert (next(st) == '[');
     let mut inputs: [ty::arg] = [];
     while peek(st) != ']' {
@@ -458,7 +468,7 @@ fn parse_ty_fn(st: @pstate, conv: conv_did) -> ty::fn_ty {
     st.pos += 1u; // eat the ']'
     let cs = parse_constrs(st, conv);
     let (ret_style, ret_ty) = parse_ret_ty(st, conv);
-    ret {proto: ast::proto_bare, inputs: inputs, output: ret_ty,
+    ret {purity: purity, proto: proto, inputs: inputs, output: ret_ty,
          ret_style: ret_style, constraints: cs};
 }
 

branches/try/src/rustc/metadata/tyencode.rs

@@ -262,7 +262,6 @@ fn enc_sty(w: io::writer, cx: @ctxt, st: ty::sty) {
         w.write_char(']');
       }
       ty::ty_fn(f) {
-        enc_proto(w, f.proto);
         enc_ty_fn(w, cx, f);
       }
       ty::ty_res(def, ty, substs) {
@@ -331,7 +330,18 @@ fn enc_mode(w: io::writer, cx: @ctxt, m: mode) {
     }
 }
 
+fn enc_purity(w: io::writer, p: purity) {
+    alt p {
+      pure_fn { w.write_char('p'); }
+      impure_fn { w.write_char('i'); }
+      unsafe_fn { w.write_char('u'); }
+      crust_fn { w.write_char('c'); }
+    }
+}
+
 fn enc_ty_fn(w: io::writer, cx: @ctxt, ft: ty::fn_ty) {
+    enc_proto(w, ft.proto);
+    enc_purity(w, ft.purity);
     w.write_char('[');
     for ft.inputs.each {|arg|
         enc_mode(w, cx, arg.mode);