---

yaml
---
r: 30045
b: refs/heads/incoming
c: 0f996f7
h: refs/heads/master
i:
  30043: d6cd3ff
v: v3

Author: msullivan

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: d324a424d8f84b1eb049b12cf34182bda91b0024
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: d0c6ce338884ee21843f4b40bf6bf18d222ce5df
-refs/heads/incoming: 34886ed488f6cc18c3fdc20cdeccab6178e00c0f
+refs/heads/incoming: 0f996f70a632d1427801f20935a69a57fbb3679e
 refs/heads/dist-snap: 2f32a1581f522e524009138b33b1c7049ced668d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/incoming/src/libsyntax/ast.rs

@@ -531,7 +531,7 @@ type ty_field_ = {ident: ident, mt: mt};
 type ty_field = spanned<ty_field_>;
 
 #[auto_serialize]
-type ty_method = {ident: ident, attrs: ~[attribute],
+type ty_method = {ident: ident, attrs: ~[attribute], purity: purity,
                   decl: fn_decl, tps: ~[ty_param], self_ty: self_ty,
                   id: node_id, span: span};
 
@@ -582,7 +582,7 @@ enum ty_ {
     ty_ptr(mt),
     ty_rptr(@region, mt),
     ty_rec(~[ty_field]),
-    ty_fn(proto, @~[ty_param_bound], fn_decl),
+    ty_fn(proto, purity, @~[ty_param_bound], fn_decl),
     ty_tup(~[@ty]),
     ty_path(@path, node_id),
     ty_fixed_length(@ty, option<uint>),
@@ -600,7 +600,6 @@ type arg = {mode: mode, ty: @ty, ident: ident, id: node_id};
 type fn_decl =
     {inputs: ~[arg],
      output: @ty,
-     purity: purity,
      cf: ret_style};
 
 #[auto_serialize]
@@ -633,7 +632,8 @@ type self_ty = spanned<self_ty_>;
 
 #[auto_serialize]
 type method = {ident: ident, attrs: ~[attribute],
-               tps: ~[ty_param], self_ty: self_ty, decl: fn_decl, body: blk,
+               tps: ~[ty_param], self_ty: self_ty,
+               purity: purity, decl: fn_decl, body: blk,
                id: node_id, span: span, self_id: node_id,
                vis: visibility};  // always public, unless it's a
                                   // class method
@@ -775,7 +775,7 @@ type item = {ident: ident, attrs: ~[attribute],
 #[auto_serialize]
 enum item_ {
     item_const(@ty, @expr),
-    item_fn(fn_decl, ~[ty_param], blk),
+    item_fn(fn_decl, purity, ~[ty_param], blk),
     item_mod(_mod),
     item_foreign_mod(foreign_mod),
     item_ty(@ty, ~[ty_param]),
@@ -821,7 +821,7 @@ type foreign_item =
 
 #[auto_serialize]
 enum foreign_item_ {
-    foreign_item_fn(fn_decl, ~[ty_param]),
+    foreign_item_fn(fn_decl, purity, ~[ty_param]),
 }
 
 // The data we save and restore about an inlined item or method.  This is not

branches/incoming/src/libsyntax/ast_util.rs

@@ -311,7 +311,8 @@ fn trait_method_to_ty_method(method: trait_method) -> ty_method {
       required(m) => m,
       provided(m) => {
         {ident: m.ident, attrs: m.attrs,
-         decl: m.decl, tps: m.tps, self_ty: m.self_ty,
+         purity: m.purity, decl: m.decl,
+         tps: m.tps, self_ty: m.self_ty,
          id: m.id, span: m.span}
       }
     }
@@ -411,7 +412,7 @@ fn dtor_dec() -> fn_decl {
     {inputs: ~[{mode: ast::expl(ast::by_ref),
                 ty: nil_t, ident: parse::token::special_idents::underscore,
                 id: 0}],
-     output: nil_t, purity: impure_fn, cf: return_val}
+     output: nil_t, cf: return_val}
 }
 
 // ______________________________________________________________________
@@ -515,7 +516,7 @@ fn id_visitor(vfn: fn@(node_id)) -> visit::vt<()> {
                 vfn(self_id);
                 vfn(parent_id.node);
               }
-              visit::fk_item_fn(_, tps) => {
+              visit::fk_item_fn(_, tps, _) => {
                 vec::iter(tps, |tp| vfn(tp.id));
               }
               visit::fk_method(_, tps, m) => {

branches/incoming/src/libsyntax/ext/auto_serialize.rs

@@ -191,10 +191,10 @@ impl ext_ctxt: ext_ctxt_helpers {
 
         @{id: self.next_id(),
           node: ast::ty_fn(ast::proto_block,
+                           ast::impure_fn,
                            @~[],
                            {inputs: args,
                             output: output,
-                            purity: ast::impure_fn,
                             cf: ast::return_val}),
           span: span}
     }
@@ -604,8 +604,8 @@ fn mk_ser_fn(cx: ext_ctxt, span: span, name: ast::ident,
       id: cx.next_id(),
       node: ast::item_fn({inputs: ser_inputs,
                           output: ser_output,
-                          purity: ast::impure_fn,
                           cf: ast::return_val},
+                         ast::impure_fn,
                          ser_tps,
                          ser_blk),
       vis: ast::public,
@@ -810,8 +810,8 @@ fn mk_deser_fn(cx: ext_ctxt, span: span,
       id: cx.next_id(),
       node: ast::item_fn({inputs: deser_inputs,
                           output: v_ty,
-                          purity: ast::impure_fn,
                           cf: ast::return_val},
+                         ast::impure_fn,
                          deser_tps,
                          deser_blk),
       vis: ast::public,

branches/incoming/src/libsyntax/ext/pipes/ast_builder.rs

@@ -203,7 +203,6 @@ impl ext_ctxt: ext_ctxt_ast_builder {
                output: @ast::ty) -> ast::fn_decl {
         {inputs: inputs,
          output: output,
-         purity: ast::impure_fn,
          cf: ast::return_val}
     }
 
@@ -226,6 +225,7 @@ impl ext_ctxt: ext_ctxt_ast_builder {
         self.item(name,
                   self.empty_span(),
                   ast::item_fn(self.fn_decl(inputs, output),
+                               ast::impure_fn,
                                ty_params,
                                body))
     }

branches/incoming/src/libsyntax/fold.rs

@@ -127,7 +127,6 @@ fn fold_mac_(m: mac, fld: ast_fold) -> mac {
 fn fold_fn_decl(decl: ast::fn_decl, fld: ast_fold) -> ast::fn_decl {
     return {inputs: vec::map(decl.inputs, |x| fold_arg_(x, fld) ),
          output: fld.fold_ty(decl.output),
-         purity: decl.purity,
          cf: decl.cf}
 }
 
@@ -190,12 +189,12 @@ fn noop_fold_foreign_item(&&ni: @foreign_item, fld: ast_fold)
           attrs: vec::map(ni.attrs, fold_attribute),
           node:
               match ni.node {
-                foreign_item_fn(fdec, typms) => {
+                foreign_item_fn(fdec, purity, typms) => {
                   foreign_item_fn({inputs: vec::map(fdec.inputs, fold_arg),
-                                  output: fld.fold_ty(fdec.output),
-                                  purity: fdec.purity,
-                                  cf: fdec.cf},
-                                 fold_ty_params(typms, fld))
+                                   output: fld.fold_ty(fdec.output),
+                                   cf: fdec.cf},
+                                  purity,
+                                  fold_ty_params(typms, fld))
                 }
               },
           id: fld.new_id(ni.id),
@@ -224,8 +223,9 @@ fn noop_fold_struct_field(&&sf: @struct_field, fld: ast_fold)
 fn noop_fold_item_underscore(i: item_, fld: ast_fold) -> item_ {
     return match i {
           item_const(t, e) => item_const(fld.fold_ty(t), fld.fold_expr(e)),
-          item_fn(decl, typms, body) => {
+          item_fn(decl, purity, typms, body) => {
               item_fn(fold_fn_decl(decl, fld),
+                      purity,
                       fold_ty_params(typms, fld),
                       fld.fold_block(body))
           }
@@ -314,6 +314,7 @@ fn noop_fold_method(&&m: @method, fld: ast_fold) -> @method {
           attrs: /* FIXME (#2543) */ copy m.attrs,
           tps: fold_ty_params(m.tps, fld),
           self_ty: m.self_ty,
+          purity: m.purity,
           decl: fold_fn_decl(m.decl, fld),
           body: fld.fold_block(m.body),
           id: fld.new_id(m.id),
@@ -531,10 +532,11 @@ fn noop_fold_ty(t: ty_, fld: ast_fold) -> ty_ {
       ty_ptr(mt) => ty_ptr(fold_mt(mt, fld)),
       ty_rptr(region, mt) => ty_rptr(region, fold_mt(mt, fld)),
       ty_rec(fields) => ty_rec(vec::map(fields, |f| fold_field(f, fld))),
-      ty_fn(proto, bounds, decl) =>
-        ty_fn(proto, @vec::map(*bounds,
-                               |x| fold_ty_param_bound(x, fld)),
-                               fold_fn_decl(decl, fld)),
+      ty_fn(proto, purity, bounds, decl) =>
+        ty_fn(proto, purity,
+              @vec::map(*bounds,
+                        |x| fold_ty_param_bound(x, fld)),
+              fold_fn_decl(decl, fld)),
       ty_tup(tys) => ty_tup(vec::map(tys, |ty| fld.fold_ty(ty))),
       ty_path(path, id) => ty_path(fld.fold_path(path), fld.new_id(id)),
       ty_fixed_length(t, vs) => ty_fixed_length(fld.fold_ty(t), vs),