auto merge of #6502 : huonw/rust/no-auto-code, r=graydon
Replace all instances of #[auto_*code] with the appropriate #[deriving] attribute and remove the majority of the actual auto_* code, leaving stubs to refer the user to the new syntax. Also, moves the useful contents of auto_encode.rs to more appropriate spots: tests and comments to deriving/encodable.rs, and the ExtCtxtMethods trait to build.rs (unused so far, but the method syntax might be nicer than using the mk_* fns in many instances).
This commit is contained in:
bors
commit
8257528b6c
@ -20,8 +20,7 @@ use syntax::{ast, ast_util, visit};
|
||||
|
||||
// A vector of defs representing the free variables referred to in a function.
|
||||
// (The def_upvar will already have been stripped).
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Encodable, Decodable)]
|
||||
pub struct freevar_entry {
|
||||
def: ast::def, //< The variable being accessed free.
|
||||
span: span //< First span where it is accessed (there can be multiple)
|
||||
|
||||
@ -221,16 +221,14 @@ use syntax::visit::vt;
|
||||
use syntax::print::pprust;
|
||||
use syntax::codemap::span;
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Encodable, Decodable)]
|
||||
pub enum CaptureMode {
|
||||
CapCopy, // Copy the value into the closure.
|
||||
CapMove, // Move the value into the closure.
|
||||
CapRef, // Reference directly from parent stack frame (used by `&fn()`).
|
||||
}
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Encodable, Decodable)]
|
||||
pub struct CaptureVar {
|
||||
def: def, // Variable being accessed free
|
||||
span: span, // Location of an access to this variable
|
||||
|
||||
@ -96,9 +96,7 @@ pub struct mt {
|
||||
mutbl: ast::mutability,
|
||||
}
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub enum vstore {
|
||||
vstore_fixed(uint),
|
||||
vstore_uniq,
|
||||
@ -106,9 +104,7 @@ pub enum vstore {
|
||||
vstore_slice(Region)
|
||||
}
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq, IterBytes)]
|
||||
#[deriving(Eq, IterBytes, Encodable, Decodable)]
|
||||
pub enum TraitStore {
|
||||
BoxTraitStore, // @Trait
|
||||
UniqTraitStore, // ~Trait
|
||||
@ -117,9 +113,7 @@ pub enum TraitStore {
|
||||
|
||||
// XXX: This should probably go away at some point. Maybe after destructors
|
||||
// do?
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub enum SelfMode {
|
||||
ByCopy,
|
||||
ByRef,
|
||||
@ -197,27 +191,22 @@ pub enum ast_ty_to_ty_cache_entry {
|
||||
|
||||
pub type opt_region_variance = Option<region_variance>;
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Decodable, Encodable)]
|
||||
pub enum region_variance { rv_covariant, rv_invariant, rv_contravariant }
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Decodable, Encodable)]
|
||||
pub enum AutoAdjustment {
|
||||
AutoAddEnv(ty::Region, ast::Sigil),
|
||||
AutoDerefRef(AutoDerefRef)
|
||||
}
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Decodable, Encodable)]
|
||||
pub struct AutoDerefRef {
|
||||
autoderefs: uint,
|
||||
autoref: Option<AutoRef>
|
||||
}
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Decodable, Encodable)]
|
||||
pub enum AutoRef {
|
||||
/// Convert from T to &T
|
||||
AutoPtr(Region, ast::mutability),
|
||||
@ -453,9 +442,7 @@ pub struct param_ty {
|
||||
}
|
||||
|
||||
/// Representation of regions:
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq, IterBytes)]
|
||||
#[deriving(Eq, IterBytes, Encodable, Decodable)]
|
||||
pub enum Region {
|
||||
/// Bound regions are found (primarily) in function types. They indicate
|
||||
/// region parameters that have yet to be replaced with actual regions
|
||||
@ -501,17 +488,13 @@ pub impl Region {
|
||||
}
|
||||
}
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq, IterBytes)]
|
||||
#[deriving(Eq, IterBytes, Encodable, Decodable)]
|
||||
pub struct FreeRegion {
|
||||
scope_id: node_id,
|
||||
bound_region: bound_region
|
||||
}
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq, IterBytes)]
|
||||
#[deriving(Eq, IterBytes, Encodable, Decodable)]
|
||||
pub enum bound_region {
|
||||
/// The self region for structs, impls (&T in a type defn or &'self T)
|
||||
br_self,
|
||||
@ -742,9 +725,7 @@ pub struct IntVid(uint);
|
||||
#[deriving(Eq)]
|
||||
pub struct FloatVid(uint);
|
||||
|
||||
#[deriving(Eq)]
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub struct RegionVid {
|
||||
id: uint
|
||||
}
|
||||
@ -777,8 +758,7 @@ impl to_bytes::IterBytes for InferTy {
|
||||
}
|
||||
}
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Encodable, Decodable)]
|
||||
pub enum InferRegion {
|
||||
ReVar(RegionVid),
|
||||
ReSkolemized(uint, bound_region)
|
||||
|
||||
@ -73,8 +73,7 @@ pub mod infer;
|
||||
pub mod collect;
|
||||
pub mod coherence;
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Encodable, Decodable)]
|
||||
pub enum method_origin {
|
||||
// supertrait method invoked on "self" inside a default method
|
||||
// first field is supertrait ID;
|
||||
@ -98,8 +97,7 @@ pub enum method_origin {
|
||||
|
||||
// details for a method invoked with a receiver whose type is a type parameter
|
||||
// with a bounded trait.
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Encodable, Decodable)]
|
||||
pub struct method_param {
|
||||
// the trait containing the method to be invoked
|
||||
trait_id: ast::def_id,
|
||||
|
||||
@ -1331,26 +1331,20 @@ mod tests {
|
||||
|
||||
use std::serialize::Decodable;
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
enum Animal {
|
||||
Dog,
|
||||
Frog(~str, int)
|
||||
}
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
struct Inner {
|
||||
a: (),
|
||||
b: uint,
|
||||
c: ~[~str],
|
||||
}
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
struct Outer {
|
||||
inner: ~[Inner],
|
||||
}
|
||||
|
||||
@ -29,9 +29,7 @@ pub mod rustrt {
|
||||
}
|
||||
|
||||
/// A record specifying a time value in seconds and nanoseconds.
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub struct Timespec { sec: i64, nsec: i32 }
|
||||
|
||||
/*
|
||||
@ -100,9 +98,7 @@ pub fn tzset() {
|
||||
}
|
||||
}
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub struct Tm {
|
||||
tm_sec: i32, // seconds after the minute ~[0-60]
|
||||
tm_min: i32, // minutes after the hour ~[0-59]
|
||||
|
||||
@ -92,9 +92,7 @@ use core::util::replace;
|
||||
*
|
||||
*/
|
||||
|
||||
#[deriving(Eq)]
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
struct WorkKey {
|
||||
kind: ~str,
|
||||
name: ~str
|
||||
|
||||
@ -58,9 +58,7 @@ enum AbiArchitecture {
|
||||
Archs(u32) // Multiple architectures (bitset)
|
||||
}
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub struct AbiSet {
|
||||
priv bits: u32 // each bit represents one of the abis below
|
||||
}
|
||||
|
||||
@ -47,9 +47,7 @@ pub type SyntaxContext = uint;
|
||||
pub type SCTable = ~[SyntaxContext_];
|
||||
pub static empty_ctxt : uint = 0;
|
||||
|
||||
#[deriving(Eq)]
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub enum SyntaxContext_ {
|
||||
EmptyCtxt,
|
||||
Mark (Mrk,SyntaxContext),
|
||||
@ -115,9 +113,7 @@ impl to_bytes::IterBytes for ident {
|
||||
// Functions may or may not have names.
|
||||
pub type fn_ident = Option<ident>;
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub struct Lifetime {
|
||||
id: node_id,
|
||||
span: span,
|
||||
@ -142,9 +138,7 @@ impl to_bytes::IterBytes for Lifetime {
|
||||
// for instance: core::cmp::Eq . It's represented
|
||||
// as a sequence of identifiers, along with a bunch
|
||||
// of supporting information.
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub struct Path {
|
||||
span: span,
|
||||
global: bool,
|
||||
@ -157,9 +151,7 @@ pub type crate_num = int;
|
||||
|
||||
pub type node_id = int;
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub struct def_id {
|
||||
crate: crate_num,
|
||||
node: node_id,
|
||||
@ -168,9 +160,7 @@ pub struct def_id {
|
||||
pub static local_crate: crate_num = 0;
|
||||
pub static crate_node_id: node_id = 0;
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
// The AST represents all type param bounds as types.
|
||||
// typeck::collect::compute_bounds matches these against
|
||||
// the "special" built-in traits (see middle::lang_items) and
|
||||
@ -180,18 +170,14 @@ pub enum TyParamBound {
|
||||
RegionTyParamBound
|
||||
}
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub struct TyParam {
|
||||
ident: ident,
|
||||
id: node_id,
|
||||
bounds: @OptVec<TyParamBound>
|
||||
}
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub struct Generics {
|
||||
lifetimes: OptVec<Lifetime>,
|
||||
ty_params: OptVec<TyParam>
|
||||
@ -209,9 +195,7 @@ pub impl Generics {
|
||||
}
|
||||
}
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub enum def {
|
||||
def_fn(def_id, purity),
|
||||
def_static_method(/* method */ def_id,
|
||||
@ -248,9 +232,7 @@ pub type crate_cfg = ~[@meta_item];
|
||||
|
||||
pub type crate = spanned<crate_>;
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub struct crate_ {
|
||||
module: _mod,
|
||||
attrs: ~[attribute],
|
||||
@ -259,9 +241,7 @@ pub struct crate_ {
|
||||
|
||||
pub type meta_item = spanned<meta_item_>;
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub enum meta_item_ {
|
||||
meta_word(@~str),
|
||||
meta_list(@~str, ~[@meta_item]),
|
||||
@ -270,9 +250,7 @@ pub enum meta_item_ {
|
||||
|
||||
pub type blk = spanned<blk_>;
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub struct blk_ {
|
||||
view_items: ~[@view_item],
|
||||
stmts: ~[@stmt],
|
||||
@ -281,26 +259,20 @@ pub struct blk_ {
|
||||
rules: blk_check_mode,
|
||||
}
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub struct pat {
|
||||
id: node_id,
|
||||
node: pat_,
|
||||
span: span,
|
||||
}
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub struct field_pat {
|
||||
ident: ident,
|
||||
pat: @pat,
|
||||
}
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub enum binding_mode {
|
||||
bind_by_copy,
|
||||
bind_by_ref(mutability),
|
||||
@ -334,9 +306,7 @@ impl to_bytes::IterBytes for binding_mode {
|
||||
}
|
||||
}
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub enum pat_ {
|
||||
pat_wild,
|
||||
// A pat_ident may either be a new bound variable,
|
||||
@ -361,9 +331,7 @@ pub enum pat_ {
|
||||
pat_vec(~[@pat], Option<@pat>, ~[@pat])
|
||||
}
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub enum mutability { m_mutbl, m_imm, m_const, }
|
||||
|
||||
#[cfg(stage0)]
|
||||
@ -379,9 +347,7 @@ impl to_bytes::IterBytes for mutability {
|
||||
}
|
||||
}
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub enum Sigil {
|
||||
BorrowedSigil,
|
||||
OwnedSigil,
|
||||
@ -411,9 +377,7 @@ impl ToStr for Sigil {
|
||||
}
|
||||
}
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub enum vstore {
|
||||
// FIXME (#3469): Change uint to @expr (actually only constant exprs)
|
||||
vstore_fixed(Option<uint>), // [1,2,3,4]
|
||||
@ -422,9 +386,7 @@ pub enum vstore {
|
||||
vstore_slice(Option<@Lifetime>) // &'foo? [1,2,3,4]
|
||||
}
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub enum expr_vstore {
|
||||
expr_vstore_uniq, // ~[1,2,3,4]
|
||||
expr_vstore_box, // @[1,2,3,4]
|
||||
@ -433,9 +395,7 @@ pub enum expr_vstore {
|
||||
expr_vstore_mut_slice, // &mut [1,2,3,4]
|
||||
}
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub enum binop {
|
||||
add,
|
||||
subtract,
|
||||
@ -457,9 +417,7 @@ pub enum binop {
|
||||
gt,
|
||||
}
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub enum unop {
|
||||
box(mutability),
|
||||
uniq(mutability),
|
||||
@ -470,9 +428,7 @@ pub enum unop {
|
||||
|
||||
pub type stmt = spanned<stmt_>;
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub enum stmt_ {
|
||||
stmt_decl(@decl, node_id),
|
||||
|
||||
@ -488,9 +444,7 @@ pub enum stmt_ {
|
||||
|
||||
// FIXME (pending discussion of #1697, #2178...): local should really be
|
||||
// a refinement on pat.
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub struct local_ {
|
||||
is_mutbl: bool,
|
||||
ty: @Ty,
|
||||
@ -503,23 +457,17 @@ pub type local = spanned<local_>;
|
||||
|
||||
pub type decl = spanned<decl_>;
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub enum decl_ { decl_local(~[@local]), decl_item(@item), }
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub struct arm {
|
||||
pats: ~[@pat],
|
||||
guard: Option<@expr>,
|
||||
body: blk,
|
||||
}
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub struct field_ {
|
||||
mutbl: mutability,
|
||||
ident: ident,
|
||||
@ -528,14 +476,10 @@ pub struct field_ {
|
||||
|
||||
pub type field = spanned<field_>;
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub enum blk_check_mode { default_blk, unsafe_blk, }
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub struct expr {
|
||||
id: node_id,
|
||||
// Extra node ID is only used for index, assign_op, unary, binary, method
|
||||
@ -545,18 +489,14 @@ pub struct expr {
|
||||
span: span,
|
||||
}
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub enum CallSugar {
|
||||
NoSugar,
|
||||
DoSugar,
|
||||
ForSugar
|
||||
}
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub enum expr_ {
|
||||
expr_vstore(@expr, expr_vstore),
|
||||
expr_vec(~[@expr], mutability),
|
||||
@ -627,9 +567,7 @@ pub enum expr_ {
|
||||
// else knows what to do with them, so you'll probably get a syntax
|
||||
// error.
|
||||
//
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
#[doc="For macro invocations; parsing is delegated to the macro"]
|
||||
pub enum token_tree {
|
||||
// a single token
|
||||
@ -702,9 +640,7 @@ pub enum token_tree {
|
||||
//
|
||||
pub type matcher = spanned<matcher_>;
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub enum matcher_ {
|
||||
// match one token
|
||||
match_tok(::parse::token::Token),
|
||||
@ -717,18 +653,14 @@ pub enum matcher_ {
|
||||
|
||||
pub type mac = spanned<mac_>;
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub enum mac_ {
|
||||
mac_invoc_tt(@Path,~[token_tree]), // new macro-invocation
|
||||
}
|
||||
|
||||
pub type lit = spanned<lit_>;
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub enum lit_ {
|
||||
lit_str(@~str),
|
||||
lit_int(i64, int_ty),
|
||||
@ -742,17 +674,13 @@ pub enum lit_ {
|
||||
|
||||
// NB: If you change this, you'll probably want to change the corresponding
|
||||
// type structure in middle/ty.rs as well.
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub struct mt {
|
||||
ty: @Ty,
|
||||
mutbl: mutability,
|
||||
}
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub struct ty_field_ {
|
||||
ident: ident,
|
||||
mt: mt,
|
||||
@ -760,9 +688,7 @@ pub struct ty_field_ {
|
||||
|
||||
pub type ty_field = spanned<ty_field_>;
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub struct ty_method {
|
||||
ident: ident,
|
||||
attrs: ~[attribute],
|
||||
@ -774,9 +700,7 @@ pub struct ty_method {
|
||||
span: span,
|
||||
}
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
// A trait method is either required (meaning it doesn't have an
|
||||
// implementation, just a signature) or provided (meaning it has a default
|
||||
// implementation).
|
||||
@ -785,9 +709,7 @@ pub enum trait_method {
|
||||
provided(@method),
|
||||
}
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub enum int_ty { ty_i, ty_char, ty_i8, ty_i16, ty_i32, ty_i64, }
|
||||
|
||||
impl ToStr for int_ty {
|
||||
@ -809,9 +731,7 @@ impl to_bytes::IterBytes for int_ty {
|
||||
}
|
||||
}
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub enum uint_ty { ty_u, ty_u8, ty_u16, ty_u32, ty_u64, }
|
||||
|
||||
impl ToStr for uint_ty {
|
||||
@ -833,9 +753,7 @@ impl to_bytes::IterBytes for uint_ty {
|
||||
}
|
||||
}
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub enum float_ty { ty_f, ty_f32, ty_f64, }
|
||||
|
||||
impl ToStr for float_ty {
|
||||
@ -858,9 +776,7 @@ impl to_bytes::IterBytes for float_ty {
|
||||
}
|
||||
|
||||
// NB Eq method appears below.
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub struct Ty {
|
||||
id: node_id,
|
||||
node: ty_,
|
||||
@ -868,9 +784,7 @@ pub struct Ty {
|
||||
}
|
||||
|
||||
// Not represented directly in the AST, referred to by name through a ty_path.
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub enum prim_ty {
|
||||
ty_int(int_ty),
|
||||
ty_uint(uint_ty),
|
||||
@ -879,9 +793,7 @@ pub enum prim_ty {
|
||||
ty_bool,
|
||||
}
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub enum Onceness {
|
||||
Once,
|
||||
Many
|
||||
@ -909,9 +821,7 @@ impl to_bytes::IterBytes for Onceness {
|
||||
}
|
||||
}
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub struct TyClosure {
|
||||
sigil: Sigil,
|
||||
region: Option<@Lifetime>,
|
||||
@ -921,9 +831,7 @@ pub struct TyClosure {
|
||||
decl: fn_decl
|
||||
}
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub struct TyBareFn {
|
||||
purity: purity,
|
||||
abis: AbiSet,
|
||||
@ -931,9 +839,7 @@ pub struct TyBareFn {
|
||||
decl: fn_decl
|
||||
}
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub enum ty_ {
|
||||
ty_nil,
|
||||
ty_bot, /* bottom type */
|
||||
@ -967,17 +873,13 @@ impl to_bytes::IterBytes for Ty {
|
||||
}
|
||||
}
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub enum asm_dialect {
|
||||
asm_att,
|
||||
asm_intel
|
||||
}
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub struct inline_asm {
|
||||
asm: @~str,
|
||||
clobbers: @~str,
|
||||
@ -988,9 +890,7 @@ pub struct inline_asm {
|
||||
dialect: asm_dialect
|
||||
}
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub struct arg {
|
||||
is_mutbl: bool,
|
||||
ty: @Ty,
|
||||
@ -998,18 +898,14 @@ pub struct arg {
|
||||
id: node_id,
|
||||
}
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub struct fn_decl {
|
||||
inputs: ~[arg],
|
||||
output: @Ty,
|
||||
cf: ret_style,
|
||||
}
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub enum purity {
|
||||
pure_fn, // declared with "pure fn"
|
||||
unsafe_fn, // declared with "unsafe fn"
|
||||
@ -1041,9 +937,7 @@ impl to_bytes::IterBytes for purity {
|
||||
}
|
||||
}
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub enum ret_style {
|
||||
noreturn, // functions with return type _|_ that always
|
||||
// raise an error or exit (i.e. never return to the caller)
|
||||
@ -1063,9 +957,7 @@ impl to_bytes::IterBytes for ret_style {
|
||||
}
|
||||
}
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub enum explicit_self_ {
|
||||
sty_static, // no self
|
||||
sty_value, // `self`
|
||||
@ -1102,9 +994,7 @@ impl to_bytes::IterBytes for explicit_self_ {
|
||||
|
||||
pub type explicit_self = spanned<explicit_self_>;
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub struct method {
|
||||
ident: ident,
|
||||
attrs: ~[attribute],
|
||||
@ -1119,23 +1009,17 @@ pub struct method {
|
||||
vis: visibility,
|
||||
}
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub struct _mod {
|
||||
view_items: ~[@view_item],
|
||||
items: ~[@item],
|
||||
}
|
||||
|
||||
// Foreign mods can be named or anonymous
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub enum foreign_mod_sort { named, anonymous }
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub struct foreign_mod {
|
||||
sort: foreign_mod_sort,
|
||||
abis: AbiSet,
|
||||
@ -1143,32 +1027,24 @@ pub struct foreign_mod {
|
||||
items: ~[@foreign_item],
|
||||
}
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub struct variant_arg {
|
||||
ty: @Ty,
|
||||
id: node_id,
|
||||
}
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub enum variant_kind {
|
||||
tuple_variant_kind(~[variant_arg]),
|
||||
struct_variant_kind(@struct_def),
|
||||
}
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub struct enum_def {
|
||||
variants: ~[variant],
|
||||
}
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub struct variant_ {
|
||||
name: ident,
|
||||
attrs: ~[attribute],
|
||||
@ -1180,9 +1056,7 @@ pub struct variant_ {
|
||||
|
||||
pub type variant = spanned<variant_>;
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub struct path_list_ident_ {
|
||||
name: ident,
|
||||
id: node_id,
|
||||
@ -1192,9 +1066,7 @@ pub type path_list_ident = spanned<path_list_ident_>;
|
||||
|
||||
pub type view_path = spanned<view_path_>;
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub enum view_path_ {
|
||||
|
||||
// quux = foo::bar::baz
|
||||
@ -1211,9 +1083,7 @@ pub enum view_path_ {
|
||||
view_path_list(@Path, ~[path_list_ident], node_id)
|
||||
}
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub struct view_item {
|
||||
node: view_item_,
|
||||
attrs: ~[attribute],
|
||||
@ -1221,9 +1091,7 @@ pub struct view_item {
|
||||
span: span,
|
||||
}
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub enum view_item_ {
|
||||
view_item_extern_mod(ident, ~[@meta_item], node_id),
|
||||
view_item_use(~[@view_path]),
|
||||
@ -1235,15 +1103,11 @@ pub type attribute = spanned<attribute_>;
|
||||
// Distinguishes between attributes that decorate items and attributes that
|
||||
// are contained as statements within items. These two cases need to be
|
||||
// distinguished for pretty-printing.
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub enum attr_style { attr_outer, attr_inner, }
|
||||
|
||||
// doc-comments are promoted to attributes that have is_sugared_doc = true
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub struct attribute_ {
|
||||
style: attr_style,
|
||||
value: @meta_item,
|
||||
@ -1257,17 +1121,13 @@ pub struct attribute_ {
|
||||
If this impl is an item_impl, the impl_id is redundant (it could be the
|
||||
same as the impl's node id).
|
||||
*/
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub struct trait_ref {
|
||||
path: @Path,
|
||||
ref_id: node_id,
|
||||
}
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub enum visibility { public, private, inherited }
|
||||
|
||||
impl visibility {
|
||||
@ -1279,9 +1139,7 @@ impl visibility {
|
||||
}
|
||||
}
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub struct struct_field_ {
|
||||
kind: struct_field_kind,
|
||||
id: node_id,
|
||||
@ -1291,17 +1149,13 @@ pub struct struct_field_ {
|
||||
|
||||
pub type struct_field = spanned<struct_field_>;
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub enum struct_field_kind {
|
||||
named_field(ident, visibility),
|
||||
unnamed_field // element of a tuple-like struct
|
||||
}
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub struct struct_def {
|
||||
fields: ~[@struct_field], /* fields, not including ctor */
|
||||
/* ID of the constructor. This is only used for tuple- or enum-like
|
||||
@ -1313,9 +1167,7 @@ pub struct struct_def {
|
||||
FIXME (#3300): Should allow items to be anonymous. Right now
|
||||
we just use dummy names for anon items.
|
||||
*/
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub struct item {
|
||||
ident: ident,
|
||||
attrs: ~[attribute],
|
||||
@ -1325,9 +1177,7 @@ pub struct item {
|
||||
span: span,
|
||||
}
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub enum item_ {
|
||||
item_const(@Ty, @expr),
|
||||
item_fn(fn_decl, purity, AbiSet, Generics, blk),
|
||||
@ -1345,9 +1195,7 @@ pub enum item_ {
|
||||
item_mac(mac),
|
||||
}
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub struct foreign_item {
|
||||
ident: ident,
|
||||
attrs: ~[attribute],
|
||||
@ -1357,9 +1205,7 @@ pub struct foreign_item {
|
||||
vis: visibility,
|
||||
}
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub enum foreign_item_ {
|
||||
foreign_item_fn(fn_decl, purity, Generics),
|
||||
foreign_item_const(@Ty)
|
||||
@ -1368,9 +1214,7 @@ pub enum foreign_item_ {
|
||||
// The data we save and restore about an inlined item or method. This is not
|
||||
// part of the AST that we parse from a file, but it becomes part of the tree
|
||||
// that we trans.
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub enum inlined_item {
|
||||
ii_item(@item),
|
||||
ii_method(def_id /* impl id */, @method),
|
||||
|
||||
@ -370,8 +370,7 @@ pub fn empty_generics() -> Generics {
|
||||
// ______________________________________________________________________
|
||||
// Enumerating the IDs which appear in an AST
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Encodable, Decodable)]
|
||||
pub struct id_range {
|
||||
min: node_id,
|
||||
max: node_id,
|
||||
|
||||
@ -127,9 +127,7 @@ pub struct span {
|
||||
expn_info: Option<@ExpnInfo>
|
||||
}
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Eq, Encodable, Decodable)]
|
||||
pub struct spanned<T> { node: T, span: span }
|
||||
|
||||
impl cmp::Eq for span {
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -538,3 +538,301 @@ pub fn duplicate_expr(cx: @ext_ctxt, expr: @ast::expr) -> @ast::expr {
|
||||
folder.fold_expr(expr)
|
||||
}
|
||||
|
||||
|
||||
|
||||
// Transitional reexports so qquote can find the paths it is looking for
|
||||
mod syntax {
|
||||
pub use ext;
|
||||
pub use parse;
|
||||
}
|
||||
|
||||
trait ExtCtxtMethods {
|
||||
fn bind_path(&self,
|
||||
span: span,
|
||||
ident: ast::ident,
|
||||
path: @ast::Path,
|
||||
bounds: @OptVec<ast::TyParamBound>)
|
||||
-> ast::TyParam;
|
||||
fn expr(&self, span: span, node: ast::expr_) -> @ast::expr;
|
||||
fn path(&self, span: span, strs: ~[ast::ident]) -> @ast::Path;
|
||||
fn path_global(&self, span: span, strs: ~[ast::ident]) -> @ast::Path;
|
||||
fn path_tps(&self, span: span, strs: ~[ast::ident], tps: ~[@ast::Ty])
|
||||
-> @ast::Path;
|
||||
fn path_tps_global(&self,
|
||||
span: span,
|
||||
strs: ~[ast::ident],
|
||||
tps: ~[@ast::Ty])
|
||||
-> @ast::Path;
|
||||
fn ty_path(&self, span: span, strs: ~[ast::ident], tps: ~[@ast::Ty])
|
||||
-> @ast::Ty;
|
||||
fn binder_pat(&self, span: span, nm: ast::ident) -> @ast::pat;
|
||||
fn stmt(&self, expr: @ast::expr) -> @ast::stmt;
|
||||
fn lit_str(&self, span: span, s: @~str) -> @ast::expr;
|
||||
fn lit_uint(&self, span: span, i: uint) -> @ast::expr;
|
||||
fn lambda0(&self, blk: ast::blk) -> @ast::expr;
|
||||
fn lambda1(&self, blk: ast::blk, ident: ast::ident) -> @ast::expr;
|
||||
fn blk(&self, span: span, stmts: ~[@ast::stmt]) -> ast::blk;
|
||||
fn expr_blk(&self, expr: @ast::expr) -> ast::blk;
|
||||
fn expr_path(&self, span: span, strs: ~[ast::ident]) -> @ast::expr;
|
||||
fn expr_path_global(&self, span: span, strs: ~[ast::ident]) -> @ast::expr;
|
||||
fn expr_var(&self, span: span, var: &str) -> @ast::expr;
|
||||
fn expr_self(&self, span: span) -> @ast::expr;
|
||||
fn expr_field(&self, span: span, expr: @ast::expr, ident: ast::ident)
|
||||
-> @ast::expr;
|
||||
fn expr_call(&self, span: span, expr: @ast::expr, args: ~[@ast::expr])
|
||||
-> @ast::expr;
|
||||
fn expr_method_call(&self,
|
||||
span: span,
|
||||
expr: @ast::expr,
|
||||
ident: ast::ident,
|
||||
args: ~[@ast::expr])
|
||||
-> @ast::expr;
|
||||
fn lambda_expr_0(&self, expr: @ast::expr) -> @ast::expr;
|
||||
fn lambda_expr_1(&self, expr: @ast::expr, ident: ast::ident)
|
||||
-> @ast::expr;
|
||||
fn lambda_stmts_0(&self, span: span, stmts: ~[@ast::stmt]) -> @ast::expr;
|
||||
fn lambda_stmts_1(&self,
|
||||
span: span,
|
||||
stmts: ~[@ast::stmt],
|
||||
ident: ast::ident)
|
||||
-> @ast::expr;
|
||||
}
|
||||
|
||||
impl ExtCtxtMethods for @ext_ctxt {
|
||||
fn bind_path(
|
||||
&self,
|
||||
_span: span,
|
||||
ident: ast::ident,
|
||||
path: @ast::Path,
|
||||
bounds: @OptVec<ast::TyParamBound>
|
||||
) -> ast::TyParam {
|
||||
let bound = ast::TraitTyParamBound(@ast::trait_ref {
|
||||
ref_id: self.next_id(),
|
||||
path: path
|
||||
});
|
||||
|
||||
ast::TyParam {
|
||||
ident: ident,
|
||||
id: self.next_id(),
|
||||
bounds: @bounds.prepend(bound)
|
||||
}
|
||||
}
|
||||
|
||||
fn expr(&self, span: span, node: ast::expr_) -> @ast::expr {
|
||||
@ast::expr {
|
||||
id: self.next_id(),
|
||||
callee_id: self.next_id(),
|
||||
node: node,
|
||||
span: span,
|
||||
}
|
||||
}
|
||||
|
||||
fn path(&self, span: span, strs: ~[ast::ident]) -> @ast::Path {
|
||||
@ast::Path {
|
||||
span: span,
|
||||
global: false,
|
||||
idents: strs,
|
||||
rp: None,
|
||||
types: ~[]
|
||||
}
|
||||
}
|
||||
|
||||
fn path_global(&self, span: span, strs: ~[ast::ident]) -> @ast::Path {
|
||||
@ast::Path {
|
||||
span: span,
|
||||
global: true,
|
||||
idents: strs,
|
||||
rp: None,
|
||||
types: ~[]
|
||||
}
|
||||
}
|
||||
|
||||
fn path_tps(
|
||||
&self,
|
||||
span: span,
|
||||
strs: ~[ast::ident],
|
||||
tps: ~[@ast::Ty]
|
||||
) -> @ast::Path {
|
||||
@ast::Path {
|
||||
span: span,
|
||||
global: false,
|
||||
idents: strs,
|
||||
rp: None,
|
||||
types: tps
|
||||
}
|
||||
}
|
||||
|
||||
fn path_tps_global(
|
||||
&self,
|
||||
span: span,
|
||||
strs: ~[ast::ident],
|
||||
tps: ~[@ast::Ty]
|
||||
) -> @ast::Path {
|
||||
@ast::Path {
|
||||
span: span,
|
||||
global: true,
|
||||
idents: strs,
|
||||
rp: None,
|
||||
types: tps
|
||||
}
|
||||
}
|
||||
|
||||
fn ty_path(
|
||||
&self,
|
||||
span: span,
|
||||
strs: ~[ast::ident],
|
||||
tps: ~[@ast::Ty]
|
||||
) -> @ast::Ty {
|
||||
@ast::Ty {
|
||||
id: self.next_id(),
|
||||
node: ast::ty_path(
|
||||
self.path_tps(span, strs, tps),
|
||||
self.next_id()),
|
||||
span: span,
|
||||
}
|
||||
}
|
||||
|
||||
fn binder_pat(&self, span: span, nm: ast::ident) -> @ast::pat {
|
||||
@ast::pat {
|
||||
id: self.next_id(),
|
||||
node: ast::pat_ident(
|
||||
ast::bind_by_ref(ast::m_imm),
|
||||
self.path(span, ~[nm]),
|
||||
None),
|
||||
span: span,
|
||||
}
|
||||
}
|
||||
|
||||
fn stmt(&self, expr: @ast::expr) -> @ast::stmt {
|
||||
@codemap::spanned { node: ast::stmt_semi(expr, self.next_id()),
|
||||
span: expr.span }
|
||||
}
|
||||
|
||||
fn lit_str(&self, span: span, s: @~str) -> @ast::expr {
|
||||
self.expr(
|
||||
span,
|
||||
ast::expr_vstore(
|
||||
self.expr(
|
||||
span,
|
||||
ast::expr_lit(
|
||||
@codemap::spanned { node: ast::lit_str(s),
|
||||
span: span})),
|
||||
ast::expr_vstore_uniq))
|
||||
}
|
||||
|
||||
fn lit_uint(&self, span: span, i: uint) -> @ast::expr {
|
||||
self.expr(
|
||||
span,
|
||||
ast::expr_lit(
|
||||
@codemap::spanned { node: ast::lit_uint(i as u64, ast::ty_u),
|
||||
span: span}))
|
||||
}
|
||||
|
||||
fn lambda0(&self, blk: ast::blk) -> @ast::expr {
|
||||
let ext_cx = *self;
|
||||
let blk_e = self.expr(copy blk.span, ast::expr_block(copy blk));
|
||||
quote_expr!( || $blk_e )
|
||||
}
|
||||
|
||||
fn lambda1(&self, blk: ast::blk, ident: ast::ident) -> @ast::expr {
|
||||
let ext_cx = *self;
|
||||
let blk_e = self.expr(copy blk.span, ast::expr_block(copy blk));
|
||||
quote_expr!( |$ident| $blk_e )
|
||||
}
|
||||
|
||||
fn blk(&self, span: span, stmts: ~[@ast::stmt]) -> ast::blk {
|
||||
codemap::spanned {
|
||||
node: ast::blk_ {
|
||||
view_items: ~[],
|
||||
stmts: stmts,
|
||||
expr: None,
|
||||
id: self.next_id(),
|
||||
rules: ast::default_blk,
|
||||
},
|
||||
span: span,
|
||||
}
|
||||
}
|
||||
|
||||
fn expr_blk(&self, expr: @ast::expr) -> ast::blk {
|
||||
codemap::spanned {
|
||||
node: ast::blk_ {
|
||||
view_items: ~[],
|
||||
stmts: ~[],
|
||||
expr: Some(expr),
|
||||
id: self.next_id(),
|
||||
rules: ast::default_blk,
|
||||
},
|
||||
span: expr.span,
|
||||
}
|
||||
}
|
||||
|
||||
fn expr_path(&self, span: span, strs: ~[ast::ident]) -> @ast::expr {
|
||||
self.expr(span, ast::expr_path(self.path(span, strs)))
|
||||
}
|
||||
|
||||
fn expr_path_global(
|
||||
&self,
|
||||
span: span,
|
||||
strs: ~[ast::ident]
|
||||
) -> @ast::expr {
|
||||
self.expr(span, ast::expr_path(self.path_global(span, strs)))
|
||||
}
|
||||
|
||||
fn expr_var(&self, span: span, var: &str) -> @ast::expr {
|
||||
self.expr_path(span, ~[self.ident_of(var)])
|
||||
}
|
||||
|
||||
fn expr_self(&self, span: span) -> @ast::expr {
|
||||
self.expr(span, ast::expr_self)
|
||||
}
|
||||
|
||||
fn expr_field(
|
||||
&self,
|
||||
span: span,
|
||||
expr: @ast::expr,
|
||||
ident: ast::ident
|
||||
) -> @ast::expr {
|
||||
self.expr(span, ast::expr_field(expr, ident, ~[]))
|
||||
}
|
||||
|
||||
fn expr_call(
|
||||
&self,
|
||||
span: span,
|
||||
expr: @ast::expr,
|
||||
args: ~[@ast::expr]
|
||||
) -> @ast::expr {
|
||||
self.expr(span, ast::expr_call(expr, args, ast::NoSugar))
|
||||
}
|
||||
|
||||
fn expr_method_call(
|
||||
&self,
|
||||
span: span,
|
||||
expr: @ast::expr,
|
||||
ident: ast::ident,
|
||||
args: ~[@ast::expr]
|
||||
) -> @ast::expr {
|
||||
self.expr(span,
|
||||
ast::expr_method_call(expr, ident, ~[], args, ast::NoSugar))
|
||||
}
|
||||
|
||||
fn lambda_expr_0(&self, expr: @ast::expr) -> @ast::expr {
|
||||
self.lambda0(self.expr_blk(expr))
|
||||
}
|
||||
|
||||
fn lambda_expr_1(&self, expr: @ast::expr, ident: ast::ident)
|
||||
-> @ast::expr {
|
||||
self.lambda1(self.expr_blk(expr), ident)
|
||||
}
|
||||
|
||||
fn lambda_stmts_0(&self, span: span, stmts: ~[@ast::stmt]) -> @ast::expr {
|
||||
self.lambda0(self.blk(span, stmts))
|
||||
}
|
||||
|
||||
fn lambda_stmts_1(&self,
|
||||
span: span,
|
||||
stmts: ~[@ast::stmt],
|
||||
ident: ast::ident)
|
||||
-> @ast::expr {
|
||||
self.lambda1(self.blk(span, stmts), ident)
|
||||
}
|
||||
}
|
||||
|
||||
@ -8,6 +8,11 @@
|
||||
// option. This file may not be copied, modified, or distributed
|
||||
// except according to those terms.
|
||||
|
||||
/*!
|
||||
The compiler code necessary for #[deriving(Decodable)]. See
|
||||
encodable.rs for more.
|
||||
*/
|
||||
|
||||
use ast;
|
||||
use ast::*;
|
||||
use ext::base::ext_ctxt;
|
||||
|
||||
@ -8,6 +8,74 @@
|
||||
// option. This file may not be copied, modified, or distributed
|
||||
// except according to those terms.
|
||||
|
||||
/*!
|
||||
|
||||
The compiler code necessary to implement the #[deriving(Encodable)]
|
||||
(and Decodable, in decodable.rs) extension. The idea here is that
|
||||
type-defining items may be tagged with #[deriving(Encodable,
|
||||
Decodable)].
|
||||
|
||||
For example, a type like:
|
||||
|
||||
#[deriving(Encodable, Decodable)]
|
||||
struct Node {id: uint}
|
||||
|
||||
would generate two implementations like:
|
||||
|
||||
impl<S:std::serialize::Encoder> Encodable<S> for Node {
|
||||
fn encode(&self, s: &S) {
|
||||
do s.emit_struct("Node", 1) {
|
||||
s.emit_field("id", 0, || s.emit_uint(self.id))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<D:Decoder> Decodable for node_id {
|
||||
fn decode(d: &D) -> Node {
|
||||
do d.read_struct("Node", 1) {
|
||||
Node {
|
||||
id: d.read_field(~"x", 0, || decode(d))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Other interesting scenarios are whe the item has type parameters or
|
||||
references other non-built-in types. A type definition like:
|
||||
|
||||
#[deriving(Encodable, Decodable)]
|
||||
struct spanned<T> {node: T, span: span}
|
||||
|
||||
would yield functions like:
|
||||
|
||||
impl<
|
||||
S: Encoder,
|
||||
T: Encodable<S>
|
||||
> spanned<T>: Encodable<S> {
|
||||
fn encode<S:Encoder>(s: &S) {
|
||||
do s.emit_rec {
|
||||
s.emit_field("node", 0, || self.node.encode(s));
|
||||
s.emit_field("span", 1, || self.span.encode(s));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<
|
||||
D: Decoder,
|
||||
T: Decodable<D>
|
||||
> spanned<T>: Decodable<D> {
|
||||
fn decode(d: &D) -> spanned<T> {
|
||||
do d.read_rec {
|
||||
{
|
||||
node: d.read_field(~"node", 0, || decode(d)),
|
||||
span: d.read_field(~"span", 1, || decode(d)),
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
*/
|
||||
|
||||
|
||||
use ast;
|
||||
use ast::*;
|
||||
use ext::base::ext_ctxt;
|
||||
@ -403,3 +471,247 @@ fn expand_deriving_encodable_enum_method(
|
||||
// Create the method.
|
||||
create_encode_method(cx, span, ~[stmt])
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod test {
|
||||
extern mod std;
|
||||
use core::option::{None, Some};
|
||||
use std::serialize::Encodable;
|
||||
use std::serialize::Encoder;
|
||||
|
||||
// just adding the ones I want to test, for now:
|
||||
#[deriving(Eq)]
|
||||
pub enum call {
|
||||
CallToEmitEnum(~str),
|
||||
CallToEmitEnumVariant(~str, uint, uint),
|
||||
CallToEmitEnumVariantArg(uint),
|
||||
CallToEmitUint(uint),
|
||||
CallToEmitNil,
|
||||
CallToEmitStruct(~str,uint),
|
||||
CallToEmitField(~str,uint),
|
||||
CallToEmitOption,
|
||||
CallToEmitOptionNone,
|
||||
CallToEmitOptionSome,
|
||||
// all of the ones I was too lazy to handle:
|
||||
CallToOther
|
||||
}
|
||||
// using `@mut` rather than changing the
|
||||
// type of self in every method of every encoder everywhere.
|
||||
pub struct TestEncoder {call_log : @mut ~[call]}
|
||||
|
||||
pub impl TestEncoder {
|
||||
// these self's should be &mut self's, as well....
|
||||
fn add_to_log (&self, c : call) {
|
||||
self.call_log.push(copy c);
|
||||
}
|
||||
fn add_unknown_to_log (&self) {
|
||||
self.add_to_log (CallToOther)
|
||||
}
|
||||
}
|
||||
|
||||
impl Encoder for TestEncoder {
|
||||
fn emit_nil(&mut self) { self.add_to_log(CallToEmitNil) }
|
||||
|
||||
fn emit_uint(&mut self, v: uint) {
|
||||
self.add_to_log(CallToEmitUint(v));
|
||||
}
|
||||
fn emit_u64(&mut self, _v: u64) { self.add_unknown_to_log(); }
|
||||
fn emit_u32(&mut self, _v: u32) { self.add_unknown_to_log(); }
|
||||
fn emit_u16(&mut self, _v: u16) { self.add_unknown_to_log(); }
|
||||
fn emit_u8(&mut self, _v: u8) { self.add_unknown_to_log(); }
|
||||
|
||||
fn emit_int(&mut self, _v: int) { self.add_unknown_to_log(); }
|
||||
fn emit_i64(&mut self, _v: i64) { self.add_unknown_to_log(); }
|
||||
fn emit_i32(&mut self, _v: i32) { self.add_unknown_to_log(); }
|
||||
fn emit_i16(&mut self, _v: i16) { self.add_unknown_to_log(); }
|
||||
fn emit_i8(&mut self, _v: i8) { self.add_unknown_to_log(); }
|
||||
|
||||
fn emit_bool(&mut self, _v: bool) { self.add_unknown_to_log(); }
|
||||
|
||||
fn emit_f64(&mut self, _v: f64) { self.add_unknown_to_log(); }
|
||||
fn emit_f32(&mut self, _v: f32) { self.add_unknown_to_log(); }
|
||||
fn emit_float(&mut self, _v: float) { self.add_unknown_to_log(); }
|
||||
|
||||
fn emit_char(&mut self, _v: char) { self.add_unknown_to_log(); }
|
||||
fn emit_str(&mut self, _v: &str) { self.add_unknown_to_log(); }
|
||||
|
||||
fn emit_enum(&mut self, name: &str, f: &fn(&mut TestEncoder)) {
|
||||
self.add_to_log(CallToEmitEnum(name.to_str()));
|
||||
f(self);
|
||||
}
|
||||
|
||||
fn emit_enum_variant(&mut self,
|
||||
name: &str,
|
||||
id: uint,
|
||||
cnt: uint,
|
||||
f: &fn(&mut TestEncoder)) {
|
||||
self.add_to_log(CallToEmitEnumVariant(name.to_str(), id, cnt));
|
||||
f(self);
|
||||
}
|
||||
|
||||
fn emit_enum_variant_arg(&mut self,
|
||||
idx: uint,
|
||||
f: &fn(&mut TestEncoder)) {
|
||||
self.add_to_log(CallToEmitEnumVariantArg(idx));
|
||||
f(self);
|
||||
}
|
||||
|
||||
fn emit_enum_struct_variant(&mut self,
|
||||
name: &str,
|
||||
id: uint,
|
||||
cnt: uint,
|
||||
f: &fn(&mut TestEncoder)) {
|
||||
self.emit_enum_variant(name, id, cnt, f)
|
||||
}
|
||||
|
||||
fn emit_enum_struct_variant_field(&mut self,
|
||||
_name: &str,
|
||||
idx: uint,
|
||||
f: &fn(&mut TestEncoder)) {
|
||||
self.emit_enum_variant_arg(idx, f)
|
||||
}
|
||||
|
||||
fn emit_struct(&mut self,
|
||||
name: &str,
|
||||
len: uint,
|
||||
f: &fn(&mut TestEncoder)) {
|
||||
self.add_to_log(CallToEmitStruct (name.to_str(),len));
|
||||
f(self);
|
||||
}
|
||||
fn emit_struct_field(&mut self,
|
||||
name: &str,
|
||||
idx: uint,
|
||||
f: &fn(&mut TestEncoder)) {
|
||||
self.add_to_log(CallToEmitField (name.to_str(),idx));
|
||||
f(self);
|
||||
}
|
||||
|
||||
fn emit_tuple(&mut self, _len: uint, f: &fn(&mut TestEncoder)) {
|
||||
self.add_unknown_to_log();
|
||||
f(self);
|
||||
}
|
||||
fn emit_tuple_arg(&mut self, _idx: uint, f: &fn(&mut TestEncoder)) {
|
||||
self.add_unknown_to_log();
|
||||
f(self);
|
||||
}
|
||||
|
||||
fn emit_tuple_struct(&mut self,
|
||||
_name: &str,
|
||||
_len: uint,
|
||||
f: &fn(&mut TestEncoder)) {
|
||||
self.add_unknown_to_log();
|
||||
f(self);
|
||||
}
|
||||
|
||||
fn emit_tuple_struct_arg(&mut self,
|
||||
_idx: uint,
|
||||
f: &fn(&mut TestEncoder)) {
|
||||
self.add_unknown_to_log();
|
||||
f(self);
|
||||
}
|
||||
|
||||
fn emit_option(&mut self, f: &fn(&mut TestEncoder)) {
|
||||
self.add_to_log(CallToEmitOption);
|
||||
f(self);
|
||||
}
|
||||
fn emit_option_none(&mut self) {
|
||||
self.add_to_log(CallToEmitOptionNone);
|
||||
}
|
||||
fn emit_option_some(&mut self, f: &fn(&mut TestEncoder)) {
|
||||
self.add_to_log(CallToEmitOptionSome);
|
||||
f(self);
|
||||
}
|
||||
|
||||
fn emit_seq(&mut self, _len: uint, f: &fn(&mut TestEncoder)) {
|
||||
self.add_unknown_to_log();
|
||||
f(self);
|
||||
}
|
||||
fn emit_seq_elt(&mut self, _idx: uint, f: &fn(&mut TestEncoder)) {
|
||||
self.add_unknown_to_log();
|
||||
f(self);
|
||||
}
|
||||
|
||||
fn emit_map(&mut self, _len: uint, f: &fn(&mut TestEncoder)) {
|
||||
self.add_unknown_to_log();
|
||||
f(self);
|
||||
}
|
||||
fn emit_map_elt_key(&mut self, _idx: uint, f: &fn(&mut TestEncoder)) {
|
||||
self.add_unknown_to_log();
|
||||
f(self);
|
||||
}
|
||||
fn emit_map_elt_val(&mut self, _idx: uint, f: &fn(&mut TestEncoder)) {
|
||||
self.add_unknown_to_log();
|
||||
f(self);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
fn to_call_log<E:Encodable<TestEncoder>>(val: E) -> ~[call] {
|
||||
let mut te = TestEncoder {
|
||||
call_log: @mut ~[]
|
||||
};
|
||||
val.encode(&mut te);
|
||||
copy *te.call_log
|
||||
}
|
||||
|
||||
#[deriving(Encodable)]
|
||||
enum Written {
|
||||
Book(uint,uint),
|
||||
Magazine(~str)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_encode_enum() {
|
||||
assert_eq!(
|
||||
to_call_log(Book(34,44)),
|
||||
~[
|
||||
CallToEmitEnum(~"Written"),
|
||||
CallToEmitEnumVariant(~"Book",0,2),
|
||||
CallToEmitEnumVariantArg(0),
|
||||
CallToEmitUint(34),
|
||||
CallToEmitEnumVariantArg(1),
|
||||
CallToEmitUint(44),
|
||||
]
|
||||
);
|
||||
}
|
||||
|
||||
pub struct BPos(uint);
|
||||
|
||||
#[deriving(Encodable)]
|
||||
pub struct HasPos { pos : BPos }
|
||||
|
||||
#[test]
|
||||
fn test_encode_newtype() {
|
||||
assert_eq!(
|
||||
to_call_log(HasPos { pos:BPos(48) }),
|
||||
~[
|
||||
CallToEmitStruct(~"HasPos",1),
|
||||
CallToEmitField(~"pos",0),
|
||||
CallToEmitUint(48),
|
||||
]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_encode_option() {
|
||||
let mut v = None;
|
||||
|
||||
assert_eq!(
|
||||
to_call_log(v),
|
||||
~[
|
||||
CallToEmitOption,
|
||||
CallToEmitOptionNone,
|
||||
]
|
||||
);
|
||||
|
||||
v = Some(54u);
|
||||
assert_eq!(
|
||||
to_call_log(v),
|
||||
~[
|
||||
CallToEmitOption,
|
||||
CallToEmitOptionSome,
|
||||
CallToEmitUint(54)
|
||||
]
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
@ -8,8 +8,15 @@
|
||||
// option. This file may not be copied, modified, or distributed
|
||||
// except according to those terms.
|
||||
|
||||
/// The compiler code necessary to implement the #[deriving(Eq)] and
|
||||
/// #[deriving(IterBytes)] extensions.
|
||||
/*!
|
||||
The compiler code necessary to implement the #[deriving] extensions.
|
||||
|
||||
|
||||
FIXME (#2810)--Hygiene. Search for "__" strings (in other files too).
|
||||
We also assume "std" is the standard library, and "core" is the core
|
||||
library.
|
||||
|
||||
*/
|
||||
|
||||
use ast;
|
||||
use ast::{Ty, enum_def, expr, ident, item, Generics, meta_item, struct_def};
|
||||
@ -203,8 +210,6 @@ pub fn create_derived_impl(cx: @ext_ctxt,
|
||||
*
|
||||
* where B1, B2, ... are the bounds given by `bounds_paths`.
|
||||
*
|
||||
* FIXME(#5090): Remove code duplication between this and the
|
||||
* code in auto_encode.rs
|
||||
*/
|
||||
|
||||
// Copy the lifetimes
|
||||
|
||||
@ -20,8 +20,7 @@ use core::prelude::*;
|
||||
use core::old_iter;
|
||||
use core::old_iter::BaseIter;
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Encodable, Decodable)]
|
||||
pub enum OptVec<T> {
|
||||
Empty,
|
||||
Vec(~[T])
|
||||
|
||||
@ -18,9 +18,7 @@ use core::cmp::Equiv;
|
||||
use core::hashmap::HashSet;
|
||||
use core::to_bytes;
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Encodable, Decodable, Eq)]
|
||||
pub enum binop {
|
||||
PLUS,
|
||||
MINUS,
|
||||
@ -34,9 +32,7 @@ pub enum binop {
|
||||
SHR,
|
||||
}
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Encodable, Decodable, Eq)]
|
||||
pub enum Token {
|
||||
/* Expression-operator symbols. */
|
||||
EQ,
|
||||
@ -97,9 +93,7 @@ pub enum Token {
|
||||
EOF,
|
||||
}
|
||||
|
||||
#[auto_encode]
|
||||
#[auto_decode]
|
||||
#[deriving(Eq)]
|
||||
#[deriving(Encodable, Decodable, Eq)]
|
||||
/// For interpolation during macro expansion.
|
||||
pub enum nonterminal {
|
||||
nt_item(@ast::item),
|
||||
|
||||
15
src/test/compile-fail/deprecated-auto-code.rs
Normal file
15
src/test/compile-fail/deprecated-auto-code.rs
Normal file
@ -0,0 +1,15 @@
|
||||
// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
|
||||
// file at the top-level directory of this distribution and at
|
||||
// http://rust-lang.org/COPYRIGHT.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
||||
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
||||
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
||||
// option. This file may not be copied, modified, or distributed
|
||||
// except according to those terms.
|
||||
|
||||
#[auto_encode] //~ ERROR: `#[auto_encode]` is deprecated
|
||||
#[auto_decode] //~ ERROR: `#[auto_decode]` is deprecated
|
||||
struct A;
|
||||
|
||||
fn main() {}
|
||||
Loading…
x
Reference in New Issue
Block a user