Revert "Revert "Remove old auto_serialize2 code (needs snapshot)""
This reverts commit a33535e441.
This commit is contained in:
Tim Chevalier
parent
48495f9f7f
commit
22efa39382
|
|
@ -20,8 +20,6 @@ impl span: Deserializable {
|
|||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
type spanned<T> = {node: T, span: span};
|
||||
|
||||
|
||||
|
|
@ -78,8 +76,6 @@ type fn_ident = Option<ident>;
|
|||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
type path = {span: span,
|
||||
global: bool,
|
||||
idents: ~[ident],
|
||||
|
|
@ -92,8 +88,6 @@ type node_id = int;
|
|||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
type def_id = {crate: crate_num, node: node_id};
|
||||
|
||||
impl def_id : cmp::Eq {
|
||||
|
|
@ -108,8 +102,6 @@ const crate_node_id: node_id = 0;
|
|||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
enum ty_param_bound {
|
||||
bound_copy,
|
||||
bound_send,
|
||||
|
|
@ -120,14 +112,10 @@ enum ty_param_bound {
|
|||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
type ty_param = {ident: ident, id: node_id, bounds: @~[ty_param_bound]};
|
||||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
enum def {
|
||||
def_fn(def_id, purity),
|
||||
def_static_method(def_id, purity),
|
||||
|
|
@ -308,8 +296,6 @@ type meta_item = spanned<meta_item_>;
|
|||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
enum meta_item_ {
|
||||
meta_word(~str),
|
||||
meta_list(~str, ~[@meta_item]),
|
||||
|
|
@ -320,8 +306,6 @@ type blk = spanned<blk_>;
|
|||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
type blk_ = {view_items: ~[@view_item],
|
||||
stmts: ~[@stmt],
|
||||
expr: Option<@expr>,
|
||||
|
|
@ -330,20 +314,14 @@ type blk_ = {view_items: ~[@view_item],
|
|||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
type pat = {id: node_id, node: pat_, span: span};
|
||||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
type field_pat = {ident: ident, pat: @pat};
|
||||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
enum binding_mode {
|
||||
bind_by_value,
|
||||
bind_by_move,
|
||||
|
|
@ -401,8 +379,6 @@ impl binding_mode : cmp::Eq {
|
|||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
enum pat_ {
|
||||
pat_wild,
|
||||
// A pat_ident may either be a new bound variable,
|
||||
|
|
@ -427,8 +403,6 @@ enum pat_ {
|
|||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
enum mutability { m_mutbl, m_imm, m_const, }
|
||||
|
||||
impl mutability : to_bytes::IterBytes {
|
||||
|
|
@ -446,8 +420,6 @@ impl mutability : cmp::Eq {
|
|||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
enum proto {
|
||||
proto_bare, // foreign fn
|
||||
proto_uniq, // fn~
|
||||
|
|
@ -464,8 +436,6 @@ impl proto : cmp::Eq {
|
|||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
enum vstore {
|
||||
// FIXME (#2112): Change uint to @expr (actually only constant exprs)
|
||||
vstore_fixed(Option<uint>), // [1,2,3,4]/_ or 4
|
||||
|
|
@ -476,8 +446,6 @@ enum vstore {
|
|||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
enum expr_vstore {
|
||||
// FIXME (#2112): Change uint to @expr (actually only constant exprs)
|
||||
expr_vstore_fixed(Option<uint>), // [1,2,3,4]/_ or 4
|
||||
|
|
@ -495,8 +463,6 @@ pure fn is_blockish(p: ast::proto) -> bool {
|
|||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
enum binop {
|
||||
add,
|
||||
subtract,
|
||||
|
|
@ -527,8 +493,6 @@ impl binop : cmp::Eq {
|
|||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
enum unop {
|
||||
box(mutability),
|
||||
uniq(mutability),
|
||||
|
|
@ -581,8 +545,6 @@ impl unop : cmp::Eq {
|
|||
// using ty::resolved_T(...).
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
enum inferable<T> {
|
||||
expl(T),
|
||||
infer(node_id)
|
||||
|
|
@ -623,8 +585,6 @@ impl<T:cmp::Eq> inferable<T> : cmp::Eq {
|
|||
// "resolved" mode: the real modes.
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
enum rmode { by_ref, by_val, by_move, by_copy }
|
||||
|
||||
impl rmode : to_bytes::IterBytes {
|
||||
|
|
@ -648,8 +608,6 @@ type stmt = spanned<stmt_>;
|
|||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
enum stmt_ {
|
||||
stmt_decl(@decl, node_id),
|
||||
|
||||
|
|
@ -662,8 +620,6 @@ enum stmt_ {
|
|||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
enum init_op { init_assign, init_move, }
|
||||
|
||||
impl init_op : cmp::Eq {
|
||||
|
|
@ -688,16 +644,12 @@ impl init_op : cmp::Eq {
|
|||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
type initializer = {op: init_op, expr: @expr};
|
||||
|
||||
// FIXME (pending discussion of #1697, #2178...): local should really be
|
||||
// a refinement on pat.
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
type local_ = {is_mutbl: bool, ty: @ty, pat: @pat,
|
||||
init: Option<initializer>, id: node_id};
|
||||
|
||||
|
|
@ -707,28 +659,20 @@ type decl = spanned<decl_>;
|
|||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
enum decl_ { decl_local(~[@local]), decl_item(@item), }
|
||||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
type arm = {pats: ~[@pat], guard: Option<@expr>, body: blk};
|
||||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
type field_ = {mutbl: mutability, ident: ident, expr: @expr};
|
||||
|
||||
type field = spanned<field_>;
|
||||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
enum blk_check_mode { default_blk, unsafe_blk, }
|
||||
|
||||
impl blk_check_mode : cmp::Eq {
|
||||
|
|
@ -745,28 +689,20 @@ impl blk_check_mode : cmp::Eq {
|
|||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
type expr = {id: node_id, callee_id: node_id, node: expr_, span: span};
|
||||
// Extra node ID is only used for index, assign_op, unary, binary
|
||||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
enum log_level { error, debug, other }
|
||||
// 0 = error, 1 = debug, 2 = other
|
||||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
enum alt_mode { alt_check, alt_exhaustive, }
|
||||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
enum expr_ {
|
||||
expr_vstore(@expr, expr_vstore),
|
||||
expr_vec(~[@expr], mutability),
|
||||
|
|
@ -824,8 +760,6 @@ enum expr_ {
|
|||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
type capture_item_ = {
|
||||
id: int,
|
||||
is_move: bool,
|
||||
|
|
@ -855,8 +789,6 @@ type capture_clause = @~[capture_item];
|
|||
//
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
#[doc="For macro invocations; parsing is delegated to the macro"]
|
||||
enum token_tree {
|
||||
tt_tok(span, token::token),
|
||||
|
|
@ -922,8 +854,6 @@ type matcher = spanned<matcher_>;
|
|||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
enum matcher_ {
|
||||
// match one token
|
||||
match_tok(token::token),
|
||||
|
|
@ -940,16 +870,12 @@ type mac_arg = Option<@expr>;
|
|||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
type mac_body_ = {span: span};
|
||||
|
||||
type mac_body = Option<mac_body_>;
|
||||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
enum mac_ {
|
||||
mac_invoc(@path, mac_arg, mac_body), // old macro-invocation
|
||||
mac_invoc_tt(@path,~[token_tree]), // new macro-invocation
|
||||
|
|
@ -964,8 +890,6 @@ type lit = spanned<lit_>;
|
|||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
enum lit_ {
|
||||
lit_str(@~str),
|
||||
lit_int(i64, int_ty),
|
||||
|
|
@ -1008,30 +932,22 @@ impl ast::lit_: cmp::Eq {
|
|||
// type structure in middle/ty.rs as well.
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
type mt = {ty: @ty, mutbl: mutability};
|
||||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
type ty_field_ = {ident: ident, mt: mt};
|
||||
|
||||
type ty_field = spanned<ty_field_>;
|
||||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
type ty_method = {ident: ident, attrs: ~[attribute], purity: purity,
|
||||
decl: fn_decl, tps: ~[ty_param], self_ty: self_ty,
|
||||
id: node_id, span: span};
|
||||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
// A trait method is either required (meaning it doesn't have an
|
||||
// implementation, just a signature) or provided (meaning it has a default
|
||||
// implementation).
|
||||
|
|
@ -1042,8 +958,6 @@ enum trait_method {
|
|||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
enum int_ty { ty_i, ty_char, ty_i8, ty_i16, ty_i32, ty_i64, }
|
||||
|
||||
impl int_ty : to_bytes::IterBytes {
|
||||
|
|
@ -1074,8 +988,6 @@ impl int_ty : cmp::Eq {
|
|||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
enum uint_ty { ty_u, ty_u8, ty_u16, ty_u32, ty_u64, }
|
||||
|
||||
impl uint_ty : to_bytes::IterBytes {
|
||||
|
|
@ -1104,8 +1016,6 @@ impl uint_ty : cmp::Eq {
|
|||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
enum float_ty { ty_f, ty_f32, ty_f64, }
|
||||
|
||||
impl float_ty : to_bytes::IterBytes {
|
||||
|
|
@ -1125,15 +1035,11 @@ impl float_ty : cmp::Eq {
|
|||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
type ty = {id: node_id, node: ty_, span: span};
|
||||
|
||||
// Not represented directly in the AST, referred to by name through a ty_path.
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
enum prim_ty {
|
||||
ty_int(int_ty),
|
||||
ty_uint(uint_ty),
|
||||
|
|
@ -1182,14 +1088,10 @@ impl prim_ty : cmp::Eq {
|
|||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
type region = {id: node_id, node: region_};
|
||||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
enum region_ {
|
||||
re_anon,
|
||||
re_static,
|
||||
|
|
@ -1199,8 +1101,6 @@ enum region_ {
|
|||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
enum ty_ {
|
||||
ty_nil,
|
||||
ty_bot, /* bottom type */
|
||||
|
|
@ -1241,14 +1141,10 @@ impl ty : to_bytes::IterBytes {
|
|||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
type arg = {mode: mode, ty: @ty, ident: ident, id: node_id};
|
||||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
type fn_decl =
|
||||
{inputs: ~[arg],
|
||||
output: @ty,
|
||||
|
|
@ -1256,8 +1152,6 @@ type fn_decl =
|
|||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
enum purity {
|
||||
pure_fn, // declared with "pure fn"
|
||||
unsafe_fn, // declared with "unsafe fn"
|
||||
|
|
@ -1280,8 +1174,6 @@ impl purity : cmp::Eq {
|
|||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
enum ret_style {
|
||||
noreturn, // functions with return type _|_ that always
|
||||
// raise an error or exit (i.e. never return to the caller)
|
||||
|
|
@ -1308,8 +1200,6 @@ impl ret_style : cmp::Eq {
|
|||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
enum self_ty_ {
|
||||
sty_static, // no self: static method
|
||||
sty_by_ref, // old by-reference self: ``
|
||||
|
|
@ -1367,8 +1257,6 @@ type self_ty = spanned<self_ty_>;
|
|||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
type method = {ident: ident, attrs: ~[attribute],
|
||||
tps: ~[ty_param], self_ty: self_ty,
|
||||
purity: purity, decl: fn_decl, body: blk,
|
||||
|
|
@ -1377,14 +1265,10 @@ type method = {ident: ident, attrs: ~[attribute],
|
|||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
type _mod = {view_items: ~[@view_item], items: ~[@item]};
|
||||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
enum foreign_abi {
|
||||
foreign_abi_rust_intrinsic,
|
||||
foreign_abi_cdecl,
|
||||
|
|
@ -1394,8 +1278,6 @@ enum foreign_abi {
|
|||
// Foreign mods can be named or anonymous
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
enum foreign_mod_sort { named, anonymous }
|
||||
|
||||
impl foreign_mod_sort : cmp::Eq {
|
||||
|
|
@ -1421,8 +1303,6 @@ impl foreign_abi : cmp::Eq {
|
|||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
type foreign_mod =
|
||||
{sort: foreign_mod_sort,
|
||||
view_items: ~[@view_item],
|
||||
|
|
@ -1430,14 +1310,10 @@ type foreign_mod =
|
|||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
type variant_arg = {ty: @ty, id: node_id};
|
||||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
enum variant_kind {
|
||||
tuple_variant_kind(~[variant_arg]),
|
||||
struct_variant_kind(@struct_def),
|
||||
|
|
@ -1446,20 +1322,14 @@ enum variant_kind {
|
|||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
type enum_def_ = { variants: ~[variant], common: Option<@struct_def> };
|
||||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
enum enum_def = enum_def_;
|
||||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
type variant_ = {name: ident, attrs: ~[attribute], kind: variant_kind,
|
||||
id: node_id, disr_expr: Option<@expr>, vis: visibility};
|
||||
|
||||
|
|
@ -1467,16 +1337,12 @@ type variant = spanned<variant_>;
|
|||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
type path_list_ident_ = {name: ident, id: node_id};
|
||||
|
||||
type path_list_ident = spanned<path_list_ident_>;
|
||||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
enum namespace { module_ns, type_value_ns }
|
||||
|
||||
impl namespace : cmp::Eq {
|
||||
|
|
@ -1490,8 +1356,6 @@ type view_path = spanned<view_path_>;
|
|||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
enum view_path_ {
|
||||
|
||||
// quux = foo::bar::baz
|
||||
|
|
@ -1510,15 +1374,11 @@ enum view_path_ {
|
|||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
type view_item = {node: view_item_, attrs: ~[attribute],
|
||||
vis: visibility, span: span};
|
||||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
enum view_item_ {
|
||||
view_item_use(ident, ~[@meta_item], node_id),
|
||||
view_item_import(~[@view_path]),
|
||||
|
|
@ -1533,8 +1393,6 @@ type attribute = spanned<attribute_>;
|
|||
// distinguished for pretty-printing.
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
enum attr_style { attr_outer, attr_inner, }
|
||||
|
||||
impl attr_style : cmp::Eq {
|
||||
|
|
@ -1547,8 +1405,6 @@ impl attr_style : cmp::Eq {
|
|||
// doc-comments are promoted to attributes that have is_sugared_doc = true
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
type attribute_ = {style: attr_style, value: meta_item, is_sugared_doc: bool};
|
||||
|
||||
/*
|
||||
|
|
@ -1562,14 +1418,10 @@ type attribute_ = {style: attr_style, value: meta_item, is_sugared_doc: bool};
|
|||
*/
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
type trait_ref = {path: @path, ref_id: node_id, impl_id: node_id};
|
||||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
enum visibility { public, private, inherited }
|
||||
|
||||
impl visibility : cmp::Eq {
|
||||
|
|
@ -1588,8 +1440,6 @@ impl visibility : cmp::Eq {
|
|||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
type struct_field_ = {
|
||||
kind: struct_field_kind,
|
||||
id: node_id,
|
||||
|
|
@ -1600,8 +1450,6 @@ type struct_field = spanned<struct_field_>;
|
|||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
enum struct_field_kind {
|
||||
named_field(ident, class_mutability, visibility),
|
||||
unnamed_field // element of a tuple-like struct
|
||||
|
|
@ -1609,8 +1457,6 @@ enum struct_field_kind {
|
|||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
type struct_def = {
|
||||
traits: ~[@trait_ref], /* traits this struct implements */
|
||||
fields: ~[@struct_field], /* fields */
|
||||
|
|
@ -1628,16 +1474,12 @@ type struct_def = {
|
|||
*/
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
type item = {ident: ident, attrs: ~[attribute],
|
||||
id: node_id, node: item_,
|
||||
vis: visibility, span: span};
|
||||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
enum item_ {
|
||||
item_const(@ty, @expr),
|
||||
item_fn(fn_decl, purity, ~[ty_param], blk),
|
||||
|
|
@ -1656,8 +1498,6 @@ enum item_ {
|
|||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
enum class_mutability { class_mutable, class_immutable }
|
||||
|
||||
impl class_mutability : to_bytes::IterBytes {
|
||||
|
|
@ -1682,8 +1522,6 @@ type class_ctor = spanned<class_ctor_>;
|
|||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
type class_ctor_ = {id: node_id,
|
||||
attrs: ~[attribute],
|
||||
self_id: node_id,
|
||||
|
|
@ -1694,8 +1532,6 @@ type class_dtor = spanned<class_dtor_>;
|
|||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
type class_dtor_ = {id: node_id,
|
||||
attrs: ~[attribute],
|
||||
self_id: node_id,
|
||||
|
|
@ -1703,8 +1539,6 @@ type class_dtor_ = {id: node_id,
|
|||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
type foreign_item =
|
||||
{ident: ident,
|
||||
attrs: ~[attribute],
|
||||
|
|
@ -1715,8 +1549,6 @@ type foreign_item =
|
|||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
enum foreign_item_ {
|
||||
foreign_item_fn(fn_decl, purity, ~[ty_param]),
|
||||
foreign_item_const(@ty)
|
||||
|
|
@ -1727,8 +1559,6 @@ enum foreign_item_ {
|
|||
// that we trans.
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
enum inlined_item {
|
||||
ii_item(@item),
|
||||
ii_method(def_id /* impl id */, @method),
|
||||
|
|
|
|||
|
|
@ -408,8 +408,6 @@ fn dtor_dec() -> fn_decl {
|
|||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
type id_range = {min: node_id, max: node_id};
|
||||
|
||||
fn empty(range: id_range) -> bool {
|
||||
|
|
|
|||
|
|
@ -1,991 +0,0 @@
|
|||
/*
|
||||
|
||||
The compiler code necessary to implement the #[auto_serialize2] and
|
||||
#[auto_deserialize2] extension. The idea here is that type-defining items may
|
||||
be tagged with #[auto_serialize2] and #[auto_deserialize2], which will cause
|
||||
us to generate a little companion module with the same name as the item.
|
||||
|
||||
For example, a type like:
|
||||
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
struct Node {id: uint}
|
||||
|
||||
would generate two implementations like:
|
||||
|
||||
impl Node: Serializable {
|
||||
fn serialize<S: Serializer>(s: &S) {
|
||||
do s.emit_struct("Node") {
|
||||
s.emit_field("id", 0, || s.emit_uint(self))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl node_id: Deserializable {
|
||||
static fn deserialize<D: Deserializer>(d: &D) -> Node {
|
||||
do d.read_struct("Node") {
|
||||
Node {
|
||||
id: d.read_field(~"x", 0, || deserialize(d))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Other interesting scenarios are whe the item has type parameters or
|
||||
references other non-built-in types. A type definition like:
|
||||
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
type spanned<T> = {node: T, span: span};
|
||||
|
||||
would yield functions like:
|
||||
|
||||
impl<T: Serializable> spanned<T>: Serializable {
|
||||
fn serialize<S: Serializer>(s: &S) {
|
||||
do s.emit_rec {
|
||||
s.emit_field("node", 0, || self.node.serialize(s));
|
||||
s.emit_field("span", 1, || self.span.serialize(s));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: Deserializable> spanned<T>: Deserializable {
|
||||
static fn deserialize<D: Deserializer>(d: &D) -> spanned<T> {
|
||||
do d.read_rec {
|
||||
{
|
||||
node: d.read_field(~"node", 0, || deserialize(d)),
|
||||
span: d.read_field(~"span", 1, || deserialize(d)),
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
FIXME (#2810)--Hygiene. Search for "__" strings. We also assume "std" is the
|
||||
standard library.
|
||||
|
||||
Misc notes:
|
||||
-----------
|
||||
|
||||
I use move mode arguments for ast nodes that will get inserted as is
|
||||
into the tree. This is intended to prevent us from inserting the same
|
||||
node twice.
|
||||
|
||||
*/
|
||||
|
||||
use base::*;
|
||||
use codemap::span;
|
||||
use std::map;
|
||||
use std::map::HashMap;
|
||||
|
||||
export expand_auto_serialize;
|
||||
export expand_auto_deserialize;
|
||||
|
||||
// Transitional reexports so qquote can find the paths it is looking for
|
||||
mod syntax {
|
||||
pub use ext;
|
||||
pub use parse;
|
||||
}
|
||||
|
||||
fn expand_auto_serialize(
|
||||
cx: ext_ctxt,
|
||||
span: span,
|
||||
_mitem: ast::meta_item,
|
||||
in_items: ~[@ast::item]
|
||||
) -> ~[@ast::item] {
|
||||
fn is_auto_serialize2(a: &ast::attribute) -> bool {
|
||||
attr::get_attr_name(*a) == ~"auto_serialize2"
|
||||
}
|
||||
|
||||
fn filter_attrs(item: @ast::item) -> @ast::item {
|
||||
@{attrs: vec::filter(item.attrs, |a| !is_auto_serialize2(a)),
|
||||
.. *item}
|
||||
}
|
||||
|
||||
do vec::flat_map(in_items) |item| {
|
||||
if item.attrs.any(is_auto_serialize2) {
|
||||
match item.node {
|
||||
ast::item_ty(@{node: ast::ty_rec(fields), _}, tps) => {
|
||||
let ser_impl = mk_rec_ser_impl(
|
||||
cx,
|
||||
item.span,
|
||||
item.ident,
|
||||
fields,
|
||||
tps
|
||||
);
|
||||
|
||||
~[filter_attrs(*item), ser_impl]
|
||||
},
|
||||
ast::item_class(@{ fields, _}, tps) => {
|
||||
let ser_impl = mk_struct_ser_impl(
|
||||
cx,
|
||||
item.span,
|
||||
item.ident,
|
||||
fields,
|
||||
tps
|
||||
);
|
||||
|
||||
~[filter_attrs(*item), ser_impl]
|
||||
},
|
||||
ast::item_enum(enum_def, tps) => {
|
||||
let ser_impl = mk_enum_ser_impl(
|
||||
cx,
|
||||
item.span,
|
||||
item.ident,
|
||||
enum_def,
|
||||
tps
|
||||
);
|
||||
|
||||
~[filter_attrs(*item), ser_impl]
|
||||
},
|
||||
_ => {
|
||||
cx.span_err(span, ~"#[auto_serialize2] can only be \
|
||||
applied to structs, record types, \
|
||||
and enum definitions");
|
||||
~[*item]
|
||||
}
|
||||
}
|
||||
} else {
|
||||
~[*item]
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn expand_auto_deserialize(
|
||||
cx: ext_ctxt,
|
||||
span: span,
|
||||
_mitem: ast::meta_item,
|
||||
in_items: ~[@ast::item]
|
||||
) -> ~[@ast::item] {
|
||||
fn is_auto_deserialize2(a: &ast::attribute) -> bool {
|
||||
attr::get_attr_name(*a) == ~"auto_deserialize2"
|
||||
}
|
||||
|
||||
fn filter_attrs(item: @ast::item) -> @ast::item {
|
||||
@{attrs: vec::filter(item.attrs, |a| !is_auto_deserialize2(a)),
|
||||
.. *item}
|
||||
}
|
||||
|
||||
do vec::flat_map(in_items) |item| {
|
||||
if item.attrs.any(is_auto_deserialize2) {
|
||||
match item.node {
|
||||
ast::item_ty(@{node: ast::ty_rec(fields), _}, tps) => {
|
||||
let deser_impl = mk_rec_deser_impl(
|
||||
cx,
|
||||
item.span,
|
||||
item.ident,
|
||||
fields,
|
||||
tps
|
||||
);
|
||||
|
||||
~[filter_attrs(*item), deser_impl]
|
||||
},
|
||||
ast::item_class(@{ fields, _}, tps) => {
|
||||
let deser_impl = mk_struct_deser_impl(
|
||||
cx,
|
||||
item.span,
|
||||
item.ident,
|
||||
fields,
|
||||
tps
|
||||
);
|
||||
|
||||
~[filter_attrs(*item), deser_impl]
|
||||
},
|
||||
ast::item_enum(enum_def, tps) => {
|
||||
let deser_impl = mk_enum_deser_impl(
|
||||
cx,
|
||||
item.span,
|
||||
item.ident,
|
||||
enum_def,
|
||||
tps
|
||||
);
|
||||
|
||||
~[filter_attrs(*item), deser_impl]
|
||||
},
|
||||
_ => {
|
||||
cx.span_err(span, ~"#[auto_deserialize2] can only be \
|
||||
applied to structs, record types, \
|
||||
and enum definitions");
|
||||
~[*item]
|
||||
}
|
||||
}
|
||||
} else {
|
||||
~[*item]
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn mk_impl(
|
||||
cx: ext_ctxt,
|
||||
span: span,
|
||||
ident: ast::ident,
|
||||
path: @ast::path,
|
||||
tps: ~[ast::ty_param],
|
||||
f: fn(@ast::ty) -> @ast::method
|
||||
) -> @ast::item {
|
||||
// All the type parameters need to bound to the trait.
|
||||
let trait_tps = do tps.map |tp| {
|
||||
let t_bound = ast::bound_trait(@{
|
||||
id: cx.next_id(),
|
||||
node: ast::ty_path(path, cx.next_id()),
|
||||
span: span,
|
||||
});
|
||||
|
||||
{
|
||||
ident: tp.ident,
|
||||
id: cx.next_id(),
|
||||
bounds: @vec::append(~[t_bound], *tp.bounds)
|
||||
}
|
||||
};
|
||||
|
||||
let opt_trait = Some(@{
|
||||
path: path,
|
||||
ref_id: cx.next_id(),
|
||||
impl_id: cx.next_id(),
|
||||
});
|
||||
|
||||
let ty = cx.ty_path(
|
||||
span,
|
||||
~[ident],
|
||||
tps.map(|tp| cx.ty_path(span, ~[tp.ident], ~[]))
|
||||
);
|
||||
|
||||
@{
|
||||
// This is a new-style impl declaration.
|
||||
// XXX: clownshoes
|
||||
ident: ast::token::special_idents::clownshoes_extensions,
|
||||
attrs: ~[],
|
||||
id: cx.next_id(),
|
||||
node: ast::item_impl(trait_tps, opt_trait, ty, ~[f(ty)]),
|
||||
vis: ast::public,
|
||||
span: span,
|
||||
}
|
||||
}
|
||||
|
||||
fn mk_ser_impl(
|
||||
cx: ext_ctxt,
|
||||
span: span,
|
||||
ident: ast::ident,
|
||||
tps: ~[ast::ty_param],
|
||||
body: @ast::expr
|
||||
) -> @ast::item {
|
||||
// Make a path to the std::serialization2::Serializable trait.
|
||||
let path = cx.path(
|
||||
span,
|
||||
~[
|
||||
cx.ident_of(~"std"),
|
||||
cx.ident_of(~"serialization2"),
|
||||
cx.ident_of(~"Serializable"),
|
||||
]
|
||||
);
|
||||
|
||||
mk_impl(
|
||||
cx,
|
||||
span,
|
||||
ident,
|
||||
path,
|
||||
tps,
|
||||
|_ty| mk_ser_method(cx, span, cx.expr_blk(body))
|
||||
)
|
||||
}
|
||||
|
||||
fn mk_deser_impl(
|
||||
cx: ext_ctxt,
|
||||
span: span,
|
||||
ident: ast::ident,
|
||||
tps: ~[ast::ty_param],
|
||||
body: @ast::expr
|
||||
) -> @ast::item {
|
||||
// Make a path to the std::serialization2::Deserializable trait.
|
||||
let path = cx.path(
|
||||
span,
|
||||
~[
|
||||
cx.ident_of(~"std"),
|
||||
cx.ident_of(~"serialization2"),
|
||||
cx.ident_of(~"Deserializable"),
|
||||
]
|
||||
);
|
||||
|
||||
mk_impl(
|
||||
cx,
|
||||
span,
|
||||
ident,
|
||||
path,
|
||||
tps,
|
||||
|ty| mk_deser_method(cx, span, ty, cx.expr_blk(body))
|
||||
)
|
||||
}
|
||||
|
||||
fn mk_ser_method(
|
||||
cx: ext_ctxt,
|
||||
span: span,
|
||||
ser_body: ast::blk
|
||||
) -> @ast::method {
|
||||
let ser_bound = cx.ty_path(
|
||||
span,
|
||||
~[
|
||||
cx.ident_of(~"std"),
|
||||
cx.ident_of(~"serialization2"),
|
||||
cx.ident_of(~"Serializer"),
|
||||
],
|
||||
~[]
|
||||
);
|
||||
|
||||
let ser_tps = ~[{
|
||||
ident: cx.ident_of(~"__S"),
|
||||
id: cx.next_id(),
|
||||
bounds: @~[ast::bound_trait(ser_bound)],
|
||||
}];
|
||||
|
||||
let ty_s = @{
|
||||
id: cx.next_id(),
|
||||
node: ast::ty_rptr(
|
||||
@{
|
||||
id: cx.next_id(),
|
||||
node: ast::re_anon,
|
||||
},
|
||||
{
|
||||
ty: cx.ty_path(span, ~[cx.ident_of(~"__S")], ~[]),
|
||||
mutbl: ast::m_imm
|
||||
}
|
||||
),
|
||||
span: span,
|
||||
};
|
||||
|
||||
let ser_inputs = ~[{
|
||||
mode: ast::infer(cx.next_id()),
|
||||
ty: ty_s,
|
||||
ident: cx.ident_of(~"__s"),
|
||||
id: cx.next_id(),
|
||||
}];
|
||||
|
||||
let ser_output = @{
|
||||
id: cx.next_id(),
|
||||
node: ast::ty_nil,
|
||||
span: span,
|
||||
};
|
||||
|
||||
let ser_decl = {
|
||||
inputs: ser_inputs,
|
||||
output: ser_output,
|
||||
cf: ast::return_val,
|
||||
};
|
||||
|
||||
@{
|
||||
ident: cx.ident_of(~"serialize"),
|
||||
attrs: ~[],
|
||||
tps: ser_tps,
|
||||
self_ty: { node: ast::sty_region(ast::m_imm), span: span },
|
||||
purity: ast::impure_fn,
|
||||
decl: ser_decl,
|
||||
body: ser_body,
|
||||
id: cx.next_id(),
|
||||
span: span,
|
||||
self_id: cx.next_id(),
|
||||
vis: ast::public,
|
||||
}
|
||||
}
|
||||
|
||||
fn mk_deser_method(
|
||||
cx: ext_ctxt,
|
||||
span: span,
|
||||
ty: @ast::ty,
|
||||
deser_body: ast::blk
|
||||
) -> @ast::method {
|
||||
let deser_bound = cx.ty_path(
|
||||
span,
|
||||
~[
|
||||
cx.ident_of(~"std"),
|
||||
cx.ident_of(~"serialization2"),
|
||||
cx.ident_of(~"Deserializer"),
|
||||
],
|
||||
~[]
|
||||
);
|
||||
|
||||
let deser_tps = ~[{
|
||||
ident: cx.ident_of(~"__D"),
|
||||
id: cx.next_id(),
|
||||
bounds: @~[ast::bound_trait(deser_bound)],
|
||||
}];
|
||||
|
||||
let ty_d = @{
|
||||
id: cx.next_id(),
|
||||
node: ast::ty_rptr(
|
||||
@{
|
||||
id: cx.next_id(),
|
||||
node: ast::re_anon,
|
||||
},
|
||||
{
|
||||
ty: cx.ty_path(span, ~[cx.ident_of(~"__D")], ~[]),
|
||||
mutbl: ast::m_imm
|
||||
}
|
||||
),
|
||||
span: span,
|
||||
};
|
||||
|
||||
let deser_inputs = ~[{
|
||||
mode: ast::infer(cx.next_id()),
|
||||
ty: ty_d,
|
||||
ident: cx.ident_of(~"__d"),
|
||||
id: cx.next_id(),
|
||||
}];
|
||||
|
||||
let deser_decl = {
|
||||
inputs: deser_inputs,
|
||||
output: ty,
|
||||
cf: ast::return_val,
|
||||
};
|
||||
|
||||
@{
|
||||
ident: cx.ident_of(~"deserialize"),
|
||||
attrs: ~[],
|
||||
tps: deser_tps,
|
||||
self_ty: { node: ast::sty_static, span: span },
|
||||
purity: ast::impure_fn,
|
||||
decl: deser_decl,
|
||||
body: deser_body,
|
||||
id: cx.next_id(),
|
||||
span: span,
|
||||
self_id: cx.next_id(),
|
||||
vis: ast::public,
|
||||
}
|
||||
}
|
||||
|
||||
fn mk_rec_ser_impl(
|
||||
cx: ext_ctxt,
|
||||
span: span,
|
||||
ident: ast::ident,
|
||||
fields: ~[ast::ty_field],
|
||||
tps: ~[ast::ty_param]
|
||||
) -> @ast::item {
|
||||
let fields = mk_ser_fields(cx, span, mk_rec_fields(fields));
|
||||
|
||||
// ast for `__s.emit_rec(|| $(fields))`
|
||||
let body = cx.expr_call(
|
||||
span,
|
||||
cx.expr_field(
|
||||
span,
|
||||
cx.expr_var(span, ~"__s"),
|
||||
cx.ident_of(~"emit_rec")
|
||||
),
|
||||
~[cx.lambda_stmts(span, fields)]
|
||||
);
|
||||
|
||||
mk_ser_impl(cx, span, ident, tps, body)
|
||||
}
|
||||
|
||||
fn mk_rec_deser_impl(
|
||||
cx: ext_ctxt,
|
||||
span: span,
|
||||
ident: ast::ident,
|
||||
fields: ~[ast::ty_field],
|
||||
tps: ~[ast::ty_param]
|
||||
) -> @ast::item {
|
||||
let fields = mk_deser_fields(cx, span, mk_rec_fields(fields));
|
||||
|
||||
// ast for `read_rec(|| $(fields))`
|
||||
let body = cx.expr_call(
|
||||
span,
|
||||
cx.expr_field(
|
||||
span,
|
||||
cx.expr_var(span, ~"__d"),
|
||||
cx.ident_of(~"read_rec")
|
||||
),
|
||||
~[
|
||||
cx.lambda_expr(
|
||||
cx.expr(
|
||||
span,
|
||||
ast::expr_rec(fields, None)
|
||||
)
|
||||
)
|
||||
]
|
||||
);
|
||||
|
||||
mk_deser_impl(cx, span, ident, tps, body)
|
||||
}
|
||||
|
||||
fn mk_struct_ser_impl(
|
||||
cx: ext_ctxt,
|
||||
span: span,
|
||||
ident: ast::ident,
|
||||
fields: ~[@ast::struct_field],
|
||||
tps: ~[ast::ty_param]
|
||||
) -> @ast::item {
|
||||
let fields = mk_ser_fields(cx, span, mk_struct_fields(fields));
|
||||
|
||||
// ast for `__s.emit_struct($(name), || $(fields))`
|
||||
let ser_body = cx.expr_call(
|
||||
span,
|
||||
cx.expr_field(
|
||||
span,
|
||||
cx.expr_var(span, ~"__s"),
|
||||
cx.ident_of(~"emit_struct")
|
||||
),
|
||||
~[
|
||||
cx.lit_str(span, @cx.str_of(ident)),
|
||||
cx.lambda_stmts(span, fields),
|
||||
]
|
||||
);
|
||||
|
||||
mk_ser_impl(cx, span, ident, tps, ser_body)
|
||||
}
|
||||
|
||||
fn mk_struct_deser_impl(
|
||||
cx: ext_ctxt,
|
||||
span: span,
|
||||
ident: ast::ident,
|
||||
fields: ~[@ast::struct_field],
|
||||
tps: ~[ast::ty_param]
|
||||
) -> @ast::item {
|
||||
let fields = mk_deser_fields(cx, span, mk_struct_fields(fields));
|
||||
|
||||
// ast for `read_struct($(name), || $(fields))`
|
||||
let body = cx.expr_call(
|
||||
span,
|
||||
cx.expr_field(
|
||||
span,
|
||||
cx.expr_var(span, ~"__d"),
|
||||
cx.ident_of(~"read_struct")
|
||||
),
|
||||
~[
|
||||
cx.lit_str(span, @cx.str_of(ident)),
|
||||
cx.lambda_expr(
|
||||
cx.expr(
|
||||
span,
|
||||
ast::expr_struct(
|
||||
cx.path(span, ~[ident]),
|
||||
fields,
|
||||
None
|
||||
)
|
||||
)
|
||||
),
|
||||
]
|
||||
);
|
||||
|
||||
mk_deser_impl(cx, span, ident, tps, body)
|
||||
}
|
||||
|
||||
// Records and structs don't have the same fields types, but they share enough
|
||||
// that if we extract the right subfields out we can share the serialization
|
||||
// generator code.
|
||||
type field = { span: span, ident: ast::ident, mutbl: ast::mutability };
|
||||
|
||||
fn mk_rec_fields(fields: ~[ast::ty_field]) -> ~[field] {
|
||||
do fields.map |field| {
|
||||
{
|
||||
span: field.span,
|
||||
ident: field.node.ident,
|
||||
mutbl: field.node.mt.mutbl,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn mk_struct_fields(fields: ~[@ast::struct_field]) -> ~[field] {
|
||||
do fields.map |field| {
|
||||
let (ident, mutbl) = match field.node.kind {
|
||||
ast::named_field(ident, mutbl, _) => (ident, mutbl),
|
||||
_ => fail ~"[auto_serialize2] does not support \
|
||||
unnamed fields",
|
||||
};
|
||||
|
||||
{
|
||||
span: field.span,
|
||||
ident: ident,
|
||||
mutbl: match mutbl {
|
||||
ast::class_mutable => ast::m_mutbl,
|
||||
ast::class_immutable => ast::m_imm,
|
||||
},
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn mk_ser_fields(
|
||||
cx: ext_ctxt,
|
||||
span: span,
|
||||
fields: ~[field]
|
||||
) -> ~[@ast::stmt] {
|
||||
do fields.mapi |idx, field| {
|
||||
// ast for `|| self.$(name).serialize(__s)`
|
||||
let expr_lambda = cx.lambda_expr(
|
||||
cx.expr_call(
|
||||
span,
|
||||
cx.expr_field(
|
||||
span,
|
||||
cx.expr_field(
|
||||
span,
|
||||
cx.expr_var(span, ~"self"),
|
||||
field.ident
|
||||
),
|
||||
cx.ident_of(~"serialize")
|
||||
),
|
||||
~[cx.expr_var(span, ~"__s")]
|
||||
)
|
||||
);
|
||||
|
||||
// ast for `__s.emit_field($(name), $(idx), $(expr_lambda))`
|
||||
cx.stmt(
|
||||
cx.expr_call(
|
||||
span,
|
||||
cx.expr_field(
|
||||
span,
|
||||
cx.expr_var(span, ~"__s"),
|
||||
cx.ident_of(~"emit_field")
|
||||
),
|
||||
~[
|
||||
cx.lit_str(span, @cx.str_of(field.ident)),
|
||||
cx.lit_uint(span, idx),
|
||||
expr_lambda,
|
||||
]
|
||||
)
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
fn mk_deser_fields(
|
||||
cx: ext_ctxt,
|
||||
span: span,
|
||||
fields: ~[{ span: span, ident: ast::ident, mutbl: ast::mutability }]
|
||||
) -> ~[ast::field] {
|
||||
do fields.mapi |idx, field| {
|
||||
// ast for `|| std::serialization2::deserialize(__d)`
|
||||
let expr_lambda = cx.lambda(
|
||||
cx.expr_blk(
|
||||
cx.expr_call(
|
||||
span,
|
||||
cx.expr_path(span, ~[
|
||||
cx.ident_of(~"std"),
|
||||
cx.ident_of(~"serialization2"),
|
||||
cx.ident_of(~"deserialize"),
|
||||
]),
|
||||
~[cx.expr_var(span, ~"__d")]
|
||||
)
|
||||
)
|
||||
);
|
||||
|
||||
// ast for `__d.read_field($(name), $(idx), $(expr_lambda))`
|
||||
let expr: @ast::expr = cx.expr_call(
|
||||
span,
|
||||
cx.expr_field(
|
||||
span,
|
||||
cx.expr_var(span, ~"__d"),
|
||||
cx.ident_of(~"read_field")
|
||||
),
|
||||
~[
|
||||
cx.lit_str(span, @cx.str_of(field.ident)),
|
||||
cx.lit_uint(span, idx),
|
||||
expr_lambda,
|
||||
]
|
||||
);
|
||||
|
||||
{
|
||||
node: { mutbl: field.mutbl, ident: field.ident, expr: expr },
|
||||
span: span,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn mk_enum_ser_impl(
|
||||
cx: ext_ctxt,
|
||||
span: span,
|
||||
ident: ast::ident,
|
||||
enum_def: ast::enum_def,
|
||||
tps: ~[ast::ty_param]
|
||||
) -> @ast::item {
|
||||
let body = mk_enum_ser_body(
|
||||
cx,
|
||||
span,
|
||||
ident,
|
||||
enum_def.variants
|
||||
);
|
||||
|
||||
mk_ser_impl(cx, span, ident, tps, body)
|
||||
}
|
||||
|
||||
fn mk_enum_deser_impl(
|
||||
cx: ext_ctxt,
|
||||
span: span,
|
||||
ident: ast::ident,
|
||||
enum_def: ast::enum_def,
|
||||
tps: ~[ast::ty_param]
|
||||
) -> @ast::item {
|
||||
let body = mk_enum_deser_body(
|
||||
cx,
|
||||
span,
|
||||
ident,
|
||||
enum_def.variants
|
||||
);
|
||||
|
||||
mk_deser_impl(cx, span, ident, tps, body)
|
||||
}
|
||||
|
||||
fn ser_variant(
|
||||
cx: ext_ctxt,
|
||||
span: span,
|
||||
v_name: ast::ident,
|
||||
v_idx: uint,
|
||||
args: ~[ast::variant_arg]
|
||||
) -> ast::arm {
|
||||
// Name the variant arguments.
|
||||
let names = args.mapi(|i, _arg| cx.ident_of(fmt!("__v%u", i)));
|
||||
|
||||
// Bind the names to the variant argument type.
|
||||
let pats = args.mapi(|i, arg| cx.binder_pat(arg.ty.span, names[i]));
|
||||
|
||||
let pat_node = if pats.is_empty() {
|
||||
ast::pat_ident(
|
||||
ast::bind_by_implicit_ref,
|
||||
cx.path(span, ~[v_name]),
|
||||
None
|
||||
)
|
||||
} else {
|
||||
ast::pat_enum(
|
||||
cx.path(span, ~[v_name]),
|
||||
Some(pats)
|
||||
)
|
||||
};
|
||||
|
||||
let pat = @{
|
||||
id: cx.next_id(),
|
||||
node: pat_node,
|
||||
span: span,
|
||||
};
|
||||
|
||||
let stmts = do args.mapi |a_idx, _arg| {
|
||||
// ast for `__s.emit_enum_variant_arg`
|
||||
let expr_emit = cx.expr_field(
|
||||
span,
|
||||
cx.expr_var(span, ~"__s"),
|
||||
cx.ident_of(~"emit_enum_variant_arg")
|
||||
);
|
||||
|
||||
// ast for `|| $(v).serialize(__s)`
|
||||
let expr_serialize = cx.lambda_expr(
|
||||
cx.expr_call(
|
||||
span,
|
||||
cx.expr_field(
|
||||
span,
|
||||
cx.expr_path(span, ~[names[a_idx]]),
|
||||
cx.ident_of(~"serialize")
|
||||
),
|
||||
~[cx.expr_var(span, ~"__s")]
|
||||
)
|
||||
);
|
||||
|
||||
// ast for `$(expr_emit)($(a_idx), $(expr_serialize))`
|
||||
cx.stmt(
|
||||
cx.expr_call(
|
||||
span,
|
||||
expr_emit,
|
||||
~[cx.lit_uint(span, a_idx), expr_serialize]
|
||||
)
|
||||
)
|
||||
};
|
||||
|
||||
// ast for `__s.emit_enum_variant($(name), $(idx), $(sz), $(lambda))`
|
||||
let body = cx.expr_call(
|
||||
span,
|
||||
cx.expr_field(
|
||||
span,
|
||||
cx.expr_var(span, ~"__s"),
|
||||
cx.ident_of(~"emit_enum_variant")
|
||||
),
|
||||
~[
|
||||
cx.lit_str(span, @cx.str_of(v_name)),
|
||||
cx.lit_uint(span, v_idx),
|
||||
cx.lit_uint(span, stmts.len()),
|
||||
cx.lambda_stmts(span, stmts),
|
||||
]
|
||||
);
|
||||
|
||||
{ pats: ~[pat], guard: None, body: cx.expr_blk(body) }
|
||||
}
|
||||
|
||||
fn mk_enum_ser_body(
|
||||
cx: ext_ctxt,
|
||||
span: span,
|
||||
name: ast::ident,
|
||||
variants: ~[ast::variant]
|
||||
) -> @ast::expr {
|
||||
let arms = do variants.mapi |v_idx, variant| {
|
||||
match variant.node.kind {
|
||||
ast::tuple_variant_kind(args) =>
|
||||
ser_variant(cx, span, variant.node.name, v_idx, args),
|
||||
ast::struct_variant_kind(*) =>
|
||||
fail ~"struct variants unimplemented",
|
||||
ast::enum_variant_kind(*) =>
|
||||
fail ~"enum variants unimplemented",
|
||||
}
|
||||
};
|
||||
|
||||
// ast for `match *self { $(arms) }`
|
||||
let match_expr = cx.expr(
|
||||
span,
|
||||
ast::expr_match(
|
||||
cx.expr(
|
||||
span,
|
||||
ast::expr_unary(ast::deref, cx.expr_var(span, ~"self"))
|
||||
),
|
||||
arms
|
||||
)
|
||||
);
|
||||
|
||||
// ast for `__s.emit_enum($(name), || $(match_expr))`
|
||||
cx.expr_call(
|
||||
span,
|
||||
cx.expr_field(
|
||||
span,
|
||||
cx.expr_var(span, ~"__s"),
|
||||
cx.ident_of(~"emit_enum")
|
||||
),
|
||||
~[
|
||||
cx.lit_str(span, @cx.str_of(name)),
|
||||
cx.lambda_expr(match_expr),
|
||||
]
|
||||
)
|
||||
}
|
||||
|
||||
fn mk_enum_deser_variant_nary(
|
||||
cx: ext_ctxt,
|
||||
span: span,
|
||||
name: ast::ident,
|
||||
args: ~[ast::variant_arg]
|
||||
) -> @ast::expr {
|
||||
let args = do args.mapi |idx, _arg| {
|
||||
// ast for `|| std::serialization2::deserialize(__d)`
|
||||
let expr_lambda = cx.lambda_expr(
|
||||
cx.expr_call(
|
||||
span,
|
||||
cx.expr_path(span, ~[
|
||||
cx.ident_of(~"std"),
|
||||
cx.ident_of(~"serialization2"),
|
||||
cx.ident_of(~"deserialize"),
|
||||
]),
|
||||
~[cx.expr_var(span, ~"__d")]
|
||||
)
|
||||
);
|
||||
|
||||
// ast for `__d.read_enum_variant_arg($(a_idx), $(expr_lambda))`
|
||||
cx.expr_call(
|
||||
span,
|
||||
cx.expr_field(
|
||||
span,
|
||||
cx.expr_var(span, ~"__d"),
|
||||
cx.ident_of(~"read_enum_variant_arg")
|
||||
),
|
||||
~[cx.lit_uint(span, idx), expr_lambda]
|
||||
)
|
||||
};
|
||||
|
||||
// ast for `$(name)($(args))`
|
||||
cx.expr_call(span, cx.expr_path(span, ~[name]), args)
|
||||
}
|
||||
|
||||
fn mk_enum_deser_body(
|
||||
cx: ext_ctxt,
|
||||
span: span,
|
||||
name: ast::ident,
|
||||
variants: ~[ast::variant]
|
||||
) -> @ast::expr {
|
||||
let mut arms = do variants.mapi |v_idx, variant| {
|
||||
let body = match variant.node.kind {
|
||||
ast::tuple_variant_kind(args) => {
|
||||
if args.is_empty() {
|
||||
// for a nullary variant v, do "v"
|
||||
cx.expr_path(span, ~[variant.node.name])
|
||||
} else {
|
||||
// for an n-ary variant v, do "v(a_1, ..., a_n)"
|
||||
mk_enum_deser_variant_nary(
|
||||
cx,
|
||||
span,
|
||||
variant.node.name,
|
||||
args
|
||||
)
|
||||
}
|
||||
},
|
||||
ast::struct_variant_kind(*) =>
|
||||
fail ~"struct variants unimplemented",
|
||||
ast::enum_variant_kind(*) =>
|
||||
fail ~"enum variants unimplemented",
|
||||
};
|
||||
|
||||
let pat = @{
|
||||
id: cx.next_id(),
|
||||
node: ast::pat_lit(cx.lit_uint(span, v_idx)),
|
||||
span: span,
|
||||
};
|
||||
|
||||
{
|
||||
pats: ~[pat],
|
||||
guard: None,
|
||||
body: cx.expr_blk(body),
|
||||
}
|
||||
};
|
||||
|
||||
let impossible_case = {
|
||||
pats: ~[@{ id: cx.next_id(), node: ast::pat_wild, span: span}],
|
||||
guard: None,
|
||||
|
||||
// FIXME(#3198): proper error message
|
||||
body: cx.expr_blk(cx.expr(span, ast::expr_fail(None))),
|
||||
};
|
||||
|
||||
arms.push(impossible_case);
|
||||
|
||||
// ast for `|i| { match i { $(arms) } }`
|
||||
let expr_lambda = cx.expr(
|
||||
span,
|
||||
ast::expr_fn_block(
|
||||
{
|
||||
inputs: ~[{
|
||||
mode: ast::infer(cx.next_id()),
|
||||
ty: @{
|
||||
id: cx.next_id(),
|
||||
node: ast::ty_infer,
|
||||
span: span
|
||||
},
|
||||
ident: cx.ident_of(~"i"),
|
||||
id: cx.next_id(),
|
||||
}],
|
||||
output: @{
|
||||
id: cx.next_id(),
|
||||
node: ast::ty_infer,
|
||||
span: span,
|
||||
},
|
||||
cf: ast::return_val,
|
||||
},
|
||||
cx.expr_blk(
|
||||
cx.expr(
|
||||
span,
|
||||
ast::expr_match(cx.expr_var(span, ~"i"), arms)
|
||||
)
|
||||
),
|
||||
@~[]
|
||||
)
|
||||
);
|
||||
|
||||
// ast for `__d.read_enum_variant($(expr_lambda))`
|
||||
let expr_lambda = cx.lambda_expr(
|
||||
cx.expr_call(
|
||||
span,
|
||||
cx.expr_field(
|
||||
span,
|
||||
cx.expr_var(span, ~"__d"),
|
||||
cx.ident_of(~"read_enum_variant")
|
||||
),
|
||||
~[expr_lambda]
|
||||
)
|
||||
);
|
||||
|
||||
// ast for `__d.read_enum($(e_name), $(expr_lambda))`
|
||||
cx.expr_call(
|
||||
span,
|
||||
cx.expr_field(
|
||||
span,
|
||||
cx.expr_var(span, ~"__d"),
|
||||
cx.ident_of(~"read_enum")
|
||||
),
|
||||
~[
|
||||
cx.lit_str(span, @cx.str_of(name)),
|
||||
expr_lambda
|
||||
]
|
||||
)
|
||||
}
|
||||
|
|
@ -54,7 +54,7 @@ enum syntax_extension {
|
|||
// macro_defining() is obsolete, remove when #old_macros go away.
|
||||
macro_defining(macro_definer),
|
||||
|
||||
// #[auto_serialize2] and such. will probably survive death of #old_macros
|
||||
// #[auto_serialize] and such. will probably survive death of #old_macros
|
||||
item_decorator(item_decorator),
|
||||
|
||||
// Token-tree expanders
|
||||
|
|
@ -64,65 +64,6 @@ enum syntax_extension {
|
|||
|
||||
// A temporary hard-coded map of methods for expanding syntax extension
|
||||
// AST nodes into full ASTs
|
||||
#[cfg(stage0)]
|
||||
fn syntax_expander_table() -> HashMap<~str, syntax_extension> {
|
||||
fn builtin(f: syntax_expander_) -> syntax_extension
|
||||
{normal({expander: f, span: None})}
|
||||
fn builtin_expr_tt(f: syntax_expander_tt_) -> syntax_extension {
|
||||
expr_tt({expander: f, span: None})
|
||||
}
|
||||
fn builtin_item_tt(f: syntax_expander_tt_item_) -> syntax_extension {
|
||||
item_tt({expander: f, span: None})
|
||||
}
|
||||
let syntax_expanders = HashMap();
|
||||
syntax_expanders.insert(~"macro",
|
||||
macro_defining(ext::simplext::add_new_extension));
|
||||
syntax_expanders.insert(~"macro_rules",
|
||||
builtin_item_tt(
|
||||
ext::tt::macro_rules::add_new_extension));
|
||||
syntax_expanders.insert(~"fmt", builtin(ext::fmt::expand_syntax_ext));
|
||||
syntax_expanders.insert(
|
||||
~"auto_serialize2",
|
||||
item_decorator(ext::auto_serialize2::expand_auto_serialize));
|
||||
syntax_expanders.insert(
|
||||
~"auto_deserialize2",
|
||||
item_decorator(ext::auto_serialize2::expand_auto_deserialize));
|
||||
syntax_expanders.insert(~"env", builtin(ext::env::expand_syntax_ext));
|
||||
syntax_expanders.insert(~"concat_idents",
|
||||
builtin(ext::concat_idents::expand_syntax_ext));
|
||||
syntax_expanders.insert(~"ident_to_str",
|
||||
builtin(ext::ident_to_str::expand_syntax_ext));
|
||||
syntax_expanders.insert(~"log_syntax",
|
||||
builtin_expr_tt(
|
||||
ext::log_syntax::expand_syntax_ext));
|
||||
syntax_expanders.insert(~"ast",
|
||||
builtin(ext::qquote::expand_ast));
|
||||
syntax_expanders.insert(~"line",
|
||||
builtin(ext::source_util::expand_line));
|
||||
syntax_expanders.insert(~"col",
|
||||
builtin(ext::source_util::expand_col));
|
||||
syntax_expanders.insert(~"file",
|
||||
builtin(ext::source_util::expand_file));
|
||||
syntax_expanders.insert(~"stringify",
|
||||
builtin(ext::source_util::expand_stringify));
|
||||
syntax_expanders.insert(~"include",
|
||||
builtin(ext::source_util::expand_include));
|
||||
syntax_expanders.insert(~"include_str",
|
||||
builtin(ext::source_util::expand_include_str));
|
||||
syntax_expanders.insert(~"include_bin",
|
||||
builtin(ext::source_util::expand_include_bin));
|
||||
syntax_expanders.insert(~"module_path",
|
||||
builtin(ext::source_util::expand_mod));
|
||||
syntax_expanders.insert(~"proto",
|
||||
builtin_item_tt(ext::pipes::expand_proto));
|
||||
syntax_expanders.insert(
|
||||
~"trace_macros",
|
||||
builtin_expr_tt(ext::trace_macros::expand_trace_macros));
|
||||
return syntax_expanders;
|
||||
}
|
||||
|
||||
#[cfg(stage1)]
|
||||
#[cfg(stage2)]
|
||||
fn syntax_expander_table() -> HashMap<~str, syntax_extension> {
|
||||
fn builtin(f: syntax_expander_) -> syntax_extension
|
||||
{normal({expander: f, span: None})}
|
||||
|
|
|
|||
|
|
@ -124,7 +124,7 @@ fn expand_expr(exts: HashMap<~str, syntax_extension>, cx: ext_ctxt,
|
|||
}
|
||||
|
||||
// This is a secondary mechanism for invoking syntax extensions on items:
|
||||
// "decorator" attributes, such as #[auto_serialize2]. These are invoked by an
|
||||
// "decorator" attributes, such as #[auto_serialize]. These are invoked by an
|
||||
// attribute prefixing an item, and are interpreted by feeding the item
|
||||
// through the named attribute _as a syntax extension_ and splicing in the
|
||||
// resulting item vec into place in favour of the decorator. Note that
|
||||
|
|
|
|||
|
|
@ -4,8 +4,6 @@ use std::map::HashMap;
|
|||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
enum binop {
|
||||
PLUS,
|
||||
MINUS,
|
||||
|
|
@ -21,8 +19,6 @@ enum binop {
|
|||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
enum token {
|
||||
/* Expression-operator symbols. */
|
||||
EQ,
|
||||
|
|
@ -81,8 +77,6 @@ enum token {
|
|||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
/// For interpolation during macro expansion.
|
||||
enum nonterminal {
|
||||
nt_item(@ast::item),
|
||||
|
|
|
|||
|
|
@ -130,9 +130,6 @@ mod ext {
|
|||
mod log_syntax;
|
||||
#[legacy_exports]
|
||||
mod auto_serialize;
|
||||
#[cfg(stage0)]
|
||||
#[legacy_exports]
|
||||
mod auto_serialize2;
|
||||
#[legacy_exports]
|
||||
mod source_util;
|
||||
|
||||
|
|
|
|||
|
|
@ -18,8 +18,6 @@ export has_freevars;
|
|||
// (The def_upvar will already have been stripped).
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
type freevar_entry = {
|
||||
def: ast::def, //< The variable being accessed free.
|
||||
span: span //< First span where it is accessed (there can be multiple)
|
||||
|
|
|
|||
|
|
@ -213,8 +213,6 @@ type mt = {ty: t, mutbl: ast::mutability};
|
|||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
enum vstore {
|
||||
vstore_fixed(uint),
|
||||
vstore_uniq,
|
||||
|
|
@ -275,8 +273,6 @@ type opt_region_variance = Option<region_variance>;
|
|||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
enum region_variance { rv_covariant, rv_invariant, rv_contravariant }
|
||||
|
||||
impl region_variance : cmp::Eq {
|
||||
|
|
@ -295,8 +291,6 @@ impl region_variance : cmp::Eq {
|
|||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
type AutoAdjustment = {
|
||||
autoderefs: uint,
|
||||
autoref: Option<AutoRef>
|
||||
|
|
@ -304,8 +298,6 @@ type AutoAdjustment = {
|
|||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
type AutoRef = {
|
||||
kind: AutoRefKind,
|
||||
region: region,
|
||||
|
|
@ -314,8 +306,6 @@ type AutoRef = {
|
|||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
enum AutoRefKind {
|
||||
/// Convert from @[]/~[] to &[] (or str)
|
||||
AutoSlice,
|
||||
|
|
@ -521,8 +511,6 @@ impl param_ty : to_bytes::IterBytes {
|
|||
/// Representation of regions:
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
enum region {
|
||||
/// Bound regions are found (primarily) in function types. They indicate
|
||||
/// region parameters that have yet to be replaced with actual regions
|
||||
|
|
@ -552,8 +540,6 @@ enum region {
|
|||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
enum bound_region {
|
||||
/// The self region for classes, impls (&T in a type defn or &self/T)
|
||||
br_self,
|
||||
|
|
@ -685,8 +671,6 @@ enum IntVid = uint;
|
|||
enum FnVid = uint;
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
enum RegionVid = uint;
|
||||
|
||||
enum InferTy {
|
||||
|
|
|
|||
|
|
@ -77,8 +77,6 @@ export provided_methods_map;
|
|||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
enum method_origin {
|
||||
// fully statically resolved method
|
||||
method_static(ast::def_id),
|
||||
|
|
@ -97,8 +95,6 @@ enum method_origin {
|
|||
// with a bounded trait.
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
#[auto_serialize2]
|
||||
#[auto_deserialize2]
|
||||
type method_param = {
|
||||
// the trait containing the method to be invoked
|
||||
trait_id: ast::def_id,
|
||||
|
|
|
|||
Loading…
Reference in a new issue