From e2f6052c6d34229e41530d2260cd1915d11659bc Mon Sep 17 00:00:00 2001 From: Patrick Walton Date: Fri, 9 Mar 2012 14:40:36 -0800 Subject: [PATCH] Revert "rustc: Create def IDs for region parameters" This reverts commit 0d4cb759494f9589ba57c4f2c41f5a5737ab74e0. --- src/rustc/metadata/astencode.rs | 3 +- src/rustc/metadata/astencode_gen.rs | 1720 +++++++++++++-------------- src/rustc/middle/resolve.rs | 3 +- src/rustc/syntax/ast.rs | 7 +- src/rustc/syntax/ast_util.rs | 3 +- src/rustc/syntax/parse/parser.rs | 2 +- src/rustc/syntax/print/pprust.rs | 2 +- 7 files changed, 841 insertions(+), 899 deletions(-) diff --git a/src/rustc/metadata/astencode.rs b/src/rustc/metadata/astencode.rs index 6775b539ec57..c317e2fa1f25 100644 --- a/src/rustc/metadata/astencode.rs +++ b/src/rustc/metadata/astencode.rs @@ -434,7 +434,6 @@ impl of tr for ast::def { ast::def_class_method(did0, did1) { ast::def_class_method(did0.tr(xcx), did1.tr(xcx)) } - ast::def_region_param(did) { ast::def_region_param(did.tr(xcx)) } } } } @@ -1005,4 +1004,4 @@ fn test_simplification() { } _ { fail; } } -} +} \ No newline at end of file diff --git a/src/rustc/metadata/astencode_gen.rs b/src/rustc/metadata/astencode_gen.rs index 1688c5afb1d1..05f351c3d3c0 100644 --- a/src/rustc/metadata/astencode_gen.rs +++ b/src/rustc/metadata/astencode_gen.rs @@ -570,26 +570,13 @@ fn serialize_32(s: S, v: syntax::ast::mt) { } }); } -/*syntax::ast::region_param*/ -fn serialize_35(s: S, - v: - syntax::ast::region_param) { - s.emit_rec(/*syntax::ast::ident*//*syntax::ast::node_id*/ - {|| - { - s.emit_rec_field("ident", 0u, - {|| serialize_1(s, v.ident) }); - s.emit_rec_field("id", 1u, {|| serialize_27(s, v.id) }) - } - }); -} /*syntax::ast::region*/ fn serialize_34(s: S, v: syntax::ast::region) { s.emit_enum("syntax::ast::region", - /*syntax::ast::region_param*/ + /*syntax::ast::ident*/ {|| alt v { syntax::ast::re_inferred { @@ -602,8 +589,8 @@ fn serialize_34(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_35(s, - v0) + serialize_1(s, + v0) }) } }) @@ -616,7 +603,7 @@ fn serialize_34(s: S, }); } /*syntax::ast::ty_field_*/ -fn serialize_38(s: S, +fn serialize_37(s: S, v: syntax::ast::ty_field_) { s.emit_rec(/*syntax::ast::ident*//*syntax::ast::mt*/ @@ -629,33 +616,33 @@ fn serialize_38(s: S, }); } /*syntax::ast::ty_field*/ -fn serialize_37(s: S, +fn serialize_36(s: S, v: syntax::ast::ty_field) { s.emit_rec(/*syntax::ast::ty_field_*//*syntax::codemap::span*/ {|| { s.emit_rec_field("node", 0u, - {|| serialize_38(s, v.node) }); + {|| serialize_37(s, v.node) }); s.emit_rec_field("span", 1u, {|| serialize_19(s, v.span) }) } }); } /*[syntax::ast::ty_field]*/ -fn serialize_36(s: S, +fn serialize_35(s: S, v: [syntax::ast::ty_field]) { s.emit_vec(vec::len(v), /*syntax::ast::ty_field*/ {|| vec::iteri(v, {|i, e| - s.emit_vec_elt(i, {|| serialize_37(s, e) }) + s.emit_vec_elt(i, {|| serialize_36(s, e) }) }) }); } /*syntax::ast::proto*/ -fn serialize_39(s: S, +fn serialize_38(s: S, v: syntax::ast::proto) { s.emit_enum("syntax::ast::proto", @@ -689,7 +676,7 @@ fn serialize_39(s: S, }); } /*syntax::ast::rmode*/ -fn serialize_44(s: S, +fn serialize_43(s: S, v: syntax::ast::rmode) { s.emit_enum("syntax::ast::rmode", @@ -723,7 +710,7 @@ fn serialize_44(s: S, }); } /*syntax::ast::mode*/ -fn serialize_43(s: S, +fn serialize_42(s: S, v: syntax::ast::mode) { s.emit_enum("syntax::ast::inferable", @@ -737,7 +724,7 @@ fn serialize_43(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_44(s, + serialize_43(s, v0) }) } @@ -759,7 +746,7 @@ fn serialize_43(s: S, }); } /*syntax::ast::arg*/ -fn serialize_42(s: S, +fn serialize_41(s: S, v: syntax::ast::arg) { s.emit_rec(/*syntax::ast::mode*//*@syntax::ast::ty*/ @@ -767,7 +754,7 @@ fn serialize_42(s: S, {|| { s.emit_rec_field("mode", 0u, - {|| serialize_43(s, v.mode) }); + {|| serialize_42(s, v.mode) }); s.emit_rec_field("ty", 1u, {|| serialize_29(s, v.ty) }); s.emit_rec_field("ident", 2u, @@ -777,19 +764,19 @@ fn serialize_42(s: S, }); } /*[syntax::ast::arg]*/ -fn serialize_41(s: S, +fn serialize_40(s: S, v: [syntax::ast::arg]) { s.emit_vec(vec::len(v), /*syntax::ast::arg*/ {|| vec::iteri(v, {|i, e| - s.emit_vec_elt(i, {|| serialize_42(s, e) }) + s.emit_vec_elt(i, {|| serialize_41(s, e) }) }) }); } /*syntax::ast::purity*/ -fn serialize_45(s: S, +fn serialize_44(s: S, v: syntax::ast::purity) { s.emit_enum("syntax::ast::purity", @@ -818,7 +805,7 @@ fn serialize_45(s: S, }); } /*syntax::ast::ret_style*/ -fn serialize_46(s: S, +fn serialize_45(s: S, v: syntax::ast::ret_style) { s.emit_enum("syntax::ast::ret_style", @@ -837,7 +824,7 @@ fn serialize_46(s: S, }); } /*[syntax::ast::ident]*/ -fn serialize_54(s: S, +fn serialize_53(s: S, v: [syntax::ast::ident]) { s.emit_vec(vec::len(v), /*syntax::ast::ident*/ @@ -849,7 +836,7 @@ fn serialize_54(s: S, }); } /*[@syntax::ast::ty]*/ -fn serialize_55(s: S, +fn serialize_54(s: S, v: [@syntax::ast::ty]) { s.emit_vec(vec::len(v), /*@syntax::ast::ty*/ @@ -861,7 +848,7 @@ fn serialize_55(s: S, }); } /*syntax::ast::path_*/ -fn serialize_53(s: S, +fn serialize_52(s: S, v: syntax::ast::path_) { s.emit_rec(/*bool*//*[syntax::ast::ident]*//*[@syntax::ast::ty]*/ @@ -870,40 +857,40 @@ fn serialize_53(s: S, s.emit_rec_field("global", 0u, {|| serialize_18(s, v.global) }); s.emit_rec_field("idents", 1u, - {|| serialize_54(s, v.idents) }); + {|| serialize_53(s, v.idents) }); s.emit_rec_field("types", 2u, - {|| serialize_55(s, v.types) }) + {|| serialize_54(s, v.types) }) } }); } /*syntax::ast::path*/ -fn serialize_52(s: S, +fn serialize_51(s: S, v: syntax::ast::path) { s.emit_rec(/*syntax::ast::path_*//*syntax::codemap::span*/ {|| { s.emit_rec_field("node", 0u, - {|| serialize_53(s, v.node) }); + {|| serialize_52(s, v.node) }); s.emit_rec_field("span", 1u, {|| serialize_19(s, v.span) }) } }); } /*@syntax::ast::path*/ -fn serialize_51(s: S, +fn serialize_50(s: S, v: @syntax::ast::path) { - s.emit_box(/*syntax::ast::path*/{|| serialize_52(s, *v) }); + s.emit_box(/*syntax::ast::path*/{|| serialize_51(s, *v) }); } /*@syntax::ast::lit*/ -fn serialize_60(s: S, +fn serialize_59(s: S, v: @syntax::ast::lit) { s.emit_box(/*syntax::ast::lit*/{|| serialize_10(s, *v) }); } /*syntax::ast::constr_arg_general_*/ -fn serialize_59(s: S, +fn serialize_58(s: S, v: syntax::ast::constr_arg_general_) { s.emit_enum("syntax::ast::constr_arg_general_", @@ -934,7 +921,7 @@ fn serialize_59(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_60(s, + serialize_59(s, v0) }) } @@ -944,7 +931,7 @@ fn serialize_59(s: S, }); } /*{node: syntax::ast::constr_arg_general_,span: syntax::codemap::span}*/ -fn serialize_58(s: S, +fn serialize_57(s: S, v: {node: syntax::ast::constr_arg_general_, @@ -955,7 +942,7 @@ fn serialize_58(s: S, {|| { s.emit_rec_field("node", 0u, - {|| serialize_59(s, v.node) }); + {|| serialize_58(s, v.node) }); s.emit_rec_field("span", 1u, {|| serialize_19(s, v.span) }) } @@ -963,7 +950,7 @@ fn serialize_58(s: S, } /*@{node: syntax::ast::constr_arg_general_,span: syntax::codemap::span}*/ -fn serialize_57(s: S, +fn serialize_56(s: S, v: @{node: syntax::ast::constr_arg_general_, @@ -971,11 +958,11 @@ fn serialize_57(s: S, syntax::codemap::span,}) { s.emit_box( /*{node: syntax::ast::constr_arg_general_,span: syntax::codemap::span}*/ - {|| serialize_58(s, *v) }); + {|| serialize_57(s, *v) }); } /*[@{node: syntax::ast::constr_arg_general_,span: syntax::codemap::span}]*/ -fn serialize_56(s: S, +fn serialize_55(s: S, v: [@{node: syntax::ast::constr_arg_general_, @@ -986,13 +973,13 @@ fn serialize_56(s: S, {|| vec::iteri(v, {|i, e| - s.emit_vec_elt(i, {|| serialize_57(s, e) }) + s.emit_vec_elt(i, {|| serialize_56(s, e) }) }) }); } /*{path: @syntax::ast::path,args: [@{node: syntax::ast::constr_arg_general_,span: syntax::codemap::span}],id: syntax::ast::node_id}*/ -fn serialize_50(s: S, +fn serialize_49(s: S, v: {path: @syntax::ast::path, @@ -1009,15 +996,15 @@ fn serialize_50(s: S, {|| { s.emit_rec_field("path", 0u, - {|| serialize_51(s, v.path) }); + {|| serialize_50(s, v.path) }); s.emit_rec_field("args", 1u, - {|| serialize_56(s, v.args) }); + {|| serialize_55(s, v.args) }); s.emit_rec_field("id", 2u, {|| serialize_27(s, v.id) }) } }); } /*syntax::ast::constr*/ -fn serialize_49(s: S, +fn serialize_48(s: S, v: syntax::ast::constr) { s.emit_rec( @@ -1026,32 +1013,32 @@ fn serialize_49(s: S, {|| { s.emit_rec_field("node", 0u, - {|| serialize_50(s, v.node) }); + {|| serialize_49(s, v.node) }); s.emit_rec_field("span", 1u, {|| serialize_19(s, v.span) }) } }); } /*@syntax::ast::constr*/ -fn serialize_48(s: S, +fn serialize_47(s: S, v: @syntax::ast::constr) { - s.emit_box(/*syntax::ast::constr*/{|| serialize_49(s, *v) }); + s.emit_box(/*syntax::ast::constr*/{|| serialize_48(s, *v) }); } /*[@syntax::ast::constr]*/ -fn serialize_47(s: S, +fn serialize_46(s: S, v: [@syntax::ast::constr]) { s.emit_vec(vec::len(v), /*@syntax::ast::constr*/ {|| vec::iteri(v, {|i, e| - s.emit_vec_elt(i, {|| serialize_48(s, e) }) + s.emit_vec_elt(i, {|| serialize_47(s, e) }) }) }); } /*syntax::ast::fn_decl*/ -fn serialize_40(s: S, +fn serialize_39(s: S, v: syntax::ast::fn_decl) { s.emit_rec(/*[syntax::ast::arg]*//*@syntax::ast::ty*/ @@ -1060,20 +1047,20 @@ fn serialize_40(s: S, {|| { s.emit_rec_field("inputs", 0u, - {|| serialize_41(s, v.inputs) }); + {|| serialize_40(s, v.inputs) }); s.emit_rec_field("output", 1u, {|| serialize_29(s, v.output) }); s.emit_rec_field("purity", 2u, - {|| serialize_45(s, v.purity) }); + {|| serialize_44(s, v.purity) }); s.emit_rec_field("cf", 3u, - {|| serialize_46(s, v.cf) }); + {|| serialize_45(s, v.cf) }); s.emit_rec_field("constraints", 4u, - {|| serialize_47(s, v.constraints) }) + {|| serialize_46(s, v.constraints) }) } }); } /*syntax::ast::constr_arg_general_<@syntax::ast::path>*/ -fn serialize_68(s: S, +fn serialize_67(s: S, v: syntax::ast::constr_arg_general_<@syntax::ast::path>) { s.emit_enum("syntax::ast::constr_arg_general_", @@ -1092,7 +1079,7 @@ fn serialize_68(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_51(s, + serialize_50(s, v0) }) } @@ -1104,7 +1091,7 @@ fn serialize_68(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_60(s, + serialize_59(s, v0) }) } @@ -1115,7 +1102,7 @@ fn serialize_68(s: S, } /*{node: syntax::ast::constr_arg_general_<@syntax::ast::path>,span: syntax::codemap::span}*/ -fn serialize_67(s: S, +fn serialize_66(s: S, v: {node: syntax::ast::constr_arg_general_<@syntax::ast::path>, @@ -1126,7 +1113,7 @@ fn serialize_67(s: S, {|| { s.emit_rec_field("node", 0u, - {|| serialize_68(s, v.node) }); + {|| serialize_67(s, v.node) }); s.emit_rec_field("span", 1u, {|| serialize_19(s, v.span) }) } @@ -1134,7 +1121,7 @@ fn serialize_67(s: S, } /*@{node: syntax::ast::constr_arg_general_<@syntax::ast::path>,span: syntax::codemap::span}*/ -fn serialize_66(s: S, +fn serialize_65(s: S, v: @{node: syntax::ast::constr_arg_general_<@syntax::ast::path>, @@ -1142,11 +1129,11 @@ fn serialize_66(s: S, syntax::codemap::span,}) { s.emit_box( /*{node: syntax::ast::constr_arg_general_<@syntax::ast::path>,span: syntax::codemap::span}*/ - {|| serialize_67(s, *v) }); + {|| serialize_66(s, *v) }); } /*[@{node: syntax::ast::constr_arg_general_<@syntax::ast::path>,span: syntax::codemap::span}]*/ -fn serialize_65(s: S, +fn serialize_64(s: S, v: [@{node: syntax::ast::constr_arg_general_<@syntax::ast::path>, @@ -1157,12 +1144,12 @@ fn serialize_65(s: S, {|| vec::iteri(v, {|i, e| - s.emit_vec_elt(i, {|| serialize_66(s, e) }) + s.emit_vec_elt(i, {|| serialize_65(s, e) }) }) }); } /*syntax::ast::ty_constr_*/ -fn serialize_64(s: S, +fn serialize_63(s: S, v: syntax::ast::ty_constr_) { s.emit_rec(/*@syntax::ast::path*/ @@ -1171,59 +1158,59 @@ fn serialize_64(s: S, {|| { s.emit_rec_field("path", 0u, - {|| serialize_51(s, v.path) }); + {|| serialize_50(s, v.path) }); s.emit_rec_field("args", 1u, - {|| serialize_65(s, v.args) }); + {|| serialize_64(s, v.args) }); s.emit_rec_field("id", 2u, {|| serialize_27(s, v.id) }) } }); } /*syntax::ast::ty_constr*/ -fn serialize_63(s: S, +fn serialize_62(s: S, v: syntax::ast::ty_constr) { s.emit_rec(/*syntax::ast::ty_constr_*//*syntax::codemap::span*/ {|| { s.emit_rec_field("node", 0u, - {|| serialize_64(s, v.node) }); + {|| serialize_63(s, v.node) }); s.emit_rec_field("span", 1u, {|| serialize_19(s, v.span) }) } }); } /*@syntax::ast::ty_constr*/ -fn serialize_62(s: S, +fn serialize_61(s: S, v: @syntax::ast::ty_constr) { - s.emit_box(/*syntax::ast::ty_constr*/{|| serialize_63(s, *v) }); + s.emit_box(/*syntax::ast::ty_constr*/{|| serialize_62(s, *v) }); } /*[@syntax::ast::ty_constr]*/ -fn serialize_61(s: S, +fn serialize_60(s: S, v: [@syntax::ast::ty_constr]) { s.emit_vec(vec::len(v), /*@syntax::ast::ty_constr*/ {|| vec::iteri(v, {|i, e| - s.emit_vec_elt(i, {|| serialize_62(s, e) }) + s.emit_vec_elt(i, {|| serialize_61(s, e) }) }) }); } /*[@syntax::ast::expr]*/ -fn serialize_75(s: S, +fn serialize_74(s: S, v: [@syntax::ast::expr]) { s.emit_vec(vec::len(v), /*@syntax::ast::expr*/ {|| vec::iteri(v, {|i, e| - s.emit_vec_elt(i, {|| serialize_72(s, e) }) + s.emit_vec_elt(i, {|| serialize_71(s, e) }) }) }); } /*syntax::ast::field_*/ -fn serialize_78(s: S, +fn serialize_77(s: S, v: syntax::ast::field_) { s.emit_rec(/*syntax::ast::mutability*//*syntax::ast::ident*/ @@ -1235,38 +1222,38 @@ fn serialize_78(s: S, s.emit_rec_field("ident", 1u, {|| serialize_1(s, v.ident) }); s.emit_rec_field("expr", 2u, - {|| serialize_72(s, v.expr) }) + {|| serialize_71(s, v.expr) }) } }); } /*syntax::ast::field*/ -fn serialize_77(s: S, +fn serialize_76(s: S, v: syntax::ast::field) { s.emit_rec(/*syntax::ast::field_*//*syntax::codemap::span*/ {|| { s.emit_rec_field("node", 0u, - {|| serialize_78(s, v.node) }); + {|| serialize_77(s, v.node) }); s.emit_rec_field("span", 1u, {|| serialize_19(s, v.span) }) } }); } /*[syntax::ast::field]*/ -fn serialize_76(s: S, +fn serialize_75(s: S, v: [syntax::ast::field]) { s.emit_vec(vec::len(v), /*syntax::ast::field*/ {|| vec::iteri(v, {|i, e| - s.emit_vec_elt(i, {|| serialize_77(s, e) }) + s.emit_vec_elt(i, {|| serialize_76(s, e) }) }) }); } /*core::option::t<@syntax::ast::expr>*/ -fn serialize_79(s: S, +fn serialize_78(s: S, v: core::option::t<@syntax::ast::expr>) { s.emit_enum("core::option::t", @@ -1284,7 +1271,7 @@ fn serialize_79(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_72(s, + serialize_71(s, v0) }) } @@ -1294,19 +1281,19 @@ fn serialize_79(s: S, }); } /*[core::option::t<@syntax::ast::expr>]*/ -fn serialize_80(s: S, +fn serialize_79(s: S, v: [core::option::t<@syntax::ast::expr>]) { s.emit_vec(vec::len(v), /*core::option::t<@syntax::ast::expr>*/ {|| vec::iteri(v, {|i, e| - s.emit_vec_elt(i, {|| serialize_79(s, e) }) + s.emit_vec_elt(i, {|| serialize_78(s, e) }) }) }); } /*syntax::ast::binop*/ -fn serialize_81(s: S, +fn serialize_80(s: S, v: syntax::ast::binop) { s.emit_enum("syntax::ast::binop", @@ -1398,7 +1385,7 @@ fn serialize_81(s: S, }); } /*syntax::ast::unop*/ -fn serialize_82(s: S, +fn serialize_81(s: S, v: syntax::ast::unop) { s.emit_enum("syntax::ast::unop", @@ -1446,7 +1433,7 @@ fn serialize_82(s: S, }); } /*syntax::ast::simple_path*/ -fn serialize_94(s: S, +fn serialize_93(s: S, v: syntax::ast::simple_path) { s.emit_vec(vec::len(v), /*syntax::ast::ident*/ @@ -1458,13 +1445,13 @@ fn serialize_94(s: S, }); } /*@syntax::ast::simple_path*/ -fn serialize_93(s: S, +fn serialize_92(s: S, v: @syntax::ast::simple_path) { - s.emit_box(/*syntax::ast::simple_path*/{|| serialize_94(s, *v) }); + s.emit_box(/*syntax::ast::simple_path*/{|| serialize_93(s, *v) }); } /*syntax::ast::path_list_ident_*/ -fn serialize_97(s: S, +fn serialize_96(s: S, v: syntax::ast::path_list_ident_) { s.emit_rec(/*syntax::ast::ident*//*syntax::ast::node_id*/ @@ -1477,33 +1464,33 @@ fn serialize_97(s: S, }); } /*syntax::ast::path_list_ident*/ -fn serialize_96(s: S, +fn serialize_95(s: S, v: syntax::ast::path_list_ident) { s.emit_rec(/*syntax::ast::path_list_ident_*//*syntax::codemap::span*/ {|| { s.emit_rec_field("node", 0u, - {|| serialize_97(s, v.node) }); + {|| serialize_96(s, v.node) }); s.emit_rec_field("span", 1u, {|| serialize_19(s, v.span) }) } }); } /*[syntax::ast::path_list_ident]*/ -fn serialize_95(s: S, +fn serialize_94(s: S, v: [syntax::ast::path_list_ident]) { s.emit_vec(vec::len(v), /*syntax::ast::path_list_ident*/ {|| vec::iteri(v, {|i, e| - s.emit_vec_elt(i, {|| serialize_96(s, e) }) + s.emit_vec_elt(i, {|| serialize_95(s, e) }) }) }); } /*syntax::ast::view_path_*/ -fn serialize_92(s: S, +fn serialize_91(s: S, v: syntax::ast::view_path_) { s.emit_enum("syntax::ast::view_path_", @@ -1526,7 +1513,7 @@ fn serialize_92(s: S, }); s.emit_enum_variant_arg(1u, {|| - serialize_93(s, + serialize_92(s, v1) }); s.emit_enum_variant_arg(2u, @@ -1544,7 +1531,7 @@ fn serialize_92(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_93(s, + serialize_92(s, v0) }); s.emit_enum_variant_arg(1u, @@ -1562,12 +1549,12 @@ fn serialize_92(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_93(s, + serialize_92(s, v0) }); s.emit_enum_variant_arg(1u, {|| - serialize_95(s, + serialize_94(s, v1) }); s.emit_enum_variant_arg(2u, @@ -1582,39 +1569,39 @@ fn serialize_92(s: S, }); } /*syntax::ast::view_path*/ -fn serialize_91(s: S, +fn serialize_90(s: S, v: syntax::ast::view_path) { s.emit_rec(/*syntax::ast::view_path_*//*syntax::codemap::span*/ {|| { s.emit_rec_field("node", 0u, - {|| serialize_92(s, v.node) }); + {|| serialize_91(s, v.node) }); s.emit_rec_field("span", 1u, {|| serialize_19(s, v.span) }) } }); } /*@syntax::ast::view_path*/ -fn serialize_90(s: S, +fn serialize_89(s: S, v: @syntax::ast::view_path) { - s.emit_box(/*syntax::ast::view_path*/{|| serialize_91(s, *v) }); + s.emit_box(/*syntax::ast::view_path*/{|| serialize_90(s, *v) }); } /*[@syntax::ast::view_path]*/ -fn serialize_89(s: S, +fn serialize_88(s: S, v: [@syntax::ast::view_path]) { s.emit_vec(vec::len(v), /*@syntax::ast::view_path*/ {|| vec::iteri(v, {|i, e| - s.emit_vec_elt(i, {|| serialize_90(s, e) }) + s.emit_vec_elt(i, {|| serialize_89(s, e) }) }) }); } /*syntax::ast::view_item_*/ -fn serialize_88(s: S, +fn serialize_87(s: S, v: syntax::ast::view_item_) { s.emit_enum("syntax::ast::view_item_", @@ -1654,7 +1641,7 @@ fn serialize_88(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_89(s, + serialize_88(s, v0) }) } @@ -1667,7 +1654,7 @@ fn serialize_88(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_89(s, + serialize_88(s, v0) }) } @@ -1677,39 +1664,39 @@ fn serialize_88(s: S, }); } /*syntax::ast::view_item*/ -fn serialize_87(s: S, +fn serialize_86(s: S, v: syntax::ast::view_item) { s.emit_rec(/*syntax::ast::view_item_*//*syntax::codemap::span*/ {|| { s.emit_rec_field("node", 0u, - {|| serialize_88(s, v.node) }); + {|| serialize_87(s, v.node) }); s.emit_rec_field("span", 1u, {|| serialize_19(s, v.span) }) } }); } /*@syntax::ast::view_item*/ -fn serialize_86(s: S, +fn serialize_85(s: S, v: @syntax::ast::view_item) { - s.emit_box(/*syntax::ast::view_item*/{|| serialize_87(s, *v) }); + s.emit_box(/*syntax::ast::view_item*/{|| serialize_86(s, *v) }); } /*[@syntax::ast::view_item]*/ -fn serialize_85(s: S, +fn serialize_84(s: S, v: [@syntax::ast::view_item]) { s.emit_vec(vec::len(v), /*@syntax::ast::view_item*/ {|| vec::iteri(v, {|i, e| - s.emit_vec_elt(i, {|| serialize_86(s, e) }) + s.emit_vec_elt(i, {|| serialize_85(s, e) }) }) }); } /*core::option::t<@syntax::ast::pat>*/ -fn serialize_112(s: S, +fn serialize_111(s: S, v: core::option::t<@syntax::ast::pat>) { s.emit_enum("core::option::t", @@ -1727,7 +1714,7 @@ fn serialize_112(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_109(s, + serialize_108(s, v0) }) } @@ -1737,19 +1724,19 @@ fn serialize_112(s: S, }); } /*[@syntax::ast::pat]*/ -fn serialize_113(s: S, +fn serialize_112(s: S, v: [@syntax::ast::pat]) { s.emit_vec(vec::len(v), /*@syntax::ast::pat*/ {|| vec::iteri(v, {|i, e| - s.emit_vec_elt(i, {|| serialize_109(s, e) }) + s.emit_vec_elt(i, {|| serialize_108(s, e) }) }) }); } /*syntax::ast::field_pat*/ -fn serialize_115(s: S, +fn serialize_114(s: S, v: syntax::ast::field_pat) { s.emit_rec(/*syntax::ast::ident*//*@syntax::ast::pat*/ @@ -1758,24 +1745,24 @@ fn serialize_115(s: S, s.emit_rec_field("ident", 0u, {|| serialize_1(s, v.ident) }); s.emit_rec_field("pat", 1u, - {|| serialize_109(s, v.pat) }) + {|| serialize_108(s, v.pat) }) } }); } /*[syntax::ast::field_pat]*/ -fn serialize_114(s: S, +fn serialize_113(s: S, v: [syntax::ast::field_pat]) { s.emit_vec(vec::len(v), /*syntax::ast::field_pat*/ {|| vec::iteri(v, {|i, e| - s.emit_vec_elt(i, {|| serialize_115(s, e) }) + s.emit_vec_elt(i, {|| serialize_114(s, e) }) }) }); } /*syntax::ast::pat_*/ -fn serialize_111(s: S, +fn serialize_110(s: S, v: syntax::ast::pat_) { s.emit_enum("syntax::ast::pat_", @@ -1800,12 +1787,12 @@ fn serialize_111(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_51(s, + serialize_50(s, v0) }); s.emit_enum_variant_arg(1u, {|| - serialize_112(s, + serialize_111(s, v1) }) } @@ -1817,12 +1804,12 @@ fn serialize_111(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_51(s, + serialize_50(s, v0) }); s.emit_enum_variant_arg(1u, {|| - serialize_113(s, + serialize_112(s, v1) }) } @@ -1834,7 +1821,7 @@ fn serialize_111(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_114(s, + serialize_113(s, v0) }); s.emit_enum_variant_arg(1u, @@ -1851,7 +1838,7 @@ fn serialize_111(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_113(s, + serialize_112(s, v0) }) } @@ -1863,7 +1850,7 @@ fn serialize_111(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_109(s, + serialize_108(s, v0) }) } @@ -1875,7 +1862,7 @@ fn serialize_111(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_109(s, + serialize_108(s, v0) }) } @@ -1887,7 +1874,7 @@ fn serialize_111(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_72(s, + serialize_71(s, v0) }) } @@ -1899,12 +1886,12 @@ fn serialize_111(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_72(s, + serialize_71(s, v0) }); s.emit_enum_variant_arg(1u, {|| - serialize_72(s, + serialize_71(s, v1) }) } @@ -1914,7 +1901,7 @@ fn serialize_111(s: S, }); } /*syntax::ast::pat*/ -fn serialize_110(s: S, +fn serialize_109(s: S, v: syntax::ast::pat) { s.emit_rec(/*syntax::ast::node_id*//*syntax::ast::pat_*/ @@ -1924,20 +1911,20 @@ fn serialize_110(s: S, s.emit_rec_field("id", 0u, {|| serialize_27(s, v.id) }); s.emit_rec_field("node", 1u, - {|| serialize_111(s, v.node) }); + {|| serialize_110(s, v.node) }); s.emit_rec_field("span", 2u, {|| serialize_19(s, v.span) }) } }); } /*@syntax::ast::pat*/ -fn serialize_109(s: S, +fn serialize_108(s: S, v: @syntax::ast::pat) { - s.emit_box(/*syntax::ast::pat*/{|| serialize_110(s, *v) }); + s.emit_box(/*syntax::ast::pat*/{|| serialize_109(s, *v) }); } /*syntax::ast::init_op*/ -fn serialize_118(s: S, +fn serialize_117(s: S, v: syntax::ast::init_op) { s.emit_enum("syntax::ast::init_op", @@ -1956,21 +1943,21 @@ fn serialize_118(s: S, }); } /*syntax::ast::initializer*/ -fn serialize_117(s: S, +fn serialize_116(s: S, v: syntax::ast::initializer) { s.emit_rec(/*syntax::ast::init_op*//*@syntax::ast::expr*/ {|| { s.emit_rec_field("op", 0u, - {|| serialize_118(s, v.op) }); + {|| serialize_117(s, v.op) }); s.emit_rec_field("expr", 1u, - {|| serialize_72(s, v.expr) }) + {|| serialize_71(s, v.expr) }) } }); } /*core::option::t*/ -fn serialize_116(s: S, +fn serialize_115(s: S, v: core::option::t) { s.emit_enum("core::option::t", @@ -1988,7 +1975,7 @@ fn serialize_116(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_117(s, + serialize_116(s, v0) }) } @@ -1998,7 +1985,7 @@ fn serialize_116(s: S, }); } /*syntax::ast::local_*/ -fn serialize_108(s: S, +fn serialize_107(s: S, v: syntax::ast::local_) { s.emit_rec(/*bool*//*@syntax::ast::ty*//*@syntax::ast::pat*/ @@ -2011,53 +1998,53 @@ fn serialize_108(s: S, s.emit_rec_field("ty", 1u, {|| serialize_29(s, v.ty) }); s.emit_rec_field("pat", 2u, - {|| serialize_109(s, v.pat) }); + {|| serialize_108(s, v.pat) }); s.emit_rec_field("init", 3u, - {|| serialize_116(s, v.init) }); + {|| serialize_115(s, v.init) }); s.emit_rec_field("id", 4u, {|| serialize_27(s, v.id) }) } }); } /*syntax::ast::local*/ -fn serialize_107(s: S, +fn serialize_106(s: S, v: syntax::ast::local) { s.emit_rec(/*syntax::ast::local_*//*syntax::codemap::span*/ {|| { s.emit_rec_field("node", 0u, - {|| serialize_108(s, v.node) }); + {|| serialize_107(s, v.node) }); s.emit_rec_field("span", 1u, {|| serialize_19(s, v.span) }) } }); } /*@syntax::ast::local*/ -fn serialize_106(s: S, +fn serialize_105(s: S, v: @syntax::ast::local) { - s.emit_box(/*syntax::ast::local*/{|| serialize_107(s, *v) }); + s.emit_box(/*syntax::ast::local*/{|| serialize_106(s, *v) }); } /*[@syntax::ast::local]*/ -fn serialize_105(s: S, +fn serialize_104(s: S, v: [@syntax::ast::local]) { s.emit_vec(vec::len(v), /*@syntax::ast::local*/ {|| vec::iteri(v, {|i, e| - s.emit_vec_elt(i, {|| serialize_106(s, e) }) + s.emit_vec_elt(i, {|| serialize_105(s, e) }) }) }); } /*@syntax::ast::item*/ -fn serialize_119(s: S, +fn serialize_118(s: S, v: @syntax::ast::item) { s.emit_box(/*syntax::ast::item*/{|| serialize_0(s, *v) }); } /*syntax::ast::decl_*/ -fn serialize_104(s: S, +fn serialize_103(s: S, v: syntax::ast::decl_) { s.emit_enum("syntax::ast::decl_", @@ -2071,7 +2058,7 @@ fn serialize_104(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_105(s, + serialize_104(s, v0) }) } @@ -2083,7 +2070,7 @@ fn serialize_104(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_119(s, + serialize_118(s, v0) }) } @@ -2093,27 +2080,27 @@ fn serialize_104(s: S, }); } /*syntax::ast::decl*/ -fn serialize_103(s: S, +fn serialize_102(s: S, v: syntax::ast::decl) { s.emit_rec(/*syntax::ast::decl_*//*syntax::codemap::span*/ {|| { s.emit_rec_field("node", 0u, - {|| serialize_104(s, v.node) }); + {|| serialize_103(s, v.node) }); s.emit_rec_field("span", 1u, {|| serialize_19(s, v.span) }) } }); } /*@syntax::ast::decl*/ -fn serialize_102(s: S, +fn serialize_101(s: S, v: @syntax::ast::decl) { - s.emit_box(/*syntax::ast::decl*/{|| serialize_103(s, *v) }); + s.emit_box(/*syntax::ast::decl*/{|| serialize_102(s, *v) }); } /*syntax::ast::stmt_*/ -fn serialize_101(s: S, +fn serialize_100(s: S, v: syntax::ast::stmt_) { s.emit_enum("syntax::ast::stmt_", @@ -2128,7 +2115,7 @@ fn serialize_101(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_102(s, + serialize_101(s, v0) }); s.emit_enum_variant_arg(1u, @@ -2145,7 +2132,7 @@ fn serialize_101(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_72(s, + serialize_71(s, v0) }); s.emit_enum_variant_arg(1u, @@ -2162,7 +2149,7 @@ fn serialize_101(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_72(s, + serialize_71(s, v0) }); s.emit_enum_variant_arg(1u, @@ -2177,39 +2164,39 @@ fn serialize_101(s: S, }); } /*syntax::ast::stmt*/ -fn serialize_100(s: S, - v: syntax::ast::stmt) { +fn serialize_99(s: S, + v: syntax::ast::stmt) { s.emit_rec(/*syntax::ast::stmt_*//*syntax::codemap::span*/ {|| { s.emit_rec_field("node", 0u, - {|| serialize_101(s, v.node) }); + {|| serialize_100(s, v.node) }); s.emit_rec_field("span", 1u, {|| serialize_19(s, v.span) }) } }); } /*@syntax::ast::stmt*/ -fn serialize_99(s: S, +fn serialize_98(s: S, v: @syntax::ast::stmt) { - s.emit_box(/*syntax::ast::stmt*/{|| serialize_100(s, *v) }); + s.emit_box(/*syntax::ast::stmt*/{|| serialize_99(s, *v) }); } /*[@syntax::ast::stmt]*/ -fn serialize_98(s: S, +fn serialize_97(s: S, v: [@syntax::ast::stmt]) { s.emit_vec(vec::len(v), /*@syntax::ast::stmt*/ {|| vec::iteri(v, {|i, e| - s.emit_vec_elt(i, {|| serialize_99(s, e) }) + s.emit_vec_elt(i, {|| serialize_98(s, e) }) }) }); } /*syntax::ast::blk_check_mode*/ -fn serialize_120(s: S, +fn serialize_119(s: S, v: syntax::ast::blk_check_mode) { s.emit_enum("syntax::ast::blk_check_mode", @@ -2233,7 +2220,7 @@ fn serialize_120(s: S, }); } /*syntax::ast::blk_*/ -fn serialize_84(s: S, +fn serialize_83(s: S, v: syntax::ast::blk_) { s.emit_rec(/*[@syntax::ast::view_item]*//*[@syntax::ast::stmt]*/ @@ -2242,34 +2229,34 @@ fn serialize_84(s: S, {|| { s.emit_rec_field("view_items", 0u, - {|| serialize_85(s, v.view_items) }); + {|| serialize_84(s, v.view_items) }); s.emit_rec_field("stmts", 1u, - {|| serialize_98(s, v.stmts) }); + {|| serialize_97(s, v.stmts) }); s.emit_rec_field("expr", 2u, - {|| serialize_79(s, v.expr) }); + {|| serialize_78(s, v.expr) }); s.emit_rec_field("id", 3u, {|| serialize_27(s, v.id) }); s.emit_rec_field("rules", 4u, - {|| serialize_120(s, v.rules) }) + {|| serialize_119(s, v.rules) }) } }); } /*syntax::ast::blk*/ -fn serialize_83(s: S, +fn serialize_82(s: S, v: syntax::ast::blk) { s.emit_rec(/*syntax::ast::blk_*//*syntax::codemap::span*/ {|| { s.emit_rec_field("node", 0u, - {|| serialize_84(s, v.node) }); + {|| serialize_83(s, v.node) }); s.emit_rec_field("span", 1u, {|| serialize_19(s, v.span) }) } }); } /*syntax::ast::arm*/ -fn serialize_122(s: S, +fn serialize_121(s: S, v: syntax::ast::arm) { s.emit_rec(/*[@syntax::ast::pat]*//*core::option::t<@syntax::ast::expr>*/ @@ -2277,28 +2264,28 @@ fn serialize_122(s: S, {|| { s.emit_rec_field("pats", 0u, - {|| serialize_113(s, v.pats) }); + {|| serialize_112(s, v.pats) }); s.emit_rec_field("guard", 1u, - {|| serialize_79(s, v.guard) }); + {|| serialize_78(s, v.guard) }); s.emit_rec_field("body", 2u, - {|| serialize_83(s, v.body) }) + {|| serialize_82(s, v.body) }) } }); } /*[syntax::ast::arm]*/ -fn serialize_121(s: S, +fn serialize_120(s: S, v: [syntax::ast::arm]) { s.emit_vec(vec::len(v), /*syntax::ast::arm*/ {|| vec::iteri(v, {|i, e| - s.emit_vec_elt(i, {|| serialize_122(s, e) }) + s.emit_vec_elt(i, {|| serialize_121(s, e) }) }) }); } /*syntax::ast::alt_mode*/ -fn serialize_123(s: S, +fn serialize_122(s: S, v: syntax::ast::alt_mode) { s.emit_enum("syntax::ast::alt_mode", @@ -2317,19 +2304,19 @@ fn serialize_123(s: S, }); } /*int*/ -fn serialize_129(s: S, v: int) { +fn serialize_128(s: S, v: int) { s.emit_int(v); } /*syntax::ast::capture_item*/ -fn serialize_128(s: S, +fn serialize_127(s: S, v: syntax::ast::capture_item) { s.emit_rec(/*int*//*syntax::ast::ident*//*syntax::codemap::span*/ {|| { s.emit_rec_field("id", 0u, - {|| serialize_129(s, v.id) }); + {|| serialize_128(s, v.id) }); s.emit_rec_field("name", 1u, {|| serialize_1(s, v.name) }); s.emit_rec_field("span", 2u, @@ -2338,25 +2325,25 @@ fn serialize_128(s: S, }); } /*@syntax::ast::capture_item*/ -fn serialize_127(s: S, +fn serialize_126(s: S, v: @syntax::ast::capture_item) { - s.emit_box(/*syntax::ast::capture_item*/{|| serialize_128(s, *v) }); + s.emit_box(/*syntax::ast::capture_item*/{|| serialize_127(s, *v) }); } /*[@syntax::ast::capture_item]*/ -fn serialize_126(s: S, +fn serialize_125(s: S, v: [@syntax::ast::capture_item]) { s.emit_vec(vec::len(v), /*@syntax::ast::capture_item*/ {|| vec::iteri(v, {|i, e| - s.emit_vec_elt(i, {|| serialize_127(s, e) }) + s.emit_vec_elt(i, {|| serialize_126(s, e) }) }) }); } /*syntax::ast::capture_clause*/ -fn serialize_125(s: S, +fn serialize_124(s: S, v: syntax::ast::capture_clause) { s.emit_rec(/*[@syntax::ast::capture_item]*/ @@ -2364,20 +2351,20 @@ fn serialize_125(s: S, {|| { s.emit_rec_field("copies", 0u, - {|| serialize_126(s, v.copies) }); + {|| serialize_125(s, v.copies) }); s.emit_rec_field("moves", 1u, - {|| serialize_126(s, v.moves) }) + {|| serialize_125(s, v.moves) }) } }); } /*@syntax::ast::capture_clause*/ -fn serialize_124(s: S, +fn serialize_123(s: S, v: @syntax::ast::capture_clause) { - s.emit_box(/*syntax::ast::capture_clause*/{|| serialize_125(s, *v) }); + s.emit_box(/*syntax::ast::capture_clause*/{|| serialize_124(s, *v) }); } /*syntax::ast::expr_check_mode*/ -fn serialize_130(s: S, +fn serialize_129(s: S, v: syntax::ast::expr_check_mode) { s.emit_enum("syntax::ast::expr_check_mode", @@ -2396,7 +2383,7 @@ fn serialize_130(s: S, }); } /*syntax::ast::expr_*/ -fn serialize_74(s: S, +fn serialize_73(s: S, v: syntax::ast::expr_) { s.emit_enum("syntax::ast::expr_", @@ -2454,7 +2441,7 @@ fn serialize_74(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_75(s, + serialize_74(s, v0) }); s.emit_enum_variant_arg(1u, @@ -2471,12 +2458,12 @@ fn serialize_74(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_76(s, + serialize_75(s, v0) }); s.emit_enum_variant_arg(1u, {|| - serialize_79(s, + serialize_78(s, v1) }) } @@ -2488,12 +2475,12 @@ fn serialize_74(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_72(s, + serialize_71(s, v0) }); s.emit_enum_variant_arg(1u, {|| - serialize_75(s, + serialize_74(s, v1) }); s.emit_enum_variant_arg(2u, @@ -2510,7 +2497,7 @@ fn serialize_74(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_75(s, + serialize_74(s, v0) }) } @@ -2522,12 +2509,12 @@ fn serialize_74(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_72(s, + serialize_71(s, v0) }); s.emit_enum_variant_arg(1u, {|| - serialize_80(s, + serialize_79(s, v1) }) } @@ -2540,17 +2527,17 @@ fn serialize_74(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_81(s, + serialize_80(s, v0) }); s.emit_enum_variant_arg(1u, {|| - serialize_72(s, + serialize_71(s, v1) }); s.emit_enum_variant_arg(2u, {|| - serialize_72(s, + serialize_71(s, v2) }) } @@ -2562,12 +2549,12 @@ fn serialize_74(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_82(s, + serialize_81(s, v0) }); s.emit_enum_variant_arg(1u, {|| - serialize_72(s, + serialize_71(s, v1) }) } @@ -2579,7 +2566,7 @@ fn serialize_74(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_60(s, + serialize_59(s, v0) }) } @@ -2591,7 +2578,7 @@ fn serialize_74(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_72(s, + serialize_71(s, v0) }); s.emit_enum_variant_arg(1u, @@ -2608,17 +2595,17 @@ fn serialize_74(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_72(s, + serialize_71(s, v0) }); s.emit_enum_variant_arg(1u, {|| - serialize_83(s, + serialize_82(s, v1) }); s.emit_enum_variant_arg(2u, {|| - serialize_79(s, + serialize_78(s, v2) }) } @@ -2631,12 +2618,12 @@ fn serialize_74(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_72(s, + serialize_71(s, v0) }); s.emit_enum_variant_arg(1u, {|| - serialize_83(s, + serialize_82(s, v1) }) } @@ -2648,17 +2635,17 @@ fn serialize_74(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_106(s, + serialize_105(s, v0) }); s.emit_enum_variant_arg(1u, {|| - serialize_72(s, + serialize_71(s, v1) }); s.emit_enum_variant_arg(2u, {|| - serialize_83(s, + serialize_82(s, v2) }) } @@ -2671,12 +2658,12 @@ fn serialize_74(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_83(s, + serialize_82(s, v0) }); s.emit_enum_variant_arg(1u, {|| - serialize_72(s, + serialize_71(s, v1) }) } @@ -2688,17 +2675,17 @@ fn serialize_74(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_72(s, + serialize_71(s, v0) }); s.emit_enum_variant_arg(1u, {|| - serialize_121(s, + serialize_120(s, v1) }); s.emit_enum_variant_arg(2u, {|| - serialize_123(s, + serialize_122(s, v2) }) } @@ -2710,22 +2697,22 @@ fn serialize_74(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_39(s, + serialize_38(s, v0) }); s.emit_enum_variant_arg(1u, {|| - serialize_40(s, + serialize_39(s, v1) }); s.emit_enum_variant_arg(2u, {|| - serialize_83(s, + serialize_82(s, v2) }); s.emit_enum_variant_arg(3u, {|| - serialize_124(s, + serialize_123(s, v3) }) } @@ -2738,12 +2725,12 @@ fn serialize_74(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_40(s, + serialize_39(s, v0) }); s.emit_enum_variant_arg(1u, {|| - serialize_83(s, + serialize_82(s, v1) }) } @@ -2756,7 +2743,7 @@ fn serialize_74(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_83(s, + serialize_82(s, v0) }) } @@ -2768,7 +2755,7 @@ fn serialize_74(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_72(s, + serialize_71(s, v0) }) } @@ -2780,12 +2767,12 @@ fn serialize_74(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_72(s, + serialize_71(s, v0) }); s.emit_enum_variant_arg(1u, {|| - serialize_72(s, + serialize_71(s, v1) }) } @@ -2798,12 +2785,12 @@ fn serialize_74(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_72(s, + serialize_71(s, v0) }); s.emit_enum_variant_arg(1u, {|| - serialize_72(s, + serialize_71(s, v1) }) } @@ -2815,12 +2802,12 @@ fn serialize_74(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_72(s, + serialize_71(s, v0) }); s.emit_enum_variant_arg(1u, {|| - serialize_72(s, + serialize_71(s, v1) }) } @@ -2833,17 +2820,17 @@ fn serialize_74(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_81(s, + serialize_80(s, v0) }); s.emit_enum_variant_arg(1u, {|| - serialize_72(s, + serialize_71(s, v1) }); s.emit_enum_variant_arg(2u, {|| - serialize_72(s, + serialize_71(s, v2) }) } @@ -2856,7 +2843,7 @@ fn serialize_74(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_72(s, + serialize_71(s, v0) }); s.emit_enum_variant_arg(1u, @@ -2866,7 +2853,7 @@ fn serialize_74(s: S, }); s.emit_enum_variant_arg(2u, {|| - serialize_55(s, + serialize_54(s, v2) }) } @@ -2879,12 +2866,12 @@ fn serialize_74(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_72(s, + serialize_71(s, v0) }); s.emit_enum_variant_arg(1u, {|| - serialize_72(s, + serialize_71(s, v1) }) } @@ -2896,7 +2883,7 @@ fn serialize_74(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_51(s, + serialize_50(s, v0) }) } @@ -2914,7 +2901,7 @@ fn serialize_74(s: S, }); s.emit_enum_variant_arg(1u, {|| - serialize_72(s, + serialize_71(s, v1) }) } @@ -2926,7 +2913,7 @@ fn serialize_74(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_79(s, + serialize_78(s, v0) }) } @@ -2946,7 +2933,7 @@ fn serialize_74(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_79(s, + serialize_78(s, v0) }) } @@ -2958,7 +2945,7 @@ fn serialize_74(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_72(s, + serialize_71(s, v0) }) } @@ -2970,17 +2957,17 @@ fn serialize_74(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_129(s, + serialize_128(s, v0) }); s.emit_enum_variant_arg(1u, {|| - serialize_72(s, + serialize_71(s, v1) }); s.emit_enum_variant_arg(2u, {|| - serialize_72(s, + serialize_71(s, v2) }) } @@ -2993,7 +2980,7 @@ fn serialize_74(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_72(s, + serialize_71(s, v0) }) } @@ -3006,12 +2993,12 @@ fn serialize_74(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_130(s, + serialize_129(s, v0) }); s.emit_enum_variant_arg(1u, {|| - serialize_72(s, + serialize_71(s, v1) }) } @@ -3024,17 +3011,17 @@ fn serialize_74(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_72(s, + serialize_71(s, v0) }); s.emit_enum_variant_arg(1u, {|| - serialize_83(s, + serialize_82(s, v1) }); s.emit_enum_variant_arg(2u, {|| - serialize_79(s, + serialize_78(s, v2) }) } @@ -3046,7 +3033,7 @@ fn serialize_74(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_69(s, + serialize_68(s, v0) }) } @@ -3056,7 +3043,7 @@ fn serialize_74(s: S, }); } /*syntax::ast::expr*/ -fn serialize_73(s: S, +fn serialize_72(s: S, v: syntax::ast::expr) { s.emit_rec(/*syntax::ast::node_id*//*syntax::ast::expr_*/ @@ -3066,20 +3053,20 @@ fn serialize_73(s: S, s.emit_rec_field("id", 0u, {|| serialize_27(s, v.id) }); s.emit_rec_field("node", 1u, - {|| serialize_74(s, v.node) }); + {|| serialize_73(s, v.node) }); s.emit_rec_field("span", 2u, {|| serialize_19(s, v.span) }) } }); } /*@syntax::ast::expr*/ -fn serialize_72(s: S, +fn serialize_71(s: S, v: @syntax::ast::expr) { - s.emit_box(/*syntax::ast::expr*/{|| serialize_73(s, *v) }); + s.emit_box(/*syntax::ast::expr*/{|| serialize_72(s, *v) }); } /*syntax::ast::mac_arg<@syntax::ast::expr>*/ -fn serialize_71(s: S, +fn serialize_70(s: S, v: syntax::ast::mac_arg<@syntax::ast::expr>) { s.emit_enum("core::option::t", @@ -3097,7 +3084,7 @@ fn serialize_71(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_72(s, + serialize_71(s, v0) }) } @@ -3107,7 +3094,7 @@ fn serialize_71(s: S, }); } /*syntax::ast::mac_body_*/ -fn serialize_132(s: S, +fn serialize_131(s: S, v: syntax::ast::mac_body_) { s.emit_rec(/*syntax::codemap::span*/ @@ -3119,7 +3106,7 @@ fn serialize_132(s: S, }); } /*syntax::ast::mac_body*/ -fn serialize_131(s: S, +fn serialize_130(s: S, v: syntax::ast::mac_body) { s.emit_enum("core::option::t", @@ -3137,7 +3124,7 @@ fn serialize_131(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_132(s, + serialize_131(s, v0) }) } @@ -3147,7 +3134,7 @@ fn serialize_131(s: S, }); } /*syntax::ast::mac_*/ -fn serialize_70(s: S, +fn serialize_69(s: S, v: syntax::ast::mac_) { s.emit_enum("syntax::ast::mac_", @@ -3167,17 +3154,17 @@ fn serialize_70(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_51(s, + serialize_50(s, v0) }); s.emit_enum_variant_arg(1u, {|| - serialize_71(s, + serialize_70(s, v1) }); s.emit_enum_variant_arg(2u, {|| - serialize_131(s, + serialize_130(s, v2) }) } @@ -3203,7 +3190,7 @@ fn serialize_70(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_83(s, + serialize_82(s, v0) }) } @@ -3224,7 +3211,7 @@ fn serialize_70(s: S, }); s.emit_enum_variant_arg(1u, {|| - serialize_72(s, + serialize_71(s, v1) }) } @@ -3246,14 +3233,14 @@ fn serialize_70(s: S, }); } /*syntax::ast::mac*/ -fn serialize_69(s: S, +fn serialize_68(s: S, v: syntax::ast::mac) { s.emit_rec(/*syntax::ast::mac_*//*syntax::codemap::span*/ {|| { s.emit_rec_field("node", 0u, - {|| serialize_70(s, v.node) }); + {|| serialize_69(s, v.node) }); s.emit_rec_field("span", 1u, {|| serialize_19(s, v.span) }) } @@ -3358,7 +3345,7 @@ fn serialize_31(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_36(s, + serialize_35(s, v0) }) } @@ -3370,12 +3357,12 @@ fn serialize_31(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_39(s, + serialize_38(s, v0) }); s.emit_enum_variant_arg(1u, {|| - serialize_40(s, + serialize_39(s, v1) }) } @@ -3387,7 +3374,7 @@ fn serialize_31(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_55(s, + serialize_54(s, v0) }) } @@ -3399,7 +3386,7 @@ fn serialize_31(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_51(s, + serialize_50(s, v0) }); s.emit_enum_variant_arg(1u, @@ -3421,7 +3408,7 @@ fn serialize_31(s: S, }); s.emit_enum_variant_arg(1u, {|| - serialize_61(s, + serialize_60(s, v1) }) } @@ -3433,7 +3420,7 @@ fn serialize_31(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_69(s, + serialize_68(s, v0) }) } @@ -3466,7 +3453,7 @@ fn serialize_29(s: S, s.emit_box(/*syntax::ast::ty*/{|| serialize_30(s, *v) }); } /*syntax::ast::ty_param_bound*/ -fn serialize_137(s: S, +fn serialize_136(s: S, v: syntax::ast::ty_param_bound) { s.emit_enum("syntax::ast::ty_param_bound", @@ -3500,25 +3487,25 @@ fn serialize_137(s: S, }); } /*[syntax::ast::ty_param_bound]*/ -fn serialize_136(s: S, +fn serialize_135(s: S, v: [syntax::ast::ty_param_bound]) { s.emit_vec(vec::len(v), /*syntax::ast::ty_param_bound*/ {|| vec::iteri(v, {|i, e| - s.emit_vec_elt(i, {|| serialize_137(s, e) }) + s.emit_vec_elt(i, {|| serialize_136(s, e) }) }) }); } /*@[syntax::ast::ty_param_bound]*/ -fn serialize_135(s: S, +fn serialize_134(s: S, v: @[syntax::ast::ty_param_bound]) { - s.emit_box(/*[syntax::ast::ty_param_bound]*/{|| serialize_136(s, *v) }); + s.emit_box(/*[syntax::ast::ty_param_bound]*/{|| serialize_135(s, *v) }); } /*syntax::ast::ty_param*/ -fn serialize_134(s: S, +fn serialize_133(s: S, v: syntax::ast::ty_param) { s.emit_rec(/*syntax::ast::ident*//*syntax::ast::node_id*/ @@ -3530,50 +3517,50 @@ fn serialize_134(s: S, s.emit_rec_field("id", 1u, {|| serialize_27(s, v.id) }); s.emit_rec_field("bounds", 2u, - {|| serialize_135(s, v.bounds) }) + {|| serialize_134(s, v.bounds) }) } }); } /*[syntax::ast::ty_param]*/ -fn serialize_133(s: S, +fn serialize_132(s: S, v: [syntax::ast::ty_param]) { s.emit_vec(vec::len(v), /*syntax::ast::ty_param*/ {|| vec::iteri(v, {|i, e| - s.emit_vec_elt(i, {|| serialize_134(s, e) }) + s.emit_vec_elt(i, {|| serialize_133(s, e) }) }) }); } /*[@syntax::ast::item]*/ -fn serialize_139(s: S, +fn serialize_138(s: S, v: [@syntax::ast::item]) { s.emit_vec(vec::len(v), /*@syntax::ast::item*/ {|| vec::iteri(v, {|i, e| - s.emit_vec_elt(i, {|| serialize_119(s, e) }) + s.emit_vec_elt(i, {|| serialize_118(s, e) }) }) }); } /*syntax::ast::_mod*/ -fn serialize_138(s: S, +fn serialize_137(s: S, v: syntax::ast::_mod) { s.emit_rec(/*[@syntax::ast::view_item]*//*[@syntax::ast::item]*/ {|| { s.emit_rec_field("view_items", 0u, - {|| serialize_85(s, v.view_items) }); + {|| serialize_84(s, v.view_items) }); s.emit_rec_field("items", 1u, - {|| serialize_139(s, v.items) }) + {|| serialize_138(s, v.items) }) } }); } /*syntax::ast::native_item_*/ -fn serialize_144(s: S, +fn serialize_143(s: S, v: syntax::ast::native_item_) { s.emit_enum("syntax::ast::native_item_", @@ -3587,12 +3574,12 @@ fn serialize_144(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_40(s, + serialize_39(s, v0) }); s.emit_enum_variant_arg(1u, {|| - serialize_133(s, + serialize_132(s, v1) }) } @@ -3602,7 +3589,7 @@ fn serialize_144(s: S, }); } /*syntax::ast::native_item*/ -fn serialize_143(s: S, +fn serialize_142(s: S, v: syntax::ast::native_item) { s.emit_rec(/*syntax::ast::ident*//*[syntax::ast::attribute]*/ @@ -3615,7 +3602,7 @@ fn serialize_143(s: S, s.emit_rec_field("attrs", 1u, {|| serialize_2(s, v.attrs) }); s.emit_rec_field("node", 2u, - {|| serialize_144(s, v.node) }); + {|| serialize_143(s, v.node) }); s.emit_rec_field("id", 3u, {|| serialize_27(s, v.id) }); s.emit_rec_field("span", 4u, @@ -3624,39 +3611,39 @@ fn serialize_143(s: S, }); } /*@syntax::ast::native_item*/ -fn serialize_142(s: S, +fn serialize_141(s: S, v: @syntax::ast::native_item) { - s.emit_box(/*syntax::ast::native_item*/{|| serialize_143(s, *v) }); + s.emit_box(/*syntax::ast::native_item*/{|| serialize_142(s, *v) }); } /*[@syntax::ast::native_item]*/ -fn serialize_141(s: S, +fn serialize_140(s: S, v: [@syntax::ast::native_item]) { s.emit_vec(vec::len(v), /*@syntax::ast::native_item*/ {|| vec::iteri(v, {|i, e| - s.emit_vec_elt(i, {|| serialize_142(s, e) }) + s.emit_vec_elt(i, {|| serialize_141(s, e) }) }) }); } /*syntax::ast::native_mod*/ -fn serialize_140(s: S, +fn serialize_139(s: S, v: syntax::ast::native_mod) { s.emit_rec(/*[@syntax::ast::view_item]*//*[@syntax::ast::native_item]*/ {|| { s.emit_rec_field("view_items", 0u, - {|| serialize_85(s, v.view_items) }); + {|| serialize_84(s, v.view_items) }); s.emit_rec_field("items", 1u, - {|| serialize_141(s, v.items) }) + {|| serialize_140(s, v.items) }) } }); } /*syntax::ast::variant_arg*/ -fn serialize_149(s: S, +fn serialize_148(s: S, v: syntax::ast::variant_arg) { s.emit_rec(/*@syntax::ast::ty*//*syntax::ast::node_id*/ @@ -3669,19 +3656,19 @@ fn serialize_149(s: S, }); } /*[syntax::ast::variant_arg]*/ -fn serialize_148(s: S, +fn serialize_147(s: S, v: [syntax::ast::variant_arg]) { s.emit_vec(vec::len(v), /*syntax::ast::variant_arg*/ {|| vec::iteri(v, {|i, e| - s.emit_vec_elt(i, {|| serialize_149(s, e) }) + s.emit_vec_elt(i, {|| serialize_148(s, e) }) }) }); } /*syntax::ast::variant_*/ -fn serialize_147(s: S, +fn serialize_146(s: S, v: syntax::ast::variant_) { s.emit_rec(/*syntax::ast::ident*//*[syntax::ast::attribute]*/ @@ -3694,42 +3681,42 @@ fn serialize_147(s: S, s.emit_rec_field("attrs", 1u, {|| serialize_2(s, v.attrs) }); s.emit_rec_field("args", 2u, - {|| serialize_148(s, v.args) }); + {|| serialize_147(s, v.args) }); s.emit_rec_field("id", 3u, {|| serialize_27(s, v.id) }); s.emit_rec_field("disr_expr", 4u, - {|| serialize_79(s, v.disr_expr) }) + {|| serialize_78(s, v.disr_expr) }) } }); } /*syntax::ast::variant*/ -fn serialize_146(s: S, +fn serialize_145(s: S, v: syntax::ast::variant) { s.emit_rec(/*syntax::ast::variant_*//*syntax::codemap::span*/ {|| { s.emit_rec_field("node", 0u, - {|| serialize_147(s, v.node) }); + {|| serialize_146(s, v.node) }); s.emit_rec_field("span", 1u, {|| serialize_19(s, v.span) }) } }); } /*[syntax::ast::variant]*/ -fn serialize_145(s: S, +fn serialize_144(s: S, v: [syntax::ast::variant]) { s.emit_vec(vec::len(v), /*syntax::ast::variant*/ {|| vec::iteri(v, {|i, e| - s.emit_vec_elt(i, {|| serialize_146(s, e) }) + s.emit_vec_elt(i, {|| serialize_145(s, e) }) }) }); } /*syntax::ast::privacy*/ -fn serialize_154(s: S, +fn serialize_153(s: S, v: syntax::ast::privacy) { s.emit_enum("syntax::ast::privacy", @@ -3747,7 +3734,7 @@ fn serialize_154(s: S, }); } /*syntax::ast::class_mutability*/ -fn serialize_156(s: S, +fn serialize_155(s: S, v: syntax::ast::class_mutability) { s.emit_enum("syntax::ast::class_mutability", @@ -3766,7 +3753,7 @@ fn serialize_156(s: S, }); } /*syntax::ast::class_member*/ -fn serialize_155(s: S, +fn serialize_154(s: S, v: syntax::ast::class_member) { s.emit_enum("syntax::ast::class_member", @@ -3792,7 +3779,7 @@ fn serialize_155(s: S, }); s.emit_enum_variant_arg(2u, {|| - serialize_156(s, + serialize_155(s, v2) }); s.emit_enum_variant_arg(3u, @@ -3810,7 +3797,7 @@ fn serialize_155(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_119(s, + serialize_118(s, v0) }) } @@ -3820,53 +3807,53 @@ fn serialize_155(s: S, }); } /*syntax::ast::class_item_*/ -fn serialize_153(s: S, +fn serialize_152(s: S, v: syntax::ast::class_item_) { s.emit_rec(/*syntax::ast::privacy*//*syntax::ast::class_member*/ {|| { s.emit_rec_field("privacy", 0u, - {|| serialize_154(s, v.privacy) }); + {|| serialize_153(s, v.privacy) }); s.emit_rec_field("decl", 1u, - {|| serialize_155(s, v.decl) }) + {|| serialize_154(s, v.decl) }) } }); } /*syntax::ast::class_item*/ -fn serialize_152(s: S, +fn serialize_151(s: S, v: syntax::ast::class_item) { s.emit_rec(/*syntax::ast::class_item_*//*syntax::codemap::span*/ {|| { s.emit_rec_field("node", 0u, - {|| serialize_153(s, v.node) }); + {|| serialize_152(s, v.node) }); s.emit_rec_field("span", 1u, {|| serialize_19(s, v.span) }) } }); } /*@syntax::ast::class_item*/ -fn serialize_151(s: S, +fn serialize_150(s: S, v: @syntax::ast::class_item) { - s.emit_box(/*syntax::ast::class_item*/{|| serialize_152(s, *v) }); + s.emit_box(/*syntax::ast::class_item*/{|| serialize_151(s, *v) }); } /*[@syntax::ast::class_item]*/ -fn serialize_150(s: S, +fn serialize_149(s: S, v: [@syntax::ast::class_item]) { s.emit_vec(vec::len(v), /*@syntax::ast::class_item*/ {|| vec::iteri(v, {|i, e| - s.emit_vec_elt(i, {|| serialize_151(s, e) }) + s.emit_vec_elt(i, {|| serialize_150(s, e) }) }) }); } /*syntax::ast::class_ctor_*/ -fn serialize_158(s: S, +fn serialize_157(s: S, v: syntax::ast::class_ctor_) { s.emit_rec(/*syntax::ast::node_id*//*syntax::ast::fn_decl*/ @@ -3876,28 +3863,28 @@ fn serialize_158(s: S, s.emit_rec_field("id", 0u, {|| serialize_27(s, v.id) }); s.emit_rec_field("dec", 1u, - {|| serialize_40(s, v.dec) }); + {|| serialize_39(s, v.dec) }); s.emit_rec_field("body", 2u, - {|| serialize_83(s, v.body) }) + {|| serialize_82(s, v.body) }) } }); } /*syntax::ast::class_ctor*/ -fn serialize_157(s: S, +fn serialize_156(s: S, v: syntax::ast::class_ctor) { s.emit_rec(/*syntax::ast::class_ctor_*//*syntax::codemap::span*/ {|| { s.emit_rec_field("node", 0u, - {|| serialize_158(s, v.node) }); + {|| serialize_157(s, v.node) }); s.emit_rec_field("span", 1u, {|| serialize_19(s, v.span) }) } }); } /*syntax::ast::ty_method*/ -fn serialize_160(s: S, +fn serialize_159(s: S, v: syntax::ast::ty_method) { s.emit_rec(/*syntax::ast::ident*//*[syntax::ast::attribute]*/ @@ -3910,28 +3897,28 @@ fn serialize_160(s: S, s.emit_rec_field("attrs", 1u, {|| serialize_2(s, v.attrs) }); s.emit_rec_field("decl", 2u, - {|| serialize_40(s, v.decl) }); + {|| serialize_39(s, v.decl) }); s.emit_rec_field("tps", 3u, - {|| serialize_133(s, v.tps) }); + {|| serialize_132(s, v.tps) }); s.emit_rec_field("span", 4u, {|| serialize_19(s, v.span) }) } }); } /*[syntax::ast::ty_method]*/ -fn serialize_159(s: S, +fn serialize_158(s: S, v: [syntax::ast::ty_method]) { s.emit_vec(vec::len(v), /*syntax::ast::ty_method*/ {|| vec::iteri(v, {|i, e| - s.emit_vec_elt(i, {|| serialize_160(s, e) }) + s.emit_vec_elt(i, {|| serialize_159(s, e) }) }) }); } /*core::option::t<@syntax::ast::ty>*/ -fn serialize_161(s: S, +fn serialize_160(s: S, v: core::option::t<@syntax::ast::ty>) { s.emit_enum("core::option::t", @@ -3959,7 +3946,7 @@ fn serialize_161(s: S, }); } /*syntax::ast::method*/ -fn serialize_164(s: S, +fn serialize_163(s: S, v: syntax::ast::method) { s.emit_rec(/*syntax::ast::ident*//*[syntax::ast::attribute]*/ @@ -3973,11 +3960,11 @@ fn serialize_164(s: S, s.emit_rec_field("attrs", 1u, {|| serialize_2(s, v.attrs) }); s.emit_rec_field("tps", 2u, - {|| serialize_133(s, v.tps) }); + {|| serialize_132(s, v.tps) }); s.emit_rec_field("decl", 3u, - {|| serialize_40(s, v.decl) }); + {|| serialize_39(s, v.decl) }); s.emit_rec_field("body", 4u, - {|| serialize_83(s, v.body) }); + {|| serialize_82(s, v.body) }); s.emit_rec_field("id", 5u, {|| serialize_27(s, v.id) }); s.emit_rec_field("span", 6u, @@ -3988,20 +3975,20 @@ fn serialize_164(s: S, }); } /*@syntax::ast::method*/ -fn serialize_163(s: S, +fn serialize_162(s: S, v: @syntax::ast::method) { - s.emit_box(/*syntax::ast::method*/{|| serialize_164(s, *v) }); + s.emit_box(/*syntax::ast::method*/{|| serialize_163(s, *v) }); } /*[@syntax::ast::method]*/ -fn serialize_162(s: S, +fn serialize_161(s: S, v: [@syntax::ast::method]) { s.emit_vec(vec::len(v), /*@syntax::ast::method*/ {|| vec::iteri(v, {|i, e| - s.emit_vec_elt(i, {|| serialize_163(s, e) }) + s.emit_vec_elt(i, {|| serialize_162(s, e) }) }) }); } @@ -4039,7 +4026,7 @@ fn serialize_28(s: S, }); s.emit_enum_variant_arg(1u, {|| - serialize_72(s, + serialize_71(s, v1) }) } @@ -4051,17 +4038,17 @@ fn serialize_28(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_40(s, + serialize_39(s, v0) }); s.emit_enum_variant_arg(1u, {|| - serialize_133(s, + serialize_132(s, v1) }); s.emit_enum_variant_arg(2u, {|| - serialize_83(s, + serialize_82(s, v2) }) } @@ -4073,7 +4060,7 @@ fn serialize_28(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_138(s, + serialize_137(s, v0) }) } @@ -4086,7 +4073,7 @@ fn serialize_28(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_140(s, + serialize_139(s, v0) }) } @@ -4103,7 +4090,7 @@ fn serialize_28(s: S, }); s.emit_enum_variant_arg(1u, {|| - serialize_133(s, + serialize_132(s, v1) }) } @@ -4115,12 +4102,12 @@ fn serialize_28(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_145(s, + serialize_144(s, v0) }); s.emit_enum_variant_arg(1u, {|| - serialize_133(s, + serialize_132(s, v1) }) } @@ -4132,17 +4119,17 @@ fn serialize_28(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_40(s, + serialize_39(s, v0) }); s.emit_enum_variant_arg(1u, {|| - serialize_133(s, + serialize_132(s, v1) }); s.emit_enum_variant_arg(2u, {|| - serialize_83(s, + serialize_82(s, v2) }); s.emit_enum_variant_arg(3u, @@ -4164,17 +4151,17 @@ fn serialize_28(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_133(s, + serialize_132(s, v0) }); s.emit_enum_variant_arg(1u, {|| - serialize_150(s, + serialize_149(s, v1) }); s.emit_enum_variant_arg(2u, {|| - serialize_157(s, + serialize_156(s, v2) }) } @@ -4186,12 +4173,12 @@ fn serialize_28(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_133(s, + serialize_132(s, v0) }); s.emit_enum_variant_arg(1u, {|| - serialize_159(s, + serialize_158(s, v1) }) } @@ -4203,12 +4190,12 @@ fn serialize_28(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_133(s, + serialize_132(s, v0) }); s.emit_enum_variant_arg(1u, {|| - serialize_161(s, + serialize_160(s, v1) }); s.emit_enum_variant_arg(2u, @@ -4218,7 +4205,7 @@ fn serialize_28(s: S, }); s.emit_enum_variant_arg(3u, {|| - serialize_162(s, + serialize_161(s, v3) }) } @@ -4763,30 +4750,13 @@ fn deserialize_32(s: S) -> }) } -/*syntax::ast::region_param*/ -fn deserialize_35(s: S) -> - syntax::ast::region_param { - - s.read_rec( - - - /*syntax::ast::ident*/ - - /*syntax::ast::node_id*/ - - {|| - {ident: - s.read_rec_field("ident", 0u, {|| deserialize_1(s) }), - id: s.read_rec_field("id", 1u, {|| deserialize_27(s) }),} - }) -} /*syntax::ast::region*/ fn deserialize_34(s: S) -> syntax::ast::region { s.read_enum("syntax::ast::region", - /*syntax::ast::region_param*/ + /*syntax::ast::ident*/ {|| @@ -4796,7 +4766,7 @@ fn deserialize_34(s: S) -> 1u { syntax::ast::re_named(s.read_enum_variant_arg(0u, {|| - deserialize_35(s) + deserialize_1(s) })) } 2u { syntax::ast::re_self } @@ -4805,7 +4775,7 @@ fn deserialize_34(s: S) -> }) } /*syntax::ast::ty_field_*/ -fn deserialize_38(s: S) -> +fn deserialize_37(s: S) -> syntax::ast::ty_field_ { s.read_rec( @@ -4822,7 +4792,7 @@ fn deserialize_38(s: S) -> }) } /*syntax::ast::ty_field*/ -fn deserialize_37(s: S) -> +fn deserialize_36(s: S) -> syntax::ast::ty_field { s.read_rec( @@ -4834,7 +4804,7 @@ fn deserialize_37(s: S) -> {|| {node: - s.read_rec_field("node", 0u, {|| deserialize_38(s) }), + s.read_rec_field("node", 0u, {|| deserialize_37(s) }), span: s.read_rec_field("span", 1u, {|| deserialize_19(s) }),} @@ -4842,7 +4812,7 @@ fn deserialize_37(s: S) -> } /*[syntax::ast::ty_field]*/ -fn deserialize_36(s: S) -> +fn deserialize_35(s: S) -> [syntax::ast::ty_field] { s.read_vec( @@ -4850,12 +4820,12 @@ fn deserialize_36(s: S) -> {|len| vec::init_fn(len, {|i| - s.read_vec_elt(i, {|| deserialize_37(s) }) + s.read_vec_elt(i, {|| deserialize_36(s) }) }) }) } /*syntax::ast::proto*/ -fn deserialize_39(s: S) -> +fn deserialize_38(s: S) -> syntax::ast::proto { s.read_enum("syntax::ast::proto", @@ -4880,7 +4850,7 @@ fn deserialize_39(s: S) -> }) } /*syntax::ast::rmode*/ -fn deserialize_44(s: S) -> +fn deserialize_43(s: S) -> syntax::ast::rmode { s.read_enum("syntax::ast::rmode", @@ -4905,7 +4875,7 @@ fn deserialize_44(s: S) -> }) } /*syntax::ast::mode*/ -fn deserialize_43(s: S) -> +fn deserialize_42(s: S) -> syntax::ast::mode { s.read_enum("syntax::ast::inferable", /*syntax::ast::rmode*/ @@ -4917,7 +4887,7 @@ fn deserialize_43(s: S) -> 0u { syntax::ast::expl(s.read_enum_variant_arg(0u, {|| - deserialize_44(s) + deserialize_43(s) })) } 1u { @@ -4931,7 +4901,7 @@ fn deserialize_43(s: S) -> }) } /*syntax::ast::arg*/ -fn deserialize_42(s: S) -> +fn deserialize_41(s: S) -> syntax::ast::arg { s.read_rec( @@ -4947,7 +4917,7 @@ fn deserialize_42(s: S) -> {|| {mode: - s.read_rec_field("mode", 0u, {|| deserialize_43(s) }), + s.read_rec_field("mode", 0u, {|| deserialize_42(s) }), ty: s.read_rec_field("ty", 1u, {|| deserialize_29(s) }), ident: s.read_rec_field("ident", 2u, {|| deserialize_1(s) }), @@ -4955,7 +4925,7 @@ fn deserialize_42(s: S) -> }) } /*[syntax::ast::arg]*/ -fn deserialize_41(s: S) -> +fn deserialize_40(s: S) -> [syntax::ast::arg] { s.read_vec( @@ -4963,12 +4933,12 @@ fn deserialize_41(s: S) -> {|len| vec::init_fn(len, {|i| - s.read_vec_elt(i, {|| deserialize_42(s) }) + s.read_vec_elt(i, {|| deserialize_41(s) }) }) }) } /*syntax::ast::purity*/ -fn deserialize_45(s: S) -> +fn deserialize_44(s: S) -> syntax::ast::purity { s.read_enum("syntax::ast::purity", @@ -4990,7 +4960,7 @@ fn deserialize_45(s: S) -> }) } /*syntax::ast::ret_style*/ -fn deserialize_46(s: S) -> +fn deserialize_45(s: S) -> syntax::ast::ret_style { s.read_enum("syntax::ast::ret_style", @@ -5006,7 +4976,7 @@ fn deserialize_46(s: S) -> }) } /*[syntax::ast::ident]*/ -fn deserialize_54(s: S) -> +fn deserialize_53(s: S) -> [syntax::ast::ident] { s.read_vec( @@ -5019,7 +4989,7 @@ fn deserialize_54(s: S) -> }) } /*[@syntax::ast::ty]*/ -fn deserialize_55(s: S) -> +fn deserialize_54(s: S) -> [@syntax::ast::ty] { s.read_vec( @@ -5032,7 +5002,7 @@ fn deserialize_55(s: S) -> }) } /*syntax::ast::path_*/ -fn deserialize_53(s: S) -> +fn deserialize_52(s: S) -> syntax::ast::path_ { s.read_rec( @@ -5050,15 +5020,15 @@ fn deserialize_53(s: S) -> {|| deserialize_18(s) }), idents: s.read_rec_field("idents", 1u, - {|| deserialize_54(s) }), + {|| deserialize_53(s) }), types: s.read_rec_field("types", 2u, - {|| deserialize_55(s) }),} + {|| deserialize_54(s) }),} }) } /*syntax::ast::path*/ -fn deserialize_52(s: S) -> +fn deserialize_51(s: S) -> syntax::ast::path { s.read_rec( @@ -5070,7 +5040,7 @@ fn deserialize_52(s: S) -> {|| {node: - s.read_rec_field("node", 0u, {|| deserialize_53(s) }), + s.read_rec_field("node", 0u, {|| deserialize_52(s) }), span: s.read_rec_field("span", 1u, {|| deserialize_19(s) }),} @@ -5078,21 +5048,21 @@ fn deserialize_52(s: S) -> } /*@syntax::ast::path*/ -fn deserialize_51(s: S) -> +fn deserialize_50(s: S) -> @syntax::ast::path { - s.read_box(/*syntax::ast::path*/{|| @deserialize_52(s) }) + s.read_box(/*syntax::ast::path*/{|| @deserialize_51(s) }) } /*@syntax::ast::lit*/ -fn deserialize_60(s: S) -> +fn deserialize_59(s: S) -> @syntax::ast::lit { s.read_box(/*syntax::ast::lit*/{|| @deserialize_10(s) }) } /*syntax::ast::constr_arg_general_*/ -fn deserialize_59(s: S) -> +fn deserialize_58(s: S) -> syntax::ast::constr_arg_general_ { s.read_enum("syntax::ast::constr_arg_general_", @@ -5113,7 +5083,7 @@ fn deserialize_59(s: S) -> 2u { syntax::ast::carg_lit(s.read_enum_variant_arg(0u, {|| - deserialize_60(s) + deserialize_59(s) })) } } @@ -5121,7 +5091,7 @@ fn deserialize_59(s: S) -> }) } /*{node: syntax::ast::constr_arg_general_,span: syntax::codemap::span}*/ -fn deserialize_58(s: S) -> +fn deserialize_57(s: S) -> {node: syntax::ast::constr_arg_general_, span: syntax::codemap::span,} { @@ -5134,7 +5104,7 @@ fn deserialize_58(s: S) -> {|| {node: - s.read_rec_field("node", 0u, {|| deserialize_59(s) }), + s.read_rec_field("node", 0u, {|| deserialize_58(s) }), span: s.read_rec_field("span", 1u, {|| deserialize_19(s) }),} @@ -5142,17 +5112,17 @@ fn deserialize_58(s: S) -> } /*@{node: syntax::ast::constr_arg_general_,span: syntax::codemap::span}*/ -fn deserialize_57(s: S) -> +fn deserialize_56(s: S) -> @{node: syntax::ast::constr_arg_general_, span: syntax::codemap::span,} { s.read_box( /*{node: syntax::ast::constr_arg_general_,span: syntax::codemap::span}*/ - {|| @deserialize_58(s) }) + {|| @deserialize_57(s) }) } /*[@{node: syntax::ast::constr_arg_general_,span: syntax::codemap::span}]*/ -fn deserialize_56(s: S) -> +fn deserialize_55(s: S) -> [@{node: syntax::ast::constr_arg_general_, span: syntax::codemap::span,}] { s.read_vec( @@ -5163,12 +5133,12 @@ fn deserialize_56(s: S) -> {|len| vec::init_fn(len, {|i| - s.read_vec_elt(i, {|| deserialize_57(s) }) + s.read_vec_elt(i, {|| deserialize_56(s) }) }) }) } /*{path: @syntax::ast::path,args: [@{node: syntax::ast::constr_arg_general_,span: syntax::codemap::span}],id: syntax::ast::node_id}*/ -fn deserialize_50(s: S) -> +fn deserialize_49(s: S) -> {path: @syntax::ast::path, args: [@{node: syntax::ast::constr_arg_general_, @@ -5188,14 +5158,14 @@ fn deserialize_50(s: S) -> {|| {path: - s.read_rec_field("path", 0u, {|| deserialize_51(s) }), + s.read_rec_field("path", 0u, {|| deserialize_50(s) }), args: - s.read_rec_field("args", 1u, {|| deserialize_56(s) }), + s.read_rec_field("args", 1u, {|| deserialize_55(s) }), id: s.read_rec_field("id", 2u, {|| deserialize_27(s) }),} }) } /*syntax::ast::constr*/ -fn deserialize_49(s: S) -> +fn deserialize_48(s: S) -> syntax::ast::constr { s.read_rec( @@ -5209,7 +5179,7 @@ fn deserialize_49(s: S) -> {|| {node: - s.read_rec_field("node", 0u, {|| deserialize_50(s) }), + s.read_rec_field("node", 0u, {|| deserialize_49(s) }), span: s.read_rec_field("span", 1u, {|| deserialize_19(s) }),} @@ -5217,14 +5187,14 @@ fn deserialize_49(s: S) -> } /*@syntax::ast::constr*/ -fn deserialize_48(s: S) -> +fn deserialize_47(s: S) -> @syntax::ast::constr { - s.read_box(/*syntax::ast::constr*/{|| @deserialize_49(s) }) + s.read_box(/*syntax::ast::constr*/{|| @deserialize_48(s) }) } /*[@syntax::ast::constr]*/ -fn deserialize_47(s: S) -> +fn deserialize_46(s: S) -> [@syntax::ast::constr] { s.read_vec( @@ -5232,12 +5202,12 @@ fn deserialize_47(s: S) -> {|len| vec::init_fn(len, {|i| - s.read_vec_elt(i, {|| deserialize_48(s) }) + s.read_vec_elt(i, {|| deserialize_47(s) }) }) }) } /*syntax::ast::fn_decl*/ -fn deserialize_40(s: S) -> +fn deserialize_39(s: S) -> syntax::ast::fn_decl { s.read_rec( @@ -5256,22 +5226,22 @@ fn deserialize_40(s: S) -> {|| {inputs: s.read_rec_field("inputs", 0u, - {|| deserialize_41(s) }), + {|| deserialize_40(s) }), output: s.read_rec_field("output", 1u, {|| deserialize_29(s) }), purity: s.read_rec_field("purity", 2u, - {|| deserialize_45(s) }), - cf: s.read_rec_field("cf", 3u, {|| deserialize_46(s) }), + {|| deserialize_44(s) }), + cf: s.read_rec_field("cf", 3u, {|| deserialize_45(s) }), constraints: s.read_rec_field("constraints", 4u, - {|| deserialize_47(s) }),} + {|| deserialize_46(s) }),} }) } /*syntax::ast::constr_arg_general_<@syntax::ast::path>*/ -fn deserialize_68(s: S) -> +fn deserialize_67(s: S) -> syntax::ast::constr_arg_general_<@syntax::ast::path> { s.read_enum("syntax::ast::constr_arg_general_", @@ -5286,13 +5256,13 @@ fn deserialize_68(s: S) -> 1u { syntax::ast::carg_ident(s.read_enum_variant_arg(0u, {|| - deserialize_51(s) + deserialize_50(s) })) } 2u { syntax::ast::carg_lit(s.read_enum_variant_arg(0u, {|| - deserialize_60(s) + deserialize_59(s) })) } } @@ -5300,7 +5270,7 @@ fn deserialize_68(s: S) -> }) } /*{node: syntax::ast::constr_arg_general_<@syntax::ast::path>,span: syntax::codemap::span}*/ -fn deserialize_67(s: S) -> +fn deserialize_66(s: S) -> {node: syntax::ast::constr_arg_general_<@syntax::ast::path>, span: syntax::codemap::span,} { @@ -5313,7 +5283,7 @@ fn deserialize_67(s: S) -> {|| {node: - s.read_rec_field("node", 0u, {|| deserialize_68(s) }), + s.read_rec_field("node", 0u, {|| deserialize_67(s) }), span: s.read_rec_field("span", 1u, {|| deserialize_19(s) }),} @@ -5321,17 +5291,17 @@ fn deserialize_67(s: S) -> } /*@{node: syntax::ast::constr_arg_general_<@syntax::ast::path>,span: syntax::codemap::span}*/ -fn deserialize_66(s: S) -> +fn deserialize_65(s: S) -> @{node: syntax::ast::constr_arg_general_<@syntax::ast::path>, span: syntax::codemap::span,} { s.read_box( /*{node: syntax::ast::constr_arg_general_<@syntax::ast::path>,span: syntax::codemap::span}*/ - {|| @deserialize_67(s) }) + {|| @deserialize_66(s) }) } /*[@{node: syntax::ast::constr_arg_general_<@syntax::ast::path>,span: syntax::codemap::span}]*/ -fn deserialize_65(s: S) -> +fn deserialize_64(s: S) -> [@{node: syntax::ast::constr_arg_general_<@syntax::ast::path>, span: syntax::codemap::span,}] { s.read_vec( @@ -5342,12 +5312,12 @@ fn deserialize_65(s: S) -> {|len| vec::init_fn(len, {|i| - s.read_vec_elt(i, {|| deserialize_66(s) }) + s.read_vec_elt(i, {|| deserialize_65(s) }) }) }) } /*syntax::ast::ty_constr_*/ -fn deserialize_64(s: S) -> +fn deserialize_63(s: S) -> syntax::ast::ty_constr_ { s.read_rec( @@ -5363,14 +5333,14 @@ fn deserialize_64(s: S) -> {|| {path: - s.read_rec_field("path", 0u, {|| deserialize_51(s) }), + s.read_rec_field("path", 0u, {|| deserialize_50(s) }), args: - s.read_rec_field("args", 1u, {|| deserialize_65(s) }), + s.read_rec_field("args", 1u, {|| deserialize_64(s) }), id: s.read_rec_field("id", 2u, {|| deserialize_27(s) }),} }) } /*syntax::ast::ty_constr*/ -fn deserialize_63(s: S) -> +fn deserialize_62(s: S) -> syntax::ast::ty_constr { s.read_rec( @@ -5382,7 +5352,7 @@ fn deserialize_63(s: S) -> {|| {node: - s.read_rec_field("node", 0u, {|| deserialize_64(s) }), + s.read_rec_field("node", 0u, {|| deserialize_63(s) }), span: s.read_rec_field("span", 1u, {|| deserialize_19(s) }),} @@ -5390,14 +5360,14 @@ fn deserialize_63(s: S) -> } /*@syntax::ast::ty_constr*/ -fn deserialize_62(s: S) -> +fn deserialize_61(s: S) -> @syntax::ast::ty_constr { - s.read_box(/*syntax::ast::ty_constr*/{|| @deserialize_63(s) }) + s.read_box(/*syntax::ast::ty_constr*/{|| @deserialize_62(s) }) } /*[@syntax::ast::ty_constr]*/ -fn deserialize_61(s: S) -> +fn deserialize_60(s: S) -> [@syntax::ast::ty_constr] { s.read_vec( @@ -5405,12 +5375,12 @@ fn deserialize_61(s: S) -> {|len| vec::init_fn(len, {|i| - s.read_vec_elt(i, {|| deserialize_62(s) }) + s.read_vec_elt(i, {|| deserialize_61(s) }) }) }) } /*[@syntax::ast::expr]*/ -fn deserialize_75(s: S) -> +fn deserialize_74(s: S) -> [@syntax::ast::expr] { s.read_vec( @@ -5418,12 +5388,12 @@ fn deserialize_75(s: S) -> {|len| vec::init_fn(len, {|i| - s.read_vec_elt(i, {|| deserialize_72(s) }) + s.read_vec_elt(i, {|| deserialize_71(s) }) }) }) } /*syntax::ast::field_*/ -fn deserialize_78(s: S) -> +fn deserialize_77(s: S) -> syntax::ast::field_ { s.read_rec( @@ -5443,12 +5413,12 @@ fn deserialize_78(s: S) -> s.read_rec_field("ident", 1u, {|| deserialize_1(s) }), expr: s.read_rec_field("expr", 2u, - {|| deserialize_72(s) }),} + {|| deserialize_71(s) }),} }) } /*syntax::ast::field*/ -fn deserialize_77(s: S) -> +fn deserialize_76(s: S) -> syntax::ast::field { s.read_rec( @@ -5460,7 +5430,7 @@ fn deserialize_77(s: S) -> {|| {node: - s.read_rec_field("node", 0u, {|| deserialize_78(s) }), + s.read_rec_field("node", 0u, {|| deserialize_77(s) }), span: s.read_rec_field("span", 1u, {|| deserialize_19(s) }),} @@ -5468,7 +5438,7 @@ fn deserialize_77(s: S) -> } /*[syntax::ast::field]*/ -fn deserialize_76(s: S) -> +fn deserialize_75(s: S) -> [syntax::ast::field] { s.read_vec( @@ -5476,12 +5446,12 @@ fn deserialize_76(s: S) -> {|len| vec::init_fn(len, {|i| - s.read_vec_elt(i, {|| deserialize_77(s) }) + s.read_vec_elt(i, {|| deserialize_76(s) }) }) }) } /*core::option::t<@syntax::ast::expr>*/ -fn deserialize_79(s: S) -> +fn deserialize_78(s: S) -> core::option::t<@syntax::ast::expr> { s.read_enum("core::option::t", @@ -5494,7 +5464,7 @@ fn deserialize_79(s: S) -> 1u { core::option::some(s.read_enum_variant_arg(0u, {|| - deserialize_72(s) + deserialize_71(s) })) } } @@ -5502,7 +5472,7 @@ fn deserialize_79(s: S) -> }) } /*[core::option::t<@syntax::ast::expr>]*/ -fn deserialize_80(s: S) -> +fn deserialize_79(s: S) -> [core::option::t<@syntax::ast::expr>] { s.read_vec( @@ -5510,12 +5480,12 @@ fn deserialize_80(s: S) -> {|len| vec::init_fn(len, {|i| - s.read_vec_elt(i, {|| deserialize_79(s) }) + s.read_vec_elt(i, {|| deserialize_78(s) }) }) }) } /*syntax::ast::binop*/ -fn deserialize_81(s: S) -> +fn deserialize_80(s: S) -> syntax::ast::binop { s.read_enum("syntax::ast::binop", @@ -5582,7 +5552,7 @@ fn deserialize_81(s: S) -> }) } /*syntax::ast::unop*/ -fn deserialize_82(s: S) -> +fn deserialize_81(s: S) -> syntax::ast::unop { s.read_enum("syntax::ast::unop", /*syntax::ast::mutability*/ @@ -5617,7 +5587,7 @@ fn deserialize_82(s: S) -> }) } /*syntax::ast::simple_path*/ -fn deserialize_94(s: S) -> +fn deserialize_93(s: S) -> syntax::ast::simple_path { s.read_vec( @@ -5630,14 +5600,14 @@ fn deserialize_94(s: S) -> }) } /*@syntax::ast::simple_path*/ -fn deserialize_93(s: S) -> +fn deserialize_92(s: S) -> @syntax::ast::simple_path { - s.read_box(/*syntax::ast::simple_path*/{|| @deserialize_94(s) }) + s.read_box(/*syntax::ast::simple_path*/{|| @deserialize_93(s) }) } /*syntax::ast::path_list_ident_*/ -fn deserialize_97(s: S) -> +fn deserialize_96(s: S) -> syntax::ast::path_list_ident_ { s.read_rec( @@ -5654,7 +5624,7 @@ fn deserialize_97(s: S) -> }) } /*syntax::ast::path_list_ident*/ -fn deserialize_96(s: S) -> +fn deserialize_95(s: S) -> syntax::ast::path_list_ident { s.read_rec( @@ -5666,7 +5636,7 @@ fn deserialize_96(s: S) -> {|| {node: - s.read_rec_field("node", 0u, {|| deserialize_97(s) }), + s.read_rec_field("node", 0u, {|| deserialize_96(s) }), span: s.read_rec_field("span", 1u, {|| deserialize_19(s) }),} @@ -5674,7 +5644,7 @@ fn deserialize_96(s: S) -> } /*[syntax::ast::path_list_ident]*/ -fn deserialize_95(s: S) -> +fn deserialize_94(s: S) -> [syntax::ast::path_list_ident] { s.read_vec( @@ -5682,12 +5652,12 @@ fn deserialize_95(s: S) -> {|len| vec::init_fn(len, {|i| - s.read_vec_elt(i, {|| deserialize_96(s) }) + s.read_vec_elt(i, {|| deserialize_95(s) }) }) }) } /*syntax::ast::view_path_*/ -fn deserialize_92(s: S) -> +fn deserialize_91(s: S) -> syntax::ast::view_path_ { s.read_enum("syntax::ast::view_path_", /*syntax::ast::ident*//*@syntax::ast::simple_path*/ @@ -5707,7 +5677,7 @@ fn deserialize_92(s: S) -> }), s.read_enum_variant_arg(1u, {|| - deserialize_93(s) + deserialize_92(s) }), s.read_enum_variant_arg(2u, {|| @@ -5717,7 +5687,7 @@ fn deserialize_92(s: S) -> 1u { syntax::ast::view_path_glob(s.read_enum_variant_arg(0u, {|| - deserialize_93(s) + deserialize_92(s) }), s.read_enum_variant_arg(1u, {|| @@ -5727,11 +5697,11 @@ fn deserialize_92(s: S) -> 2u { syntax::ast::view_path_list(s.read_enum_variant_arg(0u, {|| - deserialize_93(s) + deserialize_92(s) }), s.read_enum_variant_arg(1u, {|| - deserialize_95(s) + deserialize_94(s) }), s.read_enum_variant_arg(2u, {|| @@ -5743,7 +5713,7 @@ fn deserialize_92(s: S) -> }) } /*syntax::ast::view_path*/ -fn deserialize_91(s: S) -> +fn deserialize_90(s: S) -> syntax::ast::view_path { s.read_rec( @@ -5755,7 +5725,7 @@ fn deserialize_91(s: S) -> {|| {node: - s.read_rec_field("node", 0u, {|| deserialize_92(s) }), + s.read_rec_field("node", 0u, {|| deserialize_91(s) }), span: s.read_rec_field("span", 1u, {|| deserialize_19(s) }),} @@ -5763,14 +5733,14 @@ fn deserialize_91(s: S) -> } /*@syntax::ast::view_path*/ -fn deserialize_90(s: S) -> +fn deserialize_89(s: S) -> @syntax::ast::view_path { - s.read_box(/*syntax::ast::view_path*/{|| @deserialize_91(s) }) + s.read_box(/*syntax::ast::view_path*/{|| @deserialize_90(s) }) } /*[@syntax::ast::view_path]*/ -fn deserialize_89(s: S) -> +fn deserialize_88(s: S) -> [@syntax::ast::view_path] { s.read_vec( @@ -5778,12 +5748,12 @@ fn deserialize_89(s: S) -> {|len| vec::init_fn(len, {|i| - s.read_vec_elt(i, {|| deserialize_90(s) }) + s.read_vec_elt(i, {|| deserialize_89(s) }) }) }) } /*syntax::ast::view_item_*/ -fn deserialize_88(s: S) -> +fn deserialize_87(s: S) -> syntax::ast::view_item_ { s.read_enum("syntax::ast::view_item_", /*syntax::ast::ident*//*[@syntax::ast::meta_item]*/ @@ -5812,13 +5782,13 @@ fn deserialize_88(s: S) -> 1u { syntax::ast::view_item_import(s.read_enum_variant_arg(0u, {|| - deserialize_89(s) + deserialize_88(s) })) } 2u { syntax::ast::view_item_export(s.read_enum_variant_arg(0u, {|| - deserialize_89(s) + deserialize_88(s) })) } } @@ -5826,7 +5796,7 @@ fn deserialize_88(s: S) -> }) } /*syntax::ast::view_item*/ -fn deserialize_87(s: S) -> +fn deserialize_86(s: S) -> syntax::ast::view_item { s.read_rec( @@ -5838,7 +5808,7 @@ fn deserialize_87(s: S) -> {|| {node: - s.read_rec_field("node", 0u, {|| deserialize_88(s) }), + s.read_rec_field("node", 0u, {|| deserialize_87(s) }), span: s.read_rec_field("span", 1u, {|| deserialize_19(s) }),} @@ -5846,14 +5816,14 @@ fn deserialize_87(s: S) -> } /*@syntax::ast::view_item*/ -fn deserialize_86(s: S) -> +fn deserialize_85(s: S) -> @syntax::ast::view_item { - s.read_box(/*syntax::ast::view_item*/{|| @deserialize_87(s) }) + s.read_box(/*syntax::ast::view_item*/{|| @deserialize_86(s) }) } /*[@syntax::ast::view_item]*/ -fn deserialize_85(s: S) -> +fn deserialize_84(s: S) -> [@syntax::ast::view_item] { s.read_vec( @@ -5861,12 +5831,12 @@ fn deserialize_85(s: S) -> {|len| vec::init_fn(len, {|i| - s.read_vec_elt(i, {|| deserialize_86(s) }) + s.read_vec_elt(i, {|| deserialize_85(s) }) }) }) } /*core::option::t<@syntax::ast::pat>*/ -fn deserialize_112(s: S) -> +fn deserialize_111(s: S) -> core::option::t<@syntax::ast::pat> { s.read_enum("core::option::t", @@ -5879,7 +5849,7 @@ fn deserialize_112(s: S) -> 1u { core::option::some(s.read_enum_variant_arg(0u, {|| - deserialize_109(s) + deserialize_108(s) })) } } @@ -5887,7 +5857,7 @@ fn deserialize_112(s: S) -> }) } /*[@syntax::ast::pat]*/ -fn deserialize_113(s: S) -> +fn deserialize_112(s: S) -> [@syntax::ast::pat] { s.read_vec( @@ -5896,12 +5866,12 @@ fn deserialize_113(s: S) -> vec::init_fn(len, {|i| s.read_vec_elt(i, - {|| deserialize_109(s) }) + {|| deserialize_108(s) }) }) }) } /*syntax::ast::field_pat*/ -fn deserialize_115(s: S) -> +fn deserialize_114(s: S) -> syntax::ast::field_pat { s.read_rec( @@ -5916,12 +5886,12 @@ fn deserialize_115(s: S) -> s.read_rec_field("ident", 0u, {|| deserialize_1(s) }), pat: s.read_rec_field("pat", 1u, - {|| deserialize_109(s) }),} + {|| deserialize_108(s) }),} }) } /*[syntax::ast::field_pat]*/ -fn deserialize_114(s: S) -> +fn deserialize_113(s: S) -> [syntax::ast::field_pat] { s.read_vec( @@ -5930,12 +5900,12 @@ fn deserialize_114(s: S) -> vec::init_fn(len, {|i| s.read_vec_elt(i, - {|| deserialize_115(s) }) + {|| deserialize_114(s) }) }) }) } /*syntax::ast::pat_*/ -fn deserialize_111(s: S) -> +fn deserialize_110(s: S) -> syntax::ast::pat_ { s.read_enum("syntax::ast::pat_", @@ -5962,27 +5932,27 @@ fn deserialize_111(s: S) -> 1u { syntax::ast::pat_ident(s.read_enum_variant_arg(0u, {|| - deserialize_51(s) + deserialize_50(s) }), s.read_enum_variant_arg(1u, {|| - deserialize_112(s) + deserialize_111(s) })) } 2u { syntax::ast::pat_enum(s.read_enum_variant_arg(0u, {|| - deserialize_51(s) + deserialize_50(s) }), s.read_enum_variant_arg(1u, {|| - deserialize_113(s) + deserialize_112(s) })) } 3u { syntax::ast::pat_rec(s.read_enum_variant_arg(0u, {|| - deserialize_114(s) + deserialize_113(s) }), s.read_enum_variant_arg(1u, {|| @@ -5992,35 +5962,35 @@ fn deserialize_111(s: S) -> 4u { syntax::ast::pat_tup(s.read_enum_variant_arg(0u, {|| - deserialize_113(s) + deserialize_112(s) })) } 5u { syntax::ast::pat_box(s.read_enum_variant_arg(0u, {|| - deserialize_109(s) + deserialize_108(s) })) } 6u { syntax::ast::pat_uniq(s.read_enum_variant_arg(0u, {|| - deserialize_109(s) + deserialize_108(s) })) } 7u { syntax::ast::pat_lit(s.read_enum_variant_arg(0u, {|| - deserialize_72(s) + deserialize_71(s) })) } 8u { syntax::ast::pat_range(s.read_enum_variant_arg(0u, {|| - deserialize_72(s) + deserialize_71(s) }), s.read_enum_variant_arg(1u, {|| - deserialize_72(s) + deserialize_71(s) })) } } @@ -6028,7 +5998,7 @@ fn deserialize_111(s: S) -> }) } /*syntax::ast::pat*/ -fn deserialize_110(s: S) -> +fn deserialize_109(s: S) -> syntax::ast::pat { s.read_rec( @@ -6044,7 +6014,7 @@ fn deserialize_110(s: S) -> {id: s.read_rec_field("id", 0u, {|| deserialize_27(s) }), node: s.read_rec_field("node", 1u, - {|| deserialize_111(s) }), + {|| deserialize_110(s) }), span: s.read_rec_field("span", 2u, {|| deserialize_19(s) }),} @@ -6052,14 +6022,14 @@ fn deserialize_110(s: S) -> } /*@syntax::ast::pat*/ -fn deserialize_109(s: S) -> +fn deserialize_108(s: S) -> @syntax::ast::pat { - s.read_box(/*syntax::ast::pat*/{|| @deserialize_110(s) }) + s.read_box(/*syntax::ast::pat*/{|| @deserialize_109(s) }) } /*syntax::ast::init_op*/ -fn deserialize_118(s: S) -> +fn deserialize_117(s: S) -> syntax::ast::init_op { s.read_enum("syntax::ast::init_op", @@ -6075,7 +6045,7 @@ fn deserialize_118(s: S) -> }) } /*syntax::ast::initializer*/ -fn deserialize_117(s: S) -> +fn deserialize_116(s: S) -> syntax::ast::initializer { s.read_rec( @@ -6086,15 +6056,15 @@ fn deserialize_117(s: S) -> /*@syntax::ast::expr*/ {|| - {op: s.read_rec_field("op", 0u, {|| deserialize_118(s) }), + {op: s.read_rec_field("op", 0u, {|| deserialize_117(s) }), expr: s.read_rec_field("expr", 1u, - {|| deserialize_72(s) }),} + {|| deserialize_71(s) }),} }) } /*core::option::t*/ -fn deserialize_116(s: S) -> +fn deserialize_115(s: S) -> core::option::t { s.read_enum("core::option::t", @@ -6107,7 +6077,7 @@ fn deserialize_116(s: S) -> 1u { core::option::some(s.read_enum_variant_arg(0u, {|| - deserialize_117(s) + deserialize_116(s) })) } } @@ -6115,7 +6085,7 @@ fn deserialize_116(s: S) -> }) } /*syntax::ast::local_*/ -fn deserialize_108(s: S) -> +fn deserialize_107(s: S) -> syntax::ast::local_ { s.read_rec( @@ -6137,15 +6107,15 @@ fn deserialize_108(s: S) -> {|| deserialize_18(s) }), ty: s.read_rec_field("ty", 1u, {|| deserialize_29(s) }), pat: - s.read_rec_field("pat", 2u, {|| deserialize_109(s) }), + s.read_rec_field("pat", 2u, {|| deserialize_108(s) }), init: s.read_rec_field("init", 3u, - {|| deserialize_116(s) }), + {|| deserialize_115(s) }), id: s.read_rec_field("id", 4u, {|| deserialize_27(s) }),} }) } /*syntax::ast::local*/ -fn deserialize_107(s: S) -> +fn deserialize_106(s: S) -> syntax::ast::local { s.read_rec( @@ -6158,7 +6128,7 @@ fn deserialize_107(s: S) -> {|| {node: s.read_rec_field("node", 0u, - {|| deserialize_108(s) }), + {|| deserialize_107(s) }), span: s.read_rec_field("span", 1u, {|| deserialize_19(s) }),} @@ -6166,14 +6136,14 @@ fn deserialize_107(s: S) -> } /*@syntax::ast::local*/ -fn deserialize_106(s: S) -> +fn deserialize_105(s: S) -> @syntax::ast::local { - s.read_box(/*syntax::ast::local*/{|| @deserialize_107(s) }) + s.read_box(/*syntax::ast::local*/{|| @deserialize_106(s) }) } /*[@syntax::ast::local]*/ -fn deserialize_105(s: S) -> +fn deserialize_104(s: S) -> [@syntax::ast::local] { s.read_vec( @@ -6182,19 +6152,19 @@ fn deserialize_105(s: S) -> vec::init_fn(len, {|i| s.read_vec_elt(i, - {|| deserialize_106(s) }) + {|| deserialize_105(s) }) }) }) } /*@syntax::ast::item*/ -fn deserialize_119(s: S) -> +fn deserialize_118(s: S) -> @syntax::ast::item { s.read_box(/*syntax::ast::item*/{|| @deserialize_0(s) }) } /*syntax::ast::decl_*/ -fn deserialize_104(s: S) -> +fn deserialize_103(s: S) -> syntax::ast::decl_ { s.read_enum("syntax::ast::decl_", /*[@syntax::ast::local]*/ @@ -6206,13 +6176,13 @@ fn deserialize_104(s: S) -> 0u { syntax::ast::decl_local(s.read_enum_variant_arg(0u, {|| - deserialize_105(s) + deserialize_104(s) })) } 1u { syntax::ast::decl_item(s.read_enum_variant_arg(0u, {|| - deserialize_119(s) + deserialize_118(s) })) } } @@ -6220,7 +6190,7 @@ fn deserialize_104(s: S) -> }) } /*syntax::ast::decl*/ -fn deserialize_103(s: S) -> +fn deserialize_102(s: S) -> syntax::ast::decl { s.read_rec( @@ -6233,7 +6203,7 @@ fn deserialize_103(s: S) -> {|| {node: s.read_rec_field("node", 0u, - {|| deserialize_104(s) }), + {|| deserialize_103(s) }), span: s.read_rec_field("span", 1u, {|| deserialize_19(s) }),} @@ -6241,14 +6211,14 @@ fn deserialize_103(s: S) -> } /*@syntax::ast::decl*/ -fn deserialize_102(s: S) -> +fn deserialize_101(s: S) -> @syntax::ast::decl { - s.read_box(/*syntax::ast::decl*/{|| @deserialize_103(s) }) + s.read_box(/*syntax::ast::decl*/{|| @deserialize_102(s) }) } /*syntax::ast::stmt_*/ -fn deserialize_101(s: S) -> +fn deserialize_100(s: S) -> syntax::ast::stmt_ { s.read_enum("syntax::ast::stmt_", /*@syntax::ast::decl*//*syntax::ast::node_id*/ @@ -6262,7 +6232,7 @@ fn deserialize_101(s: S) -> 0u { syntax::ast::stmt_decl(s.read_enum_variant_arg(0u, {|| - deserialize_102(s) + deserialize_101(s) }), s.read_enum_variant_arg(1u, {|| @@ -6272,7 +6242,7 @@ fn deserialize_101(s: S) -> 1u { syntax::ast::stmt_expr(s.read_enum_variant_arg(0u, {|| - deserialize_72(s) + deserialize_71(s) }), s.read_enum_variant_arg(1u, {|| @@ -6282,7 +6252,7 @@ fn deserialize_101(s: S) -> 2u { syntax::ast::stmt_semi(s.read_enum_variant_arg(0u, {|| - deserialize_72(s) + deserialize_71(s) }), s.read_enum_variant_arg(1u, {|| @@ -6294,7 +6264,7 @@ fn deserialize_101(s: S) -> }) } /*syntax::ast::stmt*/ -fn deserialize_100(s: S) -> +fn deserialize_99(s: S) -> syntax::ast::stmt { s.read_rec( @@ -6307,7 +6277,7 @@ fn deserialize_100(s: S) -> {|| {node: s.read_rec_field("node", 0u, - {|| deserialize_101(s) }), + {|| deserialize_100(s) }), span: s.read_rec_field("span", 1u, {|| deserialize_19(s) }),} @@ -6315,14 +6285,14 @@ fn deserialize_100(s: S) -> } /*@syntax::ast::stmt*/ -fn deserialize_99(s: S) -> +fn deserialize_98(s: S) -> @syntax::ast::stmt { - s.read_box(/*syntax::ast::stmt*/{|| @deserialize_100(s) }) + s.read_box(/*syntax::ast::stmt*/{|| @deserialize_99(s) }) } /*[@syntax::ast::stmt]*/ -fn deserialize_98(s: S) -> +fn deserialize_97(s: S) -> [@syntax::ast::stmt] { s.read_vec( @@ -6330,12 +6300,12 @@ fn deserialize_98(s: S) -> {|len| vec::init_fn(len, {|i| - s.read_vec_elt(i, {|| deserialize_99(s) }) + s.read_vec_elt(i, {|| deserialize_98(s) }) }) }) } /*syntax::ast::blk_check_mode*/ -fn deserialize_120(s: S) -> +fn deserialize_119(s: S) -> syntax::ast::blk_check_mode { s.read_enum("syntax::ast::blk_check_mode", @@ -6356,7 +6326,7 @@ fn deserialize_120(s: S) -> }) } /*syntax::ast::blk_*/ -fn deserialize_84(s: S) -> +fn deserialize_83(s: S) -> syntax::ast::blk_ { s.read_rec( @@ -6375,21 +6345,21 @@ fn deserialize_84(s: S) -> {|| {view_items: s.read_rec_field("view_items", 0u, - {|| deserialize_85(s) }), + {|| deserialize_84(s) }), stmts: s.read_rec_field("stmts", 1u, - {|| deserialize_98(s) }), + {|| deserialize_97(s) }), expr: - s.read_rec_field("expr", 2u, {|| deserialize_79(s) }), + s.read_rec_field("expr", 2u, {|| deserialize_78(s) }), id: s.read_rec_field("id", 3u, {|| deserialize_27(s) }), rules: s.read_rec_field("rules", 4u, - {|| deserialize_120(s) }),} + {|| deserialize_119(s) }),} }) } /*syntax::ast::blk*/ -fn deserialize_83(s: S) -> +fn deserialize_82(s: S) -> syntax::ast::blk { s.read_rec( @@ -6401,7 +6371,7 @@ fn deserialize_83(s: S) -> {|| {node: - s.read_rec_field("node", 0u, {|| deserialize_84(s) }), + s.read_rec_field("node", 0u, {|| deserialize_83(s) }), span: s.read_rec_field("span", 1u, {|| deserialize_19(s) }),} @@ -6409,7 +6379,7 @@ fn deserialize_83(s: S) -> } /*syntax::ast::arm*/ -fn deserialize_122(s: S) -> +fn deserialize_121(s: S) -> syntax::ast::arm { s.read_rec( @@ -6424,18 +6394,18 @@ fn deserialize_122(s: S) -> {|| {pats: s.read_rec_field("pats", 0u, - {|| deserialize_113(s) }), + {|| deserialize_112(s) }), guard: s.read_rec_field("guard", 1u, - {|| deserialize_79(s) }), + {|| deserialize_78(s) }), body: s.read_rec_field("body", 2u, - {|| deserialize_83(s) }),} + {|| deserialize_82(s) }),} }) } /*[syntax::ast::arm]*/ -fn deserialize_121(s: S) -> +fn deserialize_120(s: S) -> [syntax::ast::arm] { s.read_vec( @@ -6444,12 +6414,12 @@ fn deserialize_121(s: S) -> vec::init_fn(len, {|i| s.read_vec_elt(i, - {|| deserialize_122(s) }) + {|| deserialize_121(s) }) }) }) } /*syntax::ast::alt_mode*/ -fn deserialize_123(s: S) -> +fn deserialize_122(s: S) -> syntax::ast::alt_mode { s.read_enum("syntax::ast::alt_mode", @@ -6467,11 +6437,11 @@ fn deserialize_123(s: S) -> }) } /*int*/ -fn deserialize_129(s: S) -> int { +fn deserialize_128(s: S) -> int { s.read_int() } /*syntax::ast::capture_item*/ -fn deserialize_128(s: S) -> +fn deserialize_127(s: S) -> syntax::ast::capture_item { s.read_rec( @@ -6484,7 +6454,7 @@ fn deserialize_128(s: S) -> /*syntax::codemap::span*/ {|| - {id: s.read_rec_field("id", 0u, {|| deserialize_129(s) }), + {id: s.read_rec_field("id", 0u, {|| deserialize_128(s) }), name: s.read_rec_field("name", 1u, {|| deserialize_1(s) }), span: @@ -6494,14 +6464,14 @@ fn deserialize_128(s: S) -> } /*@syntax::ast::capture_item*/ -fn deserialize_127(s: S) -> +fn deserialize_126(s: S) -> @syntax::ast::capture_item { - s.read_box(/*syntax::ast::capture_item*/{|| @deserialize_128(s) }) + s.read_box(/*syntax::ast::capture_item*/{|| @deserialize_127(s) }) } /*[@syntax::ast::capture_item]*/ -fn deserialize_126(s: S) -> +fn deserialize_125(s: S) -> [@syntax::ast::capture_item] { s.read_vec( @@ -6510,12 +6480,12 @@ fn deserialize_126(s: S) -> vec::init_fn(len, {|i| s.read_vec_elt(i, - {|| deserialize_127(s) }) + {|| deserialize_126(s) }) }) }) } /*syntax::ast::capture_clause*/ -fn deserialize_125(s: S) -> +fn deserialize_124(s: S) -> syntax::ast::capture_clause { s.read_rec( @@ -6528,22 +6498,22 @@ fn deserialize_125(s: S) -> {|| {copies: s.read_rec_field("copies", 0u, - {|| deserialize_126(s) }), + {|| deserialize_125(s) }), moves: s.read_rec_field("moves", 1u, - {|| deserialize_126(s) }),} + {|| deserialize_125(s) }),} }) } /*@syntax::ast::capture_clause*/ -fn deserialize_124(s: S) -> +fn deserialize_123(s: S) -> @syntax::ast::capture_clause { - s.read_box(/*syntax::ast::capture_clause*/{|| @deserialize_125(s) }) + s.read_box(/*syntax::ast::capture_clause*/{|| @deserialize_124(s) }) } /*syntax::ast::expr_check_mode*/ -fn deserialize_130(s: S) -> +fn deserialize_129(s: S) -> syntax::ast::expr_check_mode { s.read_enum("syntax::ast::expr_check_mode", @@ -6559,7 +6529,7 @@ fn deserialize_130(s: S) -> }) } /*syntax::ast::expr_*/ -fn deserialize_74(s: S) -> +fn deserialize_73(s: S) -> syntax::ast::expr_ { s.read_enum("syntax::ast::expr_", /*[@syntax::ast::expr]*//*syntax::ast::mutability*/ @@ -6649,7 +6619,7 @@ fn deserialize_74(s: S) -> 0u { syntax::ast::expr_vec(s.read_enum_variant_arg(0u, {|| - deserialize_75(s) + deserialize_74(s) }), s.read_enum_variant_arg(1u, {|| @@ -6659,21 +6629,21 @@ fn deserialize_74(s: S) -> 1u { syntax::ast::expr_rec(s.read_enum_variant_arg(0u, {|| - deserialize_76(s) + deserialize_75(s) }), s.read_enum_variant_arg(1u, {|| - deserialize_79(s) + deserialize_78(s) })) } 2u { syntax::ast::expr_call(s.read_enum_variant_arg(0u, {|| - deserialize_72(s) + deserialize_71(s) }), s.read_enum_variant_arg(1u, {|| - deserialize_75(s) + deserialize_74(s) }), s.read_enum_variant_arg(2u, {|| @@ -6683,53 +6653,53 @@ fn deserialize_74(s: S) -> 3u { syntax::ast::expr_tup(s.read_enum_variant_arg(0u, {|| - deserialize_75(s) + deserialize_74(s) })) } 4u { syntax::ast::expr_bind(s.read_enum_variant_arg(0u, {|| - deserialize_72(s) + deserialize_71(s) }), s.read_enum_variant_arg(1u, {|| - deserialize_80(s) + deserialize_79(s) })) } 5u { syntax::ast::expr_binary(s.read_enum_variant_arg(0u, {|| - deserialize_81(s) + deserialize_80(s) }), s.read_enum_variant_arg(1u, {|| - deserialize_72(s) + deserialize_71(s) }), s.read_enum_variant_arg(2u, {|| - deserialize_72(s) + deserialize_71(s) })) } 6u { syntax::ast::expr_unary(s.read_enum_variant_arg(0u, {|| - deserialize_82(s) + deserialize_81(s) }), s.read_enum_variant_arg(1u, {|| - deserialize_72(s) + deserialize_71(s) })) } 7u { syntax::ast::expr_lit(s.read_enum_variant_arg(0u, {|| - deserialize_60(s) + deserialize_59(s) })) } 8u { syntax::ast::expr_cast(s.read_enum_variant_arg(0u, {|| - deserialize_72(s) + deserialize_71(s) }), s.read_enum_variant_arg(1u, {|| @@ -6739,153 +6709,153 @@ fn deserialize_74(s: S) -> 9u { syntax::ast::expr_if(s.read_enum_variant_arg(0u, {|| - deserialize_72(s) + deserialize_71(s) }), s.read_enum_variant_arg(1u, {|| - deserialize_83(s) + deserialize_82(s) }), s.read_enum_variant_arg(2u, {|| - deserialize_79(s) + deserialize_78(s) })) } 10u { syntax::ast::expr_while(s.read_enum_variant_arg(0u, {|| - deserialize_72(s) + deserialize_71(s) }), s.read_enum_variant_arg(1u, {|| - deserialize_83(s) + deserialize_82(s) })) } 11u { syntax::ast::expr_for(s.read_enum_variant_arg(0u, {|| - deserialize_106(s) + deserialize_105(s) }), s.read_enum_variant_arg(1u, {|| - deserialize_72(s) + deserialize_71(s) }), s.read_enum_variant_arg(2u, {|| - deserialize_83(s) + deserialize_82(s) })) } 12u { syntax::ast::expr_do_while(s.read_enum_variant_arg(0u, {|| - deserialize_83(s) + deserialize_82(s) }), s.read_enum_variant_arg(1u, {|| - deserialize_72(s) + deserialize_71(s) })) } 13u { syntax::ast::expr_alt(s.read_enum_variant_arg(0u, {|| - deserialize_72(s) + deserialize_71(s) }), s.read_enum_variant_arg(1u, {|| - deserialize_121(s) + deserialize_120(s) }), s.read_enum_variant_arg(2u, {|| - deserialize_123(s) + deserialize_122(s) })) } 14u { syntax::ast::expr_fn(s.read_enum_variant_arg(0u, {|| - deserialize_39(s) + deserialize_38(s) }), s.read_enum_variant_arg(1u, {|| - deserialize_40(s) + deserialize_39(s) }), s.read_enum_variant_arg(2u, {|| - deserialize_83(s) + deserialize_82(s) }), s.read_enum_variant_arg(3u, {|| - deserialize_124(s) + deserialize_123(s) })) } 15u { syntax::ast::expr_fn_block(s.read_enum_variant_arg(0u, {|| - deserialize_40(s) + deserialize_39(s) }), s.read_enum_variant_arg(1u, {|| - deserialize_83(s) + deserialize_82(s) })) } 16u { syntax::ast::expr_block(s.read_enum_variant_arg(0u, {|| - deserialize_83(s) + deserialize_82(s) })) } 17u { syntax::ast::expr_copy(s.read_enum_variant_arg(0u, {|| - deserialize_72(s) + deserialize_71(s) })) } 18u { syntax::ast::expr_move(s.read_enum_variant_arg(0u, {|| - deserialize_72(s) + deserialize_71(s) }), s.read_enum_variant_arg(1u, {|| - deserialize_72(s) + deserialize_71(s) })) } 19u { syntax::ast::expr_assign(s.read_enum_variant_arg(0u, {|| - deserialize_72(s) + deserialize_71(s) }), s.read_enum_variant_arg(1u, {|| - deserialize_72(s) + deserialize_71(s) })) } 20u { syntax::ast::expr_swap(s.read_enum_variant_arg(0u, {|| - deserialize_72(s) + deserialize_71(s) }), s.read_enum_variant_arg(1u, {|| - deserialize_72(s) + deserialize_71(s) })) } 21u { syntax::ast::expr_assign_op(s.read_enum_variant_arg(0u, {|| - deserialize_81(s) + deserialize_80(s) }), s.read_enum_variant_arg(1u, {|| - deserialize_72(s) + deserialize_71(s) }), s.read_enum_variant_arg(2u, {|| - deserialize_72(s) + deserialize_71(s) })) } 22u { syntax::ast::expr_field(s.read_enum_variant_arg(0u, {|| - deserialize_72(s) + deserialize_71(s) }), s.read_enum_variant_arg(1u, {|| @@ -6893,23 +6863,23 @@ fn deserialize_74(s: S) -> }), s.read_enum_variant_arg(2u, {|| - deserialize_55(s) + deserialize_54(s) })) } 23u { syntax::ast::expr_index(s.read_enum_variant_arg(0u, {|| - deserialize_72(s) + deserialize_71(s) }), s.read_enum_variant_arg(1u, {|| - deserialize_72(s) + deserialize_71(s) })) } 24u { syntax::ast::expr_path(s.read_enum_variant_arg(0u, {|| - deserialize_51(s) + deserialize_50(s) })) } 25u { @@ -6919,13 +6889,13 @@ fn deserialize_74(s: S) -> }), s.read_enum_variant_arg(1u, {|| - deserialize_72(s) + deserialize_71(s) })) } 26u { syntax::ast::expr_fail(s.read_enum_variant_arg(0u, {|| - deserialize_79(s) + deserialize_78(s) })) } 27u { syntax::ast::expr_break } @@ -6933,63 +6903,63 @@ fn deserialize_74(s: S) -> 29u { syntax::ast::expr_ret(s.read_enum_variant_arg(0u, {|| - deserialize_79(s) + deserialize_78(s) })) } 30u { syntax::ast::expr_be(s.read_enum_variant_arg(0u, {|| - deserialize_72(s) + deserialize_71(s) })) } 31u { syntax::ast::expr_log(s.read_enum_variant_arg(0u, {|| - deserialize_129(s) + deserialize_128(s) }), s.read_enum_variant_arg(1u, {|| - deserialize_72(s) + deserialize_71(s) }), s.read_enum_variant_arg(2u, {|| - deserialize_72(s) + deserialize_71(s) })) } 32u { syntax::ast::expr_assert(s.read_enum_variant_arg(0u, {|| - deserialize_72(s) + deserialize_71(s) })) } 33u { syntax::ast::expr_check(s.read_enum_variant_arg(0u, {|| - deserialize_130(s) + deserialize_129(s) }), s.read_enum_variant_arg(1u, {|| - deserialize_72(s) + deserialize_71(s) })) } 34u { syntax::ast::expr_if_check(s.read_enum_variant_arg(0u, {|| - deserialize_72(s) + deserialize_71(s) }), s.read_enum_variant_arg(1u, {|| - deserialize_83(s) + deserialize_82(s) }), s.read_enum_variant_arg(2u, {|| - deserialize_79(s) + deserialize_78(s) })) } 35u { syntax::ast::expr_mac(s.read_enum_variant_arg(0u, {|| - deserialize_69(s) + deserialize_68(s) })) } } @@ -6997,7 +6967,7 @@ fn deserialize_74(s: S) -> }) } /*syntax::ast::expr*/ -fn deserialize_73(s: S) -> +fn deserialize_72(s: S) -> syntax::ast::expr { s.read_rec( @@ -7012,7 +6982,7 @@ fn deserialize_73(s: S) -> {|| {id: s.read_rec_field("id", 0u, {|| deserialize_27(s) }), node: - s.read_rec_field("node", 1u, {|| deserialize_74(s) }), + s.read_rec_field("node", 1u, {|| deserialize_73(s) }), span: s.read_rec_field("span", 2u, {|| deserialize_19(s) }),} @@ -7020,14 +6990,14 @@ fn deserialize_73(s: S) -> } /*@syntax::ast::expr*/ -fn deserialize_72(s: S) -> +fn deserialize_71(s: S) -> @syntax::ast::expr { - s.read_box(/*syntax::ast::expr*/{|| @deserialize_73(s) }) + s.read_box(/*syntax::ast::expr*/{|| @deserialize_72(s) }) } /*syntax::ast::mac_arg<@syntax::ast::expr>*/ -fn deserialize_71(s: S) -> +fn deserialize_70(s: S) -> syntax::ast::mac_arg<@syntax::ast::expr> { s.read_enum("core::option::t", @@ -7040,7 +7010,7 @@ fn deserialize_71(s: S) -> 1u { core::option::some(s.read_enum_variant_arg(0u, {|| - deserialize_72(s) + deserialize_71(s) })) } } @@ -7048,7 +7018,7 @@ fn deserialize_71(s: S) -> }) } /*syntax::ast::mac_body_*/ -fn deserialize_132(s: S) -> +fn deserialize_131(s: S) -> syntax::ast::mac_body_ { s.read_rec( @@ -7064,7 +7034,7 @@ fn deserialize_132(s: S) -> } /*syntax::ast::mac_body*/ -fn deserialize_131(s: S) -> +fn deserialize_130(s: S) -> syntax::ast::mac_body { s.read_enum("core::option::t", @@ -7077,7 +7047,7 @@ fn deserialize_131(s: S) -> 1u { core::option::some(s.read_enum_variant_arg(0u, {|| - deserialize_132(s) + deserialize_131(s) })) } } @@ -7085,7 +7055,7 @@ fn deserialize_131(s: S) -> }) } /*syntax::ast::mac_*/ -fn deserialize_70(s: S) -> +fn deserialize_69(s: S) -> syntax::ast::mac_ { s.read_enum("syntax::ast::mac_", /*@syntax::ast::path*/ @@ -7107,15 +7077,15 @@ fn deserialize_70(s: S) -> 0u { syntax::ast::mac_invoc(s.read_enum_variant_arg(0u, {|| - deserialize_51(s) + deserialize_50(s) }), s.read_enum_variant_arg(1u, {|| - deserialize_71(s) + deserialize_70(s) }), s.read_enum_variant_arg(2u, {|| - deserialize_131(s) + deserialize_130(s) })) } 1u { @@ -7127,7 +7097,7 @@ fn deserialize_70(s: S) -> 2u { syntax::ast::mac_embed_block(s.read_enum_variant_arg(0u, {|| - deserialize_83(s) + deserialize_82(s) })) } 3u { syntax::ast::mac_ellipsis } @@ -7138,7 +7108,7 @@ fn deserialize_70(s: S) -> }), s.read_enum_variant_arg(1u, {|| - deserialize_72(s) + deserialize_71(s) })) } 5u { @@ -7152,7 +7122,7 @@ fn deserialize_70(s: S) -> }) } /*syntax::ast::mac*/ -fn deserialize_69(s: S) -> +fn deserialize_68(s: S) -> syntax::ast::mac { s.read_rec( @@ -7164,7 +7134,7 @@ fn deserialize_69(s: S) -> {|| {node: - s.read_rec_field("node", 0u, {|| deserialize_70(s) }), + s.read_rec_field("node", 0u, {|| deserialize_69(s) }), span: s.read_rec_field("span", 1u, {|| deserialize_19(s) }),} @@ -7244,29 +7214,29 @@ fn deserialize_31(s: S) -> 7u { syntax::ast::ty_rec(s.read_enum_variant_arg(0u, {|| - deserialize_36(s) + deserialize_35(s) })) } 8u { syntax::ast::ty_fn(s.read_enum_variant_arg(0u, {|| - deserialize_39(s) + deserialize_38(s) }), s.read_enum_variant_arg(1u, {|| - deserialize_40(s) + deserialize_39(s) })) } 9u { syntax::ast::ty_tup(s.read_enum_variant_arg(0u, {|| - deserialize_55(s) + deserialize_54(s) })) } 10u { syntax::ast::ty_path(s.read_enum_variant_arg(0u, {|| - deserialize_51(s) + deserialize_50(s) }), s.read_enum_variant_arg(1u, {|| @@ -7280,13 +7250,13 @@ fn deserialize_31(s: S) -> }), s.read_enum_variant_arg(1u, {|| - deserialize_61(s) + deserialize_60(s) })) } 12u { syntax::ast::ty_mac(s.read_enum_variant_arg(0u, {|| - deserialize_69(s) + deserialize_68(s) })) } 13u { syntax::ast::ty_infer } @@ -7322,7 +7292,7 @@ fn deserialize_29(s: S) -> } /*syntax::ast::ty_param_bound*/ -fn deserialize_137(s: S) -> +fn deserialize_136(s: S) -> syntax::ast::ty_param_bound { s.read_enum("syntax::ast::ty_param_bound", @@ -7346,7 +7316,7 @@ fn deserialize_137(s: S) -> }) } /*[syntax::ast::ty_param_bound]*/ -fn deserialize_136(s: S) -> +fn deserialize_135(s: S) -> [syntax::ast::ty_param_bound] { s.read_vec( @@ -7355,19 +7325,19 @@ fn deserialize_136(s: S) -> vec::init_fn(len, {|i| s.read_vec_elt(i, - {|| deserialize_137(s) }) + {|| deserialize_136(s) }) }) }) } /*@[syntax::ast::ty_param_bound]*/ -fn deserialize_135(s: S) -> +fn deserialize_134(s: S) -> @[syntax::ast::ty_param_bound] { - s.read_box(/*[syntax::ast::ty_param_bound]*/{|| @deserialize_136(s) }) + s.read_box(/*[syntax::ast::ty_param_bound]*/{|| @deserialize_135(s) }) } /*syntax::ast::ty_param*/ -fn deserialize_134(s: S) -> +fn deserialize_133(s: S) -> syntax::ast::ty_param { s.read_rec( @@ -7385,12 +7355,12 @@ fn deserialize_134(s: S) -> id: s.read_rec_field("id", 1u, {|| deserialize_27(s) }), bounds: s.read_rec_field("bounds", 2u, - {|| deserialize_135(s) }),} + {|| deserialize_134(s) }),} }) } /*[syntax::ast::ty_param]*/ -fn deserialize_133(s: S) -> +fn deserialize_132(s: S) -> [syntax::ast::ty_param] { s.read_vec( @@ -7399,12 +7369,12 @@ fn deserialize_133(s: S) -> vec::init_fn(len, {|i| s.read_vec_elt(i, - {|| deserialize_134(s) }) + {|| deserialize_133(s) }) }) }) } /*[@syntax::ast::item]*/ -fn deserialize_139(s: S) -> +fn deserialize_138(s: S) -> [@syntax::ast::item] { s.read_vec( @@ -7413,12 +7383,12 @@ fn deserialize_139(s: S) -> vec::init_fn(len, {|i| s.read_vec_elt(i, - {|| deserialize_119(s) }) + {|| deserialize_118(s) }) }) }) } /*syntax::ast::_mod*/ -fn deserialize_138(s: S) -> +fn deserialize_137(s: S) -> syntax::ast::_mod { s.read_rec( @@ -7431,15 +7401,15 @@ fn deserialize_138(s: S) -> {|| {view_items: s.read_rec_field("view_items", 0u, - {|| deserialize_85(s) }), + {|| deserialize_84(s) }), items: s.read_rec_field("items", 1u, - {|| deserialize_139(s) }),} + {|| deserialize_138(s) }),} }) } /*syntax::ast::native_item_*/ -fn deserialize_144(s: S) -> +fn deserialize_143(s: S) -> syntax::ast::native_item_ { s.read_enum("syntax::ast::native_item_", /*syntax::ast::fn_decl*//*[syntax::ast::ty_param]*/ @@ -7449,11 +7419,11 @@ fn deserialize_144(s: S) -> 0u { syntax::ast::native_item_fn(s.read_enum_variant_arg(0u, {|| - deserialize_40(s) + deserialize_39(s) }), s.read_enum_variant_arg(1u, {|| - deserialize_133(s) + deserialize_132(s) })) } } @@ -7461,7 +7431,7 @@ fn deserialize_144(s: S) -> }) } /*syntax::ast::native_item*/ -fn deserialize_143(s: S) -> +fn deserialize_142(s: S) -> syntax::ast::native_item { s.read_rec( @@ -7484,7 +7454,7 @@ fn deserialize_143(s: S) -> s.read_rec_field("attrs", 1u, {|| deserialize_2(s) }), node: s.read_rec_field("node", 2u, - {|| deserialize_144(s) }), + {|| deserialize_143(s) }), id: s.read_rec_field("id", 3u, {|| deserialize_27(s) }), span: s.read_rec_field("span", 4u, @@ -7493,14 +7463,14 @@ fn deserialize_143(s: S) -> } /*@syntax::ast::native_item*/ -fn deserialize_142(s: S) -> +fn deserialize_141(s: S) -> @syntax::ast::native_item { - s.read_box(/*syntax::ast::native_item*/{|| @deserialize_143(s) }) + s.read_box(/*syntax::ast::native_item*/{|| @deserialize_142(s) }) } /*[@syntax::ast::native_item]*/ -fn deserialize_141(s: S) -> +fn deserialize_140(s: S) -> [@syntax::ast::native_item] { s.read_vec( @@ -7509,12 +7479,12 @@ fn deserialize_141(s: S) -> vec::init_fn(len, {|i| s.read_vec_elt(i, - {|| deserialize_142(s) }) + {|| deserialize_141(s) }) }) }) } /*syntax::ast::native_mod*/ -fn deserialize_140(s: S) -> +fn deserialize_139(s: S) -> syntax::ast::native_mod { s.read_rec( @@ -7527,15 +7497,15 @@ fn deserialize_140(s: S) -> {|| {view_items: s.read_rec_field("view_items", 0u, - {|| deserialize_85(s) }), + {|| deserialize_84(s) }), items: s.read_rec_field("items", 1u, - {|| deserialize_141(s) }),} + {|| deserialize_140(s) }),} }) } /*syntax::ast::variant_arg*/ -fn deserialize_149(s: S) -> +fn deserialize_148(s: S) -> syntax::ast::variant_arg { s.read_rec( @@ -7551,7 +7521,7 @@ fn deserialize_149(s: S) -> }) } /*[syntax::ast::variant_arg]*/ -fn deserialize_148(s: S) -> +fn deserialize_147(s: S) -> [syntax::ast::variant_arg] { s.read_vec( @@ -7560,12 +7530,12 @@ fn deserialize_148(s: S) -> vec::init_fn(len, {|i| s.read_vec_elt(i, - {|| deserialize_149(s) }) + {|| deserialize_148(s) }) }) }) } /*syntax::ast::variant_*/ -fn deserialize_147(s: S) -> +fn deserialize_146(s: S) -> syntax::ast::variant_ { s.read_rec( @@ -7588,16 +7558,16 @@ fn deserialize_147(s: S) -> s.read_rec_field("attrs", 1u, {|| deserialize_2(s) }), args: s.read_rec_field("args", 2u, - {|| deserialize_148(s) }), + {|| deserialize_147(s) }), id: s.read_rec_field("id", 3u, {|| deserialize_27(s) }), disr_expr: s.read_rec_field("disr_expr", 4u, - {|| deserialize_79(s) }),} + {|| deserialize_78(s) }),} }) } /*syntax::ast::variant*/ -fn deserialize_146(s: S) -> +fn deserialize_145(s: S) -> syntax::ast::variant { s.read_rec( @@ -7610,7 +7580,7 @@ fn deserialize_146(s: S) -> {|| {node: s.read_rec_field("node", 0u, - {|| deserialize_147(s) }), + {|| deserialize_146(s) }), span: s.read_rec_field("span", 1u, {|| deserialize_19(s) }),} @@ -7618,7 +7588,7 @@ fn deserialize_146(s: S) -> } /*[syntax::ast::variant]*/ -fn deserialize_145(s: S) -> +fn deserialize_144(s: S) -> [syntax::ast::variant] { s.read_vec( @@ -7627,12 +7597,12 @@ fn deserialize_145(s: S) -> vec::init_fn(len, {|i| s.read_vec_elt(i, - {|| deserialize_146(s) }) + {|| deserialize_145(s) }) }) }) } /*syntax::ast::privacy*/ -fn deserialize_154(s: S) -> +fn deserialize_153(s: S) -> syntax::ast::privacy { s.read_enum("syntax::ast::privacy", @@ -7648,7 +7618,7 @@ fn deserialize_154(s: S) -> }) } /*syntax::ast::class_mutability*/ -fn deserialize_156(s: S) -> +fn deserialize_155(s: S) -> syntax::ast::class_mutability { s.read_enum("syntax::ast::class_mutability", @@ -7668,7 +7638,7 @@ fn deserialize_156(s: S) -> }) } /*syntax::ast::class_member*/ -fn deserialize_155(s: S) -> +fn deserialize_154(s: S) -> syntax::ast::class_member { s.read_enum("syntax::ast::class_member", /*syntax::ast::ident*//*@syntax::ast::ty*/ @@ -7689,7 +7659,7 @@ fn deserialize_155(s: S) -> }), s.read_enum_variant_arg(2u, {|| - deserialize_156(s) + deserialize_155(s) }), s.read_enum_variant_arg(3u, {|| @@ -7699,7 +7669,7 @@ fn deserialize_155(s: S) -> 1u { syntax::ast::class_method(s.read_enum_variant_arg(0u, {|| - deserialize_119(s) + deserialize_118(s) })) } } @@ -7707,7 +7677,7 @@ fn deserialize_155(s: S) -> }) } /*syntax::ast::class_item_*/ -fn deserialize_153(s: S) -> +fn deserialize_152(s: S) -> syntax::ast::class_item_ { s.read_rec( @@ -7720,15 +7690,15 @@ fn deserialize_153(s: S) -> {|| {privacy: s.read_rec_field("privacy", 0u, - {|| deserialize_154(s) }), + {|| deserialize_153(s) }), decl: s.read_rec_field("decl", 1u, - {|| deserialize_155(s) }),} + {|| deserialize_154(s) }),} }) } /*syntax::ast::class_item*/ -fn deserialize_152(s: S) -> +fn deserialize_151(s: S) -> syntax::ast::class_item { s.read_rec( @@ -7741,7 +7711,7 @@ fn deserialize_152(s: S) -> {|| {node: s.read_rec_field("node", 0u, - {|| deserialize_153(s) }), + {|| deserialize_152(s) }), span: s.read_rec_field("span", 1u, {|| deserialize_19(s) }),} @@ -7749,14 +7719,14 @@ fn deserialize_152(s: S) -> } /*@syntax::ast::class_item*/ -fn deserialize_151(s: S) -> +fn deserialize_150(s: S) -> @syntax::ast::class_item { - s.read_box(/*syntax::ast::class_item*/{|| @deserialize_152(s) }) + s.read_box(/*syntax::ast::class_item*/{|| @deserialize_151(s) }) } /*[@syntax::ast::class_item]*/ -fn deserialize_150(s: S) -> +fn deserialize_149(s: S) -> [@syntax::ast::class_item] { s.read_vec( @@ -7765,12 +7735,12 @@ fn deserialize_150(s: S) -> vec::init_fn(len, {|i| s.read_vec_elt(i, - {|| deserialize_151(s) }) + {|| deserialize_150(s) }) }) }) } /*syntax::ast::class_ctor_*/ -fn deserialize_158(s: S) -> +fn deserialize_157(s: S) -> syntax::ast::class_ctor_ { s.read_rec( @@ -7784,15 +7754,15 @@ fn deserialize_158(s: S) -> {|| {id: s.read_rec_field("id", 0u, {|| deserialize_27(s) }), - dec: s.read_rec_field("dec", 1u, {|| deserialize_40(s) }), + dec: s.read_rec_field("dec", 1u, {|| deserialize_39(s) }), body: s.read_rec_field("body", 2u, - {|| deserialize_83(s) }),} + {|| deserialize_82(s) }),} }) } /*syntax::ast::class_ctor*/ -fn deserialize_157(s: S) -> +fn deserialize_156(s: S) -> syntax::ast::class_ctor { s.read_rec( @@ -7805,7 +7775,7 @@ fn deserialize_157(s: S) -> {|| {node: s.read_rec_field("node", 0u, - {|| deserialize_158(s) }), + {|| deserialize_157(s) }), span: s.read_rec_field("span", 1u, {|| deserialize_19(s) }),} @@ -7813,7 +7783,7 @@ fn deserialize_157(s: S) -> } /*syntax::ast::ty_method*/ -fn deserialize_160(s: S) -> +fn deserialize_159(s: S) -> syntax::ast::ty_method { s.read_rec( @@ -7835,9 +7805,9 @@ fn deserialize_160(s: S) -> attrs: s.read_rec_field("attrs", 1u, {|| deserialize_2(s) }), decl: - s.read_rec_field("decl", 2u, {|| deserialize_40(s) }), + s.read_rec_field("decl", 2u, {|| deserialize_39(s) }), tps: - s.read_rec_field("tps", 3u, {|| deserialize_133(s) }), + s.read_rec_field("tps", 3u, {|| deserialize_132(s) }), span: s.read_rec_field("span", 4u, {|| deserialize_19(s) }),} @@ -7845,7 +7815,7 @@ fn deserialize_160(s: S) -> } /*[syntax::ast::ty_method]*/ -fn deserialize_159(s: S) -> +fn deserialize_158(s: S) -> [syntax::ast::ty_method] { s.read_vec( @@ -7854,12 +7824,12 @@ fn deserialize_159(s: S) -> vec::init_fn(len, {|i| s.read_vec_elt(i, - {|| deserialize_160(s) }) + {|| deserialize_159(s) }) }) }) } /*core::option::t<@syntax::ast::ty>*/ -fn deserialize_161(s: S) -> +fn deserialize_160(s: S) -> core::option::t<@syntax::ast::ty> { s.read_enum("core::option::t", @@ -7880,7 +7850,7 @@ fn deserialize_161(s: S) -> }) } /*syntax::ast::method*/ -fn deserialize_164(s: S) -> +fn deserialize_163(s: S) -> syntax::ast::method { s.read_rec( @@ -7908,11 +7878,11 @@ fn deserialize_164(s: S) -> attrs: s.read_rec_field("attrs", 1u, {|| deserialize_2(s) }), tps: - s.read_rec_field("tps", 2u, {|| deserialize_133(s) }), + s.read_rec_field("tps", 2u, {|| deserialize_132(s) }), decl: - s.read_rec_field("decl", 3u, {|| deserialize_40(s) }), + s.read_rec_field("decl", 3u, {|| deserialize_39(s) }), body: - s.read_rec_field("body", 4u, {|| deserialize_83(s) }), + s.read_rec_field("body", 4u, {|| deserialize_82(s) }), id: s.read_rec_field("id", 5u, {|| deserialize_27(s) }), span: s.read_rec_field("span", 6u, {|| deserialize_19(s) }), @@ -7923,14 +7893,14 @@ fn deserialize_164(s: S) -> } /*@syntax::ast::method*/ -fn deserialize_163(s: S) -> +fn deserialize_162(s: S) -> @syntax::ast::method { - s.read_box(/*syntax::ast::method*/{|| @deserialize_164(s) }) + s.read_box(/*syntax::ast::method*/{|| @deserialize_163(s) }) } /*[@syntax::ast::method]*/ -fn deserialize_162(s: S) -> +fn deserialize_161(s: S) -> [@syntax::ast::method] { s.read_vec( @@ -7939,7 +7909,7 @@ fn deserialize_162(s: S) -> vec::init_fn(len, {|i| s.read_vec_elt(i, - {|| deserialize_163(s) }) + {|| deserialize_162(s) }) }) }) } @@ -7982,33 +7952,33 @@ fn deserialize_28(s: S) -> }), s.read_enum_variant_arg(1u, {|| - deserialize_72(s) + deserialize_71(s) })) } 1u { syntax::ast::item_fn(s.read_enum_variant_arg(0u, {|| - deserialize_40(s) + deserialize_39(s) }), s.read_enum_variant_arg(1u, {|| - deserialize_133(s) + deserialize_132(s) }), s.read_enum_variant_arg(2u, {|| - deserialize_83(s) + deserialize_82(s) })) } 2u { syntax::ast::item_mod(s.read_enum_variant_arg(0u, {|| - deserialize_138(s) + deserialize_137(s) })) } 3u { syntax::ast::item_native_mod(s.read_enum_variant_arg(0u, {|| - deserialize_140(s) + deserialize_139(s) })) } 4u { @@ -8018,31 +7988,31 @@ fn deserialize_28(s: S) -> }), s.read_enum_variant_arg(1u, {|| - deserialize_133(s) + deserialize_132(s) })) } 5u { syntax::ast::item_enum(s.read_enum_variant_arg(0u, {|| - deserialize_145(s) + deserialize_144(s) }), s.read_enum_variant_arg(1u, {|| - deserialize_133(s) + deserialize_132(s) })) } 6u { syntax::ast::item_res(s.read_enum_variant_arg(0u, {|| - deserialize_40(s) + deserialize_39(s) }), s.read_enum_variant_arg(1u, {|| - deserialize_133(s) + deserialize_132(s) }), s.read_enum_variant_arg(2u, {|| - deserialize_83(s) + deserialize_82(s) }), s.read_enum_variant_arg(3u, {|| @@ -8056,35 +8026,35 @@ fn deserialize_28(s: S) -> 7u { syntax::ast::item_class(s.read_enum_variant_arg(0u, {|| - deserialize_133(s) + deserialize_132(s) }), s.read_enum_variant_arg(1u, {|| - deserialize_150(s) + deserialize_149(s) }), s.read_enum_variant_arg(2u, {|| - deserialize_157(s) + deserialize_156(s) })) } 8u { syntax::ast::item_iface(s.read_enum_variant_arg(0u, {|| - deserialize_133(s) + deserialize_132(s) }), s.read_enum_variant_arg(1u, {|| - deserialize_159(s) + deserialize_158(s) })) } 9u { syntax::ast::item_impl(s.read_enum_variant_arg(0u, {|| - deserialize_133(s) + deserialize_132(s) }), s.read_enum_variant_arg(1u, {|| - deserialize_161(s) + deserialize_160(s) }), s.read_enum_variant_arg(2u, {|| @@ -8092,7 +8062,7 @@ fn deserialize_28(s: S) -> }), s.read_enum_variant_arg(3u, {|| - deserialize_162(s) + deserialize_161(s) })) } } @@ -8135,27 +8105,27 @@ fn deserialize_syntax_ast_item(s: S) -> deserialize_0(s) } /*syntax::ast::crate_num*/ -fn serialize_167(s: S, +fn serialize_166(s: S, v: syntax::ast::crate_num) { s.emit_int(v); } /*syntax::ast::def_id*/ -fn serialize_166(s: S, +fn serialize_165(s: S, v: syntax::ast::def_id) { s.emit_rec(/*syntax::ast::crate_num*//*syntax::ast::node_id*/ {|| { s.emit_rec_field("crate", 0u, - {|| serialize_167(s, v.crate) }); + {|| serialize_166(s, v.crate) }); s.emit_rec_field("node", 1u, {|| serialize_27(s, v.node) }) } }); } /*syntax::ast::prim_ty*/ -fn serialize_168(s: S, +fn serialize_167(s: S, v: syntax::ast::prim_ty) { s.emit_enum("syntax::ast::prim_ty", @@ -8213,13 +8183,13 @@ fn serialize_168(s: S, }); } /*@syntax::ast::def*/ -fn serialize_169(s: S, +fn serialize_168(s: S, v: @syntax::ast::def) { - s.emit_box(/*syntax::ast::def*/{|| serialize_165(s, *v) }); + s.emit_box(/*syntax::ast::def*/{|| serialize_164(s, *v) }); } /*syntax::ast::def*/ -fn serialize_165(s: S, +fn serialize_164(s: S, v: syntax::ast::def) { s.emit_enum("syntax::ast::def", @@ -8242,7 +8212,6 @@ fn serialize_165(s: S, /*syntax::ast::def_id*/ /*syntax::ast::def_id*//*syntax::ast::def_id*/ /*syntax::ast::def_id*//*syntax::ast::def_id*/ - /*syntax::ast::def_id*/ {|| alt v { syntax::ast::def_fn(v0, v1) { @@ -8251,12 +8220,12 @@ fn serialize_165(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_166(s, + serialize_165(s, v0) }); s.emit_enum_variant_arg(1u, {|| - serialize_45(s, + serialize_44(s, v1) }) } @@ -8280,7 +8249,7 @@ fn serialize_165(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_166(s, + serialize_165(s, v0) }) } @@ -8293,7 +8262,7 @@ fn serialize_165(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_166(s, + serialize_165(s, v0) }) } @@ -8305,7 +8274,7 @@ fn serialize_165(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_166(s, + serialize_165(s, v0) }) } @@ -8322,7 +8291,7 @@ fn serialize_165(s: S, }); s.emit_enum_variant_arg(1u, {|| - serialize_43(s, + serialize_42(s, v1) }) } @@ -8352,12 +8321,12 @@ fn serialize_165(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_166(s, + serialize_165(s, v0) }); s.emit_enum_variant_arg(1u, {|| - serialize_166(s, + serialize_165(s, v1) }) } @@ -8369,7 +8338,7 @@ fn serialize_165(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_166(s, + serialize_165(s, v0) }) } @@ -8382,7 +8351,7 @@ fn serialize_165(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_168(s, + serialize_167(s, v0) }) } @@ -8395,7 +8364,7 @@ fn serialize_165(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_166(s, + serialize_165(s, v0) }); s.emit_enum_variant_arg(1u, @@ -8425,7 +8394,7 @@ fn serialize_165(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_166(s, + serialize_165(s, v0) }) } @@ -8442,7 +8411,7 @@ fn serialize_165(s: S, }); s.emit_enum_variant_arg(1u, {|| - serialize_169(s, + serialize_168(s, v1) }); s.emit_enum_variant_arg(2u, @@ -8459,7 +8428,7 @@ fn serialize_165(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_166(s, + serialize_165(s, v0) }) } @@ -8472,12 +8441,12 @@ fn serialize_165(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_166(s, + serialize_165(s, v0) }); s.emit_enum_variant_arg(1u, {|| - serialize_166(s, + serialize_165(s, v1) }) } @@ -8490,45 +8459,32 @@ fn serialize_165(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_166(s, + serialize_165(s, v0) }); s.emit_enum_variant_arg(1u, {|| - serialize_166(s, + serialize_165(s, v1) }) } }) } - syntax::ast::def_region_param(v0) { - s.emit_enum_variant("syntax::ast::def_region_param", - 17u, 1u, - {|| - { - s.emit_enum_variant_arg(0u, - {|| - serialize_166(s, - v0) - }) - } - }) - } } }); } fn serialize_syntax_ast_def(s: S, v: syntax::ast::def) { - serialize_165(s, v); + serialize_164(s, v); } /*syntax::ast::crate_num*/ -fn deserialize_167(s: S) -> +fn deserialize_166(s: S) -> syntax::ast::crate_num { s.read_int() } /*syntax::ast::def_id*/ -fn deserialize_166(s: S) -> +fn deserialize_165(s: S) -> syntax::ast::def_id { s.read_rec( @@ -8541,7 +8497,7 @@ fn deserialize_166(s: S) -> {|| {crate: s.read_rec_field("crate", 0u, - {|| deserialize_167(s) }), + {|| deserialize_166(s) }), node: s.read_rec_field("node", 1u, {|| deserialize_27(s) }),} @@ -8549,7 +8505,7 @@ fn deserialize_166(s: S) -> } /*syntax::ast::prim_ty*/ -fn deserialize_168(s: S) -> +fn deserialize_167(s: S) -> syntax::ast::prim_ty { s.read_enum("syntax::ast::prim_ty", /*syntax::ast::int_ty*/ @@ -8589,14 +8545,14 @@ fn deserialize_168(s: S) -> }) } /*@syntax::ast::def*/ -fn deserialize_169(s: S) -> +fn deserialize_168(s: S) -> @syntax::ast::def { - s.read_box(/*syntax::ast::def*/{|| @deserialize_165(s) }) + s.read_box(/*syntax::ast::def*/{|| @deserialize_164(s) }) } /*syntax::ast::def*/ -fn deserialize_165(s: S) -> +fn deserialize_164(s: S) -> syntax::ast::def { s.read_enum("syntax::ast::def", /*syntax::ast::def_id*//*syntax::ast::purity*/ @@ -8634,19 +8590,17 @@ fn deserialize_165(s: S) -> /*syntax::ast::def_id*//*syntax::ast::def_id*/ /*syntax::ast::def_id*//*syntax::ast::def_id*/ - - /*syntax::ast::def_id*/ {|| s.read_enum_variant({|v_id| alt check v_id { 0u { syntax::ast::def_fn(s.read_enum_variant_arg(0u, {|| - deserialize_166(s) + deserialize_165(s) }), s.read_enum_variant_arg(1u, {|| - deserialize_45(s) + deserialize_44(s) })) } 1u { @@ -8658,19 +8612,19 @@ fn deserialize_165(s: S) -> 2u { syntax::ast::def_mod(s.read_enum_variant_arg(0u, {|| - deserialize_166(s) + deserialize_165(s) })) } 3u { syntax::ast::def_native_mod(s.read_enum_variant_arg(0u, {|| - deserialize_166(s) + deserialize_165(s) })) } 4u { syntax::ast::def_const(s.read_enum_variant_arg(0u, {|| - deserialize_166(s) + deserialize_165(s) })) } 5u { @@ -8680,7 +8634,7 @@ fn deserialize_165(s: S) -> }), s.read_enum_variant_arg(1u, {|| - deserialize_43(s) + deserialize_42(s) })) } 6u { @@ -8696,29 +8650,29 @@ fn deserialize_165(s: S) -> 7u { syntax::ast::def_variant(s.read_enum_variant_arg(0u, {|| - deserialize_166(s) + deserialize_165(s) }), s.read_enum_variant_arg(1u, {|| - deserialize_166(s) + deserialize_165(s) })) } 8u { syntax::ast::def_ty(s.read_enum_variant_arg(0u, {|| - deserialize_166(s) + deserialize_165(s) })) } 9u { syntax::ast::def_prim_ty(s.read_enum_variant_arg(0u, {|| - deserialize_168(s) + deserialize_167(s) })) } 10u { syntax::ast::def_ty_param(s.read_enum_variant_arg(0u, {|| - deserialize_166(s) + deserialize_165(s) }), s.read_enum_variant_arg(1u, {|| @@ -8734,7 +8688,7 @@ fn deserialize_165(s: S) -> 12u { syntax::ast::def_use(s.read_enum_variant_arg(0u, {|| - deserialize_166(s) + deserialize_165(s) })) } 13u { @@ -8744,7 +8698,7 @@ fn deserialize_165(s: S) -> }), s.read_enum_variant_arg(1u, {|| - deserialize_169(s) + deserialize_168(s) }), s.read_enum_variant_arg(2u, {|| @@ -8754,33 +8708,27 @@ fn deserialize_165(s: S) -> 14u { syntax::ast::def_class(s.read_enum_variant_arg(0u, {|| - deserialize_166(s) + deserialize_165(s) })) } 15u { syntax::ast::def_class_field(s.read_enum_variant_arg(0u, {|| - deserialize_166(s) + deserialize_165(s) }), s.read_enum_variant_arg(1u, {|| - deserialize_166(s) + deserialize_165(s) })) } 16u { syntax::ast::def_class_method(s.read_enum_variant_arg(0u, {|| - deserialize_166(s) + deserialize_165(s) }), s.read_enum_variant_arg(1u, {|| - deserialize_166(s) - })) - } - 17u { - syntax::ast::def_region_param(s.read_enum_variant_arg(0u, - {|| - deserialize_166(s) + deserialize_165(s) })) } } @@ -8789,10 +8737,10 @@ fn deserialize_165(s: S) -> } fn deserialize_syntax_ast_def(s: S) -> syntax::ast::def { - deserialize_165(s) + deserialize_164(s) } /*middle::typeck::method_origin*/ -fn serialize_170(s: S, +fn serialize_169(s: S, v: middle::typeck::method_origin) { s.emit_enum("middle::typeck::method_origin", @@ -8808,7 +8756,7 @@ fn serialize_170(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_166(s, + serialize_165(s, v0) }) } @@ -8821,7 +8769,7 @@ fn serialize_170(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_166(s, + serialize_165(s, v0) }); s.emit_enum_variant_arg(1u, @@ -8849,7 +8797,7 @@ fn serialize_170(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_166(s, + serialize_165(s, v0) }); s.emit_enum_variant_arg(1u, @@ -8867,10 +8815,10 @@ fn serialize_middle_typeck_method_origin(s: S, v: middle::typeck::method_origin) { - serialize_170(s, v); + serialize_169(s, v); } /*middle::typeck::method_origin*/ -fn deserialize_170(s: S) -> +fn deserialize_169(s: S) -> middle::typeck::method_origin { s.read_enum("middle::typeck::method_origin", /*syntax::ast::def_id*/ @@ -8884,13 +8832,13 @@ fn deserialize_170(s: S) -> 0u { middle::typeck::method_static(s.read_enum_variant_arg(0u, {|| - deserialize_166(s) + deserialize_165(s) })) } 1u { middle::typeck::method_param(s.read_enum_variant_arg(0u, {|| - deserialize_166(s) + deserialize_165(s) }), s.read_enum_variant_arg(1u, {|| @@ -8908,7 +8856,7 @@ fn deserialize_170(s: S) -> 2u { middle::typeck::method_iface(s.read_enum_variant_arg(0u, {|| - deserialize_166(s) + deserialize_165(s) }), s.read_enum_variant_arg(1u, {|| @@ -8922,17 +8870,17 @@ fn deserialize_170(s: S) -> fn deserialize_middle_typeck_method_origin(s: S) -> middle::typeck::method_origin { - deserialize_170(s) + deserialize_169(s) } /*middle::freevars::freevar_entry*/ -fn serialize_171(s: S, +fn serialize_170(s: S, v: middle::freevars::freevar_entry) { s.emit_rec(/*syntax::ast::def*//*syntax::codemap::span*/ {|| { s.emit_rec_field("def", 0u, - {|| serialize_165(s, v.def) }); + {|| serialize_164(s, v.def) }); s.emit_rec_field("span", 1u, {|| serialize_19(s, v.span) }) } @@ -8942,10 +8890,10 @@ fn serialize_middle_freevars_freevar_entry(s: S, v: middle::freevars::freevar_entry) { - serialize_171(s, v); + serialize_170(s, v); } /*middle::freevars::freevar_entry*/ -fn deserialize_171(s: S) -> +fn deserialize_170(s: S) -> middle::freevars::freevar_entry { s.read_rec( @@ -8957,7 +8905,7 @@ fn deserialize_171(s: S) -> {|| {def: - s.read_rec_field("def", 0u, {|| deserialize_165(s) }), + s.read_rec_field("def", 0u, {|| deserialize_164(s) }), span: s.read_rec_field("span", 1u, {|| deserialize_19(s) }),} @@ -8967,19 +8915,19 @@ fn deserialize_171(s: S) -> fn deserialize_middle_freevars_freevar_entry(s: S) -> middle::freevars::freevar_entry { - deserialize_171(s) + deserialize_170(s) } fn serialize_syntax_ast_def_id(s: S, v: syntax::ast::def_id) { - serialize_166(s, v); + serialize_165(s, v); } fn deserialize_syntax_ast_def_id(s: S) -> syntax::ast::def_id { - deserialize_166(s) + deserialize_165(s) } /*syntax::ast::inlined_item*/ -fn serialize_172(s: S, +fn serialize_171(s: S, v: syntax::ast::inlined_item) { s.emit_enum("syntax::ast::inlined_item", @@ -8993,7 +8941,7 @@ fn serialize_172(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_119(s, + serialize_118(s, v0) }) } @@ -9005,12 +8953,12 @@ fn serialize_172(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_166(s, + serialize_165(s, v0) }); s.emit_enum_variant_arg(1u, {|| - serialize_163(s, + serialize_162(s, v1) }) } @@ -9022,10 +8970,10 @@ fn serialize_172(s: S, fn serialize_syntax_ast_inlined_item(s: S, v: syntax::ast::inlined_item) { - serialize_172(s, v); + serialize_171(s, v); } /*syntax::ast::inlined_item*/ -fn deserialize_172(s: S) -> +fn deserialize_171(s: S) -> syntax::ast::inlined_item { s.read_enum("syntax::ast::inlined_item", /*@syntax::ast::item*/ @@ -9037,17 +8985,17 @@ fn deserialize_172(s: S) -> 0u { syntax::ast::ii_item(s.read_enum_variant_arg(0u, {|| - deserialize_119(s) + deserialize_118(s) })) } 1u { syntax::ast::ii_method(s.read_enum_variant_arg(0u, {|| - deserialize_166(s) + deserialize_165(s) }), s.read_enum_variant_arg(1u, {|| - deserialize_163(s) + deserialize_162(s) })) } } @@ -9057,10 +9005,10 @@ fn deserialize_172(s: S) -> fn deserialize_syntax_ast_inlined_item(s: S) -> syntax::ast::inlined_item { - deserialize_172(s) + deserialize_171(s) } /*[syntax::ast::node_id]*/ -fn serialize_174(s: S, +fn serialize_173(s: S, v: [syntax::ast::node_id]) { s.emit_vec(vec::len(v), /*syntax::ast::node_id*/ @@ -9072,7 +9020,7 @@ fn serialize_174(s: S, }); } /*middle::last_use::is_last_use*/ -fn serialize_173(s: S, +fn serialize_172(s: S, v: middle::last_use::is_last_use) { s.emit_enum("middle::last_use::is_last_use", @@ -9096,7 +9044,7 @@ fn serialize_173(s: S, { s.emit_enum_variant_arg(0u, {|| - serialize_174(s, + serialize_173(s, v0) }) } @@ -9109,10 +9057,10 @@ fn serialize_middle_last_use_is_last_use(s: S, v: middle::last_use::is_last_use) { - serialize_173(s, v); + serialize_172(s, v); } /*[syntax::ast::node_id]*/ -fn deserialize_174(s: S) -> +fn deserialize_173(s: S) -> [syntax::ast::node_id] { s.read_vec( @@ -9125,7 +9073,7 @@ fn deserialize_174(s: S) -> }) } /*middle::last_use::is_last_use*/ -fn deserialize_173(s: S) -> +fn deserialize_172(s: S) -> middle::last_use::is_last_use { s.read_enum("middle::last_use::is_last_use", @@ -9145,7 +9093,7 @@ fn deserialize_173(s: S) -> 2u { middle::last_use::closes_over(s.read_enum_variant_arg(0u, {|| - deserialize_174(s) + deserialize_173(s) })) } } @@ -9155,5 +9103,5 @@ fn deserialize_173(s: S) -> fn deserialize_middle_last_use_is_last_use(s: S) -> middle::last_use::is_last_use { - deserialize_173(s) + deserialize_172(s) } diff --git a/src/rustc/middle/resolve.rs b/src/rustc/middle/resolve.rs index 9a69e549fd1c..b3e55754e3b8 100644 --- a/src/rustc/middle/resolve.rs +++ b/src/rustc/middle/resolve.rs @@ -1711,8 +1711,7 @@ fn ns_for_def(d: def) -> namespace { { ns_val(value_or_enum) } ast::def_mod(_) | ast::def_native_mod(_) { ns_module } ast::def_ty(_) | ast::def_binding(_) | ast::def_use(_) | - ast::def_ty_param(_, _) | ast::def_prim_ty(_) | ast::def_class(_) | - ast::def_region_param(_) + ast::def_ty_param(_, _) | ast::def_prim_ty(_) | ast::def_class(_) { ns_type } } } diff --git a/src/rustc/syntax/ast.rs b/src/rustc/syntax/ast.rs index 6445d3f4bf25..d5f198a6a8c4 100644 --- a/src/rustc/syntax/ast.rs +++ b/src/rustc/syntax/ast.rs @@ -28,8 +28,6 @@ enum ty_param_bound { type ty_param = {ident: ident, id: node_id, bounds: @[ty_param_bound]}; -type region_param = {ident: ident, id: node_id}; - enum def { def_fn(def_id, purity), def_self(node_id), @@ -52,8 +50,7 @@ enum def { def_class_field(def_id, def_id), // No purity allowed for now, I guess // (simpler this way, b/c presumably methods read mutable state) - def_class_method(def_id, def_id), - def_region_param(def_id), + def_class_method(def_id, def_id) } // The set of meta_items that define the compilation environment of the crate, @@ -345,7 +342,7 @@ enum prim_ty { enum region { re_inferred, - re_named(region_param), + re_named(ident), re_self } diff --git a/src/rustc/syntax/ast_util.rs b/src/rustc/syntax/ast_util.rs index e6e539244ed9..98f87008a60b 100644 --- a/src/rustc/syntax/ast_util.rs +++ b/src/rustc/syntax/ast_util.rs @@ -39,8 +39,7 @@ fn def_id_of_def(d: def) -> def_id { def_native_mod(id) | def_const(id) | def_variant(_, id) | def_ty(id) | def_ty_param(id, _) | def_use(id) | - def_class(id) | def_class_field(_, id) | def_class_method(_, id) | - def_region_param(id) { id } + def_class(id) | def_class_field(_, id) | def_class_method(_, id) { id } def_arg(id, _) | def_local(id, _) | def_self(id) | def_upvar(id, _, _) | def_binding(id) { diff --git a/src/rustc/syntax/parse/parser.rs b/src/rustc/syntax/parse/parser.rs index 2e3eac602caa..d7f0982adde9 100644 --- a/src/rustc/syntax/parse/parser.rs +++ b/src/rustc/syntax/parse/parser.rs @@ -424,7 +424,7 @@ fn parse_region(p: parser) -> ast::region { if string == "self" { ast::re_self } else { - ast::re_named({ ident: string, id: p.get_id()}) + ast::re_named(string) } } _ { ast::re_inferred } diff --git a/src/rustc/syntax/print/pprust.rs b/src/rustc/syntax/print/pprust.rs index e11ad472df8b..53a86f9b3409 100644 --- a/src/rustc/syntax/print/pprust.rs +++ b/src/rustc/syntax/print/pprust.rs @@ -316,7 +316,7 @@ fn print_native_mod(s: ps, nmod: ast::native_mod, attrs: [ast::attribute]) { fn print_region(s: ps, region: ast::region) { alt region { ast::re_inferred { /* no-op */ } - ast::re_named(name) { word(s.s, name.ident); word(s.s, "."); } + ast::re_named(name) { word(s.s, name); word(s.s, "."); } ast::re_self { word(s.s, "self"); word(s.s, "."); } } }