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