rust/src/libsyntax/ast.rs

1359 lines
31 KiB
Rust
Raw Normal View History

// Copyright 2012 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.
// The Rust abstract syntax tree.
2013-03-31 21:27:51 -05:00
use codemap::{span, spanned};
use abi::AbiSet;
use opt_vec::OptVec;
2012-05-21 12:45:56 -05:00
use core::cast;
use core::option::{None, Option, Some};
use core::task;
use core::to_bytes;
use core::to_str::ToStr;
use std::serialize::{Encodable, Decodable, Encoder, Decoder};
/* can't import macros yet, so this is copied from token.rs. See its comment
* there. */
macro_rules! interner_key (
() => (cast::transmute::<(uint, uint),
&fn(+v: @@::parse::token::ident_interner)>(
(-3 as uint, 0u)))
)
// an identifier contains an index into the interner
// table and a SyntaxContext to track renaming and
// macro expansion per Flatt et al., "Macros
// That Work Together"
#[deriving(Eq)]
pub struct ident { repr: Name }
// a SyntaxContext represents a chain of macro-expandings
// and renamings. Each macro expansion corresponds to
// a fresh uint
#[deriving(Eq)]
pub enum SyntaxContext {
MT,
Mark (Mrk,~SyntaxContext),
Rename (~ident,Name,~SyntaxContext)
}
/*
// ** this is going to have to apply to paths, not to idents.
// Returns true if these two identifiers access the same
// local binding or top-level binding... that's what it
// should do. For now, it just compares the names.
pub fn free_ident_eq (a : ident, b: ident) -> bool{
a.repr == b.repr
}
*/
// a name represents a string, interned
type Name = uint;
// a mark represents a unique id associated
// with a macro expansion
type Mrk = uint;
impl<S:Encoder> Encodable<S> for ident {
fn encode(&self, s: &S) {
let intr = match unsafe {
task::local_data::local_data_get(interner_key!())
} {
None => fail!(~"encode: TLS interner not set up"),
Some(intr) => intr
};
s.emit_str(*(*intr).get(*self));
}
}
impl<D:Decoder> Decodable<D> for ident {
fn decode(d: &D) -> ident {
let intr = match unsafe {
task::local_data::local_data_get(interner_key!())
} {
None => fail!(~"decode: TLS interner not set up"),
Some(intr) => intr
};
(*intr).intern(@d.read_str())
}
2012-07-18 18:18:02 -05:00
}
impl to_bytes::IterBytes for ident {
fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
self.repr.iter_bytes(lsb0, f)
}
}
// Functions may or may not have names.
pub type fn_ident = Option<ident>;
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub struct Lifetime {
id: node_id,
span: span,
ident: ident
}
// a "Path" is essentially Rust's notion of a name;
// 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)]
pub struct path {
2013-01-13 12:48:09 -06:00
span: span,
global: bool,
idents: ~[ident],
rp: Option<@Lifetime>,
2013-01-13 12:48:09 -06:00
types: ~[@Ty],
}
pub type crate_num = int;
pub type node_id = int;
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub struct def_id {
2013-01-13 13:05:40 -06:00
crate: crate_num,
node: node_id,
}
pub static local_crate: crate_num = 0;
pub static crate_node_id: node_id = 0;
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
// 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
// detects Copy, Send, Owned, and Const.
pub enum TyParamBound {
TraitTyParamBound(@trait_ref),
RegionTyParamBound
}
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub struct TyParam {
2013-01-13 13:15:14 -06:00
ident: ident,
id: node_id,
bounds: @OptVec<TyParamBound>
}
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub struct Generics {
lifetimes: OptVec<Lifetime>,
ty_params: OptVec<TyParam>
}
pub impl Generics {
fn is_parameterized(&self) -> bool {
self.lifetimes.len() + self.ty_params.len() > 0
}
fn is_lt_parameterized(&self) -> bool {
self.lifetimes.len() > 0
}
fn is_type_parameterized(&self) -> bool {
self.ty_params.len() > 0
}
2013-01-13 13:15:14 -06:00
}
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub enum def {
2012-01-19 19:56:05 -06:00
def_fn(def_id, purity),
def_static_method(/* method */ def_id,
/* trait */ Option<def_id>,
purity),
def_self(node_id, bool /* is_implicit */),
def_self_ty(/* trait id */ node_id),
2012-01-19 19:56:05 -06:00
def_mod(def_id),
def_foreign_mod(def_id),
2012-01-19 19:56:05 -06:00
def_const(def_id),
2013-01-03 11:57:08 -06:00
def_arg(node_id, mode, bool /* is_mutbl */),
def_local(node_id, bool /* is_mutbl */),
2012-01-19 19:56:05 -06:00
def_variant(def_id /* enum */, def_id /* variant */),
def_ty(def_id),
def_trait(def_id),
def_prim_ty(prim_ty),
2012-01-19 19:56:05 -06:00
def_ty_param(def_id, uint),
def_binding(node_id, binding_mode),
2012-01-19 19:56:05 -06:00
def_use(def_id),
2012-08-27 18:26:35 -05:00
def_upvar(node_id, // id of closed over var
@def, // closed over def
node_id, // expr node that creates the closure
node_id), // id for the block/body of the closure expr
def_struct(def_id),
def_typaram_binder(node_id), /* struct, impl or trait with ty params */
def_region(node_id),
def_label(node_id)
}
2012-08-27 18:26:35 -05:00
// The set of meta_items that define the compilation environment of the crate,
// used to drive conditional compilation
pub type crate_cfg = ~[@meta_item];
pub type crate = spanned<crate_>;
2013-02-13 14:49:45 -06:00
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub struct crate_ {
2013-01-14 21:06:59 -06:00
module: _mod,
attrs: ~[attribute],
config: crate_cfg,
}
pub type meta_item = spanned<meta_item_>;
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub enum meta_item_ {
2013-02-14 09:34:21 -06:00
meta_word(@~str),
meta_list(@~str, ~[@meta_item]),
meta_name_value(@~str, lit),
}
2010-12-30 10:21:37 -06:00
pub type blk = spanned<blk_>;
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub struct blk_ {
2013-01-14 21:35:08 -06:00
view_items: ~[@view_item],
stmts: ~[@stmt],
expr: Option<@expr>,
id: node_id,
rules: blk_check_mode,
}
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub struct pat {
id: node_id,
node: pat_,
span: span,
}
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub struct field_pat {
ident: ident,
pat: @pat,
}
2011-07-11 07:13:20 -05:00
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub enum binding_mode {
bind_by_copy,
2013-01-11 14:33:50 -06:00
bind_by_ref(mutability),
bind_infer
}
impl to_bytes::IterBytes for binding_mode {
fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
match *self {
bind_by_copy => 0u8.iter_bytes(lsb0, f),
bind_by_ref(ref m) =>
to_bytes::iter_bytes_2(&1u8, m, lsb0, f),
bind_infer =>
2u8.iter_bytes(lsb0, f),
}
}
}
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub enum pat_ {
2012-01-19 19:56:05 -06:00
pat_wild,
// A pat_ident may either be a new bound variable,
2012-01-19 16:24:03 -06:00
// or a nullary enum (in which case the second field
2012-08-20 14:23:37 -05:00
// is None).
2012-01-19 16:24:03 -06:00
// In the nullary enum case, the parser can't determine
// which it is. The resolver determines this, and
// records this pattern's node_id in an auxiliary
// set (of "pat_idents that refer to nullary enums")
2012-08-20 14:23:37 -05:00
pat_ident(binding_mode, @path, Option<@pat>),
pat_enum(@path, Option<~[@pat]>), /* "none" means a * pattern where
* we don't bind the fields to names */
pat_struct(@path, ~[field_pat], bool),
pat_tup(~[@pat]),
2012-01-19 19:56:05 -06:00
pat_box(@pat),
pat_uniq(@pat),
2012-09-07 19:07:32 -05:00
pat_region(@pat), // borrowed pointer pattern
2012-01-19 19:56:05 -06:00
pat_lit(@expr),
pat_range(@expr, @expr),
// [a, b, ..i, y, z] is represented as
// pat_vec(~[a, b], Some(i), ~[y, z])
pat_vec(~[@pat], Option<@pat>, ~[@pat])
2010-11-24 16:42:01 -06:00
}
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub enum mutability { m_mutbl, m_imm, m_const, }
impl to_bytes::IterBytes for mutability {
fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
(*self as u8).iter_bytes(lsb0, f)
}
}
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub enum Sigil {
BorrowedSigil,
OwnedSigil,
ManagedSigil
}
impl to_bytes::IterBytes for Sigil {
fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
(*self as uint).iter_bytes(lsb0, f)
}
}
impl ToStr for Sigil {
fn to_str(&self) -> ~str {
match *self {
BorrowedSigil => ~"&",
OwnedSigil => ~"~",
ManagedSigil => ~"@"
}
}
}
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub enum vstore {
2012-10-11 17:35:31 -05:00
// FIXME (#3469): Change uint to @expr (actually only constant exprs)
vstore_fixed(Option<uint>), // [1,2,3,4]
vstore_uniq, // ~[1,2,3,4]
vstore_box, // @[1,2,3,4]
vstore_slice(Option<@Lifetime>) // &'foo? [1,2,3,4]
2012-04-09 19:32:49 -05:00
}
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub enum expr_vstore {
expr_vstore_uniq, // ~[1,2,3,4]
expr_vstore_box, // @[1,2,3,4]
expr_vstore_mut_box, // @mut [1,2,3,4]
expr_vstore_slice, // &[1,2,3,4]
expr_vstore_mut_slice, // &mut [1,2,3,4]
}
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub enum binop {
2012-01-19 19:56:05 -06:00
add,
subtract,
mul,
div,
rem,
and,
or,
bitxor,
bitand,
bitor,
shl,
shr,
2012-01-19 19:56:05 -06:00
eq,
lt,
le,
ne,
ge,
gt,
}
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub enum unop {
2012-01-19 19:56:05 -06:00
box(mutability),
uniq(mutability),
deref,
not,
neg
}
// Generally, after typeck you can get the inferred value
// using ty::resolved_T(...).
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub enum inferable<T> {
2012-08-27 18:26:35 -05:00
expl(T),
infer(node_id)
}
impl<T:to_bytes::IterBytes> to_bytes::IterBytes for inferable<T> {
fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
match *self {
expl(ref t) =>
to_bytes::iter_bytes_2(&0u8, t, lsb0, f),
infer(ref n) =>
to_bytes::iter_bytes_2(&1u8, n, lsb0, f),
}
}
}
// "resolved" mode: the real modes.
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub enum rmode { by_ref, by_copy }
impl to_bytes::IterBytes for rmode {
fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
(*self as u8).iter_bytes(lsb0, f)
}
}
// inferable mode.
pub type mode = inferable<rmode>;
2010-12-03 20:03:28 -06:00
pub type stmt = spanned<stmt_>;
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub enum stmt_ {
2012-01-19 19:56:05 -06:00
stmt_decl(@decl, node_id),
// expr without trailing semi-colon (must have unit type):
2012-01-19 19:56:05 -06:00
stmt_expr(@expr, node_id),
// expr with trailing semi-colon (may have any type):
stmt_semi(@expr, node_id),
// bool: is there a trailing sem-colon?
stmt_mac(mac, bool),
}
// FIXME (pending discussion of #1697, #2178...): local should really be
// a refinement on pat.
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub struct local_ {
is_mutbl: bool,
ty: @Ty,
pat: @pat,
init: Option<@expr>,
id: node_id,
}
pub type local = spanned<local_>;
pub type decl = spanned<decl_>;
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub enum decl_ { decl_local(~[@local]), decl_item(@item), }
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub struct arm {
pats: ~[@pat],
guard: Option<@expr>,
body: blk,
}
2010-11-24 17:45:59 -06:00
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub struct field_ {
mutbl: mutability,
ident: ident,
expr: @expr,
}
pub type field = spanned<field_>;
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub enum blk_check_mode { default_blk, unsafe_blk, }
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub struct expr {
2013-01-15 15:51:43 -06:00
id: node_id,
// Extra node ID is only used for index, assign_op, unary, binary, method
// call
callee_id: node_id,
node: expr_,
span: span,
}
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub enum CallSugar {
NoSugar,
DoSugar,
ForSugar
}
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub enum expr_ {
expr_vstore(@expr, expr_vstore),
expr_vec(~[@expr], mutability),
expr_call(@expr, ~[@expr], CallSugar),
expr_method_call(@expr, ident, ~[@Ty], ~[@expr], CallSugar),
expr_tup(~[@expr]),
2012-01-19 19:56:05 -06:00
expr_binary(binop, @expr, @expr),
expr_unary(unop, @expr),
expr_lit(@lit),
expr_cast(@expr, @Ty),
2012-08-20 14:23:37 -05:00
expr_if(@expr, blk, Option<@expr>),
2012-01-19 19:56:05 -06:00
expr_while(@expr, blk),
/* Conditionless loop (can be exited with break, cont, or ret)
Same semantics as while(true) { body }, but typestate knows that the
(implicit) condition is always true. */
2012-08-20 14:23:37 -05:00
expr_loop(blk, Option<ident>),
2012-08-24 23:03:51 -05:00
expr_match(@expr, ~[arm]),
expr_fn_block(fn_decl, blk),
// Inner expr is always an expr_fn_block. We need the wrapping node to
// easily type this (a function returning nil on the inside but bool on
// the outside).
expr_loop_body(@expr),
2012-06-18 19:42:09 -05:00
// Like expr_loop_body but for 'do' blocks
expr_do_body(@expr),
2012-01-19 19:56:05 -06:00
expr_block(blk),
2012-01-19 19:56:05 -06:00
expr_copy(@expr),
expr_assign(@expr, @expr),
expr_swap(@expr, @expr),
expr_assign_op(binop, @expr, @expr),
expr_field(@expr, ident, ~[@Ty]),
2012-01-19 19:56:05 -06:00
expr_index(@expr, @expr),
expr_path(@path),
expr_addr_of(mutability, @expr),
2012-08-20 14:23:37 -05:00
expr_break(Option<ident>),
expr_again(Option<ident>),
expr_ret(Option<@expr>),
expr_log(@expr, @expr),
2013-03-12 02:09:53 -05:00
expr_inline_asm(inline_asm),
2012-01-19 19:56:05 -06:00
expr_mac(mac),
// A struct literal expression.
2012-08-20 14:23:37 -05:00
expr_struct(@path, ~[field], Option<@expr>),
// A vector literal constructed from one repeated element.
expr_repeat(@expr /* element */, @expr /* count */, mutability),
// No-op: used solely so we can pretty-print faithfully
expr_paren(@expr)
}
// When the main rust parser encounters a syntax-extension invocation, it
// parses the arguments to the invocation as a token-tree. This is a very
// loose structure, such that all sorts of different AST-fragments can
// be passed to syntax extensions using a uniform type.
//
// If the syntax extension is an MBE macro, it will attempt to match its
// LHS "matchers" against the provided token tree, and if it finds a
// match, will transcribe the RHS token tree, splicing in any captured
// macro_parser::matched_nonterminals into the tt_nonterminals it finds.
//
// The RHS of an MBE macro is the only place a tt_nonterminal or tt_seq
// makes any real sense. You could write them elsewhere but nothing
// else knows what to do with them, so you'll probably get a syntax
// error.
//
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
#[doc="For macro invocations; parsing is delegated to the macro"]
pub enum token_tree {
2013-02-04 15:15:17 -06:00
// a single token
tt_tok(span, ::parse::token::Token),
2013-02-04 15:15:17 -06:00
// a delimited sequence (the delimiters appear as the first
// and last elements of the vector)
tt_delim(~[token_tree]),
2013-02-04 15:15:17 -06:00
// These only make sense for right-hand-sides of MBE macros:
// a kleene-style repetition sequence with a span, a tt_forest,
// an optional separator (?), and a boolean where true indicates
// zero or more (*), and false indicates one or more (+).
tt_seq(span, ~[token_tree], Option<::parse::token::Token>, bool),
2013-02-04 15:15:17 -06:00
// a syntactic variable that will be filled in by macro expansion.
tt_nonterminal(span, ident)
2012-05-21 12:45:56 -05:00
}
//
// Matchers are nodes defined-by and recognized-by the main rust parser and
// language, but they're only ever found inside syntax-extension invocations;
// indeed, the only thing that ever _activates_ the rules in the rust parser
// for parsing a matcher is a matcher looking for the 'matchers' nonterminal
// itself. Matchers represent a small sub-language for pattern-matching
// token-trees, and are thus primarily used by the macro-defining extension
// itself.
//
// match_tok
// ---------
//
// A matcher that matches a single token, denoted by the token itself. So
// long as there's no $ involved.
//
//
// match_seq
// ---------
//
// A matcher that matches a sequence of sub-matchers, denoted various
// possible ways:
//
// $(M)* zero or more Ms
// $(M)+ one or more Ms
// $(M),+ one or more comma-separated Ms
// $(A B C);* zero or more semi-separated 'A B C' seqs
//
//
// match_nonterminal
// -----------------
//
// A matcher that matches one of a few interesting named rust
// nonterminals, such as types, expressions, items, or raw token-trees. A
// black-box matcher on expr, for example, binds an expr to a given ident,
// and that ident can re-occur as an interpolation in the RHS of a
// macro-by-example rule. For example:
//
// $foo:expr => 1 + $foo // interpolate an expr
// $foo:tt => $foo // interpolate a token-tree
// $foo:tt => bar! $foo // only other valid interpolation
// // is in arg position for another
// // macro
//
// As a final, horrifying aside, note that macro-by-example's input is
// also matched by one of these matchers. Holy self-referential! It is matched
// by an match_seq, specifically this one:
//
// $( $lhs:matchers => $rhs:tt );+
//
// If you understand that, you have closed to loop and understand the whole
// macro system. Congratulations.
//
pub type matcher = spanned<matcher_>;
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub enum matcher_ {
// match one token
match_tok(::parse::token::Token),
// match repetitions of a sequence: body, separator, zero ok?,
// lo, hi position-in-match-array used:
match_seq(~[matcher], Option<::parse::token::Token>, bool, uint, uint),
// parse a Rust NT: name to bind, name of NT, position in match array:
match_nonterminal(ident, ident, uint)
2012-06-12 12:59:50 -05:00
}
pub type mac = spanned<mac_>;
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub enum mac_ {
mac_invoc_tt(@path,~[token_tree]), // new macro-invocation
}
pub type lit = spanned<lit_>;
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub enum lit_ {
lit_str(@~str),
2012-01-19 19:56:05 -06:00
lit_int(i64, int_ty),
lit_uint(u64, uint_ty),
lit_int_unsuffixed(i64),
lit_float(@~str, float_ty),
lit_float_unsuffixed(@~str),
2012-01-19 19:56:05 -06:00
lit_nil,
lit_bool(bool),
}
2010-11-03 18:43:12 -05:00
// 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)]
pub struct mt {
ty: @Ty,
mutbl: mutability,
}
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub struct ty_field_ {
ident: ident,
mt: mt,
}
pub type ty_field = spanned<ty_field_>;
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub struct ty_method {
ident: ident,
attrs: ~[attribute],
purity: purity,
decl: fn_decl,
generics: Generics,
self_ty: self_ty,
id: node_id,
span: span,
}
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
// A trait method is either required (meaning it doesn't have an
// implementation, just a signature) or provided (meaning it has a default
// implementation).
pub enum trait_method {
required(ty_method),
provided(@method),
}
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub enum int_ty { ty_i, ty_char, ty_i8, ty_i16, ty_i32, ty_i64, }
impl ToStr for int_ty {
fn to_str(&self) -> ~str {
::ast_util::int_ty_to_str(*self)
}
}
impl to_bytes::IterBytes for int_ty {
fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
(*self as u8).iter_bytes(lsb0, f)
}
}
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub enum uint_ty { ty_u, ty_u8, ty_u16, ty_u32, ty_u64, }
impl ToStr for uint_ty {
fn to_str(&self) -> ~str {
::ast_util::uint_ty_to_str(*self)
}
}
impl to_bytes::IterBytes for uint_ty {
fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
(*self as u8).iter_bytes(lsb0, f)
}
}
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub enum float_ty { ty_f, ty_f32, ty_f64, }
impl ToStr for float_ty {
fn to_str(&self) -> ~str {
::ast_util::float_ty_to_str(*self)
}
}
impl to_bytes::IterBytes for float_ty {
fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
(*self as u8).iter_bytes(lsb0, f)
}
}
2013-02-06 20:35:01 -06:00
// NB Eq method appears below.
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub struct Ty {
2013-01-15 16:59:39 -06:00
id: node_id,
node: ty_,
span: span,
}
// Not represented directly in the AST, referred to by name through a ty_path.
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub enum prim_ty {
2012-01-19 19:56:05 -06:00
ty_int(int_ty),
ty_uint(uint_ty),
ty_float(float_ty),
ty_str,
ty_bool,
}
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub enum Onceness {
Once,
Many
}
impl ToStr for Onceness {
fn to_str(&self) -> ~str {
match *self {
2013-01-11 14:33:50 -06:00
Once => ~"once",
Many => ~"many"
}
}
}
impl to_bytes::IterBytes for Onceness {
fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
(*self as uint).iter_bytes(lsb0, f);
}
}
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub struct TyClosure {
sigil: Sigil,
region: Option<@Lifetime>,
lifetimes: OptVec<Lifetime>,
purity: purity,
onceness: Onceness,
decl: fn_decl
}
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub struct TyBareFn {
purity: purity,
abis: AbiSet,
lifetimes: OptVec<Lifetime>,
decl: fn_decl
}
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub enum ty_ {
ty_nil,
ty_bot, /* bottom type */
2012-01-19 19:56:05 -06:00
ty_box(mt),
ty_uniq(mt),
ty_vec(mt),
ty_fixed_length_vec(mt, @expr),
2012-01-19 19:56:05 -06:00
ty_ptr(mt),
ty_rptr(Option<@Lifetime>, mt),
ty_closure(@TyClosure),
ty_bare_fn(@TyBareFn),
ty_tup(~[@Ty]),
2012-01-19 19:56:05 -06:00
ty_path(@path, node_id),
ty_mac(mac),
// ty_infer means the type should be inferred instead of it having been
// specified. This should only appear at the "top level" of a type and not
// nested in one.
2012-01-19 19:56:05 -06:00
ty_infer,
}
impl to_bytes::IterBytes for Ty {
fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
to_bytes::iter_bytes_2(&self.span.lo, &self.span.hi, lsb0, f);
}
}
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub enum asm_dialect {
asm_att,
asm_intel
}
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub struct inline_asm {
asm: @~str,
clobbers: @~str,
inputs: ~[(@~str, @expr)],
outputs: ~[(@~str, @expr)],
volatile: bool,
alignstack: bool,
dialect: asm_dialect
}
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub struct arg {
mode: mode,
2013-01-03 10:45:07 -06:00
is_mutbl: bool,
ty: @Ty,
pat: @pat,
id: node_id,
}
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub struct fn_decl {
inputs: ~[arg],
output: @Ty,
cf: ret_style,
}
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub enum purity {
2012-01-19 19:56:05 -06:00
pure_fn, // declared with "pure fn"
unsafe_fn, // declared with "unsafe fn"
impure_fn, // declared with "fn"
2012-07-03 18:32:02 -05:00
extern_fn, // declared with "extern fn"
}
impl ToStr for purity {
fn to_str(&self) -> ~str {
match *self {
impure_fn => ~"impure",
unsafe_fn => ~"unsafe",
pure_fn => ~"pure",
extern_fn => ~"extern"
}
}
}
impl to_bytes::IterBytes for purity {
fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
(*self as u8).iter_bytes(lsb0, f)
}
}
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub enum ret_style {
2012-01-19 19:56:05 -06:00
noreturn, // functions with return type _|_ that always
// raise an error or exit (i.e. never return to the caller)
2012-01-19 19:56:05 -06:00
return_val, // everything else
}
impl to_bytes::IterBytes for ret_style {
fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
(*self as u8).iter_bytes(lsb0, f)
}
}
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub enum self_ty_ {
sty_static, // no self
sty_value, // `self`
sty_region(Option<@Lifetime>, mutability), // `&'lt self`
sty_box(mutability), // `@self`
sty_uniq(mutability) // `~self`
2012-07-30 18:33:02 -05:00
}
impl self_ty_ {
fn is_borrowed(&self) -> bool {
match *self {
sty_region(*) => true,
_ => false
}
}
}
pub type self_ty = spanned<self_ty_>;
2012-07-30 18:33:02 -05:00
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub struct method {
ident: ident,
attrs: ~[attribute],
generics: Generics,
self_ty: self_ty,
purity: purity,
decl: fn_decl,
body: blk,
id: node_id,
span: span,
self_id: node_id,
vis: visibility,
}
2010-12-14 17:32:13 -06:00
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub struct _mod {
view_items: ~[@view_item],
items: ~[@item],
}
// Foreign mods can be named or anonymous
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub enum foreign_mod_sort { named, anonymous }
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub struct foreign_mod {
sort: foreign_mod_sort,
abis: AbiSet,
view_items: ~[@view_item],
items: ~[@foreign_item],
}
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub struct variant_arg {
ty: @Ty,
id: node_id,
}
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub enum variant_kind {
tuple_variant_kind(~[variant_arg]),
struct_variant_kind(@struct_def),
}
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub struct enum_def {
variants: ~[variant],
}
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub struct variant_ {
name: ident,
attrs: ~[attribute],
kind: variant_kind,
id: node_id,
disr_expr: Option<@expr>,
vis: visibility,
}
pub type variant = spanned<variant_>;
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub struct path_list_ident_ {
name: ident,
id: node_id,
}
pub type path_list_ident = spanned<path_list_ident_>;
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub enum namespace { module_ns, type_value_ns }
2012-08-31 13:19:07 -05:00
pub type view_path = spanned<view_path_>;
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub enum view_path_ {
// quux = foo::bar::baz
//
// or just
//
// foo::bar::baz (with 'baz =' implicitly on the left)
2012-08-31 13:19:07 -05:00
view_path_simple(ident, @path, namespace, node_id),
// foo::bar::*
view_path_glob(@path, node_id),
// foo::bar::{a,b,c}
view_path_list(@path, ~[path_list_ident], node_id)
}
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub struct view_item {
node: view_item_,
attrs: ~[attribute],
vis: visibility,
span: span,
}
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub enum view_item_ {
view_item_extern_mod(ident, ~[@meta_item], node_id),
view_item_use(~[@view_path]),
}
// Meta-data associated with an item
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)]
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)]
pub struct attribute_ {
style: attr_style,
value: @meta_item,
is_sugared_doc: bool,
}
/*
trait_refs appear in impls.
resolve maps each trait_ref's ref_id to its defining trait; that's all
that the ref_id is for. The impl_id maps to the "self type" of this impl.
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)]
pub struct trait_ref {
path: @path,
ref_id: node_id,
}
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub enum visibility { public, private, inherited }
impl visibility {
fn inherit_from(&self, parent_visibility: visibility) -> visibility {
match self {
&inherited => parent_visibility,
&public | &private => *self
}
}
}
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub struct struct_field_ {
kind: struct_field_kind,
id: node_id,
ty: @Ty,
}
pub type struct_field = spanned<struct_field_>;
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub enum struct_field_kind {
named_field(ident, struct_mutability, visibility),
unnamed_field // element of a tuple-like struct
}
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub struct struct_def {
fields: ~[@struct_field], /* fields */
/* (not including ctor or dtor) */
/* dtor is optional */
dtor: Option<struct_dtor>,
/* ID of the constructor. This is only used for tuple- or enum-like
* structs. */
ctor_id: Option<node_id>
2013-01-13 15:45:57 -06:00
}
/*
FIXME (#3300): Should allow items to be anonymous. Right now
we just use dummy names for anon items.
*/
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub struct item {
2013-01-13 15:13:41 -06:00
ident: ident,
attrs: ~[attribute],
id: node_id,
node: item_,
vis: visibility,
span: span,
}
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub enum item_ {
item_const(@Ty, @expr),
item_fn(fn_decl, purity, AbiSet, Generics, blk),
2012-01-19 19:56:05 -06:00
item_mod(_mod),
item_foreign_mod(foreign_mod),
item_ty(@Ty, Generics),
item_enum(enum_def, Generics),
item_struct(@struct_def, Generics),
item_trait(Generics, ~[@trait_ref], ~[trait_method]),
item_impl(Generics,
2013-02-06 20:35:01 -06:00
Option<@trait_ref>, // (optional) trait this impl implements
@Ty, // self
~[@method]),
// a macro invocation (which includes macro definition)
item_mac(mac),
2011-05-11 08:10:24 -05:00
}
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub enum struct_mutability { struct_mutable, struct_immutable }
impl to_bytes::IterBytes for struct_mutability {
fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
(*self as u8).iter_bytes(lsb0, f)
}
}
pub type struct_dtor = spanned<struct_dtor_>;
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub struct struct_dtor_ {
id: node_id,
attrs: ~[attribute],
self_id: node_id,
body: blk,
}
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub struct foreign_item {
2013-01-13 14:02:16 -06:00
ident: ident,
attrs: ~[attribute],
node: foreign_item_,
id: node_id,
span: span,
vis: visibility,
}
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub enum foreign_item_ {
foreign_item_fn(fn_decl, purity, Generics),
foreign_item_const(@Ty)
}
// 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)]
pub enum inlined_item {
ii_item(@item),
ii_method(def_id /* impl id */, @method),
ii_foreign(@foreign_item),
ii_dtor(struct_dtor, ident, Generics, def_id /* parent id */)
}
2013-02-13 14:49:45 -06:00
#[cfg(test)]
mod test {
//are asts encodable?
// it looks like this *will* be a compiler bug, after
// I get deriving_eq for crates into incoming :)
/*
use std;
use codemap::*;
use super::*;
2013-02-13 14:49:45 -06:00
#[test] fn check_asts_encodable() {
let bogus_span = span {lo:BytePos(10),
hi:BytePos(20),
expn_info:None};
let _e : crate =
spanned{
node: crate_{
module: _mod {view_items: ~[], items: ~[]},
attrs: ~[],
config: ~[]
},
span: bogus_span};
// doesn't matter which encoder we use....
let _f = (_e as std::serialize::Encodable::<std::json::Encoder>);
}
*/
}
2010-08-12 12:27:50 -05:00
//
// Local Variables:
// mode: rust
// fill-column: 78;
// indent-tabs-mode: nil
// c-basic-offset: 4
// buffer-file-coding-system: utf-8-unix
// End:
//