2012-12-03 18:48:01 -06:00
|
|
|
// 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.
|
|
|
|
|
2011-07-05 18:23:07 -05:00
|
|
|
// The Rust abstract syntax tree.
|
2011-06-15 13:19:50 -05:00
|
|
|
|
2012-11-12 20:59:37 -06:00
|
|
|
use codemap::{span, FileName};
|
2012-05-21 12:45:56 -05:00
|
|
|
|
2012-12-23 16:41:37 -06:00
|
|
|
use core::cast;
|
|
|
|
use core::cmp;
|
2013-01-08 21:37:25 -06:00
|
|
|
use core::option::{None, Option, Some};
|
2012-12-23 16:41:37 -06:00
|
|
|
use core::ptr;
|
|
|
|
use core::task;
|
|
|
|
use core::to_bytes;
|
2013-01-08 16:00:45 -06:00
|
|
|
use core::to_str::ToStr;
|
2012-12-23 16:41:37 -06:00
|
|
|
use std::serialize::{Encodable, Decodable, Encoder, Decoder};
|
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2012-12-27 13:36:00 -06:00
|
|
|
struct spanned<T> { node: T, span: span }
|
2012-08-24 14:19:19 -05:00
|
|
|
|
|
|
|
/* can't import macros yet, so this is copied from token.rs. See its comment
|
|
|
|
* there. */
|
|
|
|
macro_rules! interner_key (
|
2013-01-08 21:37:25 -06:00
|
|
|
() => (cast::transmute::<(uint, uint),
|
|
|
|
&fn(+v: @@::parse::token::ident_interner)>(
|
2012-08-24 14:19:19 -05:00
|
|
|
(-3 as uint, 0u)))
|
|
|
|
)
|
|
|
|
|
2012-09-19 20:50:24 -05:00
|
|
|
// FIXME(#3534): Replace with the struct-based newtype when it's been
|
|
|
|
// implemented.
|
|
|
|
struct ident { repr: uint }
|
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
impl<S: Encoder> ident: Encodable<S> {
|
|
|
|
fn encode(&self, s: &S) {
|
2012-10-13 11:11:33 -05:00
|
|
|
let intr = match unsafe {
|
|
|
|
task::local_data::local_data_get(interner_key!())
|
|
|
|
} {
|
2012-12-17 21:31:04 -06:00
|
|
|
None => fail ~"encode: TLS interner not set up",
|
2012-10-13 11:11:33 -05:00
|
|
|
Some(intr) => intr
|
|
|
|
};
|
|
|
|
|
|
|
|
s.emit_owned_str(*(*intr).get(*self));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
impl<D: Decoder> ident: Decodable<D> {
|
|
|
|
static fn decode(d: &D) -> ident {
|
2012-10-13 11:11:33 -05:00
|
|
|
let intr = match unsafe {
|
|
|
|
task::local_data::local_data_get(interner_key!())
|
2012-10-07 12:31:34 -05:00
|
|
|
} {
|
2012-12-17 21:31:04 -06:00
|
|
|
None => fail ~"decode: TLS interner not set up",
|
2012-10-07 12:31:34 -05:00
|
|
|
Some(intr) => intr
|
|
|
|
};
|
|
|
|
|
|
|
|
(*intr).intern(@d.read_owned_str())
|
|
|
|
}
|
2012-07-18 18:18:02 -05:00
|
|
|
}
|
|
|
|
|
2012-09-19 20:50:24 -05:00
|
|
|
impl ident: cmp::Eq {
|
2012-11-14 20:59:30 -06:00
|
|
|
pure fn eq(&self, other: &ident) -> bool { (*self).repr == other.repr }
|
|
|
|
pure fn ne(&self, other: &ident) -> bool { !(*self).eq(other) }
|
2012-09-19 20:50:24 -05:00
|
|
|
}
|
|
|
|
|
2012-11-28 13:36:04 -06:00
|
|
|
impl ident: to_bytes::IterBytes {
|
|
|
|
pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
|
|
|
|
self.repr.iter_bytes(lsb0, f)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-06-24 17:11:22 -05:00
|
|
|
// Functions may or may not have names.
|
2012-08-20 14:23:37 -05:00
|
|
|
type fn_ident = Option<ident>;
|
2010-08-18 11:00:10 -05:00
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2013-01-13 12:48:09 -06:00
|
|
|
struct path {
|
|
|
|
span: span,
|
|
|
|
global: bool,
|
|
|
|
idents: ~[ident],
|
|
|
|
rp: Option<@region>,
|
|
|
|
types: ~[@Ty],
|
|
|
|
}
|
2010-10-04 19:25:52 -05:00
|
|
|
|
2010-10-05 20:21:44 -05:00
|
|
|
type crate_num = int;
|
2012-03-14 16:18:53 -05:00
|
|
|
|
2011-06-19 15:41:21 -05:00
|
|
|
type node_id = int;
|
2012-03-14 16:18:53 -05:00
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2013-01-13 13:05:40 -06:00
|
|
|
struct def_id {
|
|
|
|
crate: crate_num,
|
|
|
|
node: node_id,
|
|
|
|
}
|
2011-06-15 13:19:50 -05:00
|
|
|
|
2012-09-19 20:00:26 -05:00
|
|
|
impl def_id : cmp::Eq {
|
2012-11-14 20:59:30 -06:00
|
|
|
pure fn eq(&self, other: &def_id) -> bool {
|
|
|
|
(*self).crate == (*other).crate && (*self).node == (*other).node
|
|
|
|
}
|
|
|
|
pure fn ne(&self, other: &def_id) -> bool { !(*self).eq(other) }
|
2012-09-19 20:00:26 -05:00
|
|
|
}
|
2012-08-27 18:26:35 -05:00
|
|
|
|
2011-07-27 07:19:39 -05:00
|
|
|
const local_crate: crate_num = 0;
|
2011-12-16 09:55:22 -06:00
|
|
|
const crate_node_id: node_id = 0;
|
2010-10-18 18:15:25 -05:00
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2012-10-17 00:14:59 -05:00
|
|
|
// 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.
|
2013-01-10 13:16:54 -06:00
|
|
|
enum ty_param_bound {
|
|
|
|
TraitTyParamBound(@Ty),
|
|
|
|
RegionTyParamBound
|
|
|
|
}
|
2011-12-28 10:50:12 -06:00
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2013-01-13 13:15:14 -06:00
|
|
|
struct ty_param {
|
|
|
|
ident: ident,
|
|
|
|
id: node_id,
|
|
|
|
bounds: @~[ty_param_bound]
|
|
|
|
}
|
2010-11-24 20:01:20 -06:00
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2012-01-19 16:24:03 -06:00
|
|
|
enum def {
|
2012-01-19 19:56:05 -06:00
|
|
|
def_fn(def_id, purity),
|
2012-10-12 19:00:08 -05:00
|
|
|
def_static_method(/* method */ def_id,
|
2012-10-18 15:29:34 -05:00
|
|
|
/* trait */ Option<def_id>,
|
2012-10-12 19:00:08 -05:00
|
|
|
purity),
|
2012-12-10 13:58:37 -06:00
|
|
|
def_self(node_id, bool /* is_implicit */),
|
|
|
|
def_self_ty(node_id),
|
2012-01-19 19:56:05 -06:00
|
|
|
def_mod(def_id),
|
2012-06-26 18:18:37 -05:00
|
|
|
def_foreign_mod(def_id),
|
2012-01-19 19:56:05 -06:00
|
|
|
def_const(def_id),
|
2012-02-27 18:05:17 -06:00
|
|
|
def_arg(node_id, mode),
|
2012-02-28 21:28:29 -06:00
|
|
|
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),
|
2012-02-06 08:29:56 -06:00
|
|
|
def_prim_ty(prim_ty),
|
2012-01-19 19:56:05 -06:00
|
|
|
def_ty_param(def_id, uint),
|
2012-08-02 18:00:45 -05:00
|
|
|
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
|
2012-12-10 15:47:54 -06:00
|
|
|
def_struct(def_id),
|
|
|
|
def_typaram_binder(node_id), /* struct, impl or trait with ty params */
|
2012-08-14 21:20:56 -05:00
|
|
|
def_region(node_id),
|
|
|
|
def_label(node_id)
|
2010-10-05 20:21:44 -05:00
|
|
|
}
|
2010-10-04 19:25:52 -05:00
|
|
|
|
2012-09-19 20:00:26 -05:00
|
|
|
impl def : cmp::Eq {
|
2012-11-14 20:59:30 -06:00
|
|
|
pure fn eq(&self, other: &def) -> bool {
|
|
|
|
match (*self) {
|
|
|
|
def_fn(e0a, e1a) => {
|
|
|
|
match (*other) {
|
|
|
|
def_fn(e0b, e1b) => e0a == e0b && e1a == e1b,
|
|
|
|
_ => false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
def_static_method(e0a, e1a, e2a) => {
|
|
|
|
match (*other) {
|
|
|
|
def_static_method(e0b, e1b, e2b) =>
|
|
|
|
e0a == e0b && e1a == e1b && e2a == e2b,
|
|
|
|
_ => false
|
|
|
|
}
|
|
|
|
}
|
2012-12-10 13:58:37 -06:00
|
|
|
def_self(e0a, e1a) => {
|
2012-11-14 20:59:30 -06:00
|
|
|
match (*other) {
|
2012-12-10 13:58:37 -06:00
|
|
|
def_self(e0b, e1b) => e0a == e0b && e1a == e1b,
|
|
|
|
_ => false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
def_self_ty(e0a) => {
|
|
|
|
match (*other) {
|
|
|
|
def_self_ty(e0b) => e0a == e0b,
|
2012-11-14 20:59:30 -06:00
|
|
|
_ => false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
def_mod(e0a) => {
|
|
|
|
match (*other) {
|
|
|
|
def_mod(e0b) => e0a == e0b,
|
|
|
|
_ => false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
def_foreign_mod(e0a) => {
|
|
|
|
match (*other) {
|
|
|
|
def_foreign_mod(e0b) => e0a == e0b,
|
|
|
|
_ => false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
def_const(e0a) => {
|
|
|
|
match (*other) {
|
|
|
|
def_const(e0b) => e0a == e0b,
|
|
|
|
_ => false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
def_arg(e0a, e1a) => {
|
|
|
|
match (*other) {
|
|
|
|
def_arg(e0b, e1b) => e0a == e0b && e1a == e1b,
|
|
|
|
_ => false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
def_local(e0a, e1a) => {
|
|
|
|
match (*other) {
|
|
|
|
def_local(e0b, e1b) => e0a == e0b && e1a == e1b,
|
|
|
|
_ => false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
def_variant(e0a, e1a) => {
|
|
|
|
match (*other) {
|
|
|
|
def_variant(e0b, e1b) => e0a == e0b && e1a == e1b,
|
|
|
|
_ => false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
def_ty(e0a) => {
|
|
|
|
match (*other) {
|
|
|
|
def_ty(e0b) => e0a == e0b,
|
|
|
|
_ => false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
def_prim_ty(e0a) => {
|
|
|
|
match (*other) {
|
|
|
|
def_prim_ty(e0b) => e0a == e0b,
|
|
|
|
_ => false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
def_ty_param(e0a, e1a) => {
|
|
|
|
match (*other) {
|
|
|
|
def_ty_param(e0b, e1b) => e0a == e0b && e1a == e1b,
|
|
|
|
_ => false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
def_binding(e0a, e1a) => {
|
|
|
|
match (*other) {
|
|
|
|
def_binding(e0b, e1b) => e0a == e0b && e1a == e1b,
|
|
|
|
_ => false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
def_use(e0a) => {
|
|
|
|
match (*other) {
|
|
|
|
def_use(e0b) => e0a == e0b,
|
|
|
|
_ => false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
def_upvar(e0a, e1a, e2a, e3a) => {
|
|
|
|
match (*other) {
|
|
|
|
def_upvar(e0b, e1b, e2b, e3b) =>
|
|
|
|
e0a == e0b && e1a == e1b && e2a == e2b && e3a == e3b,
|
|
|
|
_ => false
|
|
|
|
}
|
|
|
|
}
|
2012-12-10 15:47:54 -06:00
|
|
|
def_struct(e0a) => {
|
2012-11-14 20:59:30 -06:00
|
|
|
match (*other) {
|
2012-12-10 15:47:54 -06:00
|
|
|
def_struct(e0b) => e0a == e0b,
|
2012-11-14 20:59:30 -06:00
|
|
|
_ => false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
def_typaram_binder(e0a) => {
|
|
|
|
match (*other) {
|
|
|
|
def_typaram_binder(e1a) => e0a == e1a,
|
|
|
|
_ => false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
def_region(e0a) => {
|
|
|
|
match (*other) {
|
|
|
|
def_region(e0b) => e0a == e0b,
|
|
|
|
_ => false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
def_label(e0a) => {
|
|
|
|
match (*other) {
|
|
|
|
def_label(e0b) => e0a == e0b,
|
|
|
|
_ => false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
pure fn ne(&self, other: &def) -> bool { !(*self).eq(other) }
|
2012-09-19 20:00:26 -05:00
|
|
|
}
|
2012-08-27 18:26:35 -05:00
|
|
|
|
2011-06-29 20:07:15 -05:00
|
|
|
// The set of meta_items that define the compilation environment of the crate,
|
|
|
|
// used to drive conditional compilation
|
2012-09-20 20:15:39 -05:00
|
|
|
type crate_cfg = ~[@meta_item];
|
2011-06-29 20:07:15 -05:00
|
|
|
|
2011-08-12 09:15:18 -05:00
|
|
|
type crate = spanned<crate_>;
|
2010-08-18 11:00:10 -05:00
|
|
|
|
2013-01-14 21:06:59 -06:00
|
|
|
struct crate_ {
|
|
|
|
module: _mod,
|
|
|
|
attrs: ~[attribute],
|
|
|
|
config: crate_cfg,
|
|
|
|
}
|
2011-06-15 13:19:50 -05:00
|
|
|
|
2011-08-12 09:15:18 -05:00
|
|
|
type meta_item = spanned<meta_item_>;
|
2011-06-15 13:19:50 -05:00
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2012-01-19 16:24:03 -06:00
|
|
|
enum meta_item_ {
|
2012-07-18 18:18:02 -05:00
|
|
|
meta_word(~str),
|
2012-09-20 20:15:39 -05:00
|
|
|
meta_list(~str, ~[@meta_item]),
|
2012-07-18 18:18:02 -05:00
|
|
|
meta_name_value(~str, lit),
|
2011-06-21 16:23:16 -05:00
|
|
|
}
|
2010-12-30 10:21:37 -06:00
|
|
|
|
2011-08-12 09:15:18 -05:00
|
|
|
type blk = spanned<blk_>;
|
2011-06-15 13:19:50 -05:00
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2013-01-14 21:35:08 -06:00
|
|
|
struct blk_ {
|
|
|
|
view_items: ~[@view_item],
|
|
|
|
stmts: ~[@stmt],
|
|
|
|
expr: Option<@expr>,
|
|
|
|
id: node_id,
|
|
|
|
rules: blk_check_mode,
|
|
|
|
}
|
2010-08-18 11:00:10 -05:00
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2013-01-14 22:52:28 -06:00
|
|
|
struct pat {
|
|
|
|
id: node_id,
|
|
|
|
node: pat_,
|
|
|
|
span: span,
|
|
|
|
}
|
2011-06-15 13:19:50 -05:00
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2013-01-14 22:52:28 -06:00
|
|
|
struct field_pat {
|
|
|
|
ident: ident,
|
|
|
|
pat: @pat,
|
|
|
|
}
|
2011-07-11 07:13:20 -05:00
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2012-07-31 21:25:24 -05:00
|
|
|
enum binding_mode {
|
|
|
|
bind_by_value,
|
2012-08-22 18:00:28 -05:00
|
|
|
bind_by_move,
|
2013-01-11 14:33:50 -06:00
|
|
|
bind_by_ref(mutability),
|
2012-12-07 21:34:57 -06:00
|
|
|
bind_infer
|
2012-07-31 21:25:24 -05:00
|
|
|
}
|
|
|
|
|
2012-11-28 13:36:04 -06:00
|
|
|
impl binding_mode : to_bytes::IterBytes {
|
|
|
|
pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
|
|
|
|
match *self {
|
|
|
|
bind_by_value => 0u8.iter_bytes(lsb0, f),
|
|
|
|
|
|
|
|
bind_by_move => 1u8.iter_bytes(lsb0, f),
|
|
|
|
|
|
|
|
bind_by_ref(ref m) =>
|
|
|
|
to_bytes::iter_bytes_2(&2u8, m, lsb0, f),
|
|
|
|
|
2012-12-07 21:34:57 -06:00
|
|
|
bind_infer =>
|
2012-11-28 13:36:04 -06:00
|
|
|
3u8.iter_bytes(lsb0, f),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-09-19 20:00:26 -05:00
|
|
|
impl binding_mode : cmp::Eq {
|
2012-11-14 20:59:30 -06:00
|
|
|
pure fn eq(&self, other: &binding_mode) -> bool {
|
|
|
|
match (*self) {
|
|
|
|
bind_by_value => {
|
|
|
|
match (*other) {
|
|
|
|
bind_by_value => true,
|
|
|
|
_ => false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
bind_by_move => {
|
|
|
|
match (*other) {
|
|
|
|
bind_by_move => true,
|
|
|
|
_ => false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
bind_by_ref(e0a) => {
|
|
|
|
match (*other) {
|
|
|
|
bind_by_ref(e0b) => e0a == e0b,
|
|
|
|
_ => false
|
|
|
|
}
|
|
|
|
}
|
2012-12-07 21:34:57 -06:00
|
|
|
bind_infer => {
|
2012-11-14 20:59:30 -06:00
|
|
|
match (*other) {
|
2012-12-07 21:34:57 -06:00
|
|
|
bind_infer => true,
|
2012-11-14 20:59:30 -06:00
|
|
|
_ => false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
pure fn ne(&self, other: &binding_mode) -> bool { !(*self).eq(other) }
|
2012-09-19 20:00:26 -05:00
|
|
|
}
|
2012-08-27 18:26:35 -05:00
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2012-01-19 16:24:03 -06:00
|
|
|
enum pat_ {
|
2012-01-19 19:56:05 -06:00
|
|
|
pat_wild,
|
2012-01-14 18:05:07 -06:00
|
|
|
// 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
|
2012-01-14 18:05:07 -06:00
|
|
|
// which it is. The resolver determines this, and
|
|
|
|
// records this pattern's node_id in an auxiliary
|
2012-01-25 07:34:31 -06:00
|
|
|
// 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
|
2012-04-20 02:54:42 -05:00
|
|
|
// we don't bind the fields to names
|
2012-06-29 18:26:56 -05:00
|
|
|
pat_rec(~[field_pat], bool),
|
2012-08-06 19:01:14 -05:00
|
|
|
pat_struct(@path, ~[field_pat], bool),
|
2012-06-29 18:26:56 -05:00
|
|
|
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),
|
2012-12-08 14:22:43 -06:00
|
|
|
pat_vec(~[@pat], Option<@pat>)
|
2010-11-24 16:42:01 -06:00
|
|
|
}
|
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2012-02-15 13:25:39 -06:00
|
|
|
enum mutability { m_mutbl, m_imm, m_const, }
|
2010-11-29 16:18:26 -06:00
|
|
|
|
2012-11-28 13:36:04 -06:00
|
|
|
impl mutability : to_bytes::IterBytes {
|
|
|
|
pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
|
|
|
|
(*self as u8).iter_bytes(lsb0, f)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-09-19 20:00:26 -05:00
|
|
|
impl mutability : cmp::Eq {
|
2012-11-14 20:59:30 -06:00
|
|
|
pure fn eq(&self, other: &mutability) -> bool {
|
|
|
|
((*self) as uint) == ((*other) as uint)
|
|
|
|
}
|
|
|
|
pure fn ne(&self, other: &mutability) -> bool { !(*self).eq(other) }
|
2012-09-19 20:00:26 -05:00
|
|
|
}
|
2012-08-27 18:26:35 -05:00
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2013-01-08 16:00:45 -06:00
|
|
|
#[deriving_eq]
|
2012-11-04 22:41:00 -06:00
|
|
|
pub enum Proto {
|
|
|
|
ProtoBare, // bare functions (deprecated)
|
|
|
|
ProtoUniq, // ~fn
|
|
|
|
ProtoBox, // @fn
|
|
|
|
ProtoBorrowed, // &fn
|
2011-10-10 15:15:47 -05:00
|
|
|
}
|
2011-02-18 19:30:57 -06:00
|
|
|
|
2012-11-28 13:36:04 -06:00
|
|
|
impl Proto : to_bytes::IterBytes {
|
|
|
|
pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
|
|
|
|
(*self as uint).iter_bytes(lsb0, f);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2012-04-09 19:32:49 -05:00
|
|
|
enum vstore {
|
2012-10-11 17:35:31 -05:00
|
|
|
// FIXME (#3469): Change uint to @expr (actually only constant exprs)
|
2012-10-09 23:28:04 -05:00
|
|
|
vstore_fixed(Option<uint>), // [1,2,3,4]
|
2012-06-29 18:26:56 -05:00
|
|
|
vstore_uniq, // ~[1,2,3,4]
|
|
|
|
vstore_box, // @[1,2,3,4]
|
|
|
|
vstore_slice(@region) // &[1,2,3,4](foo)?
|
2012-04-09 19:32:49 -05:00
|
|
|
}
|
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2012-09-11 23:25:01 -05:00
|
|
|
enum expr_vstore {
|
2012-10-11 17:35:31 -05:00
|
|
|
// FIXME (#3469): Change uint to @expr (actually only constant exprs)
|
2012-10-09 23:28:04 -05:00
|
|
|
expr_vstore_fixed(Option<uint>), // [1,2,3,4]
|
2012-09-11 23:25:01 -05:00
|
|
|
expr_vstore_uniq, // ~[1,2,3,4]
|
|
|
|
expr_vstore_box, // @[1,2,3,4]
|
2012-11-21 13:39:06 -06:00
|
|
|
expr_vstore_mut_box, // @mut [1,2,3,4]
|
2012-12-07 18:26:52 -06:00
|
|
|
expr_vstore_slice, // &[1,2,3,4]
|
|
|
|
expr_vstore_mut_slice, // &mut [1,2,3,4]
|
2012-09-11 23:25:01 -05:00
|
|
|
}
|
|
|
|
|
2013-01-11 14:33:50 -06:00
|
|
|
pure fn is_blockish(p: Proto) -> bool {
|
2012-08-06 14:34:08 -05:00
|
|
|
match p {
|
2012-11-04 22:41:00 -06:00
|
|
|
ProtoBorrowed => true,
|
|
|
|
ProtoBare | ProtoUniq | ProtoBox => false
|
2012-01-12 17:38:44 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2012-01-19 16:24:03 -06:00
|
|
|
enum binop {
|
2012-01-19 19:56:05 -06:00
|
|
|
add,
|
|
|
|
subtract,
|
|
|
|
mul,
|
|
|
|
div,
|
|
|
|
rem,
|
|
|
|
and,
|
|
|
|
or,
|
|
|
|
bitxor,
|
|
|
|
bitand,
|
|
|
|
bitor,
|
2012-05-22 16:59:15 -05:00
|
|
|
shl,
|
|
|
|
shr,
|
2012-01-19 19:56:05 -06:00
|
|
|
eq,
|
|
|
|
lt,
|
|
|
|
le,
|
|
|
|
ne,
|
|
|
|
ge,
|
|
|
|
gt,
|
2010-09-27 20:25:02 -05:00
|
|
|
}
|
|
|
|
|
2012-09-19 20:00:26 -05:00
|
|
|
impl binop : cmp::Eq {
|
2012-11-14 20:59:30 -06:00
|
|
|
pure fn eq(&self, other: &binop) -> bool {
|
|
|
|
((*self) as uint) == ((*other) as uint)
|
|
|
|
}
|
|
|
|
pure fn ne(&self, other: &binop) -> bool { !(*self).eq(other) }
|
2012-09-19 20:00:26 -05:00
|
|
|
}
|
2012-08-27 18:26:35 -05:00
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2012-01-19 16:24:03 -06:00
|
|
|
enum unop {
|
2012-01-19 19:56:05 -06:00
|
|
|
box(mutability),
|
|
|
|
uniq(mutability),
|
2012-09-07 20:53:14 -05:00
|
|
|
deref,
|
|
|
|
not,
|
|
|
|
neg
|
|
|
|
}
|
|
|
|
|
2012-09-19 20:00:26 -05:00
|
|
|
impl unop : cmp::Eq {
|
2012-11-14 20:59:30 -06:00
|
|
|
pure fn eq(&self, other: &unop) -> bool {
|
|
|
|
match (*self) {
|
|
|
|
box(e0a) => {
|
|
|
|
match (*other) {
|
|
|
|
box(e0b) => e0a == e0b,
|
|
|
|
_ => false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
uniq(e0a) => {
|
|
|
|
match (*other) {
|
|
|
|
uniq(e0b) => e0a == e0b,
|
|
|
|
_ => false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
deref => {
|
|
|
|
match (*other) {
|
|
|
|
deref => true,
|
|
|
|
_ => false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
not => {
|
|
|
|
match (*other) {
|
|
|
|
not => true,
|
|
|
|
_ => false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
neg => {
|
|
|
|
match (*other) {
|
|
|
|
neg => true,
|
|
|
|
_ => false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
pure fn ne(&self, other: &unop) -> bool {
|
|
|
|
!(*self).eq(other)
|
|
|
|
}
|
2012-09-19 20:00:26 -05:00
|
|
|
}
|
2010-09-27 20:25:02 -05:00
|
|
|
|
2012-02-02 18:50:17 -06:00
|
|
|
// Generally, after typeck you can get the inferred value
|
|
|
|
// using ty::resolved_T(...).
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2012-02-02 18:50:17 -06:00
|
|
|
enum inferable<T> {
|
2012-08-27 18:26:35 -05:00
|
|
|
expl(T),
|
|
|
|
infer(node_id)
|
|
|
|
}
|
|
|
|
|
2012-11-28 13:36:04 -06:00
|
|
|
impl<T: to_bytes::IterBytes> inferable<T> : to_bytes::IterBytes {
|
|
|
|
pure 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),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-09-19 20:00:26 -05:00
|
|
|
impl<T:cmp::Eq> inferable<T> : cmp::Eq {
|
2012-11-14 20:59:30 -06:00
|
|
|
pure fn eq(&self, other: &inferable<T>) -> bool {
|
|
|
|
match (*self) {
|
2012-12-04 12:50:00 -06:00
|
|
|
expl(ref e0a) => {
|
2012-11-14 20:59:30 -06:00
|
|
|
match (*other) {
|
2012-12-04 12:50:00 -06:00
|
|
|
expl(ref e0b) => (*e0a) == (*e0b),
|
2012-11-14 20:59:30 -06:00
|
|
|
_ => false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
infer(e0a) => {
|
|
|
|
match (*other) {
|
|
|
|
infer(e0b) => e0a == e0b,
|
|
|
|
_ => false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
pure fn ne(&self, other: &inferable<T>) -> bool { !(*self).eq(other) }
|
2012-09-19 20:00:26 -05:00
|
|
|
}
|
2012-02-02 18:50:17 -06:00
|
|
|
|
|
|
|
// "resolved" mode: the real modes.
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2012-10-06 00:07:53 -05:00
|
|
|
enum rmode { by_ref, by_val, by_move, by_copy }
|
2012-02-02 18:50:17 -06:00
|
|
|
|
2012-11-28 13:36:04 -06:00
|
|
|
impl rmode : to_bytes::IterBytes {
|
|
|
|
pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
|
|
|
|
(*self as u8).iter_bytes(lsb0, f)
|
|
|
|
}
|
|
|
|
}
|
2012-09-07 19:24:02 -05:00
|
|
|
|
|
|
|
|
2012-09-19 20:00:26 -05:00
|
|
|
impl rmode : cmp::Eq {
|
2012-11-14 20:59:30 -06:00
|
|
|
pure fn eq(&self, other: &rmode) -> bool {
|
|
|
|
((*self) as uint) == ((*other) as uint)
|
|
|
|
}
|
|
|
|
pure fn ne(&self, other: &rmode) -> bool { !(*self).eq(other) }
|
2012-09-19 20:00:26 -05:00
|
|
|
}
|
2012-08-27 18:26:35 -05:00
|
|
|
|
2012-02-02 18:50:17 -06:00
|
|
|
// inferable mode.
|
|
|
|
type mode = inferable<rmode>;
|
2010-12-03 20:03:28 -06:00
|
|
|
|
2011-08-12 09:15:18 -05:00
|
|
|
type stmt = spanned<stmt_>;
|
2011-06-15 13:19:50 -05:00
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2012-01-19 16:24:03 -06:00
|
|
|
enum stmt_ {
|
2012-01-19 19:56:05 -06:00
|
|
|
stmt_decl(@decl, node_id),
|
2012-07-03 19:30:25 -05:00
|
|
|
|
|
|
|
// expr without trailing semi-colon (must have unit type):
|
2012-01-19 19:56:05 -06:00
|
|
|
stmt_expr(@expr, node_id),
|
2012-07-03 19:30:25 -05:00
|
|
|
|
|
|
|
// expr with trailing semi-colon (may have any type):
|
|
|
|
stmt_semi(@expr, node_id),
|
2012-11-12 22:06:55 -06:00
|
|
|
|
2012-11-21 12:37:43 -06:00
|
|
|
// bool: is there a trailing sem-colon?
|
|
|
|
stmt_mac(mac, bool),
|
2010-09-09 17:59:29 -05:00
|
|
|
}
|
|
|
|
|
2012-06-21 18:44:10 -05:00
|
|
|
// FIXME (pending discussion of #1697, #2178...): local should really be
|
|
|
|
// a refinement on pat.
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2013-01-14 22:52:28 -06:00
|
|
|
struct local_ {
|
|
|
|
is_mutbl: bool,
|
|
|
|
ty: @Ty,
|
|
|
|
pat: @pat,
|
|
|
|
init: Option<@expr>,
|
|
|
|
id: node_id,
|
|
|
|
}
|
2011-03-24 20:04:29 -05:00
|
|
|
|
2011-08-12 09:15:18 -05:00
|
|
|
type local = spanned<local_>;
|
2010-10-18 20:19:16 -05:00
|
|
|
|
2011-08-12 09:15:18 -05:00
|
|
|
type decl = spanned<decl_>;
|
2011-06-15 13:19:50 -05:00
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2012-06-29 18:26:56 -05:00
|
|
|
enum decl_ { decl_local(~[@local]), decl_item(@item), }
|
2010-09-09 17:59:29 -05:00
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2013-01-14 22:52:28 -06:00
|
|
|
struct arm {
|
|
|
|
pats: ~[@pat],
|
|
|
|
guard: Option<@expr>,
|
|
|
|
body: blk,
|
|
|
|
}
|
2010-11-24 17:45:59 -06:00
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2013-01-14 23:36:27 -06:00
|
|
|
struct field_ {
|
|
|
|
mutbl: mutability,
|
|
|
|
ident: ident,
|
|
|
|
expr: @expr,
|
|
|
|
}
|
2011-06-15 13:19:50 -05:00
|
|
|
|
2011-08-12 09:15:18 -05:00
|
|
|
type field = spanned<field_>;
|
2010-11-30 18:31:43 -06:00
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2012-09-18 13:51:06 -05:00
|
|
|
enum blk_check_mode { default_blk, unsafe_blk, }
|
2011-10-06 18:42:27 -05:00
|
|
|
|
2012-09-19 20:00:26 -05:00
|
|
|
impl blk_check_mode : cmp::Eq {
|
2012-11-14 20:59:30 -06:00
|
|
|
pure fn eq(&self, other: &blk_check_mode) -> bool {
|
|
|
|
match ((*self), (*other)) {
|
|
|
|
(default_blk, default_blk) => true,
|
|
|
|
(unsafe_blk, unsafe_blk) => true,
|
|
|
|
(default_blk, _) => false,
|
|
|
|
(unsafe_blk, _) => false,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
pure fn ne(&self, other: &blk_check_mode) -> bool { !(*self).eq(other) }
|
2012-09-19 20:00:26 -05:00
|
|
|
}
|
2012-08-27 18:26:35 -05:00
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2013-01-15 15:51:43 -06:00
|
|
|
struct expr {
|
|
|
|
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,
|
|
|
|
}
|
2011-06-15 13:19:50 -05:00
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2012-11-06 20:41:06 -06:00
|
|
|
enum log_level { error, debug, log_other }
|
|
|
|
// 0 = error, 1 = debug, 2 = log_other
|
2012-08-21 19:22:45 -05:00
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2012-01-19 16:24:03 -06:00
|
|
|
enum expr_ {
|
2012-09-11 23:25:01 -05:00
|
|
|
expr_vstore(@expr, expr_vstore),
|
2012-06-29 18:26:56 -05:00
|
|
|
expr_vec(~[@expr], mutability),
|
2012-08-20 14:23:37 -05:00
|
|
|
expr_rec(~[field], Option<@expr>),
|
2012-06-29 18:26:56 -05:00
|
|
|
expr_call(@expr, ~[@expr], bool), // True iff last argument is a block
|
2012-11-30 13:18:25 -06:00
|
|
|
expr_method_call(@expr, ident, ~[@Ty], ~[@expr], bool), // Ditto
|
2012-06-29 18:26:56 -05:00
|
|
|
expr_tup(~[@expr]),
|
2012-01-19 19:56:05 -06:00
|
|
|
expr_binary(binop, @expr, @expr),
|
|
|
|
expr_unary(unop, @expr),
|
|
|
|
expr_lit(@lit),
|
2012-10-15 16:56:42 -05:00
|
|
|
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),
|
2012-03-09 18:11:56 -06:00
|
|
|
/* Conditionless loop (can be exited with break, cont, ret, or fail)
|
|
|
|
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]),
|
2012-11-04 22:41:00 -06:00
|
|
|
expr_fn(Proto, fn_decl, blk, capture_clause),
|
2012-05-04 14:33:04 -05:00
|
|
|
expr_fn_block(fn_decl, blk, capture_clause),
|
2012-03-27 05:33:13 -05:00
|
|
|
// Inner expr is always an expr_fn_block. We need the wrapping node to
|
2012-06-06 23:51:09 -05:00
|
|
|
// easily type this (a function returning nil on the inside but bool on
|
2012-03-27 05:33:13 -05:00
|
|
|
// the outside).
|
2012-03-26 09:09:27 -05:00
|
|
|
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),
|
2011-08-19 17:16:48 -05:00
|
|
|
|
2012-01-19 19:56:05 -06:00
|
|
|
expr_copy(@expr),
|
2012-07-31 19:31:24 -05:00
|
|
|
expr_unary_move(@expr),
|
2012-01-19 19:56:05 -06:00
|
|
|
expr_assign(@expr, @expr),
|
|
|
|
expr_swap(@expr, @expr),
|
|
|
|
expr_assign_op(binop, @expr, @expr),
|
2012-10-15 16:56:42 -05:00
|
|
|
expr_field(@expr, ident, ~[@Ty]),
|
2012-01-19 19:56:05 -06:00
|
|
|
expr_index(@expr, @expr),
|
|
|
|
expr_path(@path),
|
2012-03-08 18:34:36 -06:00
|
|
|
expr_addr_of(mutability, @expr),
|
2012-08-20 14:23:37 -05:00
|
|
|
expr_fail(Option<@expr>),
|
|
|
|
expr_break(Option<ident>),
|
|
|
|
expr_again(Option<ident>),
|
|
|
|
expr_ret(Option<@expr>),
|
2012-08-21 19:22:45 -05:00
|
|
|
expr_log(log_level, @expr, @expr),
|
2011-08-19 17:16:48 -05:00
|
|
|
|
2012-07-23 15:24:58 -05:00
|
|
|
/* just an assert */
|
2012-01-19 19:56:05 -06:00
|
|
|
expr_assert(@expr),
|
2011-08-19 17:16:48 -05:00
|
|
|
|
2012-01-19 19:56:05 -06:00
|
|
|
expr_mac(mac),
|
2012-07-23 18:39:18 -05:00
|
|
|
|
|
|
|
// A struct literal expression.
|
2012-08-20 14:23:37 -05:00
|
|
|
expr_struct(@path, ~[field], Option<@expr>),
|
2012-08-03 20:01:30 -05:00
|
|
|
|
|
|
|
// A vector literal constructed from one repeated element.
|
2012-10-27 19:14:09 -05:00
|
|
|
expr_repeat(@expr /* element */, @expr /* count */, mutability),
|
|
|
|
|
|
|
|
// No-op: used solely so we can pretty-print faithfully
|
|
|
|
expr_paren(@expr)
|
2011-07-08 18:35:09 -05:00
|
|
|
}
|
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2013-01-14 23:36:27 -06:00
|
|
|
struct capture_item_ {
|
2011-12-17 23:12:30 -06:00
|
|
|
id: int,
|
2012-05-04 14:33:04 -05:00
|
|
|
is_move: bool,
|
2011-12-17 23:12:30 -06:00
|
|
|
name: ident, // Currently, can only capture a local var.
|
2013-01-14 23:36:27 -06:00
|
|
|
span: span,
|
|
|
|
}
|
2012-03-14 16:18:53 -05:00
|
|
|
|
2012-10-07 12:31:34 -05:00
|
|
|
type capture_item = @capture_item_;
|
|
|
|
|
2012-06-29 18:26:56 -05:00
|
|
|
type capture_clause = @~[capture_item];
|
2011-12-08 13:47:01 -06:00
|
|
|
|
2012-07-27 21:14:46 -05:00
|
|
|
//
|
|
|
|
// 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
|
2012-08-24 20:19:39 -05:00
|
|
|
// macro_parser::matched_nonterminals into the tt_nonterminals it finds.
|
2012-07-27 21:14:46 -05:00
|
|
|
//
|
|
|
|
// 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.
|
|
|
|
//
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2012-06-27 17:29:35 -05:00
|
|
|
#[doc="For macro invocations; parsing is delegated to the macro"]
|
2012-05-30 13:36:30 -05:00
|
|
|
enum token_tree {
|
2013-01-08 21:37:25 -06:00
|
|
|
tt_tok(span, ::parse::token::Token),
|
2012-06-29 18:26:56 -05:00
|
|
|
tt_delim(~[token_tree]),
|
2012-07-27 21:14:46 -05:00
|
|
|
// These only make sense for right-hand-sides of MBE macros
|
2013-01-08 21:37:25 -06:00
|
|
|
tt_seq(span, ~[token_tree], Option<::parse::token::Token>, bool),
|
2012-07-27 21:14:46 -05:00
|
|
|
tt_nonterminal(span, ident)
|
2012-05-21 12:45:56 -05:00
|
|
|
}
|
|
|
|
|
2012-07-27 19:42:32 -05:00
|
|
|
//
|
|
|
|
// Matchers are nodes defined-by and recognized-by the main rust parser and
|
2012-07-27 21:14:46 -05:00
|
|
|
// language, but they're only ever found inside syntax-extension invocations;
|
|
|
|
// indeed, the only thing that ever _activates_ the rules in the rust parser
|
2012-07-27 21:19:40 -05:00
|
|
|
// for parsing a matcher is a matcher looking for the 'matchers' nonterminal
|
2012-07-27 21:14:46 -05:00
|
|
|
// itself. Matchers represent a small sub-language for pattern-matching
|
|
|
|
// token-trees, and are thus primarily used by the macro-defining extension
|
|
|
|
// itself.
|
2012-07-27 19:42:32 -05:00
|
|
|
//
|
2012-07-27 21:14:46 -05:00
|
|
|
// match_tok
|
|
|
|
// ---------
|
2012-07-27 19:42:32 -05:00
|
|
|
//
|
2012-07-27 21:14:46 -05:00
|
|
|
// A matcher that matches a single token, denoted by the token itself. So
|
|
|
|
// long as there's no $ involved.
|
2012-07-27 19:42:32 -05:00
|
|
|
//
|
2012-07-27 21:14:46 -05:00
|
|
|
//
|
|
|
|
// match_seq
|
|
|
|
// ---------
|
|
|
|
//
|
|
|
|
// A matcher that matches a sequence of sub-matchers, denoted various
|
|
|
|
// possible ways:
|
2012-07-27 19:42:32 -05:00
|
|
|
//
|
|
|
|
// $(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
|
|
|
|
//
|
|
|
|
//
|
2012-07-27 21:14:46 -05:00
|
|
|
// 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:
|
2012-07-27 19:42:32 -05:00
|
|
|
//
|
|
|
|
// $foo:expr => 1 + $foo // interpolate an expr
|
|
|
|
// $foo:tt => $foo // interpolate a token-tree
|
|
|
|
// $foo:tt => bar! $foo // only other valid interpolation
|
2012-07-27 20:06:24 -05:00
|
|
|
// // is in arg position for another
|
|
|
|
// // macro
|
2012-07-27 19:42:32 -05:00
|
|
|
//
|
|
|
|
// 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
|
2012-07-27 21:14:46 -05:00
|
|
|
// by an match_seq, specifically this one:
|
2012-07-27 19:42:32 -05:00
|
|
|
//
|
2012-07-27 21:19:40 -05:00
|
|
|
// $( $lhs:matchers => $rhs:tt );+
|
2012-07-27 19:42:32 -05:00
|
|
|
//
|
|
|
|
// If you understand that, you have closed to loop and understand the whole
|
|
|
|
// macro system. Congratulations.
|
|
|
|
//
|
2012-07-27 21:14:46 -05:00
|
|
|
type matcher = spanned<matcher_>;
|
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2012-06-12 12:59:50 -05:00
|
|
|
enum matcher_ {
|
2012-07-27 21:14:46 -05:00
|
|
|
// match one token
|
2013-01-08 21:37:25 -06:00
|
|
|
match_tok(::parse::token::Token),
|
2012-07-27 21:14:46 -05:00
|
|
|
// match repetitions of a sequence: body, separator, zero ok?,
|
|
|
|
// lo, hi position-in-match-array used:
|
2013-01-08 21:37:25 -06:00
|
|
|
match_seq(~[matcher], Option<::parse::token::Token>, bool, uint, uint),
|
2012-07-27 21:14:46 -05:00
|
|
|
// 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
|
|
|
}
|
|
|
|
|
2011-08-12 09:15:18 -05:00
|
|
|
type mac = spanned<mac_>;
|
2011-07-08 18:35:09 -05:00
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2012-01-19 16:24:03 -06:00
|
|
|
enum mac_ {
|
2012-07-27 20:06:24 -05:00
|
|
|
mac_invoc_tt(@path,~[token_tree]), // new macro-invocation
|
2010-09-09 17:59:29 -05:00
|
|
|
}
|
|
|
|
|
2011-08-12 09:15:18 -05:00
|
|
|
type lit = spanned<lit_>;
|
2011-06-15 13:19:50 -05:00
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2012-01-19 16:24:03 -06:00
|
|
|
enum lit_ {
|
2012-07-14 00:57:48 -05:00
|
|
|
lit_str(@~str),
|
2012-01-19 19:56:05 -06:00
|
|
|
lit_int(i64, int_ty),
|
|
|
|
lit_uint(u64, uint_ty),
|
2012-06-14 21:41:40 -05:00
|
|
|
lit_int_unsuffixed(i64),
|
2012-07-14 00:57:48 -05:00
|
|
|
lit_float(@~str, float_ty),
|
2012-11-07 20:40:34 -06:00
|
|
|
lit_float_unsuffixed(@~str),
|
2012-01-19 19:56:05 -06:00
|
|
|
lit_nil,
|
|
|
|
lit_bool(bool),
|
2010-09-09 17:59:29 -05:00
|
|
|
}
|
|
|
|
|
2013-01-11 14:33:50 -06:00
|
|
|
impl lit_: cmp::Eq {
|
|
|
|
pure fn eq(&self, other: &lit_) -> bool {
|
2012-11-14 20:59:30 -06:00
|
|
|
match ((*self), *other) {
|
|
|
|
(lit_str(a), lit_str(b)) => a == b,
|
|
|
|
(lit_int(val_a, ty_a), lit_int(val_b, ty_b)) => {
|
|
|
|
val_a == val_b && ty_a == ty_b
|
|
|
|
}
|
|
|
|
(lit_uint(val_a, ty_a), lit_uint(val_b, ty_b)) => {
|
|
|
|
val_a == val_b && ty_a == ty_b
|
|
|
|
}
|
|
|
|
(lit_int_unsuffixed(a), lit_int_unsuffixed(b)) => a == b,
|
|
|
|
(lit_float(val_a, ty_a), lit_float(val_b, ty_b)) => {
|
|
|
|
val_a == val_b && ty_a == ty_b
|
|
|
|
}
|
|
|
|
(lit_float_unsuffixed(a), lit_float_unsuffixed(b)) => a == b,
|
|
|
|
(lit_nil, lit_nil) => true,
|
|
|
|
(lit_bool(a), lit_bool(b)) => a == b,
|
|
|
|
(lit_str(_), _) => false,
|
|
|
|
(lit_int(*), _) => false,
|
|
|
|
(lit_uint(*), _) => false,
|
|
|
|
(lit_int_unsuffixed(*), _) => false,
|
|
|
|
(lit_float(*), _) => false,
|
|
|
|
(lit_float_unsuffixed(*), _) => false,
|
|
|
|
(lit_nil, _) => false,
|
|
|
|
(lit_bool(_), _) => false
|
|
|
|
}
|
|
|
|
}
|
2013-01-11 14:33:50 -06:00
|
|
|
pure fn ne(&self, other: &lit_) -> bool { !(*self).eq(other) }
|
2012-09-19 20:00:26 -05:00
|
|
|
}
|
2012-08-27 18:26:35 -05:00
|
|
|
|
2010-11-03 18:43:12 -05:00
|
|
|
// NB: If you change this, you'll probably want to change the corresponding
|
2010-12-21 14:13:51 -06:00
|
|
|
// type structure in middle/ty.rs as well.
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2013-01-14 23:36:27 -06:00
|
|
|
struct mt {
|
|
|
|
ty: @Ty,
|
|
|
|
mutbl: mutability,
|
|
|
|
}
|
2011-06-15 13:19:50 -05:00
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2011-07-27 07:19:39 -05:00
|
|
|
type ty_field_ = {ident: ident, mt: mt};
|
2011-06-15 13:19:50 -05:00
|
|
|
|
2011-08-12 09:15:18 -05:00
|
|
|
type ty_field = spanned<ty_field_>;
|
2011-06-15 13:19:50 -05:00
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2012-08-23 20:17:16 -05:00
|
|
|
type ty_method = {ident: ident, attrs: ~[attribute], purity: purity,
|
2012-07-31 18:32:37 -05:00
|
|
|
decl: fn_decl, tps: ~[ty_param], self_ty: self_ty,
|
2012-08-02 17:52:25 -05:00
|
|
|
id: node_id, span: span};
|
2011-06-03 17:26:03 -05:00
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2012-07-10 15:44:20 -05:00
|
|
|
// A trait method is either required (meaning it doesn't have an
|
|
|
|
// implementation, just a signature) or provided (meaning it has a default
|
|
|
|
// implementation).
|
|
|
|
enum trait_method {
|
|
|
|
required(ty_method),
|
|
|
|
provided(@method),
|
|
|
|
}
|
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2012-01-19 19:56:05 -06:00
|
|
|
enum int_ty { ty_i, ty_char, ty_i8, ty_i16, ty_i32, ty_i64, }
|
2011-12-07 14:06:12 -06:00
|
|
|
|
2012-11-28 13:36:04 -06:00
|
|
|
impl int_ty : to_bytes::IterBytes {
|
|
|
|
pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
|
|
|
|
(*self as u8).iter_bytes(lsb0, f)
|
|
|
|
}
|
|
|
|
}
|
2012-09-07 19:24:02 -05:00
|
|
|
|
2012-09-19 20:00:26 -05:00
|
|
|
impl int_ty : cmp::Eq {
|
2012-11-14 20:59:30 -06:00
|
|
|
pure fn eq(&self, other: &int_ty) -> bool {
|
|
|
|
match ((*self), (*other)) {
|
|
|
|
(ty_i, ty_i) => true,
|
|
|
|
(ty_char, ty_char) => true,
|
|
|
|
(ty_i8, ty_i8) => true,
|
|
|
|
(ty_i16, ty_i16) => true,
|
|
|
|
(ty_i32, ty_i32) => true,
|
|
|
|
(ty_i64, ty_i64) => true,
|
|
|
|
(ty_i, _) => false,
|
|
|
|
(ty_char, _) => false,
|
|
|
|
(ty_i8, _) => false,
|
|
|
|
(ty_i16, _) => false,
|
|
|
|
(ty_i32, _) => false,
|
|
|
|
(ty_i64, _) => false,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
pure fn ne(&self, other: &int_ty) -> bool { !(*self).eq(other) }
|
2012-09-19 20:00:26 -05:00
|
|
|
}
|
2012-08-27 18:26:35 -05:00
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2012-01-19 19:56:05 -06:00
|
|
|
enum uint_ty { ty_u, ty_u8, ty_u16, ty_u32, ty_u64, }
|
2011-12-07 14:06:12 -06:00
|
|
|
|
2012-11-28 13:36:04 -06:00
|
|
|
impl uint_ty : to_bytes::IterBytes {
|
|
|
|
pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
|
|
|
|
(*self as u8).iter_bytes(lsb0, f)
|
|
|
|
}
|
|
|
|
}
|
2012-09-07 19:24:02 -05:00
|
|
|
|
2012-09-19 20:00:26 -05:00
|
|
|
impl uint_ty : cmp::Eq {
|
2012-11-14 20:59:30 -06:00
|
|
|
pure fn eq(&self, other: &uint_ty) -> bool {
|
|
|
|
match ((*self), (*other)) {
|
|
|
|
(ty_u, ty_u) => true,
|
|
|
|
(ty_u8, ty_u8) => true,
|
|
|
|
(ty_u16, ty_u16) => true,
|
|
|
|
(ty_u32, ty_u32) => true,
|
|
|
|
(ty_u64, ty_u64) => true,
|
|
|
|
(ty_u, _) => false,
|
|
|
|
(ty_u8, _) => false,
|
|
|
|
(ty_u16, _) => false,
|
|
|
|
(ty_u32, _) => false,
|
|
|
|
(ty_u64, _) => false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
pure fn ne(&self, other: &uint_ty) -> bool { !(*self).eq(other) }
|
2012-09-19 20:00:26 -05:00
|
|
|
}
|
2012-08-27 18:26:35 -05:00
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2012-01-19 19:56:05 -06:00
|
|
|
enum float_ty { ty_f, ty_f32, ty_f64, }
|
2011-07-05 04:48:19 -05:00
|
|
|
|
2012-11-28 13:36:04 -06:00
|
|
|
impl float_ty : to_bytes::IterBytes {
|
|
|
|
pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
|
|
|
|
(*self as u8).iter_bytes(lsb0, f)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-09-19 20:00:26 -05:00
|
|
|
impl float_ty : cmp::Eq {
|
2012-11-14 20:59:30 -06:00
|
|
|
pure fn eq(&self, other: &float_ty) -> bool {
|
|
|
|
match ((*self), (*other)) {
|
|
|
|
(ty_f, ty_f) | (ty_f32, ty_f32) | (ty_f64, ty_f64) => true,
|
|
|
|
(ty_f, _) | (ty_f32, _) | (ty_f64, _) => false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
pure fn ne(&self, other: &float_ty) -> bool { !(*self).eq(other) }
|
2012-09-19 20:00:26 -05:00
|
|
|
}
|
2012-08-27 18:26:35 -05:00
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2013-01-15 16:59:39 -06:00
|
|
|
struct Ty {
|
|
|
|
id: node_id,
|
|
|
|
node: ty_,
|
|
|
|
span: span,
|
|
|
|
}
|
2011-06-15 13:19:50 -05:00
|
|
|
|
2012-02-06 08:29:56 -06:00
|
|
|
// Not represented directly in the AST, referred to by name through a ty_path.
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2012-02-06 08:29:56 -06:00
|
|
|
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,
|
2012-02-06 08:29:56 -06:00
|
|
|
ty_bool,
|
|
|
|
}
|
|
|
|
|
2012-09-19 20:00:26 -05:00
|
|
|
impl prim_ty : cmp::Eq {
|
2012-11-14 20:59:30 -06:00
|
|
|
pure fn eq(&self, other: &prim_ty) -> bool {
|
|
|
|
match (*self) {
|
|
|
|
ty_int(e0a) => {
|
|
|
|
match (*other) {
|
|
|
|
ty_int(e0b) => e0a == e0b,
|
|
|
|
_ => false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
ty_uint(e0a) => {
|
|
|
|
match (*other) {
|
|
|
|
ty_uint(e0b) => e0a == e0b,
|
|
|
|
_ => false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
ty_float(e0a) => {
|
|
|
|
match (*other) {
|
|
|
|
ty_float(e0b) => e0a == e0b,
|
|
|
|
_ => false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
ty_str => {
|
|
|
|
match (*other) {
|
|
|
|
ty_str => true,
|
|
|
|
_ => false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
ty_bool => {
|
|
|
|
match (*other) {
|
|
|
|
ty_bool => true,
|
|
|
|
_ => false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
pure fn ne(&self, other: &prim_ty) -> bool { !(*self).eq(other) }
|
2012-09-19 20:00:26 -05:00
|
|
|
}
|
2012-08-27 18:26:35 -05:00
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2012-03-09 18:10:11 -06:00
|
|
|
type region = {id: node_id, node: region_};
|
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2012-09-14 17:20:09 -05:00
|
|
|
enum region_ {
|
|
|
|
re_anon,
|
|
|
|
re_static,
|
|
|
|
re_self,
|
|
|
|
re_named(ident)
|
|
|
|
}
|
2012-03-08 12:49:43 -06:00
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2013-01-08 16:00:45 -06:00
|
|
|
#[deriving_eq]
|
2012-11-02 15:33:51 -05:00
|
|
|
enum Onceness {
|
|
|
|
Once,
|
|
|
|
Many
|
|
|
|
}
|
|
|
|
|
2013-01-08 16:00:45 -06:00
|
|
|
impl Onceness : ToStr {
|
|
|
|
pure fn to_str() -> ~str {
|
|
|
|
match self {
|
2013-01-11 14:33:50 -06:00
|
|
|
Once => ~"once",
|
|
|
|
Many => ~"many"
|
2012-11-14 20:59:30 -06:00
|
|
|
}
|
|
|
|
}
|
2013-01-08 16:00:45 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
impl Onceness : to_bytes::IterBytes {
|
|
|
|
pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
|
|
|
|
(*self as uint).iter_bytes(lsb0, f);
|
2012-11-14 20:59:30 -06:00
|
|
|
}
|
2012-11-02 15:33:51 -05:00
|
|
|
}
|
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2012-11-04 22:41:00 -06:00
|
|
|
struct TyFn {
|
|
|
|
proto: Proto,
|
|
|
|
region: Option<@region>,
|
|
|
|
purity: purity,
|
|
|
|
onceness: Onceness,
|
|
|
|
bounds: @~[ty_param_bound],
|
|
|
|
decl: fn_decl
|
|
|
|
}
|
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2012-02-06 08:29:56 -06:00
|
|
|
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),
|
2012-11-04 22:41:00 -06:00
|
|
|
ty_fixed_length_vec(mt, uint),
|
2012-01-19 19:56:05 -06:00
|
|
|
ty_ptr(mt),
|
2012-04-24 17:52:52 -05:00
|
|
|
ty_rptr(@region, mt),
|
2012-06-29 18:26:56 -05:00
|
|
|
ty_rec(~[ty_field]),
|
2012-11-04 22:41:00 -06:00
|
|
|
ty_fn(@TyFn),
|
2012-10-15 16:56:42 -05:00
|
|
|
ty_tup(~[@Ty]),
|
2012-01-19 19:56:05 -06:00
|
|
|
ty_path(@path, node_id),
|
|
|
|
ty_mac(mac),
|
2011-08-10 14:51:50 -05:00
|
|
|
// 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,
|
2010-09-09 17:59:29 -05:00
|
|
|
}
|
|
|
|
|
2012-09-07 19:24:02 -05:00
|
|
|
// Equality and byte-iter (hashing) can be quite approximate for AST types.
|
|
|
|
// since we only care about this for normalizing them to "real" types.
|
2012-10-15 16:56:42 -05:00
|
|
|
impl Ty : cmp::Eq {
|
2012-11-14 20:59:30 -06:00
|
|
|
pure fn eq(&self, other: &Ty) -> bool {
|
|
|
|
ptr::addr_of(&(*self)) == ptr::addr_of(&(*other))
|
|
|
|
}
|
|
|
|
pure fn ne(&self, other: &Ty) -> bool {
|
|
|
|
ptr::addr_of(&(*self)) != ptr::addr_of(&(*other))
|
|
|
|
}
|
2012-09-19 20:00:26 -05:00
|
|
|
}
|
2012-09-07 19:24:02 -05:00
|
|
|
|
2012-11-28 13:36:04 -06:00
|
|
|
impl Ty : to_bytes::IterBytes {
|
|
|
|
pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
|
|
|
|
to_bytes::iter_bytes_2(&self.span.lo, &self.span.hi, lsb0, f);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-09-07 19:24:02 -05:00
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2012-11-06 20:41:06 -06:00
|
|
|
type arg = {mode: mode, ty: @Ty, pat: @pat, id: node_id};
|
2011-06-15 13:19:50 -05:00
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2011-06-15 13:19:50 -05:00
|
|
|
type fn_decl =
|
2012-06-29 18:26:56 -05:00
|
|
|
{inputs: ~[arg],
|
2012-10-15 16:56:42 -05:00
|
|
|
output: @Ty,
|
2012-07-13 20:43:52 -05:00
|
|
|
cf: ret_style};
|
2011-06-15 13:19:50 -05:00
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2013-01-08 21:37:25 -06:00
|
|
|
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"
|
2011-05-04 13:28:13 -05:00
|
|
|
}
|
|
|
|
|
2013-01-08 16:00:45 -06:00
|
|
|
impl purity : ToStr {
|
|
|
|
pure fn to_str() -> ~str {
|
|
|
|
match self {
|
|
|
|
impure_fn => ~"impure",
|
|
|
|
unsafe_fn => ~"unsafe",
|
|
|
|
pure_fn => ~"pure",
|
|
|
|
extern_fn => ~"extern"
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-11-28 13:36:04 -06:00
|
|
|
impl purity : to_bytes::IterBytes {
|
|
|
|
pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
|
|
|
|
(*self as u8).iter_bytes(lsb0, f)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-09-19 20:00:26 -05:00
|
|
|
impl purity : cmp::Eq {
|
2012-11-14 20:59:30 -06:00
|
|
|
pure fn eq(&self, other: &purity) -> bool {
|
|
|
|
((*self) as uint) == ((*other) as uint)
|
|
|
|
}
|
|
|
|
pure fn ne(&self, other: &purity) -> bool { !(*self).eq(other) }
|
2012-09-19 20:00:26 -05:00
|
|
|
}
|
2012-08-27 18:26:35 -05:00
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2012-01-19 16:24:03 -06:00
|
|
|
enum ret_style {
|
2012-01-19 19:56:05 -06:00
|
|
|
noreturn, // functions with return type _|_ that always
|
2011-05-14 21:02:30 -05:00
|
|
|
// raise an error or exit (i.e. never return to the caller)
|
2012-01-19 19:56:05 -06:00
|
|
|
return_val, // everything else
|
2011-05-14 21:02:30 -05:00
|
|
|
}
|
|
|
|
|
2012-11-28 13:36:04 -06:00
|
|
|
impl ret_style : to_bytes::IterBytes {
|
|
|
|
pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
|
|
|
|
(*self as u8).iter_bytes(lsb0, f)
|
|
|
|
}
|
|
|
|
}
|
2012-09-07 19:24:02 -05:00
|
|
|
|
2012-09-19 20:00:26 -05:00
|
|
|
impl ret_style : cmp::Eq {
|
2012-11-14 20:59:30 -06:00
|
|
|
pure fn eq(&self, other: &ret_style) -> bool {
|
|
|
|
match ((*self), (*other)) {
|
|
|
|
(noreturn, noreturn) => true,
|
|
|
|
(return_val, return_val) => true,
|
|
|
|
(noreturn, _) => false,
|
|
|
|
(return_val, _) => false,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
pure fn ne(&self, other: &ret_style) -> bool { !(*self).eq(other) }
|
2012-09-19 20:00:26 -05:00
|
|
|
}
|
2012-08-27 18:26:35 -05:00
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2012-07-30 18:33:02 -05:00
|
|
|
enum self_ty_ {
|
2012-08-02 18:01:38 -05:00
|
|
|
sty_static, // no self: static method
|
2012-07-30 18:33:02 -05:00
|
|
|
sty_by_ref, // old by-reference self: ``
|
|
|
|
sty_value, // by-value self: `self`
|
2012-08-13 12:17:42 -05:00
|
|
|
sty_region(mutability), // by-region self: `&self`
|
2012-07-30 18:33:02 -05:00
|
|
|
sty_box(mutability), // by-managed-pointer self: `@self`
|
|
|
|
sty_uniq(mutability) // by-unique-pointer self: `~self`
|
|
|
|
}
|
|
|
|
|
2012-09-19 20:00:26 -05:00
|
|
|
impl self_ty_ : cmp::Eq {
|
2012-11-14 20:59:30 -06:00
|
|
|
pure fn eq(&self, other: &self_ty_) -> bool {
|
|
|
|
match (*self) {
|
|
|
|
sty_static => {
|
|
|
|
match (*other) {
|
|
|
|
sty_static => true,
|
|
|
|
_ => false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
sty_by_ref => {
|
|
|
|
match (*other) {
|
|
|
|
sty_by_ref => true,
|
|
|
|
_ => false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
sty_value => {
|
|
|
|
match (*other) {
|
|
|
|
sty_value => true,
|
|
|
|
_ => false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
sty_region(e0a) => {
|
|
|
|
match (*other) {
|
|
|
|
sty_region(e0b) => e0a == e0b,
|
|
|
|
_ => false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
sty_box(e0a) => {
|
|
|
|
match (*other) {
|
|
|
|
sty_box(e0b) => e0a == e0b,
|
|
|
|
_ => false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
sty_uniq(e0a) => {
|
|
|
|
match (*other) {
|
|
|
|
sty_uniq(e0b) => e0a == e0b,
|
|
|
|
_ => false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
pure fn ne(&self, other: &self_ty_) -> bool { !(*self).eq(other) }
|
2012-09-19 20:00:26 -05:00
|
|
|
}
|
2012-08-27 18:26:35 -05:00
|
|
|
|
2012-07-30 18:33:02 -05:00
|
|
|
type self_ty = spanned<self_ty_>;
|
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2012-06-29 18:26:56 -05:00
|
|
|
type method = {ident: ident, attrs: ~[attribute],
|
2012-08-23 20:17:16 -05:00
|
|
|
tps: ~[ty_param], self_ty: self_ty,
|
|
|
|
purity: purity, decl: fn_decl, body: blk,
|
2012-03-28 20:50:33 -05:00
|
|
|
id: node_id, span: span, self_id: node_id,
|
2012-09-04 20:28:22 -05:00
|
|
|
vis: visibility};
|
2010-12-14 17:32:13 -06:00
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2012-06-29 18:26:56 -05:00
|
|
|
type _mod = {view_items: ~[@view_item], items: ~[@item]};
|
2010-08-18 11:00:10 -05:00
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2012-06-26 18:18:37 -05:00
|
|
|
enum foreign_abi {
|
|
|
|
foreign_abi_rust_intrinsic,
|
|
|
|
foreign_abi_cdecl,
|
|
|
|
foreign_abi_stdcall,
|
2011-02-23 13:06:37 -06:00
|
|
|
}
|
|
|
|
|
2012-08-29 14:22:05 -05:00
|
|
|
// Foreign mods can be named or anonymous
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2012-08-29 14:22:05 -05:00
|
|
|
enum foreign_mod_sort { named, anonymous }
|
|
|
|
|
2012-09-19 20:00:26 -05:00
|
|
|
impl foreign_mod_sort : cmp::Eq {
|
2012-11-14 20:59:30 -06:00
|
|
|
pure fn eq(&self, other: &foreign_mod_sort) -> bool {
|
|
|
|
((*self) as uint) == ((*other) as uint)
|
|
|
|
}
|
|
|
|
pure fn ne(&self, other: &foreign_mod_sort) -> bool { !(*self).eq(other) }
|
2012-09-19 20:00:26 -05:00
|
|
|
}
|
2012-08-27 18:26:35 -05:00
|
|
|
|
2012-09-19 20:00:26 -05:00
|
|
|
impl foreign_abi : cmp::Eq {
|
2012-11-14 20:59:30 -06:00
|
|
|
pure fn eq(&self, other: &foreign_abi) -> bool {
|
|
|
|
match ((*self), (*other)) {
|
|
|
|
(foreign_abi_rust_intrinsic, foreign_abi_rust_intrinsic) => true,
|
|
|
|
(foreign_abi_cdecl, foreign_abi_cdecl) => true,
|
|
|
|
(foreign_abi_stdcall, foreign_abi_stdcall) => true,
|
|
|
|
(foreign_abi_rust_intrinsic, _) => false,
|
|
|
|
(foreign_abi_cdecl, _) => false,
|
|
|
|
(foreign_abi_stdcall, _) => false,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
pure fn ne(&self, other: &foreign_abi) -> bool { !(*self).eq(other) }
|
2012-09-19 20:00:26 -05:00
|
|
|
}
|
2012-08-27 18:26:35 -05:00
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2012-06-26 18:18:37 -05:00
|
|
|
type foreign_mod =
|
2012-08-29 14:22:05 -05:00
|
|
|
{sort: foreign_mod_sort,
|
2012-11-27 19:25:55 -06:00
|
|
|
abi: ident,
|
2012-08-29 14:22:05 -05:00
|
|
|
view_items: ~[@view_item],
|
2012-06-29 18:26:56 -05:00
|
|
|
items: ~[@foreign_item]};
|
2011-02-01 12:40:04 -06:00
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2012-10-15 16:56:42 -05:00
|
|
|
type variant_arg = {ty: @Ty, id: node_id};
|
2011-06-15 13:19:50 -05:00
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2012-08-07 16:24:04 -05:00
|
|
|
enum variant_kind {
|
|
|
|
tuple_variant_kind(~[variant_arg]),
|
2012-08-08 16:17:52 -05:00
|
|
|
struct_variant_kind(@struct_def),
|
2012-08-08 19:14:25 -05:00
|
|
|
enum_variant_kind(enum_def)
|
2012-08-07 16:24:04 -05:00
|
|
|
}
|
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2012-10-07 12:31:34 -05:00
|
|
|
type enum_def_ = { variants: ~[variant], common: Option<@struct_def> };
|
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2012-10-07 12:31:34 -05:00
|
|
|
enum enum_def = enum_def_;
|
2012-08-08 19:14:25 -05:00
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2012-08-07 16:24:04 -05:00
|
|
|
type variant_ = {name: ident, attrs: ~[attribute], kind: variant_kind,
|
2012-08-20 14:23:37 -05:00
|
|
|
id: node_id, disr_expr: Option<@expr>, vis: visibility};
|
2011-06-15 13:19:50 -05:00
|
|
|
|
2011-08-12 09:15:18 -05:00
|
|
|
type variant = spanned<variant_>;
|
2010-11-24 13:36:35 -06:00
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2013-01-13 19:27:57 -06:00
|
|
|
struct path_list_ident_ {
|
|
|
|
name: ident,
|
|
|
|
id: node_id,
|
|
|
|
}
|
2012-03-14 16:18:53 -05:00
|
|
|
|
2012-02-18 01:05:20 -06:00
|
|
|
type path_list_ident = spanned<path_list_ident_>;
|
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2012-08-31 13:19:07 -05:00
|
|
|
enum namespace { module_ns, type_value_ns }
|
|
|
|
|
2012-09-19 20:00:26 -05:00
|
|
|
impl namespace : cmp::Eq {
|
2012-11-14 20:59:30 -06:00
|
|
|
pure fn eq(&self, other: &namespace) -> bool {
|
|
|
|
((*self) as uint) == ((*other) as uint)
|
|
|
|
}
|
|
|
|
pure fn ne(&self, other: &namespace) -> bool { !(*self).eq(other) }
|
2012-09-19 20:00:26 -05:00
|
|
|
}
|
2012-08-31 13:19:07 -05:00
|
|
|
|
2012-02-18 01:05:20 -06:00
|
|
|
type view_path = spanned<view_path_>;
|
2012-03-14 16:18:53 -05:00
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2012-02-18 01:05:20 -06:00
|
|
|
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),
|
2011-08-16 17:21:30 -05:00
|
|
|
|
2012-02-18 01:05:20 -06:00
|
|
|
// foo::bar::*
|
2012-04-13 03:46:56 -05:00
|
|
|
view_path_glob(@path, node_id),
|
2011-08-16 17:21:30 -05:00
|
|
|
|
2012-02-18 01:05:20 -06:00
|
|
|
// foo::bar::{a,b,c}
|
2012-06-29 18:26:56 -05:00
|
|
|
view_path_list(@path, ~[path_list_ident], node_id)
|
2012-02-18 01:05:20 -06:00
|
|
|
}
|
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2013-01-13 18:51:48 -06:00
|
|
|
struct view_item {
|
|
|
|
node: view_item_,
|
|
|
|
attrs: ~[attribute],
|
|
|
|
vis: visibility,
|
|
|
|
span: span,
|
|
|
|
}
|
2012-03-14 16:18:53 -05:00
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2012-01-19 16:24:03 -06:00
|
|
|
enum view_item_ {
|
2012-09-20 20:15:39 -05:00
|
|
|
view_item_use(ident, ~[@meta_item], node_id),
|
2012-06-29 18:26:56 -05:00
|
|
|
view_item_import(~[@view_path]),
|
|
|
|
view_item_export(~[@view_path])
|
2011-01-01 11:55:18 -06:00
|
|
|
}
|
|
|
|
|
2011-06-14 18:13:19 -05:00
|
|
|
// Meta-data associated with an item
|
2011-08-12 09:15:18 -05:00
|
|
|
type attribute = spanned<attribute_>;
|
2011-06-14 18:13:19 -05:00
|
|
|
|
|
|
|
// 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.
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2012-01-19 19:56:05 -06:00
|
|
|
enum attr_style { attr_outer, attr_inner, }
|
2011-06-14 18:13:19 -05:00
|
|
|
|
2012-09-19 20:00:26 -05:00
|
|
|
impl attr_style : cmp::Eq {
|
2012-11-14 20:59:30 -06:00
|
|
|
pure fn eq(&self, other: &attr_style) -> bool {
|
|
|
|
((*self) as uint) == ((*other) as uint)
|
|
|
|
}
|
|
|
|
pure fn ne(&self, other: &attr_style) -> bool { !(*self).eq(other) }
|
2012-09-19 20:00:26 -05:00
|
|
|
}
|
2012-08-27 18:26:35 -05:00
|
|
|
|
2012-06-30 05:54:54 -05:00
|
|
|
// doc-comments are promoted to attributes that have is_sugared_doc = true
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2013-01-13 18:51:48 -06:00
|
|
|
struct attribute_ {
|
|
|
|
style: attr_style,
|
|
|
|
value: meta_item,
|
|
|
|
is_sugared_doc: bool,
|
|
|
|
}
|
2011-06-14 18:13:19 -05:00
|
|
|
|
2012-04-13 14:22:35 -05:00
|
|
|
/*
|
2012-12-10 15:47:54 -06:00
|
|
|
trait_refs appear in impls.
|
2012-06-26 18:25:52 -05:00
|
|
|
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
|
2012-12-10 15:47:54 -06:00
|
|
|
same as the impl's node id).
|
2012-04-13 14:22:35 -05:00
|
|
|
*/
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2012-12-06 21:12:25 -06:00
|
|
|
type trait_ref = {path: @path, ref_id: node_id};
|
2012-04-11 18:18:00 -05:00
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2012-08-03 15:58:14 -05:00
|
|
|
enum visibility { public, private, inherited }
|
2012-05-08 09:06:24 -05:00
|
|
|
|
2012-09-19 20:00:26 -05:00
|
|
|
impl visibility : cmp::Eq {
|
2012-11-14 20:59:30 -06:00
|
|
|
pure fn eq(&self, other: &visibility) -> bool {
|
|
|
|
match ((*self), (*other)) {
|
|
|
|
(public, public) => true,
|
|
|
|
(private, private) => true,
|
|
|
|
(inherited, inherited) => true,
|
|
|
|
(public, _) => false,
|
|
|
|
(private, _) => false,
|
|
|
|
(inherited, _) => false,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
pure fn ne(&self, other: &visibility) -> bool { !(*self).eq(other) }
|
2012-09-19 20:00:26 -05:00
|
|
|
}
|
2012-08-27 18:26:35 -05:00
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2013-01-13 17:28:49 -06:00
|
|
|
struct struct_field_ {
|
2012-08-15 17:53:58 -05:00
|
|
|
kind: struct_field_kind,
|
|
|
|
id: node_id,
|
2013-01-13 17:28:49 -06:00
|
|
|
ty: @Ty,
|
|
|
|
}
|
2012-08-15 17:53:58 -05:00
|
|
|
|
|
|
|
type struct_field = spanned<struct_field_>;
|
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2012-08-15 17:53:58 -05:00
|
|
|
enum struct_field_kind {
|
2012-12-10 15:47:54 -06:00
|
|
|
named_field(ident, struct_mutability, visibility),
|
2012-08-15 17:53:58 -05:00
|
|
|
unnamed_field // element of a tuple-like struct
|
|
|
|
}
|
|
|
|
|
2012-10-23 21:18:18 -05:00
|
|
|
impl struct_field_kind : cmp::Eq {
|
2012-11-14 20:59:30 -06:00
|
|
|
pure fn eq(&self, other: &struct_field_kind) -> bool {
|
|
|
|
match (*self) {
|
2012-12-10 15:47:54 -06:00
|
|
|
named_field(ident_a, struct_mutability_a, visibility_a) => {
|
2012-11-14 20:59:30 -06:00
|
|
|
match *other {
|
2012-12-10 15:47:54 -06:00
|
|
|
named_field(ident_b, struct_mutability_b, visibility_b)
|
2012-11-14 20:59:30 -06:00
|
|
|
=> {
|
|
|
|
ident_a == ident_b &&
|
2012-12-10 15:47:54 -06:00
|
|
|
struct_mutability_a == struct_mutability_b &&
|
2012-11-14 20:59:30 -06:00
|
|
|
visibility_a == visibility_b
|
|
|
|
}
|
|
|
|
unnamed_field => false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
unnamed_field => {
|
|
|
|
match *other {
|
|
|
|
named_field(*) => false,
|
|
|
|
unnamed_field => true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
pure fn ne(&self, other: &struct_field_kind) -> bool {
|
|
|
|
!(*self).eq(other)
|
|
|
|
}
|
2012-10-23 21:18:18 -05:00
|
|
|
}
|
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2013-01-13 15:45:57 -06:00
|
|
|
struct struct_def {
|
2012-08-15 17:53:58 -05:00
|
|
|
fields: ~[@struct_field], /* fields */
|
2012-08-07 17:34:07 -05:00
|
|
|
/* (not including ctor or dtor) */
|
|
|
|
/* dtor is optional */
|
2012-12-10 15:47:54 -06:00
|
|
|
dtor: Option<struct_dtor>,
|
2012-10-23 21:18:18 -05:00
|
|
|
/* ID of the constructor. This is only used for tuple- or enum-like
|
|
|
|
* structs. */
|
2012-10-24 16:36:00 -05:00
|
|
|
ctor_id: Option<node_id>
|
2013-01-13 15:45:57 -06:00
|
|
|
}
|
2012-08-07 17:34:07 -05:00
|
|
|
|
2012-08-29 14:22:05 -05:00
|
|
|
/*
|
|
|
|
FIXME (#3300): Should allow items to be anonymous. Right now
|
|
|
|
we just use dummy names for anon items.
|
|
|
|
*/
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2013-01-13 15:13:41 -06:00
|
|
|
struct item {
|
|
|
|
ident: ident,
|
|
|
|
attrs: ~[attribute],
|
|
|
|
id: node_id,
|
|
|
|
node: item_,
|
|
|
|
vis: visibility,
|
|
|
|
span: span,
|
|
|
|
}
|
2011-06-15 13:19:50 -05:00
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2012-01-19 16:24:03 -06:00
|
|
|
enum item_ {
|
2012-10-15 16:56:42 -05:00
|
|
|
item_const(@Ty, @expr),
|
2012-08-23 20:17:16 -05:00
|
|
|
item_fn(fn_decl, purity, ~[ty_param], blk),
|
2012-01-19 19:56:05 -06:00
|
|
|
item_mod(_mod),
|
2012-06-26 18:18:37 -05:00
|
|
|
item_foreign_mod(foreign_mod),
|
2012-10-15 16:56:42 -05:00
|
|
|
item_ty(@Ty, ~[ty_param]),
|
2012-08-08 19:14:25 -05:00
|
|
|
item_enum(enum_def, ~[ty_param]),
|
2012-12-10 15:47:54 -06:00
|
|
|
item_struct(@struct_def, ~[ty_param]),
|
2012-08-03 17:02:01 -05:00
|
|
|
item_trait(~[ty_param], ~[@trait_ref], ~[trait_method]),
|
2012-07-18 11:31:53 -05:00
|
|
|
item_impl(~[ty_param],
|
2012-09-07 17:11:26 -05:00
|
|
|
Option<@trait_ref>, /* (optional) trait this impl implements */
|
2012-10-15 16:56:42 -05:00
|
|
|
@Ty, /* self */
|
2012-11-13 21:08:01 -06:00
|
|
|
~[@method]),
|
2012-07-05 14:10:33 -05:00
|
|
|
item_mac(mac),
|
2011-05-11 08:10:24 -05:00
|
|
|
}
|
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2012-12-10 15:47:54 -06:00
|
|
|
enum struct_mutability { struct_mutable, struct_immutable }
|
2012-01-31 21:30:40 -06:00
|
|
|
|
2012-12-10 15:47:54 -06:00
|
|
|
impl struct_mutability : to_bytes::IterBytes {
|
2012-11-28 13:36:04 -06:00
|
|
|
pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
|
|
|
|
(*self as u8).iter_bytes(lsb0, f)
|
|
|
|
}
|
|
|
|
}
|
2012-09-07 19:24:02 -05:00
|
|
|
|
2012-12-10 15:47:54 -06:00
|
|
|
impl struct_mutability : cmp::Eq {
|
|
|
|
pure fn eq(&self, other: &struct_mutability) -> bool {
|
2012-11-14 20:59:30 -06:00
|
|
|
match ((*self), (*other)) {
|
2012-12-10 15:47:54 -06:00
|
|
|
(struct_mutable, struct_mutable) => true,
|
|
|
|
(struct_immutable, struct_immutable) => true,
|
|
|
|
(struct_mutable, _) => false,
|
|
|
|
(struct_immutable, _) => false,
|
2012-11-14 20:59:30 -06:00
|
|
|
}
|
|
|
|
}
|
2012-12-10 15:47:54 -06:00
|
|
|
pure fn ne(&self, other: &struct_mutability) -> bool {
|
|
|
|
!(*self).eq(other)
|
|
|
|
}
|
2012-09-19 20:00:26 -05:00
|
|
|
}
|
2012-08-27 18:26:35 -05:00
|
|
|
|
2012-12-10 15:47:54 -06:00
|
|
|
type struct_dtor = spanned<struct_dtor_>;
|
2012-05-14 16:13:32 -05:00
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2013-01-13 14:29:36 -06:00
|
|
|
struct struct_dtor_ {
|
|
|
|
id: node_id,
|
|
|
|
attrs: ~[attribute],
|
|
|
|
self_id: node_id,
|
|
|
|
body: blk,
|
|
|
|
}
|
2012-05-14 16:13:32 -05:00
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2013-01-13 14:02:16 -06:00
|
|
|
struct foreign_item {
|
|
|
|
ident: ident,
|
|
|
|
attrs: ~[attribute],
|
|
|
|
node: foreign_item_,
|
|
|
|
id: node_id,
|
|
|
|
span: span,
|
|
|
|
vis: visibility,
|
|
|
|
}
|
2011-06-15 13:19:50 -05:00
|
|
|
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2012-06-26 18:18:37 -05:00
|
|
|
enum foreign_item_ {
|
2012-08-23 20:17:16 -05:00
|
|
|
foreign_item_fn(fn_decl, purity, ~[ty_param]),
|
2012-10-15 16:56:42 -05:00
|
|
|
foreign_item_const(@Ty)
|
2011-02-02 09:43:57 -06:00
|
|
|
}
|
|
|
|
|
2012-03-01 21:37:52 -06:00
|
|
|
// 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.
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2012-03-01 21:37:52 -06:00
|
|
|
enum inlined_item {
|
|
|
|
ii_item(@item),
|
2012-03-21 09:42:20 -05:00
|
|
|
ii_method(def_id /* impl id */, @method),
|
2012-06-26 18:18:37 -05:00
|
|
|
ii_foreign(@foreign_item),
|
2012-12-10 15:47:54 -06:00
|
|
|
ii_dtor(struct_dtor, ident, ~[ty_param], def_id /* parent id */)
|
2012-03-01 21:37:52 -06:00
|
|
|
}
|
|
|
|
|
2012-07-27 21:32:42 -05:00
|
|
|
|
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:
|
|
|
|
//
|