//! for the `Code` associated with a particular NodeId.
use abi;
-use ast::{P, Block, FnDecl, NodeId};
+use ast::{Block, FnDecl, NodeId};
use ast;
use ast_map::{Node};
use ast_map;
/// - The default implementation for a trait method.
///
/// To construct one, use the `Code::from_node` function.
-pub struct FnLikeNode { node: ast_map::Node }
+pub struct FnLikeNode<'a> { node: ast_map::Node<'a> }
/// MaybeFnLike wraps a method that indicates if an object
/// corresponds to some FnLikeNode.
/// Components shared by fn-like things (fn items, methods, closures).
pub struct FnParts<'a> {
- pub decl: P<FnDecl>,
- pub body: P<Block>,
+ pub decl: &'a FnDecl,
+ pub body: &'a Block,
pub kind: visit::FnKind<'a>,
pub span: Span,
pub id: NodeId,
/// Carries either an FnLikeNode or a Block, as these are the two
/// constructs that correspond to "code" (as in, something from which
/// we can construct a control-flow graph).
-pub enum Code {
- FnLikeCode(FnLikeNode),
- BlockCode(P<Block>),
+pub enum Code<'a> {
+ FnLikeCode(FnLikeNode<'a>),
+ BlockCode(&'a Block),
}
-impl Code {
+impl<'a> Code<'a> {
pub fn id(&self) -> ast::NodeId {
match *self {
FnLikeCode(node) => node.id(),
/// use when implementing FnLikeNode operations.
struct ItemFnParts<'a> {
ident: ast::Ident,
- decl: P<ast::FnDecl>,
+ decl: &'a ast::FnDecl,
style: ast::FnStyle,
abi: abi::Abi,
generics: &'a ast::Generics,
- body: P<Block>,
+ body: &'a Block,
id: ast::NodeId,
span: Span
}
/// These are all the components one can extract from a closure expr
/// for use when implementing FnLikeNode operations.
-struct ClosureParts {
- decl: P<FnDecl>,
- body: P<Block>,
+struct ClosureParts<'a> {
+ decl: &'a FnDecl,
+ body: &'a Block,
id: NodeId,
span: Span
}
-impl ClosureParts {
- fn new(d: P<FnDecl>, b: P<Block>, id: NodeId, s: Span) -> ClosureParts {
+impl<'a> ClosureParts<'a> {
+ fn new(d: &'a FnDecl, b: &'a Block, id: NodeId, s: Span) -> ClosureParts<'a> {
ClosureParts { decl: d, body: b, id: id, span: s }
}
}
-impl FnLikeNode {
- pub fn to_fn_parts<'a>(&'a self) -> FnParts<'a> {
+impl<'a> FnLikeNode<'a> {
+ pub fn to_fn_parts(self) -> FnParts<'a> {
FnParts {
decl: self.decl(),
body: self.body(),
}
}
- pub fn body<'a>(&'a self) -> P<Block> {
- self.handle(|i: ItemFnParts| i.body,
- |m: &'a ast::Method| m.pe_body(),
- |c: ClosureParts| c.body)
+ pub fn body(self) -> &'a Block {
+ self.handle(|i: ItemFnParts<'a>| &*i.body,
+ |m: &'a ast::Method| m.pe_body(),
+ |c: ClosureParts<'a>| c.body)
}
- pub fn decl<'a>(&'a self) -> P<FnDecl> {
- self.handle(|i: ItemFnParts| i.decl,
- |m: &'a ast::Method| m.pe_fn_decl(),
- |c: ClosureParts| c.decl)
+ pub fn decl(self) -> &'a FnDecl {
+ self.handle(|i: ItemFnParts<'a>| &*i.decl,
+ |m: &'a ast::Method| m.pe_fn_decl(),
+ |c: ClosureParts<'a>| c.decl)
}
- pub fn span<'a>(&'a self) -> Span {
+ pub fn span(self) -> Span {
self.handle(|i: ItemFnParts| i.span,
|m: &'a ast::Method| m.span,
|c: ClosureParts| c.span)
}
- pub fn id<'a>(&'a self) -> NodeId {
+ pub fn id(self) -> NodeId {
self.handle(|i: ItemFnParts| i.id,
|m: &'a ast::Method| m.id,
|c: ClosureParts| c.id)
}
- pub fn kind<'a>(&'a self) -> visit::FnKind<'a> {
+ pub fn kind(self) -> visit::FnKind<'a> {
let item = |p: ItemFnParts<'a>| -> visit::FnKind<'a> {
visit::FkItemFn(p.ident, p.generics, p.style, p.abi)
};
self.handle(item, method, closure)
}
- fn handle<'a, A>(&'a self,
- item_fn: |ItemFnParts<'a>| -> A,
- method: |&'a ast::Method| -> A,
- closure: |ClosureParts| -> A) -> A {
+ fn handle<A>(self,
+ item_fn: |ItemFnParts<'a>| -> A,
+ method: |&'a ast::Method| -> A,
+ closure: |ClosureParts<'a>| -> A) -> A {
match self.node {
- ast_map::NodeItem(ref i) => match i.node {
- ast::ItemFn(decl, style, abi, ref generics, block) =>
+ ast_map::NodeItem(i) => match i.node {
+ ast::ItemFn(ref decl, style, abi, ref generics, ref block) =>
item_fn(ItemFnParts{
- ident: i.ident, decl: decl, style: style, body: block,
+ ident: i.ident, decl: &**decl, style: style, body: &**block,
generics: generics, abi: abi, id: i.id, span: i.span
}),
_ => fail!("item FnLikeNode that is not fn-like"),
},
- ast_map::NodeTraitItem(ref t) => match **t {
+ ast_map::NodeTraitItem(t) => match *t {
ast::ProvidedMethod(ref m) => method(&**m),
_ => fail!("trait method FnLikeNode that is not fn-like"),
},
- ast_map::NodeImplItem(ref ii) => {
- match **ii {
+ ast_map::NodeImplItem(ii) => {
+ match *ii {
ast::MethodImplItem(ref m) => method(&**m),
}
}
- ast_map::NodeExpr(ref e) => match e.node {
+ ast_map::NodeExpr(e) => match e.node {
ast::ExprFnBlock(_, ref decl, ref block) =>
- closure(ClosureParts::new(*decl, *block, e.id, e.span)),
+ closure(ClosureParts::new(&**decl, &**block, e.id, e.span)),
ast::ExprProc(ref decl, ref block) =>
- closure(ClosureParts::new(*decl, *block, e.id, e.span)),
+ closure(ClosureParts::new(&**decl, &**block, e.id, e.span)),
_ => fail!("expr FnLikeNode that is not fn-like"),
},
_ => fail!("other FnLikeNode that is not fn-like"),
use owned_slice::OwnedSlice;
use parse::token;
use print::pprust;
+use ptr::P;
use visit::Visitor;
use visit;
use std::cell::Cell;
use std::cmp;
-use std::gc::{Gc, GC};
use std::u32;
pub fn path_name_i(idents: &[Ident]) -> String {
}
}
-pub fn is_path(e: Gc<Expr>) -> bool {
+pub fn is_path(e: P<Expr>) -> bool {
return match e.node { ExprPath(_) => true, _ => false };
}
}
}
-pub fn is_call_expr(e: Gc<Expr>) -> bool {
- match e.node { ExprCall(..) => true, _ => false }
-}
-
-pub fn block_from_expr(e: Gc<Expr>) -> P<Block> {
- P(Block {
- view_items: Vec::new(),
- stmts: Vec::new(),
- expr: Some(e),
- id: e.id,
- rules: DefaultBlock,
- span: e.span
- })
-}
-
// convert a span and an identifier to the corresponding
// 1-segment path
pub fn ident_to_path(s: Span, identifier: Ident) -> Path {
}
}
-pub fn ident_to_pat(id: NodeId, s: Span, i: Ident) -> Gc<Pat> {
- box(GC) ast::Pat { id: id,
- node: PatIdent(BindByValue(MutImmutable), codemap::Spanned{span:s, node:i}, None),
- span: s }
+pub fn ident_to_pat(id: NodeId, s: Span, i: Ident) -> P<Pat> {
+ P(Pat {
+ id: id,
+ node: PatIdent(BindByValue(MutImmutable), codemap::Spanned{span:s, node:i}, None),
+ span: s
+ })
}
pub fn name_to_dummy_lifetime(name: Name) -> Lifetime {
token::gensym_ident(pretty.as_slice())
}
-pub fn trait_method_to_ty_method(method: &Method) -> TypeMethod {
- match method.node {
- MethDecl(ident,
- ref generics,
- abi,
- explicit_self,
- fn_style,
- decl,
- _,
- vis) => {
- TypeMethod {
- ident: ident,
- attrs: method.attrs.clone(),
- fn_style: fn_style,
- decl: decl,
- generics: generics.clone(),
- explicit_self: explicit_self,
- id: method.id,
- span: method.span,
- vis: vis,
- abi: abi,
- }
- },
- MethMac(_) => fail!("expected non-macro method declaration")
- }
-}
-
-/// extract a TypeMethod from a TraitItem. if the TraitItem is
-/// a default, pull out the useful fields to make a TypeMethod
-//
-// NB: to be used only after expansion is complete, and macros are gone.
-pub fn trait_item_to_ty_method(method: &TraitItem) -> TypeMethod {
- match *method {
- RequiredMethod(ref m) => (*m).clone(),
- ProvidedMethod(ref m) => trait_method_to_ty_method(&**m),
- }
-}
-
-pub fn split_trait_methods(trait_methods: &[TraitItem])
- -> (Vec<TypeMethod> , Vec<Gc<Method>> ) {
- let mut reqd = Vec::new();
- let mut provd = Vec::new();
- for trt_method in trait_methods.iter() {
- match *trt_method {
- RequiredMethod(ref tm) => reqd.push((*tm).clone()),
- ProvidedMethod(m) => provd.push(m)
- }
- };
- (reqd, provd)
-}
-
pub fn struct_field_visibility(field: ast::StructField) -> Visibility {
match field.node.kind {
ast::NamedField(_, v) | ast::UnnamedField(v) => v
visitor.result.get()
}
-pub fn is_item_impl(item: Gc<ast::Item>) -> bool {
- match item.node {
- ItemImpl(..) => true,
- _ => false
- }
-}
-
pub fn walk_pat(pat: &Pat, it: |&Pat| -> bool) -> bool {
if !it(pat) {
return false;
/// Returns true if the given pattern consists solely of an identifier
/// and false otherwise.
-pub fn pat_is_ident(pat:
Gc<ast::Pat>) -> bool {
+pub fn pat_is_ident(pat:
P<ast::Pat>) -> bool {
match pat.node {
ast::PatIdent(..) => true,
_ => false,
}
/// Returns true if this literal is a string and false otherwise.
-pub fn lit_is_str(lit: Gc<Lit>) -> bool {
+pub fn lit_is_str(lit: &Lit) -> bool {
match lit.node {
LitStr(..) => true,
_ => false,
}
}
-pub fn get_inner_tys(ty: P<Ty>) -> Vec<P<Ty>> {
- match ty.node {
- ast::TyRptr(_, mut_ty) | ast::TyPtr(mut_ty) => {
- vec!(mut_ty.ty)
- }
- ast::TyBox(ty)
- | ast::TyVec(ty)
- | ast::TyUniq(ty)
- | ast::TyFixedLengthVec(ty, _) => vec!(ty),
- ast::TyTup(ref tys) => tys.clone(),
- ast::TyParen(ty) => get_inner_tys(ty),
- _ => Vec::new()
- }
-}
-
/// Returns true if the static with the given mutability and attributes
/// has a significant address and false otherwise.
pub fn static_has_significant_address(mutbl: ast::Mutability,
fn pe_abi(&self) -> Abi;
fn pe_explicit_self<'a>(&'a self) -> &'a ast::ExplicitSelf;
fn pe_fn_style(&self) -> ast::FnStyle;
- fn pe_fn_decl(&self) -> P<ast::FnDecl>;
- fn pe_body(&self) -> P<ast::Block>;
+ fn pe_fn_decl<'a>(&'a self) -> &'a ast::FnDecl;
+ fn pe_body<'a>(&'a self) -> &'a ast::Block;
fn pe_vis(&self) -> ast::Visibility;
}
macro_rules! mf_method{
- ($meth_name:ident, $field_ty:ty, $field_pat:pat, $result:ident) => {
+ ($meth_name:ident, $field_ty:ty, $field_pat:pat, $result:expr) => {
fn $meth_name<'a>(&'a self) -> $field_ty {
match self.node {
$field_pat => $result,
mf_method!(pe_explicit_self,&'a ast::ExplicitSelf,
MethDecl(_,_,_,ref explicit_self,_,_,_,_),explicit_self)
mf_method!(pe_fn_style,ast::FnStyle,MethDecl(_,_,_,_,fn_style,_,_,_),fn_style)
- mf_method!(pe_fn_decl,P<ast::FnDecl>,MethDecl(_,_,_,_,_,decl,_,_),decl)
- mf_method!(pe_body,P<ast::Block>,MethDecl(_,_,_,_,_,_,body,_),body)
+ mf_method!(pe_fn_decl,&'a ast::FnDecl,MethDecl(_,_,_,_,_,ref decl,_,_),&**decl)
+ mf_method!(pe_body,&'a ast::Block,MethDecl(_,_,_,_,_,_,ref body,_),&**body)
mf_method!(pe_vis,ast::Visibility,MethDecl(_,_,_,_,_,_,_,vis),vis)
}
use parse::lexer::comments::{doc_comment_style, strip_doc_comment_decoration};
use parse::token::InternedString;
use parse::token;
+use ptr::P;
use std::collections::HashSet;
use std::collections::BitvSet;
-use std::gc::{Gc, GC};
local_data_key!(used_attrs: BitvSet)
/// containing a string, otherwise None.
fn value_str(&self) -> Option<InternedString>;
/// Gets a list of inner meta items from a list MetaItem type.
- fn meta_item_list<'a>(&'a self) -> Option<&'a [Gc<MetaItem>]>;
+ fn meta_item_list<'a>(&'a self) -> Option<&'a [P<MetaItem>]>;
}
impl AttrMetaMethods for Attribute {
fn value_str(&self) -> Option<InternedString> {
self.meta().value_str()
}
- fn meta_item_list<'a>(&'a self) -> Option<&'a [Gc<MetaItem>]> {
+ fn meta_item_list<'a>(&'a self) -> Option<&'a [P<MetaItem>]> {
self.node.value.meta_item_list()
}
}
}
}
- fn meta_item_list<'a>(&'a self) -> Option<&'a [Gc<MetaItem>]> {
+ fn meta_item_list<'a>(&'a self) -> Option<&'a [P<MetaItem>]> {
match self.node {
MetaList(_, ref l) => Some(l.as_slice()),
_ => None
}
// Annoying, but required to get test_cfg to work
-impl AttrMetaMethods for Gc<MetaItem> {
+impl AttrMetaMethods for P<MetaItem> {
fn name(&self) -> InternedString { (**self).name() }
fn value_str(&self) -> Option<InternedString> { (**self).value_str() }
- fn meta_item_list<'a>(&'a self) -> Option<&'a [Gc<MetaItem>]> {
+ fn meta_item_list<'a>(&'a self) -> Option<&'a [P<MetaItem>]> {
(**self).meta_item_list()
}
}
pub trait AttributeMethods {
- fn meta(&self) -> Gc<MetaItem>;
- fn desugar_doc(&self) -> Attribute;
+ fn meta<'a>(&'a self) -> &'a MetaItem;
+ fn with_desugared_doc<T>(&self, f: |&Attribute| -> T) -> T;
}
impl AttributeMethods for Attribute {
/// Extract the MetaItem from inside this Attribute.
- fn meta(&self) -> Gc<MetaItem> {
- self.node.value
+ fn meta<'a>(&'a self) -> &'a MetaItem {
+ &*self.node.value
}
/// Convert self to a normal #[doc="foo"] comment, if it is a
/// comment like `///` or `/** */`. (Returns self unchanged for
/// non-sugared doc attributes.)
- fn desugar_doc(&self) -> Attribute {
+ fn with_desugared_doc<T>(&self, f: |&Attribute| -> T) -> T {
if self.node.is_sugared_doc {
let comment = self.value_str().unwrap();
let meta = mk_name_value_item_str(
token::intern_and_get_ident(strip_doc_comment_decoration(
comment.get()).as_slice()));
if self.node.style == ast::AttrOuter {
- mk_attr_outer(self.node.id, meta)
+ f(&mk_attr_outer(self.node.id, meta))
} else {
- mk_attr_inner(self.node.id, meta)
+ f(&mk_attr_inner(self.node.id, meta))
}
} else {
- *self
+ f(self)
}
}
}
/* Constructors */
pub fn mk_name_value_item_str(name: InternedString, value: InternedString)
- -> Gc<MetaItem> {
+ -> P<MetaItem> {
let value_lit = dummy_spanned(ast::LitStr(value, ast::CookedStr));
mk_name_value_item(name, value_lit)
}
pub fn mk_name_value_item(name: InternedString, value: ast::Lit)
- -> Gc<MetaItem> {
- box(GC) dummy_spanned(MetaNameValue(name, value))
+ -> P<MetaItem> {
+ P(dummy_spanned(MetaNameValue(name, value)))
}
-pub fn mk_list_item(name: InternedString,
- items: Vec<Gc<MetaItem>>) -> Gc<MetaItem> {
- box(GC) dummy_spanned(MetaList(name, items))
+pub fn mk_list_item(name: InternedString, items: Vec<P<MetaItem>>) -> P<MetaItem> {
+ P(dummy_spanned(MetaList(name, items)))
}
-pub fn mk_word_item(name: InternedString) -> Gc<MetaItem> {
- box(GC) dummy_spanned(MetaWord(name))
+pub fn mk_word_item(name: InternedString) -> P<MetaItem> {
+ P(dummy_spanned(MetaWord(name)))
}
local_data_key!(next_attr_id: uint)
}
/// Returns an inner attribute with the given value.
-pub fn mk_attr_inner(id: AttrId, item: Gc<MetaItem>) -> Attribute {
+pub fn mk_attr_inner(id: AttrId, item: P<MetaItem>) -> Attribute {
dummy_spanned(Attribute_ {
id: id,
style: ast::AttrInner,
}
/// Returns an outer attribute with the given value.
-pub fn mk_attr_outer(id: AttrId, item: Gc<MetaItem>) -> Attribute {
+pub fn mk_attr_outer(id: AttrId, item: P<MetaItem>) -> Attribute {
dummy_spanned(Attribute_ {
id: id,
style: ast::AttrOuter,
let attr = Attribute_ {
id: id,
style: style,
- value: box(GC) spanned(lo, hi, MetaNameValue(InternedString::new("doc"),
- lit)),
+ value: P(spanned(lo, hi, MetaNameValue(InternedString::new("doc"),
+ lit))),
is_sugared_doc: true
};
spanned(lo, hi, attr)
/// Check if `needle` occurs in `haystack` by a structural
/// comparison. This is slightly subtle, and relies on ignoring the
/// span included in the `==` comparison a plain MetaItem.
-pub fn contains(haystack: &[Gc<ast::MetaItem>],
- needle: Gc<ast::MetaItem>) -> bool {
+pub fn contains(haystack: &[P<MetaItem>], needle: &MetaItem) -> bool {
debug!("attr::contains (name={})", needle.name());
haystack.iter().any(|item| {
debug!(" testing: {}", item.name());
.and_then(|at| at.value_str())
}
-pub fn last_meta_item_value_str_by_name(items: &[Gc<MetaItem>], name: &str)
+pub fn last_meta_item_value_str_by_name(items: &[P<MetaItem>], name: &str)
-> Option<InternedString> {
items.iter()
.rev()
/* Higher-level applications */
-pub fn sort_meta_items(items: &[Gc<MetaItem>]) -> Vec<Gc<MetaItem>> {
+pub fn sort_meta_items(items: Vec<P<MetaItem>>) -> Vec<P<MetaItem>> {
// This is sort of stupid here, but we need to sort by
// human-readable strings.
- let mut v = items.iter()
- .map(|&mi| (mi.name(), mi))
- .collect::<Vec<(InternedString, Gc<MetaItem>)> >();
+ let mut v = items.move_iter()
+ .map(|mi| (mi.name(), mi))
+ .collect::<Vec<(InternedString, P<MetaItem>)>>();
v.sort_by(|&(ref a, _), &(ref b, _)| a.cmp(b));
// There doesn't seem to be a more optimal way to do this
- v.move_iter().map(|(_, m)| {
- match m.node {
- MetaList(ref n, ref mis) => {
- box(GC) Spanned {
- node: MetaList((*n).clone(),
- sort_meta_items(mis.as_slice())),
- .. /*bad*/ (*m).clone()
- }
- }
- _ => m
+ v.move_iter().map(|(_, m)| m.map(|Spanned {node, span}| {
+ Spanned {
+ node: match node {
+ MetaList(n, mis) => MetaList(n, sort_meta_items(mis)),
+ _ => node
+ },
+ span: span
}
- }).collect()
+ })).collect()
}
pub fn find_crate_name(attrs: &[Attribute]) -> Option<InternedString> {
/// test_cfg(`[foo="a", bar]`, `[cfg(not(bar))]`) == false
/// test_cfg(`[foo="a", bar]`, `[cfg(bar, foo="a")]`) == true
/// test_cfg(`[foo="a", bar]`, `[cfg(bar, foo="b")]`) == false
-pub fn test_cfg<AM: AttrMetaMethods, It: Iterator<AM>>
- (cfg: &[Gc<MetaItem>], mut metas: It) -> bool {
+pub fn test_cfg<'a, AM: AttrMetaMethods, It: Iterator<&'a AM>>
+ (cfg: &[P<MetaItem>], mut metas: It) -> bool {
// having no #[cfg(...)] attributes counts as matching.
let mut no_cfgs = true;
// not match.
!not_cfgs.iter().all(|mi| {
debug!("cfg(not({}[...]))", mi.name());
- contains(cfg, *mi)
+ contains(cfg, &**mi)
})
}
- _ => contains(cfg, *cfg_mi)
+ _ => contains(cfg, &**cfg_mi)
}
})
}
};
return Some((Stability {
- level: level,
+ level: level,
text: attr.value_str()
}, attr));
}
})
}
-pub fn require_unique_names(diagnostic: &SpanHandler, metas: &[Gc<MetaItem>]) {
+pub fn require_unique_names(diagnostic: &SpanHandler, metas: &[P<MetaItem>]) {
let mut set = HashSet::new();
for meta in metas.iter() {
let name = meta.name();
Ok(())
}
-pub fn expect<T:Clone>(diag: &SpanHandler, opt: Option<T>, msg: || -> String)
- -> T {
+pub fn expect<T>(diag: &SpanHandler, opt: Option<T>, msg: || -> String) -> T {
match opt {
- Some(ref t) => (*t).clone(),
- None => diag.handler().bug(msg().as_slice()),
+ Some(t) => t,
+ None => diag.handler().bug(msg().as_slice()),
}
}
use std::cell::RefCell;
use std::collections::HashMap;
-use std::gc::Gc;
use ast;
use ast::{Ident, Name, TokenTree};
use codemap::Span;
use ext::base::{ExtCtxt, MacExpr, MacItem, MacResult};
use ext::build::AstBuilder;
use parse::token;
+use ptr::P;
local_data_key!(registered_diagnostics: RefCell<HashMap<Name, Option<Name>>>)
local_data_key!(used_diagnostics: RefCell<HashMap<Name, Span>>)
let (count, expr) = with_used_diagnostics(|diagnostics_in_use| {
with_registered_diagnostics(|diagnostics| {
- let descriptions: Vec<
Gc<ast::Expr>> = diagnostics
+ let descriptions: Vec<
P<ast::Expr>> = diagnostics
.iter().filter_map(|(code, description)| {
if !diagnostics_in_use.contains_key(code) {
ecx.span_warn(span, format!(
use ext::base::*;
use parse::token::InternedString;
use parse::token;
-
-use std::gc::GC;
+use ptr::P;
enum State {
Asm,
}
}
- MacExpr::new(box(GC) ast::Expr {
+ MacExpr::new(P(ast::Expr {
id: ast::DUMMY_NODE_ID,
node: ast::ExprInlineAsm(ast::InlineAsm {
asm: token::intern_and_get_ident(asm.get()),
dialect: dialect
}),
span: sp
- })
+ }))
}
use parse::parser;
use parse::token;
use parse::token::{InternedString, intern, str_to_ident};
+use ptr::P;
use util::small_vector::SmallVector;
use ext::mtwt;
use fold::Folder;
fn expand(&self,
ecx: &mut ExtCtxt,
sp: Span,
- meta_item: Gc<ast::MetaItem>,
- item: Gc<ast::Item>,
- push: |
Gc<ast::Item>|);
+ meta_item: &ast::MetaItem,
+ item: &ast::Item,
}
-impl ItemDecorator for fn(&mut ExtCtxt, Span,
Gc<ast::MetaItem>, Gc<ast::Item>, |Gc<ast::Item>|) {
+impl ItemDecorator for fn(&mut ExtCtxt, Span,
&ast::MetaItem, &ast::Item, |P<ast::Item>|) {
fn expand(&self,
ecx: &mut ExtCtxt,
sp: Span,
- meta_item: Gc<ast::MetaItem>,
- item: Gc<ast::Item>,
- push: |
Gc<ast::Item>|) {
+ meta_item: &ast::MetaItem,
+ item: &ast::Item,
+ push: |
P<ast::Item>|) {
(*self)(ecx, sp, meta_item, item, push)
}
}
fn expand(&self,
ecx: &mut ExtCtxt,
span: Span,
- meta_item: Gc<ast::MetaItem>,
+ meta_item: &ast::MetaItem,
}
-impl ItemModifier for fn(&mut ExtCtxt, Span,
Gc<ast::MetaItem>, Gc<ast::Item>) -> Gc<ast::Item> {
+impl ItemModifier for fn(&mut ExtCtxt, Span,
&ast::MetaItem, P<ast::Item>) -> P<ast::Item> {
fn expand(&self,
ecx: &mut ExtCtxt,
span: Span,
- meta_item: Gc<ast::MetaItem>,
+ meta_item: &ast::MetaItem,
(*self)(ecx, span, meta_item, item)
}
}
/// methods are spliced into the AST at the callsite of the macro (or
/// just into the compiler's internal macro table, for `make_def`).
pub trait MacResult {
- /// Define a new macro.
+ /// Attempt to define a new macro.
// this should go away; the idea that a macro might expand into
// either a macro definition or an expression, depending on what
// the context wants, is kind of silly.
- fn make_def(&self) -> Option<MacroDef> {
+ fn make_def(&mut self) -> Option<MacroDef> {
None
}
/// Create an expression.
- fn make_expr(
&self) -> Option<Gc<ast::Expr>> {
+ fn make_expr(
self: Box<Self>) -> Option<P<ast::Expr>> {
None
}
/// Create zero or more items.
- fn make_items(
&self) -> Option<SmallVector<Gc<ast::Item>>> {
+ fn make_items(
self: Box<Self>) -> Option<SmallVector<P<ast::Item>>> {
None
}
/// Create zero or more methods.
- fn make_methods(
&self) -> Option<SmallVector<Gc<ast::Method>>> {
+ fn make_methods(
self: Box<Self>) -> Option<SmallVector<P<ast::Method>>> {
None
}
/// Create a pattern.
- fn make_pat(
&self) -> Option<Gc<ast::Pat>> {
+ fn make_pat(
self: Box<Self>) -> Option<P<ast::Pat>> {
None
}
///
/// By default this attempts to create an expression statement,
/// returning None if that fails.
- fn make_stmt(
&self) -> Option<Gc<ast::Stmt>> {
+ fn make_stmt(
self: Box<Self>) -> Option<P<ast::Stmt>> {
self.make_expr()
- .map(|e| box(GC) codemap::respan(e.span, ast::StmtExpr(e, ast::DUMMY_NODE_ID)))
+ .map(|e| P(codemap::respan(e.span, ast::StmtExpr(e, ast::DUMMY_NODE_ID))))
}
}
/// A convenience type for macros that return a single expression.
pub struct MacExpr {
- e: Gc<ast::Expr>,
+ e: P<ast::Expr>
}
impl MacExpr {
- pub fn new(e:
Gc<ast::Expr>) -> Box<MacResult+'static> {
+ pub fn new(e:
P<ast::Expr>) -> Box<MacResult+'static> {
box MacExpr { e: e } as Box<MacResult+'static>
}
}
impl MacResult for MacExpr {
- fn make_expr(
&self) -> Option<Gc<ast::Expr>> {
+ fn make_expr(
self: Box<MacExpr>) -> Option<P<ast::Expr>> {
Some(self.e)
}
- fn make_pat(
&self) -> Option<Gc<ast::Pat>> {
+ fn make_pat(
self: Box<MacExpr>) -> Option<P<ast::Pat>> {
match self.e.node {
- ast::ExprLit(_) => Some(box(GC) ast::Pat {
+ ast::ExprLit(_) => Some(P(ast::Pat {
id: ast::DUMMY_NODE_ID,
- node: ast::PatLit(self.e),
- span: self.e.span
- }),
+ span: self.e.span,
+ node: ast::PatLit(self.e)
+ })),
_ => None
}
}
}
/// A convenience type for macros that return a single pattern.
pub struct MacPat {
- p: Gc<ast::Pat>,
+ p: P<ast::Pat>
}
impl MacPat {
- pub fn new(p:
Gc<ast::Pat>) -> Box<MacResult+'static> {
+ pub fn new(p:
P<ast::Pat>) -> Box<MacResult+'static> {
box MacPat { p: p } as Box<MacResult+'static>
}
}
impl MacResult for MacPat {
- fn make_pat(
&self) -> Option<Gc<ast::Pat>> {
+ fn make_pat(
self: Box<MacPat>) -> Option<P<ast::Pat>> {
Some(self.p)
}
}
/// A convenience type for macros that return a single item.
pub struct MacItem {
}
impl MacItem {
- pub fn new(i:
Gc<ast::Item>) -> Box<MacResult+'static> {
+ pub fn new(i:
P<ast::Item>) -> Box<MacResult+'static> {
box MacItem { i: i } as Box<MacResult+'static>
}
}
impl MacResult for MacItem {
- fn make_items(
&self) -> Option<SmallVector<Gc<ast::Item>>> {
+ fn make_items(
self: Box<MacItem>) -> Option<SmallVector<P<ast::Item>>> {
Some(SmallVector::one(self.i))
}
- fn make_stmt(
&self) -> Option<Gc<ast::Stmt>> {
- Some(box(GC) codemap::respan(
+ fn make_stmt(
self: Box<MacItem>) -> Option<P<ast::Stmt>> {
+ Some(P(codemap::respan(
self.i.span,
ast::StmtDecl(
- box(GC) codemap::respan(self.i.span, ast::DeclItem(self.i)),
- ast::DUMMY_NODE_ID)))
+ P(codemap::respan(self.i.span, ast::DeclItem(self.i))),
+ ast::DUMMY_NODE_ID))))
}
}
}
/// A plain dummy expression.
- pub fn raw_expr(sp: Span) ->
Gc<ast::Expr> {
- box(GC) ast::Expr {
+ pub fn raw_expr(sp: Span) ->
P<ast::Expr> {
+ P(ast::Expr {
id: ast::DUMMY_NODE_ID,
- node: ast::ExprLit(box(GC) codemap::respan(sp, ast::LitNil)),
+ node: ast::ExprLit(P(codemap::respan(sp, ast::LitNil))),
span: sp,
- }
+ })
}
/// A plain dummy pattern.
- pub fn raw_pat(sp: Span) -> Gc<ast::Pat> {
- box(GC) ast::Pat {
+ pub fn raw_pat(sp: Span) -> ast::Pat {
+ ast::Pat {
id: ast::DUMMY_NODE_ID,
node: ast::PatWild(ast::PatWildSingle),
span: sp,
}
impl MacResult for DummyResult {
- fn make_expr(
&self) -> Option<Gc<ast::Expr>> {
+ fn make_expr(
self: Box<DummyResult>) -> Option<P<ast::Expr>> {
Some(DummyResult::raw_expr(self.span))
}
- fn make_pat(
&self) -> Option<Gc<ast::Pat>> {
- Some(DummyResult::raw_pat(self.span))
+ fn make_pat(
self: Box<DummyResult>) -> Option<P<ast::Pat>> {
+ Some(P(DummyResult::raw_pat(self.span)))
}
- fn make_items(
&self) -> Option<SmallVector<Gc<ast::Item>>> {
+ fn make_items(
self: Box<DummyResult>) -> Option<SmallVector<P<ast::Item>>> {
// this code needs a comment... why not always just return the Some() ?
if self.expr_only {
None
Some(SmallVector::zero())
}
}
- fn make_methods(
&self) -> Option<SmallVector<Gc<ast::Method>>> {
+ fn make_methods(
self: Box<DummyResult>) -> Option<SmallVector<P<ast::Method>>> {
if self.expr_only {
None
} else {
Some(SmallVector::zero())
}
}
- fn make_stmt(
&self) -> Option<Gc<ast::Stmt>> {
- Some(box(GC) codemap::respan(self.span,
- ast::StmtExpr(DummyResult::raw_expr(self.span),
- ast::DUMMY_NODE_ID)))
+ fn make_stmt(
self: Box<DummyResult>) -> Option<P<ast::Stmt>> {
+ Some(P(codemap::respan(self.span,
+ ast::StmtExpr(DummyResult::raw_expr(self.span),
+ ast::DUMMY_NODE_ID))))
}
}
pub mod_path: Vec<ast::Ident> ,
pub trace_mac: bool,
- pub exported_macros: Vec<
Gc<ast::Item>>,
+ pub exported_macros: Vec<
P<ast::Item>>,
pub syntax_env: SyntaxEnv,
}
}
#[deprecated = "Replaced with `expander().fold_expr()`"]
- pub fn expand_expr(&mut self, e:
Gc<ast::Expr>) -> Gc<ast::Expr> {
+ pub fn expand_expr(&mut self, e:
P<ast::Expr>) -> P<ast::Expr> {
self.expander().fold_expr(e)
}
/// Extract a string literal from the macro expanded version of `expr`,
/// emitting `err_msg` if `expr` is not a string literal. This does not stop
/// compilation on error, merely emits a non-fatal error and returns None.
-pub fn expr_to_string(cx: &mut ExtCtxt, expr:
Gc<ast::Expr>, err_msg: &str)
- -> Option<(InternedString, ast::StrStyle)> {
+pub fn expr_to_string(cx: &mut ExtCtxt, expr:
P<ast::Expr>, err_msg: &str)
+ -> Option<(InternedString, ast::StrStyle)> {
// we want to be able to handle e.g. concat("foo", "bar")
let expr = cx.expander().fold_expr(expr);
match expr.node {
- ast::ExprLit(l) => match l.node {
+ ast::ExprLit(ref l) => match l.node {
ast::LitStr(ref s, style) => return Some(((*s).clone(), style)),
_ => cx.span_err(l.span, err_msg)
},
/// parsing error, emit a non-fatal error and return None.
pub fn get_exprs_from_tts(cx: &mut ExtCtxt,
sp: Span,
- tts: &[ast::TokenTree]) -> Option<Vec<
Gc<ast::Expr>>> {
+ tts: &[ast::TokenTree]) -> Option<Vec<
P<ast::Expr>>> {
let mut p = cx.new_parser_from_tts(tts);
let mut es = Vec::new();
while p.token != token::EOF {
// except according to those terms.
use abi;
-use ast::{P, Ident, Generics, NodeId, Expr};
+use ast::{Ident, Generics, Expr};
use ast;
use ast_util;
use attr;
use codemap::{Span, respan, Spanned, DUMMY_SP, Pos};
use ext::base::ExtCtxt;
-use fold::Folder;
use owned_slice::OwnedSlice;
use parse::token::special_idents;
use parse::token::InternedString;
use parse::token;
+use ptr::P;
-use std::gc::{Gc, GC};
// Transitional reexports so qquote can find the paths it is looking for
mod syntax {
fn ty_vars(&self, ty_params: &OwnedSlice<ast::TyParam>) -> Vec<P<ast::Ty>> ;
fn ty_vars_global(&self, ty_params: &OwnedSlice<ast::TyParam>) -> Vec<P<ast::Ty>> ;
fn ty_field_imm(&self, span: Span, name: Ident, ty: P<ast::Ty>) -> ast::TypeField;
- fn strip_bounds(&self, bounds: &Generics) -> Generics;
fn typaram(&self,
span: Span,
-> ast::LifetimeDef;
// statements
- fn stmt_expr(&self, expr: Gc<ast::Expr>) -> Gc<ast::Stmt>;
- fn stmt_let(&self, sp: Span, mutbl: bool, ident: ast::Ident,
- ex: Gc<ast::Expr>) -> Gc<ast::Stmt>;
+ fn stmt_expr(&self, expr: P<ast::Expr>) -> P<ast::Stmt>;
+ fn stmt_let(&self, sp: Span, mutbl: bool, ident: ast::Ident, ex: P<ast::Expr>) -> P<ast::Stmt>;
fn stmt_let_typed(&self,
sp: Span,
mutbl: bool,
ident: ast::Ident,
typ: P<ast::Ty>,
- fn stmt_item(&self, sp: Span, item:
Gc<ast::Item>) -> Gc<ast::Stmt>;
+ fn stmt_item(&self, sp: Span, item:
P<ast::Item>) -> P<ast::Stmt>;
// blocks
- fn block(&self, span: Span, stmts: Vec<
Gc<ast::Stmt>>,
- expr: Option<
Gc<ast::Expr>>) -> P<ast::Block>;
- fn block_expr(&self, expr:
Gc<ast::Expr>) -> P<ast::Block>;
+ fn block(&self, span: Span, stmts: Vec<
P<ast::Stmt>>,
+ expr: Option<
P<ast::Expr>>) -> P<ast::Block>;
+ fn block_expr(&self, expr:
P<ast::Expr>) -> P<ast::Block>;
fn block_all(&self, span: Span,
- view_items: Vec<ast::ViewItem> ,
- stmts: Vec<Gc<ast::Stmt>> ,
- expr: Option<
Gc<ast::Expr>>) -> P<ast::Block>;
+ view_items: Vec<ast::ViewItem>,
+ stmts: Vec<P<ast::Stmt>>,
+ expr: Option<
P<ast::Expr>>) -> P<ast::Block>;
// expressions
- fn expr(&self, span: Span, node: ast::Expr_) ->
Gc<ast::Expr>;
- fn expr_path(&self, path: ast::Path) ->
Gc<ast::Expr>;
- fn expr_ident(&self, span: Span, id: ast::Ident) ->
Gc<ast::Expr>;
+ fn expr(&self, span: Span, node: ast::Expr_) ->
P<ast::Expr>;
+ fn expr_path(&self, path: ast::Path) ->
P<ast::Expr>;
+ fn expr_ident(&self, span: Span, id: ast::Ident) ->
P<ast::Expr>;
- fn expr_self(&self, span: Span) ->
Gc<ast::Expr>;
+ fn expr_self(&self, span: Span) ->
P<ast::Expr>;
fn expr_binary(&self, sp: Span, op: ast::BinOp,
- lhs: Gc<ast::Expr>, rhs: Gc<ast::Expr>) -> Gc<ast::Expr>;
- fn expr_deref(&self, sp: Span, e: Gc<ast::Expr>) -> Gc<ast::Expr>;
- fn expr_unary(&self, sp: Span, op: ast::UnOp, e: Gc<ast::Expr>) -> Gc<ast::Expr>;
-
- fn expr_managed(&self, sp: Span, e: Gc<ast::Expr>) -> Gc<ast::Expr>;
- fn expr_addr_of(&self, sp: Span, e: Gc<ast::Expr>) -> Gc<ast::Expr>;
- fn expr_mut_addr_of(&self, sp: Span, e: Gc<ast::Expr>) -> Gc<ast::Expr>;
- fn expr_field_access(&self, span: Span, expr: Gc<ast::Expr>,
- ident: ast::Ident) -> Gc<ast::Expr>;
- fn expr_tup_field_access(&self, sp: Span, expr: Gc<ast::Expr>,
- idx: uint) -> Gc<ast::Expr>;
- fn expr_call(&self, span: Span, expr: Gc<ast::Expr>,
- args: Vec<Gc<ast::Expr>>) -> Gc<ast::Expr>;
- fn expr_call_ident(&self, span: Span, id: ast::Ident,
- args: Vec<Gc<ast::Expr>>) -> Gc<ast::Expr>;
- fn expr_call_global(&self, sp: Span, fn_path: Vec<ast::Ident> ,
- args: Vec<Gc<ast::Expr>>) -> Gc<ast::Expr>;
+ lhs: P<ast::Expr>, rhs: P<ast::Expr>) -> P<ast::Expr>;
+ fn expr_deref(&self, sp: Span, e: P<ast::Expr>) -> P<ast::Expr>;
+ fn expr_unary(&self, sp: Span, op: ast::UnOp, e: P<ast::Expr>) -> P<ast::Expr>;
+
+ fn expr_managed(&self, sp: Span, e: P<ast::Expr>) -> P<ast::Expr>;
+ fn expr_addr_of(&self, sp: Span, e: P<ast::Expr>) -> P<ast::Expr>;
+ fn expr_mut_addr_of(&self, sp: Span, e: P<ast::Expr>) -> P<ast::Expr>;
+ fn expr_field_access(&self, span: Span, expr: P<ast::Expr>, ident: ast::Ident) -> P<ast::Expr>;
+ fn expr_tup_field_access(&self, sp: Span, expr: P<ast::Expr>,
+ idx: uint) -> P<ast::Expr>;
+ fn expr_call(&self, span: Span, expr: P<ast::Expr>, args: Vec<P<ast::Expr>>) -> P<ast::Expr>;
+ fn expr_call_ident(&self, span: Span, id: ast::Ident, args: Vec<P<ast::Expr>>) -> P<ast::Expr>;
+ fn expr_call_global(&self, sp: Span, fn_path: Vec<ast::Ident>,
+ args: Vec<P<ast::Expr>> ) -> P<ast::Expr>;
fn expr_method_call(&self, span: Span,
- expr: Gc<ast::Expr>, ident: ast::Ident,
- args: Vec<Gc<ast::Expr>> ) -> Gc<ast::Expr>;
- fn expr_block(&self, b: P<ast::Block>) -> Gc<ast::Expr>;
- fn expr_cast(&self, sp: Span, expr: Gc<ast::Expr>,
- ty: P<ast::Ty>) -> Gc<ast::Expr>;
-
- fn field_imm(&self, span: Span, name: Ident, e: Gc<ast::Expr>) -> ast::Field;
- fn expr_struct(&self, span: Span, path: ast::Path,
- fields: Vec<ast::Field> ) -> Gc<ast::Expr>;
+ expr: P<ast::Expr>, ident: ast::Ident,
+ args: Vec<P<ast::Expr>> ) -> P<ast::Expr>;
+ fn expr_block(&self, b: P<ast::Block>) -> P<ast::Expr>;
+ fn expr_cast(&self, sp: Span, expr: P<ast::Expr>, ty: P<ast::Ty>) -> P<ast::Expr>;
+
+ fn field_imm(&self, span: Span, name: Ident, e: P<ast::Expr>) -> ast::Field;
+ fn expr_struct(&self, span: Span, path: ast::Path, fields: Vec<ast::Field>) -> P<ast::Expr>;
fn expr_struct_ident(&self, span: Span, id: ast::Ident,
- fields: Vec<ast::Field>
) -> Gc<ast::Expr>;
+ fields: Vec<ast::Field>
) -> P<ast::Expr>;
- fn expr_lit(&self, sp: Span, lit: ast::Lit_) ->
Gc<ast::Expr>;
+ fn expr_lit(&self, sp: Span, lit: ast::Lit_) ->
P<ast::Expr>;
- fn expr_uint(&self, span: Span, i: uint) ->
Gc<ast::Expr>;
- fn expr_int(&self, sp: Span, i: int) ->
Gc<ast::Expr>;
- fn expr_u8(&self, sp: Span, u: u8) ->
Gc<ast::Expr>;
- fn expr_bool(&self, sp: Span, value: bool) ->
Gc<ast::Expr>;
+ fn expr_uint(&self, span: Span, i: uint) ->
P<ast::Expr>;
+ fn expr_int(&self, sp: Span, i: int) ->
P<ast::Expr>;
+ fn expr_u8(&self, sp: Span, u: u8) ->
P<ast::Expr>;
+ fn expr_bool(&self, sp: Span, value: bool) ->
P<ast::Expr>;
- fn expr_vec(&self, sp: Span, exprs: Vec<
Gc<ast::Expr>> ) -> Gc<ast::Expr>;
- fn expr_vec_ng(&self, sp: Span) ->
Gc<ast::Expr>;
- fn expr_vec_slice(&self, sp: Span, exprs: Vec<
Gc<ast::Expr>> ) -> Gc<ast::Expr>;
- fn expr_str(&self, sp: Span, s: InternedString) ->
Gc<ast::Expr>;
+ fn expr_vec(&self, sp: Span, exprs: Vec<
P<ast::Expr>>) -> P<ast::Expr>;
+ fn expr_vec_ng(&self, sp: Span) ->
P<ast::Expr>;
+ fn expr_vec_slice(&self, sp: Span, exprs: Vec<
P<ast::Expr>>) -> P<ast::Expr>;
+ fn expr_str(&self, sp: Span, s: InternedString) ->
P<ast::Expr>;
- fn expr_some(&self, sp: Span, expr:
Gc<ast::Expr>) -> Gc<ast::Expr>;
- fn expr_none(&self, sp: Span) ->
Gc<ast::Expr>;
+ fn expr_some(&self, sp: Span, expr:
P<ast::Expr>) -> P<ast::Expr>;
+ fn expr_none(&self, sp: Span) ->
P<ast::Expr>;
- fn expr_tuple(&self, sp: Span, exprs: Vec<
Gc<ast::Expr>>) -> Gc<ast::Expr>;
+ fn expr_tuple(&self, sp: Span, exprs: Vec<
P<ast::Expr>>) -> P<ast::Expr>;
- fn expr_fail(&self, span: Span, msg: InternedString) ->
Gc<ast::Expr>;
- fn expr_unreachable(&self, span: Span) ->
Gc<ast::Expr>;
+ fn expr_fail(&self, span: Span, msg: InternedString) ->
P<ast::Expr>;
+ fn expr_unreachable(&self, span: Span) ->
P<ast::Expr>;
- fn expr_ok(&self, span: Span, expr:
Gc<ast::Expr>) -> Gc<ast::Expr>;
- fn expr_err(&self, span: Span, expr:
Gc<ast::Expr>) -> Gc<ast::Expr>;
- fn expr_try(&self, span: Span, head:
Gc<ast::Expr>) -> Gc<ast::Expr>;
+ fn expr_ok(&self, span: Span, expr:
P<ast::Expr>) -> P<ast::Expr>;
+ fn expr_err(&self, span: Span, expr:
P<ast::Expr>) -> P<ast::Expr>;
+ fn expr_try(&self, span: Span, head:
P<ast::Expr>) -> P<ast::Expr>;
- fn pat(&self, span: Span, pat: ast::Pat_) ->
Gc<ast::Pat>;
- fn pat_wild(&self, span: Span) ->
Gc<ast::Pat>;
- fn pat_lit(&self, span: Span, expr:
Gc<ast::Expr>) -> Gc<ast::Pat>;
- fn pat_ident(&self, span: Span, ident: ast::Ident) ->
Gc<ast::Pat>;
+ fn pat(&self, span: Span, pat: ast::Pat_) ->
P<ast::Pat>;
+ fn pat_wild(&self, span: Span) ->
P<ast::Pat>;
+ fn pat_lit(&self, span: Span, expr:
P<ast::Expr>) -> P<ast::Pat>;
+ fn pat_ident(&self, span: Span, ident: ast::Ident) ->
P<ast::Pat>;
fn pat_ident_binding_mode(&self,
span: Span,
ident: ast::Ident,
- bm: ast::BindingMode) -> Gc<ast::Pat>;
- fn pat_enum(&self, span: Span, path: ast::Path,
- subpats: Vec<Gc<ast::Pat>>) -> Gc<ast::Pat>;
+ bm: ast::BindingMode) -> P<ast::Pat>;
+ fn pat_enum(&self, span: Span, path: ast::Path, subpats: Vec<P<ast::Pat>> ) -> P<ast::Pat>;
fn pat_struct(&self, span: Span,
- path: ast::Path, field_pats: Vec<ast::FieldPat> ) ->
Gc<ast::Pat>;
- fn pat_tuple(&self, span: Span, pats: Vec<
Gc<ast::Pat>>) -> Gc<ast::Pat>;
+ path: ast::Path, field_pats: Vec<ast::FieldPat> ) ->
P<ast::Pat>;
+ fn pat_tuple(&self, span: Span, pats: Vec<
P<ast::Pat>>) -> P<ast::Pat>;
- fn pat_some(&self, span: Span, pat:
Gc<ast::Pat>) -> Gc<ast::Pat>;
- fn pat_none(&self, span: Span) ->
Gc<ast::Pat>;
+ fn pat_some(&self, span: Span, pat:
P<ast::Pat>) -> P<ast::Pat>;
+ fn pat_none(&self, span: Span) ->
P<ast::Pat>;
- fn pat_ok(&self, span: Span, pat:
Gc<ast::Pat>) -> Gc<ast::Pat>;
- fn pat_err(&self, span: Span, pat:
Gc<ast::Pat>) -> Gc<ast::Pat>;
+ fn pat_ok(&self, span: Span, pat:
P<ast::Pat>) -> P<ast::Pat>;
+ fn pat_err(&self, span: Span, pat:
P<ast::Pat>) -> P<ast::Pat>;
- fn arm(&self, span: Span, pats: Vec<
Gc<ast::Pat>> , expr: Gc<ast::Expr>) -> ast::Arm;
+ fn arm(&self, span: Span, pats: Vec<
P<ast::Pat>>, expr: P<ast::Expr>) -> ast::Arm;
fn arm_unreachable(&self, span: Span) -> ast::Arm;
- fn expr_match(&self, span: Span, arg:
Gc<ast::Expr>, arms: Vec<ast::Arm> ) -> Gc<ast::Expr>;
+ fn expr_match(&self, span: Span, arg:
P<ast::Expr>, arms: Vec<ast::Arm> ) -> P<ast::Expr>;
fn expr_if(&self, span: Span,
- cond: Gc<ast::Expr>, then: Gc<ast::Expr>,
- els: Option<Gc<ast::Expr>>) -> Gc<ast::Expr>;
- fn expr_loop(&self, span: Span, block: P<ast::Block>) -> Gc<ast::Expr>;
+ cond: P<ast::Expr>, then: P<ast::Expr>, els: Option<P<ast::Expr>>) -> P<ast::Expr>;
+ fn expr_loop(&self, span: Span, block: P<ast::Block>) -> P<ast::Expr>;
fn lambda_fn_decl(&self, span: Span,
- fn_decl: P<ast::FnDecl>, blk: P<ast::Block>) ->
Gc<ast::Expr>;
+ fn_decl: P<ast::FnDecl>, blk: P<ast::Block>) ->
P<ast::Expr>;
- fn lambda(&self, span: Span, ids: Vec<ast::Ident> , blk: P<ast::Block>) ->
Gc<ast::Expr>;
- fn lambda0(&self, span: Span, blk: P<ast::Block>) ->
Gc<ast::Expr>;
- fn lambda1(&self, span: Span, blk: P<ast::Block>, ident: ast::Ident) ->
Gc<ast::Expr>;
+ fn lambda(&self, span: Span, ids: Vec<ast::Ident> , blk: P<ast::Block>) ->
P<ast::Expr>;
+ fn lambda0(&self, span: Span, blk: P<ast::Block>) ->
P<ast::Expr>;
+ fn lambda1(&self, span: Span, blk: P<ast::Block>, ident: ast::Ident) ->
P<ast::Expr>;
- fn lambda_expr(&self, span: Span, ids: Vec<ast::Ident> , blk:
Gc<ast::Expr>) -> Gc<ast::Expr>;
- fn lambda_expr_0(&self, span: Span, expr:
Gc<ast::Expr>) -> Gc<ast::Expr>;
- fn lambda_expr_1(&self, span: Span, expr:
Gc<ast::Expr>, ident: ast::Ident) -> Gc<ast::Expr>;
+ fn lambda_expr(&self, span: Span, ids: Vec<ast::Ident> , blk:
P<ast::Expr>) -> P<ast::Expr>;
+ fn lambda_expr_0(&self, span: Span, expr:
P<ast::Expr>) -> P<ast::Expr>;
+ fn lambda_expr_1(&self, span: Span, expr:
P<ast::Expr>, ident: ast::Ident) -> P<ast::Expr>;
fn lambda_stmts(&self, span: Span, ids: Vec<ast::Ident>,
- blk: Vec<Gc<ast::Stmt>>) -> Gc<ast::Expr>;
- fn lambda_stmts_0(&self, span: Span,
- stmts: Vec<Gc<ast::Stmt>>) -> Gc<ast::Expr>;
- fn lambda_stmts_1(&self, span: Span,
- stmts: Vec<Gc<ast::Stmt>>, ident: ast::Ident) -> Gc<ast::Expr>;
+ blk: Vec<P<ast::Stmt>>) -> P<ast::Expr>;
+ fn lambda_stmts_0(&self, span: Span, stmts: Vec<P<ast::Stmt>>) -> P<ast::Expr>;
+ fn lambda_stmts_1(&self, span: Span, stmts: Vec<P<ast::Stmt>>,
+ ident: ast::Ident) -> P<ast::Expr>;
// items
fn item(&self, span: Span,
- name: Ident, attrs: Vec<ast::Attribute>,
- node: ast::Item_) -> Gc<ast::Item>;
+ name: Ident, attrs: Vec<ast::Attribute> , node: ast::Item_) -> P<ast::Item>;
fn arg(&self, span: Span, name: Ident, ty: P<ast::Ty>) -> ast::Arg;
// FIXME unused self
inputs: Vec<ast::Arg> ,
output: P<ast::Ty>,
generics: Generics,
- body: P<ast::Block>) ->
Gc<ast::Item>;
+ body: P<ast::Block>) ->
P<ast::Item>;
fn item_fn(&self,
span: Span,
name: Ident,
inputs: Vec<ast::Arg> ,
output: P<ast::Ty>,
- body: P<ast::Block>) ->
Gc<ast::Item>;
+ body: P<ast::Block>) ->
P<ast::Item>;
fn variant(&self, span: Span, name: Ident, tys: Vec<P<ast::Ty>> ) -> ast::Variant;
fn item_enum_poly(&self,
span: Span,
name: Ident,
enum_definition: ast::EnumDef,
- generics: Generics) -> Gc<ast::Item>;
- fn item_enum(&self, span: Span, name: Ident,
- enum_def: ast::EnumDef) -> Gc<ast::Item>;
+ generics: Generics) -> P<ast::Item>;
+ fn item_enum(&self, span: Span, name: Ident, enum_def: ast::EnumDef) -> P<ast::Item>;
fn item_struct_poly(&self,
span: Span,
name: Ident,
struct_def: ast::StructDef,
- generics: Generics) -> Gc<ast::Item>;
- fn item_struct(&self, span: Span, name: Ident,
- struct_def: ast::StructDef) -> Gc<ast::Item>;
+ generics: Generics) -> P<ast::Item>;
+ fn item_struct(&self, span: Span, name: Ident, struct_def: ast::StructDef) -> P<ast::Item>;
fn item_mod(&self, span: Span, inner_span: Span,
name: Ident, attrs: Vec<ast::Attribute>,
- vi: Vec<ast::ViewItem>,
- items: Vec<Gc<ast::Item>>) -> Gc<ast::Item>;
+ vi: Vec<ast::ViewItem> , items: Vec<P<ast::Item>> ) -> P<ast::Item>;
fn item_static(&self,
span: Span,
name: Ident,
ty: P<ast::Ty>,
mutbl: ast::Mutability,
fn item_ty_poly(&self,
span: Span,
name: Ident,
ty: P<ast::Ty>,
- generics: Generics) ->
Gc<ast::Item>;
- fn item_ty(&self, span: Span, name: Ident, ty: P<ast::Ty>) ->
Gc<ast::Item>;
+ generics: Generics) ->
P<ast::Item>;
+ fn item_ty(&self, span: Span, name: Ident, ty: P<ast::Ty>) ->
P<ast::Item>;
- fn attribute(&self, sp: Span, mi:
Gc<ast::MetaItem>) -> ast::Attribute;
+ fn attribute(&self, sp: Span, mi:
P<ast::MetaItem>) -> ast::Attribute;
- fn meta_word(&self, sp: Span, w: InternedString) ->
Gc<ast::MetaItem>;
+ fn meta_word(&self, sp: Span, w: InternedString) ->
P<ast::MetaItem>;
fn meta_list(&self,
sp: Span,
name: InternedString,
- mis: Vec<Gc<ast::MetaItem>>)
+ mis: Vec<P<ast::MetaItem>> )
fn meta_name_value(&self,
sp: Span,
name: InternedString,
value: ast::Lit_)
fn view_use(&self, sp: Span,
- vis: ast::Visibility, vp:
Gc<ast::ViewPath>) -> ast::ViewItem;
+ vis: ast::Visibility, vp:
P<ast::ViewPath>) -> ast::ViewItem;
fn view_use_simple(&self, sp: Span, vis: ast::Visibility, path: ast::Path) -> ast::ViewItem;
fn view_use_simple_(&self, sp: Span, vis: ast::Visibility,
ident: ast::Ident, path: ast::Path) -> ast::ViewItem;
self.path_global(DUMMY_SP, vec!(p.ident)), None)).collect()
}
- fn strip_bounds(&self, generics: &Generics) -> Generics {
- let new_params = generics.ty_params.map(|ty_param| {
- ast::TyParam { bounds: OwnedSlice::empty(), unbound: None, ..*ty_param }
- });
- Generics {
- ty_params: new_params,
- .. (*generics).clone()
- }
- }
-
fn trait_ref(&self, path: ast::Path) -> ast::TraitRef {
ast::TraitRef {
path: path,
}
}
- fn stmt_expr(&self, expr:
Gc<ast::Expr>) -> Gc<ast::Stmt> {
- box(GC) respan(expr.span, ast::StmtSemi(expr, ast::DUMMY_NODE_ID))
+ fn stmt_expr(&self, expr:
P<ast::Expr>) -> P<ast::Stmt> {
+ P(respan(expr.span, ast::StmtSemi(expr, ast::DUMMY_NODE_ID)))
}
fn stmt_let(&self, sp: Span, mutbl: bool, ident: ast::Ident,
- ex:
Gc<ast::Expr>) -> Gc<ast::Stmt> {
+ ex:
P<ast::Expr>) -> P<ast::Stmt> {
let pat = if mutbl {
self.pat_ident_binding_mode(sp, ident, ast::BindByValue(ast::MutMutable))
} else {
self.pat_ident(sp, ident)
};
- let local = box(GC) ast::Local {
+ let local = P(ast::Local {
ty: self.ty_infer(sp),
pat: pat,
init: Some(ex),
id: ast::DUMMY_NODE_ID,
span: sp,
source: ast::LocalLet,
- };
+ });
let decl = respan(sp, ast::DeclLocal(local));
- box(GC) respan(sp, ast::StmtDecl(box(GC) decl, ast::DUMMY_NODE_ID))
+ P(respan(sp, ast::StmtDecl(P(decl), ast::DUMMY_NODE_ID)))
}
fn stmt_let_typed(&self,
mutbl: bool,
ident: ast::Ident,
typ: P<ast::Ty>,
let pat = if mutbl {
self.pat_ident_binding_mode(sp, ident, ast::BindByValue(ast::MutMutable))
} else {
self.pat_ident(sp, ident)
};
- let local = box(GC) ast::Local {
+ let local = P(ast::Local {
ty: typ,
pat: pat,
init: Some(ex),
id: ast::DUMMY_NODE_ID,
span: sp,
source: ast::LocalLet,
- };
+ });
let decl = respan(sp, ast::DeclLocal(local));
- box(GC) respan(sp, ast::StmtDecl(box(GC) decl, ast::DUMMY_NODE_ID))
+ P(respan(sp, ast::StmtDecl(P(decl), ast::DUMMY_NODE_ID)))
}
- fn block(&self,
- span: Span,
- stmts: Vec<Gc<ast::Stmt>>,
- expr: Option<Gc<Expr>>)
- -> P<ast::Block> {
+ fn block(&self, span: Span, stmts: Vec<P<ast::Stmt>>,
+ expr: Option<P<Expr>>) -> P<ast::Block> {
self.block_all(span, Vec::new(), stmts, expr)
}
- fn stmt_item(&self, sp: Span, item:
Gc<ast::Item>) -> Gc<ast::Stmt> {
+ fn stmt_item(&self, sp: Span, item:
P<ast::Item>) -> P<ast::Stmt> {
let decl = respan(sp, ast::DeclItem(item));
- box(GC) respan(sp, ast::StmtDecl(box(GC) decl, ast::DUMMY_NODE_ID))
+ P(respan(sp, ast::StmtDecl(P(decl), ast::DUMMY_NODE_ID)))
}
- fn block_expr(&self, expr:
Gc<ast::Expr>) -> P<ast::Block> {
+ fn block_expr(&self, expr:
P<ast::Expr>) -> P<ast::Block> {
self.block_all(expr.span, Vec::new(), Vec::new(), Some(expr))
}
fn block_all(&self,
span: Span,
- view_items: Vec<ast::ViewItem> ,
- stmts: Vec<
Gc<ast::Stmt>>,
- expr: Option<
Gc<ast::Expr>>) -> P<ast::Block> {
+ view_items: Vec<ast::ViewItem>,
+ stmts: Vec<
P<ast::Stmt>>,
+ expr: Option<
P<ast::Expr>>) -> P<ast::Block> {
P(ast::Block {
view_items: view_items,
stmts: stmts,
})
}
- fn expr(&self, span: Span, node: ast::Expr_) ->
Gc<ast::Expr> {
- box(GC) ast::Expr {
+ fn expr(&self, span: Span, node: ast::Expr_) ->
P<ast::Expr> {
+ P(ast::Expr {
id: ast::DUMMY_NODE_ID,
node: node,
span: span,
- }
+ })
}
- fn expr_path(&self, path: ast::Path) ->
Gc<ast::Expr> {
+ fn expr_path(&self, path: ast::Path) ->
P<ast::Expr> {
self.expr(path.span, ast::ExprPath(path))
}
- fn expr_ident(&self, span: Span, id: ast::Ident) ->
Gc<ast::Expr> {
+ fn expr_ident(&self, span: Span, id: ast::Ident) ->
P<ast::Expr> {
self.expr_path(self.path_ident(span, id))
}
- fn expr_self(&self, span: Span) ->
Gc<ast::Expr> {
+ fn expr_self(&self, span: Span) ->
P<ast::Expr> {
self.expr_ident(span, special_idents::self_)
}
fn expr_binary(&self, sp: Span, op: ast::BinOp,
- lhs:
Gc<ast::Expr>, rhs: Gc<ast::Expr>) -> Gc<ast::Expr> {
+ lhs:
P<ast::Expr>, rhs: P<ast::Expr>) -> P<ast::Expr> {
self.expr(sp, ast::ExprBinary(op, lhs, rhs))
}
- fn expr_deref(&self, sp: Span, e:
Gc<ast::Expr>) -> Gc<ast::Expr> {
+ fn expr_deref(&self, sp: Span, e:
P<ast::Expr>) -> P<ast::Expr> {
self.expr_unary(sp, ast::UnDeref, e)
}
- fn expr_unary(&self, sp: Span, op: ast::UnOp, e:
Gc<ast::Expr>) -> Gc<ast::Expr> {
+ fn expr_unary(&self, sp: Span, op: ast::UnOp, e:
P<ast::Expr>) -> P<ast::Expr> {
self.expr(sp, ast::ExprUnary(op, e))
}
- fn expr_managed(&self, sp: Span, e:
Gc<ast::Expr>) -> Gc<ast::Expr> {
+ fn expr_managed(&self, sp: Span, e:
P<ast::Expr>) -> P<ast::Expr> {
self.expr_unary(sp, ast::UnBox, e)
}
- fn expr_field_access(&self, sp: Span, expr:
Gc<ast::Expr>, ident: ast::Ident) -> Gc<ast::Expr> {
+ fn expr_field_access(&self, sp: Span, expr:
P<ast::Expr>, ident: ast::Ident) -> P<ast::Expr> {
let field_name = token::get_ident(ident);
let field_span = Span {
lo: sp.lo - Pos::from_uint(field_name.get().len()),
let id = Spanned { node: ident, span: field_span };
self.expr(sp, ast::ExprField(expr, id, Vec::new()))
}
- fn expr_tup_field_access(&self, sp: Span, expr:
Gc<ast::Expr>, idx: uint) -> Gc<ast::Expr> {
+ fn expr_tup_field_access(&self, sp: Span, expr:
P<ast::Expr>, idx: uint) -> P<ast::Expr> {
let field_span = Span {
lo: sp.lo - Pos::from_uint(idx.to_string().len()),
hi: sp.hi,
let id = Spanned { node: idx, span: field_span };
self.expr(sp, ast::ExprTupField(expr, id, Vec::new()))
}
- fn expr_addr_of(&self, sp: Span, e:
Gc<ast::Expr>) -> Gc<ast::Expr> {
+ fn expr_addr_of(&self, sp: Span, e:
P<ast::Expr>) -> P<ast::Expr> {
self.expr(sp, ast::ExprAddrOf(ast::MutImmutable, e))
}
- fn expr_mut_addr_of(&self, sp: Span, e:
Gc<ast::Expr>) -> Gc<ast::Expr> {
+ fn expr_mut_addr_of(&self, sp: Span, e:
P<ast::Expr>) -> P<ast::Expr> {
self.expr(sp, ast::ExprAddrOf(ast::MutMutable, e))
}
- fn expr_call(&self, span: Span, expr: Gc<ast::Expr>,
- args: Vec<Gc<ast::Expr>>) -> Gc<ast::Expr> {
+ fn expr_call(&self, span: Span, expr: P<ast::Expr>, args: Vec<P<ast::Expr>>) -> P<ast::Expr> {
self.expr(span, ast::ExprCall(expr, args))
}
fn expr_call_ident(&self, span: Span, id: ast::Ident,
- args: Vec<
Gc<ast::Expr>>) -> Gc<ast::Expr> {
+ args: Vec<
P<ast::Expr>>) -> P<ast::Expr> {
self.expr(span, ast::ExprCall(self.expr_ident(span, id), args))
}
fn expr_call_global(&self, sp: Span, fn_path: Vec<ast::Ident> ,
- args: Vec<
Gc<ast::Expr>> ) -> Gc<ast::Expr> {
+ args: Vec<
P<ast::Expr>> ) -> P<ast::Expr> {
let pathexpr = self.expr_path(self.path_global(sp, fn_path));
self.expr_call(sp, pathexpr, args)
}
fn expr_method_call(&self, span: Span,
ident: ast::Ident,
- mut args: Vec<
Gc<ast::Expr>> ) -> Gc<ast::Expr> {
+ mut args: Vec<
P<ast::Expr>> ) -> P<ast::Expr> {
let id = Spanned { node: ident, span: span };
args.unshift(expr);
self.expr(span, ast::ExprMethodCall(id, Vec::new(), args))
}
- fn expr_block(&self, b: P<ast::Block>) ->
Gc<ast::Expr> {
+ fn expr_block(&self, b: P<ast::Block>) ->
P<ast::Expr> {
self.expr(b.span, ast::ExprBlock(b))
}
- fn field_imm(&self, span: Span, name: Ident, e:
Gc<ast::Expr>) -> ast::Field {
+ fn field_imm(&self, span: Span, name: Ident, e:
P<ast::Expr>) -> ast::Field {
ast::Field { ident: respan(span, name), expr: e, span: span }
}
- fn expr_struct(&self, span: Span, path: ast::Path, fields: Vec<ast::Field>
) -> Gc<ast::Expr> {
+ fn expr_struct(&self, span: Span, path: ast::Path, fields: Vec<ast::Field>
) -> P<ast::Expr> {
self.expr(span, ast::ExprStruct(path, fields, None))
}
fn expr_struct_ident(&self, span: Span,
- id: ast::Ident, fields: Vec<ast::Field>
) -> Gc<ast::Expr> {
+ id: ast::Ident, fields: Vec<ast::Field>
) -> P<ast::Expr> {
self.expr_struct(span, self.path_ident(span, id), fields)
}
- fn expr_lit(&self, sp: Span, lit: ast::Lit_) ->
Gc<ast::Expr> {
- self.expr(sp, ast::ExprLit(box(GC) respan(sp, lit)))
+ fn expr_lit(&self, sp: Span, lit: ast::Lit_) ->
P<ast::Expr> {
+ self.expr(sp, ast::ExprLit(P(respan(sp, lit))))
}
- fn expr_uint(&self, span: Span, i: uint) ->
Gc<ast::Expr> {
+ fn expr_uint(&self, span: Span, i: uint) ->
P<ast::Expr> {
self.expr_lit(span, ast::LitInt(i as u64, ast::UnsignedIntLit(ast::TyU)))
}
- fn expr_int(&self, sp: Span, i: int) ->
Gc<ast::Expr> {
+ fn expr_int(&self, sp: Span, i: int) ->
P<ast::Expr> {
self.expr_lit(sp, ast::LitInt(i as u64, ast::SignedIntLit(ast::TyI, ast::Sign::new(i))))
}
- fn expr_u8(&self, sp: Span, u: u8) ->
Gc<ast::Expr> {
+ fn expr_u8(&self, sp: Span, u: u8) ->
P<ast::Expr> {
self.expr_lit(sp, ast::LitInt(u as u64, ast::UnsignedIntLit(ast::TyU8)))
}
- fn expr_bool(&self, sp: Span, value: bool) ->
Gc<ast::Expr> {
+ fn expr_bool(&self, sp: Span, value: bool) ->
P<ast::Expr> {
self.expr_lit(sp, ast::LitBool(value))
}
- fn expr_vec(&self, sp: Span, exprs: Vec<
Gc<ast::Expr>> ) -> Gc<ast::Expr> {
+ fn expr_vec(&self, sp: Span, exprs: Vec<
P<ast::Expr>>) -> P<ast::Expr> {
self.expr(sp, ast::ExprVec(exprs))
}
- fn expr_vec_ng(&self, sp: Span) ->
Gc<ast::Expr> {
+ fn expr_vec_ng(&self, sp: Span) ->
P<ast::Expr> {
self.expr_call_global(sp,
vec!(self.ident_of("std"),
self.ident_of("vec"),
self.ident_of("new")),
Vec::new())
}
- fn expr_vec_slice(&self, sp: Span, exprs: Vec<
Gc<ast::Expr>> ) -> Gc<ast::Expr> {
+ fn expr_vec_slice(&self, sp: Span, exprs: Vec<
P<ast::Expr>>) -> P<ast::Expr> {
self.expr_addr_of(sp, self.expr_vec(sp, exprs))
}
- fn expr_str(&self, sp: Span, s: InternedString) ->
Gc<ast::Expr> {
+ fn expr_str(&self, sp: Span, s: InternedString) ->
P<ast::Expr> {
self.expr_lit(sp, ast::LitStr(s, ast::CookedStr))
}
- fn expr_cast(&self, sp: Span, expr:
Gc<ast::Expr>, ty: P<ast::Ty>) -> Gc<ast::Expr> {
+ fn expr_cast(&self, sp: Span, expr:
P<ast::Expr>, ty: P<ast::Ty>) -> P<ast::Expr> {
self.expr(sp, ast::ExprCast(expr, ty))
}
- fn expr_some(&self, sp: Span, expr:
Gc<ast::Expr>) -> Gc<ast::Expr> {
+ fn expr_some(&self, sp: Span, expr:
P<ast::Expr>) -> P<ast::Expr> {
let some = vec!(
self.ident_of("std"),
self.ident_of("option"),
self.expr_call_global(sp, some, vec!(expr))
}
- fn expr_none(&self, sp: Span) ->
Gc<ast::Expr> {
+ fn expr_none(&self, sp: Span) ->
P<ast::Expr> {
let none = self.path_global(sp, vec!(
self.ident_of("std"),
self.ident_of("option"),
self.expr_path(none)
}
- fn expr_tuple(&self, sp: Span, exprs: Vec<
Gc<ast::Expr>>) -> Gc<ast::Expr> {
+ fn expr_tuple(&self, sp: Span, exprs: Vec<
P<ast::Expr>>) -> P<ast::Expr> {
self.expr(sp, ast::ExprTup(exprs))
}
- fn expr_fail(&self, span: Span, msg: InternedString) ->
Gc<ast::Expr> {
+ fn expr_fail(&self, span: Span, msg: InternedString) ->
P<ast::Expr> {
let loc = self.codemap().lookup_char_pos(span.lo);
let expr_file = self.expr_str(span,
token::intern_and_get_ident(loc.file
expr_file_line_ptr))
}
- fn expr_unreachable(&self, span: Span) ->
Gc<ast::Expr> {
+ fn expr_unreachable(&self, span: Span) ->
P<ast::Expr> {
self.expr_fail(span,
InternedString::new(
"internal error: entered unreachable code"))
}
- fn expr_ok(&self, sp: Span, expr:
Gc<ast::Expr>) -> Gc<ast::Expr> {
+ fn expr_ok(&self, sp: Span, expr:
P<ast::Expr>) -> P<ast::Expr> {
let ok = vec!(
self.ident_of("std"),
self.ident_of("result"),
self.expr_call_global(sp, ok, vec!(expr))
}
- fn expr_err(&self, sp: Span, expr:
Gc<ast::Expr>) -> Gc<ast::Expr> {
+ fn expr_err(&self, sp: Span, expr:
P<ast::Expr>) -> P<ast::Expr> {
let err = vec!(
self.ident_of("std"),
self.ident_of("result"),
self.expr_call_global(sp, err, vec!(expr))
}
- fn expr_try(&self, sp: Span, head:
Gc<ast::Expr>) -> Gc<ast::Expr> {
+ fn expr_try(&self, sp: Span, head:
P<ast::Expr>) -> P<ast::Expr> {
let ok = self.ident_of("Ok");
let ok_path = self.path_ident(sp, ok);
let err = self.ident_of("Err");
let binding_expr = self.expr_ident(sp, binding_variable);
// Ok(__try_var) pattern
- let ok_pat = self.pat_enum(sp, ok_path, vec!(binding_pat));
+ let ok_pat = self.pat_enum(sp, ok_path, vec!(binding_pat.clone()));
// Err(__try_var) (pattern and expression resp.)
let err_pat = self.pat_enum(sp, err_path, vec!(binding_pat));
- let err_inner_expr = self.expr_call_ident(sp, err, vec!(binding_expr));
+ let err_inner_expr = self.expr_call_ident(sp, err, vec!(binding_expr.clone()));
// return Err(__try_var)
let err_expr = self.expr(sp, ast::ExprRet(Some(err_inner_expr)));
}
- fn pat(&self, span: Span, pat: ast::Pat_) ->
Gc<ast::Pat> {
- box(GC) ast::Pat { id: ast::DUMMY_NODE_ID, node: pat, span: span }
+ fn pat(&self, span: Span, pat: ast::Pat_) ->
P<ast::Pat> {
+ P(ast::Pat { id: ast::DUMMY_NODE_ID, node: pat, span: span })
}
- fn pat_wild(&self, span: Span) ->
Gc<ast::Pat> {
+ fn pat_wild(&self, span: Span) ->
P<ast::Pat> {
self.pat(span, ast::PatWild(ast::PatWildSingle))
}
- fn pat_lit(&self, span: Span, expr:
Gc<ast::Expr>) -> Gc<ast::Pat> {
+ fn pat_lit(&self, span: Span, expr:
P<ast::Expr>) -> P<ast::Pat> {
self.pat(span, ast::PatLit(expr))
}
- fn pat_ident(&self, span: Span, ident: ast::Ident) ->
Gc<ast::Pat> {
+ fn pat_ident(&self, span: Span, ident: ast::Ident) ->
P<ast::Pat> {
self.pat_ident_binding_mode(span, ident, ast::BindByValue(ast::MutImmutable))
}
fn pat_ident_binding_mode(&self,
span: Span,
ident: ast::Ident,
- bm: ast::BindingMode) ->
Gc<ast::Pat> {
+ bm: ast::BindingMode) ->
P<ast::Pat> {
let pat = ast::PatIdent(bm, Spanned{span: span, node: ident}, None);
self.pat(span, pat)
}
- fn pat_enum(&self, span: Span, path: ast::Path, subpats: Vec<
Gc<ast::Pat>> ) -> Gc<ast::Pat> {
+ fn pat_enum(&self, span: Span, path: ast::Path, subpats: Vec<
P<ast::Pat>>) -> P<ast::Pat> {
let pat = ast::PatEnum(path, Some(subpats));
self.pat(span, pat)
}
fn pat_struct(&self, span: Span,
- path: ast::Path, field_pats: Vec<ast::FieldPat>
) -> Gc<ast::Pat> {
+ path: ast::Path, field_pats: Vec<ast::FieldPat>
) -> P<ast::Pat> {
let pat = ast::PatStruct(path, field_pats, false);
self.pat(span, pat)
}
- fn pat_tuple(&self, span: Span, pats: Vec<
Gc<ast::Pat>>) -> Gc<ast::Pat> {
+ fn pat_tuple(&self, span: Span, pats: Vec<
P<ast::Pat>>) -> P<ast::Pat> {
let pat = ast::PatTup(pats);
self.pat(span, pat)
}
- fn pat_some(&self, span: Span, pat:
Gc<ast::Pat>) -> Gc<ast::Pat> {
+ fn pat_some(&self, span: Span, pat:
P<ast::Pat>) -> P<ast::Pat> {
let some = vec!(
self.ident_of("std"),
self.ident_of("option"),
self.pat_enum(span, path, vec!(pat))
}
- fn pat_none(&self, span: Span) ->
Gc<ast::Pat> {
+ fn pat_none(&self, span: Span) ->
P<ast::Pat> {
let some = vec!(
self.ident_of("std"),
self.ident_of("option"),
self.pat_enum(span, path, vec!())
}
- fn pat_ok(&self, span: Span, pat:
Gc<ast::Pat>) -> Gc<ast::Pat> {
+ fn pat_ok(&self, span: Span, pat:
P<ast::Pat>) -> P<ast::Pat> {
let some = vec!(
self.ident_of("std"),
self.ident_of("result"),
self.pat_enum(span, path, vec!(pat))
}
- fn pat_err(&self, span: Span, pat:
Gc<ast::Pat>) -> Gc<ast::Pat> {
+ fn pat_err(&self, span: Span, pat:
P<ast::Pat>) -> P<ast::Pat> {
let some = vec!(
self.ident_of("std"),
self.ident_of("result"),
self.pat_enum(span, path, vec!(pat))
}
- fn arm(&self, _span: Span, pats: Vec<
Gc<ast::Pat>> , expr: Gc<ast::Expr>) -> ast::Arm {
+ fn arm(&self, _span: Span, pats: Vec<
P<ast::Pat>>, expr: P<ast::Expr>) -> ast::Arm {
ast::Arm {
attrs: vec!(),
pats: pats,
self.arm(span, vec!(self.pat_wild(span)), self.expr_unreachable(span))
}
- fn expr_match(&self, span: Span, arg: Gc<ast::Expr>,
- arms: Vec<ast::Arm>) -> Gc<Expr> {
+ fn expr_match(&self, span: Span, arg: P<ast::Expr>, arms: Vec<ast::Arm>) -> P<Expr> {
self.expr(span, ast::ExprMatch(arg, arms))
}
- fn expr_if(&self, span: Span,
- cond: Gc<ast::Expr>, then: Gc<ast::Expr>,
- els: Option<Gc<ast::Expr>>) -> Gc<ast::Expr> {
+ fn expr_if(&self, span: Span, cond: P<ast::Expr>,
+ then: P<ast::Expr>, els: Option<P<ast::Expr>>) -> P<ast::Expr> {
let els = els.map(|x| self.expr_block(self.block_expr(x)));
self.expr(span, ast::ExprIf(cond, self.block_expr(then), els))
}
- fn expr_loop(&self, span: Span, block: P<ast::Block>) ->
Gc<ast::Expr> {
+ fn expr_loop(&self, span: Span, block: P<ast::Block>) ->
P<ast::Expr> {
self.expr(span, ast::ExprLoop(block, None))
}
fn lambda_fn_decl(&self, span: Span,
- fn_decl: P<ast::FnDecl>, blk: P<ast::Block>) ->
Gc<ast::Expr> {
+ fn_decl: P<ast::FnDecl>, blk: P<ast::Block>) ->
P<ast::Expr> {
self.expr(span, ast::ExprFnBlock(ast::CaptureByRef, fn_decl, blk))
}
- fn lambda(&self, span: Span, ids: Vec<ast::Ident>
, blk: P<ast::Block>) -> Gc<ast::Expr> {
+ fn lambda(&self, span: Span, ids: Vec<ast::Ident>
, blk: P<ast::Block>) -> P<ast::Expr> {
let fn_decl = self.fn_decl(
ids.iter().map(|id| self.arg(span, *id, self.ty_infer(span))).collect(),
self.ty_infer(span));
self.expr(span, ast::ExprFnBlock(ast::CaptureByRef, fn_decl, blk))
}
- fn lambda0(&self, span: Span, blk: P<ast::Block>) ->
Gc<ast::Expr> {
+ fn lambda0(&self, span: Span, blk: P<ast::Block>) ->
P<ast::Expr> {
self.lambda(span, Vec::new(), blk)
}
- fn lambda1(&self, span: Span, blk: P<ast::Block>, ident: ast::Ident) ->
Gc<ast::Expr> {
+ fn lambda1(&self, span: Span, blk: P<ast::Block>, ident: ast::Ident) ->
P<ast::Expr> {
self.lambda(span, vec!(ident), blk)
}
- fn lambda_expr(&self, span: Span, ids: Vec<ast::Ident> , expr: Gc<ast::Expr>) -> Gc<ast::Expr> {
+ fn lambda_expr(&self, span: Span, ids: Vec<ast::Ident>,
+ expr: P<ast::Expr>) -> P<ast::Expr> {
self.lambda(span, ids, self.block_expr(expr))
}
- fn lambda_expr_0(&self, span: Span, expr:
Gc<ast::Expr>) -> Gc<ast::Expr> {
+ fn lambda_expr_0(&self, span: Span, expr:
P<ast::Expr>) -> P<ast::Expr> {
self.lambda0(span, self.block_expr(expr))
}
- fn lambda_expr_1(&self, span: Span, expr:
Gc<ast::Expr>, ident: ast::Ident) -> Gc<ast::Expr> {
+ fn lambda_expr_1(&self, span: Span, expr:
P<ast::Expr>, ident: ast::Ident) -> P<ast::Expr> {
self.lambda1(span, self.block_expr(expr), ident)
}
fn lambda_stmts(&self,
span: Span,
ids: Vec<ast::Ident>,
- stmts: Vec<
Gc<ast::Stmt>>)
+ stmts: Vec<
P<ast::Stmt>>)
self.lambda(span, ids, self.block(span, stmts, None))
}
- fn lambda_stmts_0(&self, span: Span,
- stmts: Vec<Gc<ast::Stmt>>) -> Gc<ast::Expr> {
+ fn lambda_stmts_0(&self, span: Span, stmts: Vec<P<ast::Stmt>>) -> P<ast::Expr> {
self.lambda0(span, self.block(span, stmts, None))
}
- fn lambda_stmts_1(&self, span: Span, stmts: Vec<
Gc<ast::Stmt>>,
- ident: ast::Ident) ->
Gc<ast::Expr> {
+ fn lambda_stmts_1(&self, span: Span, stmts: Vec<
P<ast::Stmt>>,
+ ident: ast::Ident) ->
P<ast::Expr> {
self.lambda1(span, self.block(span, stmts, None), ident)
}
})
}
- fn item(&self, span: Span,
- name: Ident, attrs: Vec<ast::Attribute>,
- node: ast::Item_) -> Gc<ast::Item> {
+ fn item(&self, span: Span, name: Ident,
+ attrs: Vec<ast::Attribute>, node: ast::Item_) -> P<ast::Item> {
// FIXME: Would be nice if our generated code didn't violate
// Rust coding conventions
- box(GC) ast::Item { ident: name,
- attrs: attrs,
- id: ast::DUMMY_NODE_ID,
- node: node,
- vis: ast::Inherited,
- span: span }
+ P(ast::Item {
+ ident: name,
+ attrs: attrs,
+ id: ast::DUMMY_NODE_ID,
+ node: node,
+ vis: ast::Inherited,
+ span: span
+ })
}
fn item_fn_poly(&self,
inputs: Vec<ast::Arg> ,
output: P<ast::Ty>,
generics: Generics,
- body: P<ast::Block>) ->
Gc<ast::Item> {
+ body: P<ast::Block>) ->
P<ast::Item> {
self.item(span,
name,
Vec::new(),
inputs: Vec<ast::Arg> ,
output: P<ast::Ty>,
body: P<ast::Block>
self.item_fn_poly(
span,
name,
fn item_enum_poly(&self, span: Span, name: Ident,
enum_definition: ast::EnumDef,
- generics: Generics) ->
Gc<ast::Item> {
+ generics: Generics) ->
P<ast::Item> {
self.item(span, name, Vec::new(), ast::ItemEnum(enum_definition, generics))
}
fn item_enum(&self, span: Span, name: Ident,
- enum_definition: ast::EnumDef) ->
Gc<ast::Item> {
+ enum_definition: ast::EnumDef) ->
P<ast::Item> {
self.item_enum_poly(span, name, enum_definition,
ast_util::empty_generics())
}
fn item_struct(&self, span: Span, name: Ident,
- struct_def: ast::StructDef) ->
Gc<ast::Item> {
+ struct_def: ast::StructDef) ->
P<ast::Item> {
self.item_struct_poly(
span,
name,
}
fn item_struct_poly(&self, span: Span, name: Ident,
- struct_def: ast::StructDef, generics: Generics) ->
Gc<ast::Item> {
- self.item(span, name, Vec::new(), ast::ItemStruct(box(GC) struct_def, generics))
+ struct_def: ast::StructDef, generics: Generics) ->
P<ast::Item> {
+ self.item(span, name, Vec::new(), ast::ItemStruct(P(struct_def), generics))
}
fn item_mod(&self, span: Span, inner_span: Span, name: Ident,
attrs: Vec<ast::Attribute> ,
vi: Vec<ast::ViewItem> ,
- items: Vec<
Gc<ast::Item>>) -> Gc<ast::Item> {
+ items: Vec<
P<ast::Item>> ) -> P<ast::Item> {
self.item(
span,
name,
name: Ident,
ty: P<ast::Ty>,
mutbl: ast::Mutability,
self.item(span, name, Vec::new(), ast::ItemStatic(ty, mutbl, expr))
}
fn item_ty_poly(&self, span: Span, name: Ident, ty: P<ast::Ty>,
- generics: Generics) ->
Gc<ast::Item> {
+ generics: Generics) ->
P<ast::Item> {
self.item(span, name, Vec::new(), ast::ItemTy(ty, generics))
}
- fn item_ty(&self, span: Span, name: Ident, ty: P<ast::Ty>) ->
Gc<ast::Item> {
+ fn item_ty(&self, span: Span, name: Ident, ty: P<ast::Ty>) ->
P<ast::Item> {
self.item_ty_poly(span, name, ty, ast_util::empty_generics())
}
- fn attribute(&self, sp: Span, mi:
Gc<ast::MetaItem>) -> ast::Attribute {
+ fn attribute(&self, sp: Span, mi:
P<ast::MetaItem>) -> ast::Attribute {
respan(sp, ast::Attribute_ {
id: attr::mk_attr_id(),
style: ast::AttrOuter,
})
}
- fn meta_word(&self, sp: Span, w: InternedString) ->
Gc<ast::MetaItem> {
- box(GC) respan(sp, ast::MetaWord(w))
+ fn meta_word(&self, sp: Span, w: InternedString) ->
P<ast::MetaItem> {
+ P(respan(sp, ast::MetaWord(w)))
}
fn meta_list(&self,
sp: Span,
name: InternedString,
- mis: Vec<
Gc<ast::MetaItem>> )
- box(GC) respan(sp, ast::MetaList(name, mis))
+ mis: Vec<
P<ast::MetaItem>> )
+ P(respan(sp, ast::MetaList(name, mis)))
}
fn meta_name_value(&self,
sp: Span,
name: InternedString,
value: ast::Lit_)
- box(GC) respan(sp, ast::MetaNameValue(name, respan(sp, value)))
+ P(respan(sp, ast::MetaNameValue(name, respan(sp, value))))
}
fn view_use(&self, sp: Span,
- vis: ast::Visibility, vp:
Gc<ast::ViewPath>) -> ast::ViewItem {
+ vis: ast::Visibility, vp:
P<ast::ViewPath>) -> ast::ViewItem {
ast::ViewItem {
node: ast::ViewItemUse(vp),
attrs: Vec::new(),
fn view_use_simple_(&self, sp: Span, vis: ast::Visibility,
ident: ast::Ident, path: ast::Path) -> ast::ViewItem {
self.view_use(sp, vis,
- box(GC) respan(sp,
- ast::ViewPathSimple(ident,
- path,
- ast::DUMMY_NODE_ID)))
+ P(respan(sp,
+ ast::ViewPathSimple(ident,
+ path,
+ ast::DUMMY_NODE_ID))))
}
fn view_use_list(&self, sp: Span, vis: ast::Visibility,
}).collect();
self.view_use(sp, vis,
- box(GC) respan(sp,
- ast::ViewPathList(self.path(sp, path),
- imports,
- ast::DUMMY_NODE_ID)))
+ P(respan(sp,
+ ast::ViewPathList(self.path(sp, path),
+ imports,
+ ast::DUMMY_NODE_ID))))
}
fn view_use_glob(&self, sp: Span,
vis: ast::Visibility, path: Vec<ast::Ident> ) -> ast::ViewItem {
self.view_use(sp, vis,
- box(GC) respan(sp,
- ast::ViewPathGlob(self.path(sp, path), ast::DUMMY_NODE_ID)))
- }
-}
-
-struct Duplicator<'a>;
-
-impl<'a> Folder for Duplicator<'a> {
- fn new_id(&mut self, _: NodeId) -> NodeId {
- ast::DUMMY_NODE_ID
- }
-}
-
-pub trait Duplicate {
- //
- // Duplication functions
- //
- // These functions just duplicate AST nodes.
- //
-
- fn duplicate(&self, cx: &ExtCtxt) -> Self;
-}
-
-impl Duplicate for Gc<ast::Expr> {
- fn duplicate(&self, _: &ExtCtxt) -> Gc<ast::Expr> {
- let mut folder = Duplicator;
- folder.fold_expr(*self)
+ P(respan(sp,
+ ast::ViewPathGlob(self.path(sp, path), ast::DUMMY_NODE_ID))))
}
}
for expr in exprs.iter() {
match expr.node {
// expression is a literal
- ast::ExprLit(lit) => match lit.node {
+ ast::ExprLit(ref lit) => match lit.node {
// string literal, push each byte to vector expression
ast::LitStr(ref s, _) => {
for byte in s.get().bytes() {
}
// test_cfg searches for meta items looking like `cfg(foo, ...)`
- let in_cfg = &[cx.meta_list(sp, InternedString::new("cfg"), cfgs)];
+ let in_cfg = Some(cx.meta_list(sp, InternedString::new("cfg"), cfgs));
let matches_cfg = attr::test_cfg(cx.cfg().as_slice(),
- in_cfg.iter().map(|&x| x));
+ in_cfg.iter());
let e = cx.expr_bool(sp, matches_cfg);
MacExpr::new(e)
}
let mut accumulator = String::new();
for e in es.move_iter() {
match e.node {
- ast::ExprLit(lit) => {
+ ast::ExprLit(ref lit) => {
match lit.node {
ast::LitStr(ref s, _) |
ast::LitFloat(ref s, _) |
use owned_slice::OwnedSlice;
use parse::token;
use parse::token::{str_to_ident};
-
-use std::gc::GC;
+use ptr::P;
pub fn expand_syntax_ext<'cx>(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
-> Box<base::MacResult+'cx> {
}
let res = str_to_ident(res_str.as_slice());
- let e = box(GC) ast::Expr {
+ let e = P(ast::Expr {
id: ast::DUMMY_NODE_ID,
node: ast::ExprPath(
ast::Path {
}
),
span: sp,
- };
+ });
MacExpr::new(e)
}
use ext::base::ExtCtxt;
use ext::deriving::generic::*;
use ext::deriving::generic::ty::*;
-
-use std::gc::Gc;
+use ptr::P;
pub fn expand_deriving_bound(cx: &mut ExtCtxt,
span: Span,
- mitem: Gc<MetaItem>,
- item: Gc<Item>,
- push: |Gc<Item>|) {
+ mitem: &MetaItem,
+ item: &Item,
+ push: |P<Item>|) {
let name = match mitem.node {
MetaWord(ref tname) => {
use ext::deriving::generic::*;
use ext::deriving::generic::ty::*;
use parse::token::InternedString;
-
-use std::gc::Gc;
+use ptr::P;
pub fn expand_deriving_clone(cx: &mut ExtCtxt,
span: Span,
- mitem: Gc<MetaItem>,
- item: Gc<Item>,
- push: |Gc<Item>|) {
+ mitem: &MetaItem,
+ item: &Item,
+ push: |P<Item>|) {
let inline = cx.meta_word(span, InternedString::new("inline"));
let attrs = vec!(cx.attribute(span, inline));
let trait_def = TraitDef {
fn cs_clone(
name: &str,
cx: &mut ExtCtxt, trait_span: Span,
- substr: &Substructure) -> Gc<Expr> {
+ substr: &Substructure) -> P<Expr> {
let clone_ident = substr.method_ident;
let ctor_ident;
let all_fields;
let subcall = |field: &FieldInfo|
- cx.expr_method_call(field.span, field.self_, clone_ident, Vec::new());
+ cx.expr_method_call(field.span, field.self_.clone(), clone_ident, Vec::new());
match *substr.fields {
Struct(ref af) => {
use ext::deriving::generic::*;
use ext::deriving::generic::ty::*;
use parse::token::InternedString;
-
-use std::gc::Gc;
+use ptr::P;
pub fn expand_deriving_eq(cx: &mut ExtCtxt,
span: Span,
- mitem: Gc<MetaItem>,
- item: Gc<Item>,
- push: |Gc<Item>|) {
+ mitem: &MetaItem,
+ item: &Item,
+ push: |P<Item>|) {
// structures are equal if all fields are equal, and non equal, if
// any fields are not equal or if the enum variants are different
- fn cs_eq(cx: &mut ExtCtxt, span: Span, substr: &Substructure) -> Gc<Expr> {
+ fn cs_eq(cx: &mut ExtCtxt, span: Span, substr: &Substructure) -> P<Expr> {
cs_and(|cx, span, _, _| cx.expr_bool(span, false),
cx, span, substr)
}
- fn cs_ne(cx: &mut ExtCtxt, span: Span, substr: &Substructure) -> Gc<Expr> {
+ fn cs_ne(cx: &mut ExtCtxt, span: Span, substr: &Substructure) -> P<Expr> {
cs_or(|cx, span, _, _| cx.expr_bool(span, true),
cx, span, substr)
}
use ext::deriving::generic::*;
use ext::deriving::generic::ty::*;
use parse::token::InternedString;
-
-use std::gc::Gc;
+use ptr::P;
pub fn expand_deriving_ord(cx: &mut ExtCtxt,
span: Span,
- mitem: Gc<MetaItem>,
- item: Gc<Item>,
- push: |Gc<Item>|) {
+ mitem: &MetaItem,
+ item: &Item,
+ push: |P<Item>|) {
macro_rules! md (
($name:expr, $op:expr, $equal:expr) => { {
let inline = cx.meta_word(span, InternedString::new("inline"));
pub fn some_ordering_collapsed(cx: &mut ExtCtxt,
span: Span,
op: OrderingOp,
- self_arg_tags: &[ast::Ident]) ->
Gc<ast::Expr> {
+ self_arg_tags: &[ast::Ident]) ->
P<ast::Expr> {
let lft = cx.expr_ident(span, self_arg_tags[0]);
let rgt = cx.expr_addr_of(span, cx.expr_ident(span, self_arg_tags[1]));
let op_str = match op {
}
pub fn cs_partial_cmp(cx: &mut ExtCtxt, span: Span,
- substr: &Substructure) -> Gc<Expr> {
+ substr: &Substructure) -> P<Expr> {
let test_id = cx.ident_of("__test");
let ordering = cx.path_global(span,
vec!(cx.ident_of("std"),
}
/// Strict inequality.
-fn cs_op(less: bool, equal: bool, cx: &mut ExtCtxt, span: Span,
- substr: &Substructure) -> Gc<Expr> {
+fn cs_op(less: bool, equal: bool, cx: &mut ExtCtxt,
+ span: Span, substr: &Substructure) -> P<Expr> {
let op = if less {ast::BiLt} else {ast::BiGt};
cs_fold(
false, // need foldr,
layers of pointers, if the type includes pointers.
*/
let other_f = match other_fs {
- [o_f] => o_f,
+ [ref o_f] => o_f,
_ => cx.span_bug(span, "not exactly 2 arguments in `deriving(Ord)`")
};
- let cmp = cx.expr_binary(span, op, self_f, other_f);
+ let cmp = cx.expr_binary(span, op, self_f.clone(), other_f.clone());
let not_cmp = cx.expr_unary(span, ast::UnNot,
- cx.expr_binary(span, op, other_f, self_f));
+ cx.expr_binary(span, op, other_f.clone(), self_f));
let and = cx.expr_binary(span, ast::BiAnd, not_cmp, subexpr);
cx.expr_binary(span, ast::BiOr, cmp, and)
use ext::deriving::generic::*;
use ext::deriving::generic::ty::*;
use parse::token::InternedString;
-
-use std::gc::Gc;
+use ptr::P;
pub fn expand_deriving_totaleq(cx: &mut ExtCtxt,
span: Span,
- mitem: Gc<MetaItem>,
- item: Gc<Item>,
- push: |Gc<Item>|) {
- fn cs_total_eq_assert(cx: &mut ExtCtxt, span: Span,
- substr: &Substructure) -> Gc<Expr> {
+ mitem: &MetaItem,
+ item: &Item,
+ push: |P<Item>|) {
+ fn cs_total_eq_assert(cx: &mut ExtCtxt, span: Span, substr: &Substructure) -> P<Expr> {
cs_same_method(|cx, span, exprs| {
// create `a.<method>(); b.<method>(); c.<method>(); ...`
// (where method is `assert_receiver_is_total_eq`)
use ext::deriving::generic::*;
use ext::deriving::generic::ty::*;
use parse::token::InternedString;
-
-use std::gc::Gc;
+use ptr::P;
pub fn expand_deriving_totalord(cx: &mut ExtCtxt,
span: Span,
- mitem: Gc<MetaItem>,
- item: Gc<Item>,
- push: |Gc<Item>|) {
+ mitem: &MetaItem,
+ item: &Item,
+ push: |P<Item>|) {
let inline = cx.meta_word(span, InternedString::new("inline"));
let attrs = vec!(cx.attribute(span, inline));
let trait_def = TraitDef {
pub fn ordering_collapsed(cx: &mut ExtCtxt,
span: Span,
- self_arg_tags: &[ast::Ident]) ->
Gc<ast::Expr> {
+ self_arg_tags: &[ast::Ident]) ->
P<ast::Expr> {
let lft = cx.expr_ident(span, self_arg_tags[0]);
let rgt = cx.expr_addr_of(span, cx.expr_ident(span, self_arg_tags[1]));
cx.expr_method_call(span, lft, cx.ident_of("cmp"), vec![rgt])
}
pub fn cs_cmp(cx: &mut ExtCtxt, span: Span,
- substr: &Substructure) -> Gc<Expr> {
+ substr: &Substructure) -> P<Expr> {
let test_id = cx.ident_of("__test");
let equals_path = cx.path_global(span,
vec!(cx.ident_of("std"),
use ext::deriving::generic::ty::*;
use parse::token::InternedString;
use parse::token;
-
-use std::gc::Gc;
+use ptr::P;
pub fn expand_deriving_decodable(cx: &mut ExtCtxt,
span: Span,
- mitem: Gc<MetaItem>,
- item: Gc<Item>,
- push: |Gc<Item>|) {
+ mitem: &MetaItem,
+ item: &Item,
+ push: |P<Item>|) {
let trait_def = TraitDef {
span: span,
attributes: Vec::new(),
}
fn decodable_substructure(cx: &mut ExtCtxt, trait_span: Span,
- substr: &Substructure) -> Gc<Expr> {
- let decoder = substr.nonself_args[0];
+ substr: &Substructure) -> P<Expr> {
+ let decoder = substr.nonself_args[0].clone();
let recurse = vec!(cx.ident_of("serialize"),
cx.ident_of("Decodable"),
cx.ident_of("decode"));
// throw an underscore in front to suppress unused variable warnings
let blkarg = cx.ident_of("_d");
let blkdecoder = cx.expr_ident(trait_span, blkarg);
- let calldecode = cx.expr_call_global(trait_span, recurse, vec!(blkdecoder));
+ let calldecode = cx.expr_call_global(trait_span, recurse, vec!(blkdecoder.clone()));
let lambdadecode = cx.lambda_expr_1(trait_span, calldecode, blkarg);
return match *substr.fields {
summary,
|cx, span, name, field| {
cx.expr_try(span,
- cx.expr_method_call(span, blkdecoder, read_struct_field,
+ cx.expr_method_call(span, blkdecoder.clone(), read_struct_field,
vec!(cx.expr_str(span, name),
cx.expr_uint(span, field),
- lambdadecode)))
+ lambdadecode.clone())))
});
let result = cx.expr_ok(trait_span, result);
cx.expr_method_call(trait_span,
|cx, span, _, field| {
let idx = cx.expr_uint(span, field);
cx.expr_try(span,
- cx.expr_method_call(span, blkdecoder, rvariant_arg,
- vec!(idx, lambdadecode)))
+ cx.expr_method_call(span, blkdecoder.clone(), rvariant_arg,
+ vec!(idx, lambdadecode.clone())))
});
arms.push(cx.arm(v_span,
trait_span: Span,
outer_pat_ident: Ident,
fields: &StaticFields,
- getarg: |&mut ExtCtxt, Span, InternedString, uint| -> Gc<Expr>)
- -> Gc<Expr> {
+ getarg: |&mut ExtCtxt, Span, InternedString, uint| -> P<Expr>)
+ -> P<Expr> {
match *fields {
Unnamed(ref fields) => {
if fields.is_empty() {
use ext::deriving::generic::*;
use ext::deriving::generic::ty::*;
use parse::token::InternedString;
-
-use std::gc::Gc;
+use ptr::P;
pub fn expand_deriving_default(cx: &mut ExtCtxt,
span: Span,
- mitem: Gc<MetaItem>,
- item: Gc<Item>,
- push: |Gc<Item>|) {
+ mitem: &MetaItem,
+ item: &Item,
+ push: |P<Item>|) {
let inline = cx.meta_word(span, InternedString::new("inline"));
let attrs = vec!(cx.attribute(span, inline));
let trait_def = TraitDef {
trait_def.expand(cx, mitem, item, push)
}
-fn default_substructure(cx: &mut ExtCtxt, trait_span: Span,
- substr: &Substructure) -> Gc<Expr> {
+fn default_substructure(cx: &mut ExtCtxt, trait_span: Span, substr: &Substructure) -> P<Expr> {
let default_ident = vec!(
cx.ident_of("std"),
cx.ident_of("default"),
use ext::deriving::generic::*;
use ext::deriving::generic::ty::*;
use parse::token;
-
-use std::gc::Gc;
+use ptr::P;
pub fn expand_deriving_encodable(cx: &mut ExtCtxt,
span: Span,
- mitem: Gc<MetaItem>,
- item: Gc<Item>,
- push: |Gc<Item>|) {
+ mitem: &MetaItem,
+ item: &Item,
+ push: |P<Item>|) {
let trait_def = TraitDef {
span: span,
attributes: Vec::new(),
}
fn encodable_substructure(cx: &mut ExtCtxt, trait_span: Span,
- substr: &Substructure) -> Gc<Expr> {
- let encoder = substr.nonself_args[0];
+ substr: &Substructure) -> P<Expr> {
+ let encoder = substr.nonself_args[0].clone();
// throw an underscore in front to suppress unused variable warnings
let blkarg = cx.ident_of("_e");
let blkencoder = cx.expr_ident(trait_span, blkarg);
let last = fields.len() - 1;
for (i, &FieldInfo {
name,
- self_,
+ ref self_,
span,
..
}) in fields.iter().enumerate() {
i).as_slice())
}
};
- let enc = cx.expr_method_call(span, self_, encode, vec!(blkencoder));
+ let enc = cx.expr_method_call(span, self_.clone(),
+ encode, vec!(blkencoder.clone()));
let lambda = cx.lambda_expr_1(span, enc, blkarg);
- let call = cx.expr_method_call(span, blkencoder,
+ let call = cx.expr_method_call(span, blkencoder.clone(),
emit_struct_field,
vec!(cx.expr_str(span, name),
cx.expr_uint(span, i),
let emit_variant_arg = cx.ident_of("emit_enum_variant_arg");
let mut stmts = Vec::new();
let last = fields.len() - 1;
- for (i, &FieldInfo { self_, span, .. }) in fields.iter().enumerate() {
- let enc = cx.expr_method_call(span, self_, encode, vec!(blkencoder));
+ for (i, &FieldInfo { ref self_, span, .. }) in fields.iter().enumerate() {
+ let enc = cx.expr_method_call(span, self_.clone(),
+ encode, vec!(blkencoder.clone()));
let lambda = cx.lambda_expr_1(span, enc, blkarg);
- let call = cx.expr_method_call(span, blkencoder,
+ let call = cx.expr_method_call(span, blkencoder.clone(),
emit_variant_arg,
vec!(cx.expr_uint(span, i),
lambda));
//! ~~~
use std::cell::RefCell;
-use std::gc::{Gc, GC};
+use std::gc::GC;
+use std::vec;
use abi::Abi;
use abi;
use ast;
-use ast::{P, EnumDef, Expr, Ident, Generics, StructDef};
+use ast::{EnumDef, Expr, Ident, Generics, StructDef};
use ast_util;
use attr;
use attr::AttrMetaMethods;
use ext::build::AstBuilder;
use codemap;
use codemap::Span;
+use fold::MoveMap;
use owned_slice::OwnedSlice;
use parse::token::InternedString;
use parse::token::special_idents;
+use ptr::P;
use self::ty::{LifetimeBounds, Path, Ptr, PtrTy, Self, Ty};
/// ident of the method
pub method_ident: Ident,
/// dereferenced access to any Self or Ptr(Self, _) arguments
- pub self_args: &'a [Gc<Expr>],
+ pub self_args: &'a [P<Expr>],
/// verbatim access to any other arguments
- pub nonself_args: &'a [Gc<Expr>],
+ pub nonself_args: &'a [P<Expr>],
pub fields: &'a SubstructureFields<'a>
}
pub name: Option<Ident>,
/// The expression corresponding to this field of `self`
/// (specifically, a reference to it).
- pub self_: Gc<Expr>,
+ pub self_: P<Expr>,
/// The expressions corresponding to references to this field in
/// the other Self arguments.
- pub other: Vec<Gc<Expr>>,
+ pub other: Vec<P<Expr>>,
}
/// Fields for a static method
Idents bound to the variant index values for each of the actual
input Self arguments.
*/
- EnumNonMatchingCollapsed(Vec<Ident>, &'a [
Gc<ast::Variant>], &'a [Ident]),
+ EnumNonMatchingCollapsed(Vec<Ident>, &'a [
P<ast::Variant>], &'a [Ident]),
/// A static method where Self is a struct.
StaticStruct(&'a ast::StructDef, StaticFields),
all the fields of all the structures, see above for details.
*/
pub type CombineSubstructureFunc<'a> =
- |&mut ExtCtxt, Span, &Substructure|: 'a -> Gc<Expr>;
+ |&mut ExtCtxt, Span, &Substructure|: 'a -> P<Expr>;
/**
Deal with non-matching enum variants. The tuple is a list of
*/
pub type EnumNonMatchCollapsedFunc<'a> =
|&mut ExtCtxt,
- Span,
- (&[Ident], &[Ident]),
- &[Gc<Expr>]|: 'a
- -> Gc<Expr>;
+ Span,
+ (&[Ident], &[Ident]),
+ &[P<Expr>]|: 'a
+ -> P<Expr>;
pub fn combine_substructure<'a>(f: CombineSubstructureFunc<'a>)
-> RefCell<CombineSubstructureFunc<'a>> {
impl<'a> TraitDef<'a> {
pub fn expand(&self,
cx: &mut ExtCtxt,
- _mitem: Gc<ast::MetaItem>,
- item: Gc<ast::Item>,
- push: |
Gc<ast::Item>|) {
+ _mitem: &ast::MetaItem,
+ item: &ast::Item,
+ push: |
P<ast::Item>|) {
let newitem = match item.node {
ast::ItemStruct(ref struct_def, ref generics) => {
self.expand_struct_def(cx,
_ => false,
}
}).map(|a| a.clone()));
- push(box(GC) ast::Item {
+ push(P(ast::Item {
attrs: attrs,
..(*newitem).clone()
- })
+ }))
}
/**
cx: &mut ExtCtxt,
type_ident: Ident,
generics: &Generics,
- methods: Vec<
Gc<ast::Method>> ) -> Gc<ast::Item> {
+ methods: Vec<
P<ast::Method>>) -> P<ast::Item> {
let trait_path = self.path.to_path(cx, self.span, type_ident, generics);
let Generics { mut lifetimes, ty_params, where_clause: _ } =
cx: &mut ExtCtxt,
struct_def: &StructDef,
type_ident: Ident,
- generics: &Generics) ->
Gc<ast::Item> {
+ generics: &Generics) ->
P<ast::Item> {
let methods = self.methods.iter().map(|method_def| {
let (explicit_self, self_args, nonself_args, tys) =
method_def.split_self_nonself_args(
cx: &mut ExtCtxt,
enum_def: &EnumDef,
type_ident: Ident,
- generics: &Generics) ->
Gc<ast::Item> {
+ generics: &Generics) ->
P<ast::Item> {
let methods = self.methods.iter().map(|method_def| {
let (explicit_self, self_args, nonself_args, tys) =
method_def.split_self_nonself_args(cx, self,
self,
enum_def,
type_ident,
- self_args.as_slice(),
+ self_args,
nonself_args.as_slice())
};
}
fn variant_to_pat(cx: &mut ExtCtxt, sp: Span, variant: &ast::Variant)
let ident = cx.path_ident(sp, variant.node.name);
cx.pat(sp, match variant.node.kind {
ast::TupleVariantKind(..) => ast::PatEnum(ident, None),
cx: &mut ExtCtxt,
trait_: &TraitDef,
type_ident: Ident,
- self_args: &[Gc<Expr>],
- nonself_args: &[Gc<Expr>],
+ self_args: &[P<Expr>],
+ nonself_args: &[P<Expr>],
fields: &SubstructureFields)
- -> Gc<Expr> {
+ -> P<Expr> {
let substructure = Substructure {
type_ident: type_ident,
method_ident: cx.ident_of(self.name),
trait_: &TraitDef,
type_ident: Ident,
generics: &Generics)
- -> (ast::ExplicitSelf, Vec<Gc<Expr>>, Vec<Gc<Expr>>,
- Vec<(Ident, P<ast::Ty>)>) {
+ -> (ast::ExplicitSelf, Vec<P<Expr>>, Vec<P<Expr>>, Vec<(Ident, P<ast::Ty>)>) {
let mut self_args = Vec::new();
let mut nonself_args = Vec::new();
abi: Abi,
explicit_self: ast::ExplicitSelf,
arg_types: Vec<(Ident, P<ast::Ty>)> ,
- body: Gc<Expr>)
- -> Gc<ast::Method> {
+ body: P<Expr>) -> P<ast::Method> {
// create the generics that aren't for Self
let fn_generics = self.generics.to_generics(cx, trait_.span, type_ident, generics);
let body_block = cx.block_expr(body);
// Create the method.
- box(GC) ast::Method {
+ P(ast::Method {
attrs: self.attributes.clone(),
id: ast::DUMMY_NODE_ID,
span: trait_.span,
fn_decl,
body_block,
ast::Inherited)
- }
+ })
}
/**
trait_: &TraitDef,
struct_def: &StructDef,
type_ident: Ident,
- self_args: &[Gc<Expr>],
- nonself_args: &[Gc<Expr>])
- -> Gc<Expr> {
+ self_args: &[P<Expr>],
+ nonself_args: &[P<Expr>])
+ -> P<Expr> {
let mut raw_fields = Vec::new(); // ~[[fields of self],
// [fields of next Self arg], [etc]]
// transpose raw_fields
let fields = if raw_fields.len() > 0 {
- raw_fields.get(0)
- .iter()
- .enumerate()
- .map(|(i, &(span, opt_id, field))| {
- let other_fields = raw_fields.tail().iter().map(|l| {
- match l.get(i) {
- &(_, _, ex) => ex
- }
- }).collect();
+ let mut raw_fields = raw_fields.move_iter().map(|v| v.move_iter());
+ let first_field = raw_fields.next().unwrap();
+ let mut other_fields: Vec<vec::MoveItems<(Span, Option<Ident>, P<Expr>)>>
+ = raw_fields.collect();
+ first_field.map(|(span, opt_id, field)| {
FieldInfo {
span: span,
name: opt_id,
self_: field,
- other: other_fields
+ other: other_fields.mut_iter().map(|l| {
+ match l.next().unwrap() {
+ (_, _, ex) => ex
+ }
+ }).collect()
}
}).collect()
} else {
// make a series of nested matches, to destructure the
// structs. This is actually right-to-left, but it shouldn't
// matter.
- for (&arg_expr, &pat) in self_args.iter().zip(patterns.iter()) {
- body = cx.expr_match(trait_.span, arg_expr,
- vec!( cx.arm(trait_.span, vec!(pat), body) ))
+ for (arg_expr, pat) in self_args.iter().zip(patterns.iter()) {
+ body = cx.expr_match(trait_.span, arg_expr.clone(),
+ vec!( cx.arm(trait_.span, vec!(pat.clone()), body) ))
}
body
}
trait_: &TraitDef,
struct_def: &StructDef,
type_ident: Ident,
- self_args: &[Gc<Expr>],
- nonself_args: &[Gc<Expr>])
- -> Gc<Expr> {
+ self_args: &[P<Expr>],
+ nonself_args: &[P<Expr>])
+ -> P<Expr> {
let summary = trait_.summarise_struct(cx, struct_def);
self.call_substructure_method(cx,
trait_: &TraitDef,
enum_def: &EnumDef,
type_ident: Ident,
- self_args: &[Gc<Expr>],
- nonself_args: &[Gc<Expr>])
- -> Gc<Expr> {
+ self_args: Vec<P<Expr>>,
+ nonself_args: &[P<Expr>])
+ -> P<Expr> {
self.build_enum_match_tuple(
cx, trait_, enum_def, type_ident, self_args, nonself_args)
}
trait_: &TraitDef,
enum_def: &EnumDef,
type_ident: Ident,
- self_args: &[Gc<Expr>],
- nonself_args: &[Gc<Expr>]) -> Gc<Expr> {
+ self_args: Vec<P<Expr>>,
+ nonself_args: &[P<Expr>]) -> P<Expr> {
let sp = trait_.span;
let variants = &enum_def.variants;
// The `vi_idents` will be bound, solely in the catch-all, to
// a series of let statements mapping each self_arg to a uint
// corresponding to its variant index.
- let vi_idents
: Vec<ast::Ident> = self_arg_names.iter()
+ let vi_idents: Vec<ast::Ident> = self_arg_names.iter()
.map(|name| { let vi_suffix = format!("{:s}_vi", name.as_slice());
cx.ident_of(vi_suffix.as_slice()) })
.collect::<Vec<ast::Ident>>();
// (Variant2, Variant2, ...) => Body2
// ...
// where each tuple has length = self_args.len()
- let mut match_arms : Vec<ast::Arm> = variants.iter().enumerate()
- .map(|(index, &variant)| {
-
- // These self_pats have form Variant1, Variant2, ...
- let self_pats : Vec<(Gc<ast::Pat>,
- Vec<(Span, Option<Ident>, Gc<Expr>)>)>;
- self_pats = self_arg_names.iter()
- .map(|self_arg_name|
- trait_.create_enum_variant_pattern(
- cx, &*variant, self_arg_name.as_slice(),
- ast::MutImmutable))
- .collect();
+ let mut match_arms: Vec<ast::Arm> = variants.iter().enumerate()
+ .map(|(index, variant)| {
+ let mk_self_pat = |cx: &mut ExtCtxt, self_arg_name: &str| {
+ let (p, idents) = trait_.create_enum_variant_pattern(cx, &**variant,
+ self_arg_name,
+ ast::MutImmutable);
+ (cx.pat(sp, ast::PatRegion(p)), idents)
+ };
// A single arm has form (&VariantK, &VariantK, ...) => BodyK
// (see "Final wrinkle" note below for why.)
- let subpats = self_pats.iter()
- .map(|&(p, ref _idents)| cx.pat(sp, ast::PatRegion(p)))
- .collect::<Vec<Gc<ast::Pat>>>();
+ let mut subpats = Vec::with_capacity(self_arg_names.len());
+ let mut self_pats_idents = Vec::with_capacity(self_arg_names.len() - 1);
+ let first_self_pat_idents = {
+ let (p, idents) = mk_self_pat(cx, self_arg_names[0].as_slice());
+ subpats.push(p);
+ idents
+ };
+ for self_arg_name in self_arg_names.tail().iter() {
+ let (p, idents) = mk_self_pat(cx, self_arg_name.as_slice());
+ subpats.push(p);
+ self_pats_idents.push(idents);
+ }
// Here is the pat = `(&VariantK, &VariantK, ...)`
let single_pat = cx.pat(sp, ast::PatTup(subpats));
// we are in.
// All of the Self args have the same variant in these
- // cases. So we transpose the info in self_pats to
- // gather the getter expressions together, in the form
- // that EnumMatching expects.
+ // cases. So we transpose the info in self_pats_idents
+ // to gather the getter expressions together, in the
+ // form that EnumMatching expects.
// The transposition is driven by walking across the
// arg fields of the variant for the first self pat.
- let &(_, ref self_arg_fields) = self_pats.get(0);
-
- let field_tuples : Vec<FieldInfo>;
-
- field_tuples = self_arg_fields.iter().enumerate()
+ let field_tuples = first_self_pat_idents.move_iter().enumerate()
// For each arg field of self, pull out its getter expr ...
- .map(|(field_index, &(sp, opt_ident, self_getter_expr))| {
+ .map(|(field_index, (sp, opt_ident, self_getter_expr))| {
// ... but FieldInfo also wants getter expr
// for matching other arguments of Self type;
- // so walk across the *other* self_pats and
- // pull out getter for same field in each of
- // them (using `field_index` tracked above).
+ // so walk across the *other* self_pats_idents
+ // and pull out getter for same field in each
+ // of them (using `field_index` tracked above).
// That is the heart of the transposition.
- let others = self_pats.tail().iter()
- .map(|&(_pat, ref fields)| {
+ let others = self_pats_idents.iter().map(|fields| {
+ let &(_, _opt_ident, ref other_getter_expr) =
+ fields.get(field_index);
- let &(_, _opt_ident, other_getter_expr) =
- fields.get(field_index);
+ // All Self args have same variant, so
+ // opt_idents are the same. (Assert
+ // here to make it self-evident that
+ // it is okay to ignore `_opt_ident`.)
+ assert!(opt_ident == _opt_ident);
- // All Self args have same variant, so
- // opt_idents are the same. (Assert
- // here to make it self-evident that
- // it is okay to ignore `_opt_ident`.)
- assert!(opt_ident == _opt_ident);
-
- other_getter_expr
- }).collect::<Vec<Gc<Expr>>>();
+ other_getter_expr.clone()
+ }).collect::<Vec<P<Expr>>>();
FieldInfo { span: sp,
name: opt_ident,
// Self arg, assuming all are instances of VariantK.
// Build up code associated with such a case.
let substructure = EnumMatching(index,
- &*variant,
+ &**variant,
field_tuples);
let arm_expr = self.call_substructure_method(
- cx, trait_, type_ident, self_args, nonself_args,
+ cx, trait_, type_ident, self_args.as_slice(), nonself_args,
&substructure);
cx.arm(sp, vec![single_pat], arm_expr)
// unreachable-pattern error.
//
if variants.len() > 1 && self_args.len() > 1 {
- let arms
: Vec<ast::Arm> = variants.iter().enumerate()
- .map(|(index, &variant)| {
- let pat = variant_to_pat(cx, sp, &*variant);
+ let arms: Vec<ast::Arm> = variants.iter().enumerate()
+ .map(|(index, variant)| {
+ let pat = variant_to_pat(cx, sp, &**variant);
let lit = ast::LitInt(index as u64, ast::UnsignedIntLit(ast::TyU));
cx.arm(sp, vec![pat], cx.expr_lit(sp, lit))
}).collect();
// A => 0u, B(..) => 1u, C(..) => 2u
// };
// ```
- let mut index_let_stmts
: Vec<Gc<ast::Stmt>> = Vec::new();
- for (&ident, &self_arg) in vi_idents.iter().zip(self_args.iter()) {
- let variant_idx = cx.expr_match(sp, self_arg, arms.clone());
+ let mut index_let_stmts
: Vec<P<ast::Stmt>> = Vec::new();
+ for (&ident, self_arg) in vi_idents.iter().zip(self_args.iter()) {
+ let variant_idx = cx.expr_match(sp, self_arg.clone(), arms.clone());
let let_stmt = cx.stmt_let(sp, false, ident, variant_idx);
index_let_stmts.push(let_stmt);
}
let arm_expr = self.call_substructure_method(
- cx, trait_, type_ident, self_args, nonself_args,
+ cx, trait_, type_ident, self_args.as_slice(), nonself_args,
&catch_all_substructure);
// Builds the expression:
// them when they are fed as r-values into a tuple
// expression; here add a layer of borrowing, turning
// `(*self, *__arg_0, ...)` into `(&*self, &*__arg_0, ...)`.
- let borrowed_self_args = self_args.iter()
- .map(|&self_arg| cx.expr_addr_of(sp, self_arg))
- .collect::<Vec<Gc<ast::Expr>>>();
+ let borrowed_self_args = self_args.move_map(|self_arg| cx.expr_addr_of(sp, self_arg));
let match_arg = cx.expr(sp, ast::ExprTup(borrowed_self_args));
cx.expr_match(sp, match_arg, match_arms)
}
trait_: &TraitDef,
enum_def: &EnumDef,
type_ident: Ident,
- self_args: &[Gc<Expr>],
- nonself_args: &[Gc<Expr>])
- -> Gc<Expr> {
+ self_args: &[P<Expr>],
+ nonself_args: &[P<Expr>])
+ -> P<Expr> {
let summary = enum_def.variants.iter().map(|v| {
let ident = v.node.name;
let summary = match v.node.kind {
cx: &mut ExtCtxt,
field_paths: Vec<ast::SpannedIdent> ,
mutbl: ast::Mutability)
field_paths.iter().map(|path| {
cx.pat(path.span,
ast::PatIdent(ast::BindByRef(mutbl), (*path).clone(), None))
- }).collect()
+ }).collect()
}
fn create_struct_pattern(&self,
struct_def: &StructDef,
prefix: &str,
mutbl: ast::Mutability)
- -> (Gc<ast::Pat>, Vec<(Span, Option<Ident>, Gc<Expr>)>) {
+ -> (P<ast::Pat>, Vec<(Span, Option<Ident>, P<Expr>)>) {
if struct_def.fields.is_empty() {
return (
cx.pat_ident_binding_mode(
// struct_type is definitely not Unknown, since struct_def.fields
// must be nonempty to reach here
let pattern = if struct_type == Record {
- let field_pats = subpats.iter().zip(ident_expr.iter()).map(|(&pat, &(_, id, _))| {
+ let field_pats = subpats.move_iter().zip(ident_expr.iter()).map(|(pat, &(_, id, _))| {
// id is guaranteed to be Some
ast::FieldPat { ident: id.unwrap(), pat: pat }
}).collect();
variant: &ast::Variant,
prefix: &str,
mutbl: ast::Mutability)
- -> (Gc<ast::Pat>, Vec<(Span, Option<Ident>, Gc<Expr>)> ) {
+ -> (P<ast::Pat>, Vec<(Span, Option<Ident>, P<Expr>)>) {
let variant_ident = variant.node.name;
match variant.node.kind {
ast::TupleVariantKind(ref variant_args) => {
left-to-right (`true`) or right-to-left (`false`).
*/
pub fn cs_fold(use_foldl: bool,
- f: |&mut ExtCtxt, Span, Gc<Expr>, Gc<Expr>, &[Gc<Expr>]| -> Gc<Expr>,
- base: Gc<Expr>,
+ f: |&mut ExtCtxt, Span, P<Expr>, P<Expr>, &[P<Expr>]| -> P<Expr>,
+ base: P<Expr>,
enum_nonmatch_f: EnumNonMatchCollapsedFunc,
cx: &mut ExtCtxt,
trait_span: Span,
substructure: &Substructure)
- -> Gc<Expr> {
+ -> P<Expr> {
match *substructure.fields {
EnumMatching(_, _, ref all_fields) | Struct(ref all_fields) => {
if use_foldl {
f(cx,
field.span,
old,
- field.self_,
+ field.self_.clone(),
field.other.as_slice())
})
} else {
f(cx,
field.span,
old,
- field.self_,
+ field.self_.clone(),
field.other.as_slice())
})
}
~~~
*/
#[inline]
-pub fn cs_same_method(f: |&mut ExtCtxt, Span, Vec<Gc<Expr>>| -> Gc<Expr>,
+pub fn cs_same_method(f: |&mut ExtCtxt, Span, Vec<P<Expr>>| -> P<Expr>,
enum_nonmatch_f: EnumNonMatchCollapsedFunc,
cx: &mut ExtCtxt,
trait_span: Span,
substructure: &Substructure)
- -> Gc<Expr> {
+ -> P<Expr> {
match *substructure.fields {
EnumMatching(_, _, ref all_fields) | Struct(ref all_fields) => {
// call self_n.method(other_1_n, other_2_n, ...)
let called = all_fields.iter().map(|field| {
cx.expr_method_call(field.span,
- field.self_,
+ field.self_.clone(),
substructure.method_ident,
field.other.iter()
- .map(|e| cx.expr_addr_of(field.span, *e))
+ .map(|e| cx.expr_addr_of(field.span, e.clone()))
.collect())
}).collect();
*/
#[inline]
pub fn cs_same_method_fold(use_foldl: bool,
- f: |&mut ExtCtxt, Span, Gc<Expr>, Gc<Expr>| -> Gc<Expr>,
- base: Gc<Expr>,
+ f: |&mut ExtCtxt, Span, P<Expr>, P<Expr>| -> P<Expr>,
+ base: P<Expr>,
enum_nonmatch_f: EnumNonMatchCollapsedFunc,
cx: &mut ExtCtxt,
trait_span: Span,
substructure: &Substructure)
- -> Gc<Expr> {
+ -> P<Expr> {
cs_same_method(
|cx, span, vals| {
if use_foldl {
- vals.iter().fold(base, |old, &new| {
+ vals.move_iter().fold(base.clone(), |old, new| {
f(cx, span, old, new)
})
} else {
- vals.iter().rev().fold(base, |old, &new| {
+ vals.move_iter().rev().fold(base.clone(), |old, new| {
f(cx, span, old, new)
})
}
on all the fields.
*/
#[inline]
-pub fn cs_binop(binop: ast::BinOp, base: Gc<Expr>,
+pub fn cs_binop(binop: ast::BinOp, base: P<Expr>,
enum_nonmatch_f: EnumNonMatchCollapsedFunc,
cx: &mut ExtCtxt, trait_span: Span,
- substructure: &Substructure) -> Gc<Expr> {
+ substructure: &Substructure) -> P<Expr> {
cs_same_method_fold(
true, // foldl is good enough
|cx, span, old, new| {
#[inline]
pub fn cs_or(enum_nonmatch_f: EnumNonMatchCollapsedFunc,
cx: &mut ExtCtxt, span: Span,
- substructure: &Substructure) -> Gc<Expr> {
+ substructure: &Substructure) -> P<Expr> {
cs_binop(ast::BiOr, cx.expr_bool(span, false),
enum_nonmatch_f,
cx, span, substructure)
#[inline]
pub fn cs_and(enum_nonmatch_f: EnumNonMatchCollapsedFunc,
cx: &mut ExtCtxt, span: Span,
- substructure: &Substructure) -> Gc<Expr> {
+ substructure: &Substructure) -> P<Expr> {
cs_binop(ast::BiAnd, cx.expr_bool(span, true),
enum_nonmatch_f,
cx, span, substructure)
*/
use ast;
-use ast::{P,Expr,Generics,Ident};
+use ast::{Expr,Generics,Ident};
use ext::base::ExtCtxt;
use ext::build::AstBuilder;
use codemap::{Span,respan};
use owned_slice::OwnedSlice;
use parse::token::special_idents;
-
-use std::gc::Gc;
+use ptr::P;
/// The types of pointers
#[deriving(Clone)]
}
pub fn get_explicit_self(cx: &ExtCtxt, span: Span, self_ptr: &Option<PtrTy>)
- -> (Gc<Expr>, ast::ExplicitSelf) {
+ -> (P<Expr>, ast::ExplicitSelf) {
// this constructs a fresh `self` path, which will match the fresh `self` binding
// created below.
let self_path = cx.expr_self(span);
use ext::deriving::generic::*;
use ext::deriving::generic::ty::*;
use parse::token::InternedString;
-
-use std::gc::Gc;
+use ptr::P;
pub fn expand_deriving_hash(cx: &mut ExtCtxt,
span: Span,
- mitem: Gc<MetaItem>,
- item: Gc<Item>,
- push: |Gc<Item>|) {
+ mitem: &MetaItem,
+ item: &Item,
+ push: |P<Item>|) {
let (path, generics, args) = if cx.ecfg.deriving_hash_type_parameter {
(Path::new_(vec!("std", "hash", "Hash"), None,
hash_trait_def.expand(cx, mitem, item, push);
}
-fn hash_substructure(cx: &mut ExtCtxt, trait_span: Span,
- substr: &Substructure) -> Gc<Expr> {
+fn hash_substructure(cx: &mut ExtCtxt, trait_span: Span, substr: &Substructure) -> P<Expr> {
let state_expr = match substr.nonself_args {
- [state_expr] => state_expr,
+ [ref state_expr] => state_expr,
_ => cx.span_bug(trait_span, "incorrect number of arguments in `deriving(Hash)`")
};
let hash_ident = substr.method_ident;
let call_hash = |span, thing_expr| {
- let expr = cx.expr_method_call(span, thing_expr, hash_ident, vec!(state_expr));
+ let expr = cx.expr_method_call(span, thing_expr, hash_ident, vec!(state_expr.clone()));
cx.stmt_expr(expr)
};
let mut stmts = Vec::new();
// Determine the discriminant. We will feed this value to the byte
// iteration function.
let discriminant = match variant.node.disr_expr {
- Some(d) => d,
+ Some(ref d) => d.clone(),
None => cx.expr_uint(trait_span, index)
};
_ => cx.span_bug(trait_span, "impossible substructure in `deriving(Hash)`")
};
- for &FieldInfo { self_, span, .. } in fields.iter() {
- stmts.push(call_hash(span, self_));
+ for &FieldInfo { ref self_, span, .. } in fields.iter() {
+ stmts.push(call_hash(span, self_.clone()));
}
if stmts.len() == 0 {
use ast::{Item, MetaItem, MetaList, MetaNameValue, MetaWord};
use ext::base::ExtCtxt;
use codemap::Span;
-
-use std::gc::Gc;
+use ptr::P;
pub mod bounds;
pub mod clone;
pub fn expand_meta_deriving(cx: &mut ExtCtxt,
_span: Span,
- mitem: Gc<MetaItem>,
- item: Gc<Item>,
- push: |Gc<Item>|) {
+ mitem: &MetaItem,
+ item: &Item,
+ push: |P<Item>|) {
match mitem.node {
MetaNameValue(_, ref l) => {
cx.span_err(l.span, "unexpected value in `deriving`");
cx.span_warn(mitem.span, "empty trait list in `deriving`");
}
MetaList(_, ref titems) => {
- for &titem in titems.iter().rev() {
+ for titem in titems.iter().rev() {
match titem.node {
MetaNameValue(ref tname, _) |
MetaList(ref tname, _) |
MetaWord(ref tname) => {
macro_rules! expand(($func:path) => ($func(cx, titem.span,
- titem, item,
+ &**titem, item,
|i| push(i))));
match tname.get() {
"Clone" => expand!(clone::expand_deriving_clone),
use ext::deriving::generic::*;
use ext::deriving::generic::ty::*;
use parse::token::InternedString;
-
-use std::gc::Gc;
+use ptr::P;
pub fn expand_deriving_from_primitive(cx: &mut ExtCtxt,
span: Span,
- mitem: Gc<MetaItem>,
- item: Gc<Item>,
- push: |Gc<Item>|) {
+ mitem: &MetaItem,
+ item: &Item,
+ push: |P<Item>|) {
let inline = cx.meta_word(span, InternedString::new("inline"));
let attrs = vec!(cx.attribute(span, inline));
let trait_def = TraitDef {
trait_def.expand(cx, mitem, item, push)
}
-fn cs_from(name: &str, cx: &mut ExtCtxt, trait_span: Span,
- substr: &Substructure) -> Gc<Expr> {
+fn cs_from(name: &str, cx: &mut ExtCtxt, trait_span: Span, substr: &Substructure) -> P<Expr> {
let n = match substr.nonself_args {
- [n] => n,
+ [ref n] => n,
_ => cx.span_bug(trait_span, "incorrect number of arguments in `deriving(FromPrimitive)`")
};
// expr for `$n == $variant as $name`
let variant = cx.expr_ident(span, variant.node.name);
let ty = cx.ty_ident(span, cx.ident_of(name));
- let cast = cx.expr_cast(span, variant, ty);
- let guard = cx.expr_binary(span, ast::BiEq, n, cast);
+ let cast = cx.expr_cast(span, variant.clone(), ty);
+ let guard = cx.expr_binary(span, ast::BiEq, n.clone(), cast);
// expr for `Some($variant)`
let body = cx.expr_some(span, variant);
};
arms.push(arm);
- cx.expr_match(trait_span, n, arms)
+ cx.expr_match(trait_span, n.clone(), arms)
}
_ => cx.span_bug(trait_span, "expected StaticEnum in deriving(FromPrimitive)")
}
use ext::build::{AstBuilder};
use ext::deriving::generic::*;
use ext::deriving::generic::ty::*;
-
-use std::gc::Gc;
+use ptr::P;
pub fn expand_deriving_rand(cx: &mut ExtCtxt,
span: Span,
- mitem: Gc<MetaItem>,
- item: Gc<Item>,
- push: |Gc<Item>|) {
+ mitem: &MetaItem,
+ item: &Item,
+ push: |P<Item>|) {
let trait_def = TraitDef {
span: span,
attributes: Vec::new(),
trait_def.expand(cx, mitem, item, push)
}
-fn rand_substructure(cx: &mut ExtCtxt, trait_span: Span,
- substr: &Substructure) -> Gc<Expr> {
+fn rand_substructure(cx: &mut ExtCtxt, trait_span: Span, substr: &Substructure) -> P<Expr> {
let rng = match substr.nonself_args {
- [rng] => vec!( rng ),
+ [ref rng] => rng,
_ => cx.bug("Incorrect number of arguments to `rand` in `deriving(Rand)`")
};
let rand_ident = vec!(
let rand_call = |cx: &mut ExtCtxt, span| {
cx.expr_call_global(span,
rand_ident.clone(),
- vec!( *rng.get(0) ))
+ vec!(rng.clone()))
};
return match *substr.fields {
// ::rand::Rand::rand(rng)
let rv_call = cx.expr_call(trait_span,
rand_name,
- vec!( *rng.get(0) ));
+ vec!(rng.clone()));
// need to specify the uint-ness of the random number
let uint_ty = cx.ty_ident(trait_span, cx.ident_of("uint"));
trait_span: Span,
ctor_ident: Ident,
summary: &StaticFields,
- rand_call: |&mut ExtCtxt, Span| -> Gc<Expr>)
- -> Gc<Expr> {
+ rand_call: |&mut ExtCtxt, Span| -> P<Expr>)
+ -> P<Expr> {
match *summary {
Unnamed(ref fields) => {
if fields.is_empty() {
// except according to those terms.
use ast;
-use ast::{MetaItem, Item, Expr};
+use ast::{MetaItem, Item, Expr,};
use codemap::Span;
use ext::format;
use ext::base::ExtCtxt;
use ext::deriving::generic::*;
use ext::deriving::generic::ty::*;
use parse::token;
+use ptr::P;
use std::collections::HashMap;
-use std::string::String;
-use std::gc::Gc;
pub fn expand_deriving_show(cx: &mut ExtCtxt,
span: Span,
- mitem: Gc<MetaItem>,
- item: Gc<Item>,
- push: |Gc<Item>|) {
+ mitem: &MetaItem,
+ item: &Item,
+ push: |P<Item>|) {
// &mut ::std::fmt::Formatter
let fmtr = Ptr(box Literal(Path::new(vec!("std", "fmt", "Formatter"))),
Borrowed(None, ast::MutMutable));
/// We construct a format string and then defer to std::fmt, since that
/// knows what's up with formatting and so on.
fn show_substructure(cx: &mut ExtCtxt, span: Span,
- substr: &Substructure) -> Gc<Expr> {
+ substr: &Substructure) -> P<Expr> {
// build `<name>`, `<name>({}, {}, ...)` or `<name> { <field>: {},
// <field>: {}, ... }` based on the "shape".
//
format_string.push_str("{}");
- exprs.push(field.self_);
+ exprs.push(field.self_.clone());
}
format_string.push_str(")");
format_string.push_str(name.get());
format_string.push_str(": {}");
- exprs.push(field.self_);
+ exprs.push(field.self_.clone());
}
format_string.push_str(" }}");
// format_arg_method!(fmt, write_fmt, "<format_string>", exprs...)
//
// but doing it directly via ext::format.
- let formatter = substr.nonself_args[0];
+ let formatter = substr.nonself_args[0].clone();
let meth = cx.ident_of("write_fmt");
let s = token::intern_and_get_ident(format_string.as_slice());
use ext::deriving::generic::*;
use ext::deriving::generic::ty::*;
use parse::token::InternedString;
-
-use std::gc::Gc;
+use ptr::P;
pub fn expand_deriving_zero(cx: &mut ExtCtxt,
span: Span,
- mitem: Gc<MetaItem>,
- item: Gc<Item>,
- push: |Gc<Item>|) {
+ mitem: &MetaItem,
+ item: &Item,
+ push: |P<Item>|) {
let inline = cx.meta_word(span, InternedString::new("inline"));
let attrs = vec!(cx.attribute(span, inline));
let trait_def = TraitDef {
trait_def.expand(cx, mitem, item, push)
}
-fn zero_substructure(cx: &mut ExtCtxt, trait_span: Span,
- substr: &Substructure) -> Gc<Expr> {
+fn zero_substructure(cx: &mut ExtCtxt, trait_span: Span, substr: &Substructure) -> P<Expr> {
let zero_ident = vec!(
cx.ident_of("std"),
cx.ident_of("num"),
pub fn expand_env<'cx>(cx: &'cx mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
-> Box<base::MacResult+'cx> {
- let exprs = match get_exprs_from_tts(cx, sp, tts) {
+ let mut exprs = match get_exprs_from_tts(cx, sp, tts) {
Some(ref exprs) if exprs.len() == 0 => {
cx.span_err(sp, "env! takes 1 or 2 arguments");
return DummyResult::expr(sp);
}
None => return DummyResult::expr(sp),
- Some(exprs) => exprs
+ Some(exprs) => exprs.move_iter()
};
let var = match expr_to_string(cx,
- *exprs.get(0),
+ exprs.next().unwrap(),
"expected string literal") {
None => return DummyResult::expr(sp),
Some((v, _style)) => v
};
- let msg = match exprs.len() {
- 1 => {
+ let msg = match exprs.next() {
+ None => {
token::intern_and_get_ident(format!("environment variable `{}` \
not defined",
var).as_slice())
}
- 2 => {
- match expr_to_string(cx, *exprs.get(1), "expected string literal") {
+ Some(second) => {
+ match expr_to_string(cx, second, "expected string literal") {
None => return DummyResult::expr(sp),
Some((s, _style)) => s
}
}
- _ => {
+ };
+
+ match exprs.next() {
+ None => {}
+ Some(_) => {
cx.span_err(sp, "env! takes 1 or 2 arguments");
return DummyResult::expr(sp);
}
- };
+ }
let e = match os::getenv(var.get()) {
None => {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use ast::{P, Block, Crate, DeclLocal, ExprMac, PatMac};
+use ast::{Block, Crate, DeclLocal, ExprMac, PatMac};
use ast::{Local, Ident, MacInvocTT};
use ast::{ItemMac, Mrk, Stmt, StmtDecl, StmtMac, StmtExpr, StmtSemi};
use ast::TokenTree;
use parse;
use parse::token::{fresh_mark, fresh_name, intern};
use parse::token;
+use ptr::P;
+use util::small_vector::SmallVector;
use visit;
use visit::Visitor;
-use util::small_vector::SmallVector;
-use std::gc::{Gc, GC};
+use std::gc::Gc;
enum Either<L,R> {
Left(L),
Right(R)
}
-
fn expand_expr(e: Gc<ast::Expr>, fld: &mut MacroExpander) -> Gc<ast::Expr> {
- match e.node {
+
pub fn expand_expr(e: P<ast::Expr>, fld: &mut MacroExpander) -> P<ast::Expr> {
+ e.and_then(|ast::Expr {id, node, span}| match node {
// expr_mac should really be expr_ext or something; it's the
// entry-point for all syntax extensions.
- ExprMac(ref mac) => {
- let expanded_expr = match expand_mac_invoc(mac,&e.span,
- |r|{r.make_expr()},
- |expr,fm|{mark_expr(expr,fm)},
- fld) {
+ ExprMac(mac) => {
+ let expanded_expr = match expand_mac_invoc(mac, span,
+ |r| r.make_expr(),
+ mark_expr, fld) {
Some(expr) => expr,
None => {
- return DummyResult::raw_expr(e.span);
+ return DummyResult::raw_expr(span);
}
};
// Keep going, outside-in.
//
- // FIXME(pcwalton): Is it necessary to clone the
- // node here?
- let fully_expanded =
- fld.fold_expr(expanded_expr).node.clone();
+ let fully_expanded = fld.fold_expr(expanded_expr);
fld.cx.bt_pop();
- box(GC) ast::Expr {
+ fully_expanded.map(|e| ast::Expr {
id: ast::DUMMY_NODE_ID,
- node: fully_expanded,
- span: e.span,
- }
+ node: e.node,
+ span: span,
+ })
}
ast::ExprWhile(cond, body, opt_ident) => {
let cond = fld.fold_expr(cond);
let (body, opt_ident) = expand_loop_block(body, opt_ident, fld);
- fld.cx.expr(e.span, ast::ExprWhile(cond, body, opt_ident))
+ fld.cx.expr(span, ast::ExprWhile(cond, body, opt_ident))
}
ast::ExprLoop(loop_block, opt_ident) => {
let (loop_block, opt_ident) = expand_loop_block(loop_block, opt_ident, fld);
- fld.cx.expr(e.span, ast::ExprLoop(loop_block, opt_ident))
+ fld.cx.expr(span, ast::ExprLoop(loop_block, opt_ident))
}
ast::ExprForLoop(pat, head, body, opt_ident) => {
let pat = fld.fold_pat(pat);
let head = fld.fold_expr(head);
let (body, opt_ident) = expand_loop_block(body, opt_ident, fld);
- fld.cx.expr(e.span, ast::ExprForLoop(pat, head, body, opt_ident))
+ fld.cx.expr(span, ast::ExprForLoop(pat, head, body, opt_ident))
}
ast::ExprFnBlock(capture_clause, fn_decl, block) => {
let (rewritten_fn_decl, rewritten_block)
- = expand_and_rename_fn_decl_and_block(&*fn_decl, block, fld);
+ = expand_and_rename_fn_decl_and_block(fn_decl, block, fld);
let new_node = ast::ExprFnBlock(capture_clause,
rewritten_fn_decl,
rewritten_block);
- box(GC) ast::Expr{id:e.id, node: new_node, span: fld.new_span(e.span)}
+ P(ast::Expr{id:id, node: new_node, span: fld.new_span(span)})
}
ast::ExprProc(fn_decl, block) => {
let (rewritten_fn_decl, rewritten_block)
- = expand_and_rename_fn_decl_and_block(&*fn_decl, block, fld);
+ = expand_and_rename_fn_decl_and_block(fn_decl, block, fld);
let new_node = ast::ExprProc(rewritten_fn_decl, rewritten_block);
- box(GC) ast::Expr{id:e.id, node: new_node, span: fld.new_span(e.span)}
+ P(ast::Expr{id:id, node: new_node, span: fld.new_span(span)})
}
- _ => noop_fold_expr(e, fld)
- }
+ _ => {
+ P(noop_fold_expr(ast::Expr {
+ id: id,
+ node: node,
+ span: span
+ }, fld))
+ }
+ })
}
/// Expand a (not-ident-style) macro invocation. Returns the result
/// of expansion and the mark which must be applied to the result.
/// Our current interface doesn't allow us to apply the mark to the
/// result until after calling make_expr, make_items, etc.
-fn expand_mac_invoc<T>(mac: &ast::Mac, span: &codemap::Span,
+fn expand_mac_invoc<T>(mac: ast::Mac, span: codemap::Span,
parse_thunk: |Box<MacResult>|->Option<T>,
mark_thunk: |T,Mrk|->T,
fld: &mut MacroExpander)
-> Option<T>
{
- match (*mac).node {
+ match mac.node {
// it would almost certainly be cleaner to pass the whole
// macro invocation in, rather than pulling it apart and
// marking the tts and the ctxt separately. This also goes
// for the other three macro invocation chunks of code
// in this file.
// Token-tree macros:
- MacInvocTT(ref pth, ref tts, _) => {
+ MacInvocTT(pth, tts, _) => {
if pth.segments.len() > 1u {
fld.cx.span_err(pth.span,
"expected macro name without module \
Some(rc) => match *rc {
NormalTT(ref expandfun, exp_span) => {
fld.cx.bt_push(ExpnInfo {
- call_site: *span,
+ call_site: span,
callee: NameAndSpan {
name: extnamestr.get().to_string(),
format: MacroBang,
// in a block enclosed by loop head.
fld.cx.syntax_env.push_frame();
fld.cx.syntax_env.info().pending_renames.push(rename);
- let expanded_block = expand_block_elts(&*loop_block, fld);
+ let expanded_block = expand_block_elts(loop_block, fld);
fld.cx.syntax_env.pop_frame();
(expanded_block, Some(renamed_ident))
)
// When we enter a module, record it, for the sake of `module!`
-
fn expand_item(it: Gc<ast::Item>, fld: &mut MacroExpander)
- -> SmallVector<
Gc<ast::Item>> {
+
pub fn expand_item(it: P<ast::Item>, fld: &mut MacroExpander)
+ -> SmallVector<
P<ast::Item>> {
let it = expand_item_modifiers(it, fld);
let mut decorator_items = SmallVector::zero();
// we'd ideally decorator_items.push_all(expand_item(item, fld)),
// but that double-mut-borrows fld
- let mut items: SmallVector<Gc<ast::Item>> = SmallVector::zero();
- dec.expand(fld.cx, attr.span, attr.node.value, it, |item| items.push(item));
+ let mut items: SmallVector<P<ast::Item>> = SmallVector::zero();
+ dec.expand(fld.cx, attr.span, &*attr.node.value, &*it,
+ |item| items.push(item));
decorator_items.extend(items.move_iter()
.flat_map(|item| expand_item(item, fld).move_iter()));
let macro_escape = contains_macro_escape(new_attrs.as_slice());
let result = with_exts_frame!(fld.cx.syntax_env,
macro_escape,
- noop_fold_item(&*it, fld));
+ noop_fold_item(it, fld));
fld.cx.mod_pop();
result
},
_ => {
- let it = box(GC) ast::Item {
+ let it = P(ast::Item {
attrs: new_attrs,
..(*it).clone()
-
- };
- noop_fold_item(&*it, fld)
+ });
+ noop_fold_item(it, fld)
}
};
new_items
}
-fn expand_item_modifiers(mut it:
Gc<ast::Item>, fld: &mut MacroExpander)
+fn expand_item_modifiers(mut it:
P<ast::Item>, fld: &mut MacroExpander)
// partition the attributes into ItemModifiers and others
let (modifiers, other_attrs) = it.attrs.partitioned(|attr| {
match fld.cx.syntax_env.find(&intern(attr.name().get())) {
}
});
// update the attrs, leave everything else alone. Is this mutation really a good idea?
- it = box(GC) ast::Item {
+ it = P(ast::Item {
attrs: other_attrs,
..(*it).clone()
- };
+ });
if modifiers.is_empty() {
return it;
span: None,
}
});
- it = mac.expand(fld.cx, attr.span, attr.node.value, it);
+ it = mac.expand(fld.cx, attr.span, &*attr.node.value, it);
fld.cx.bt_pop();
}
_ => unreachable!()
}
/// Expand item_underscore
-fn expand_item_underscore(item: &ast::Item_, fld: &mut MacroExpander) -> ast::Item_ {
- match *item {
- ast::ItemFn(decl, fn_style, abi, ref generics, body) => {
+fn expand_item_underscore(item: ast::Item_, fld: &mut MacroExpander) -> ast::Item_ {
+ match item {
+ ast::ItemFn(decl, fn_style, abi, generics, body) => {
let (rewritten_fn_decl, rewritten_body)
- = expand_and_rename_fn_decl_and_block(&*decl, body, fld);
+ = expand_and_rename_fn_decl_and_block(decl, body, fld);
let expanded_generics = fold::noop_fold_generics(generics,fld);
ast::ItemFn(rewritten_fn_decl, fn_style, abi, expanded_generics, rewritten_body)
}
- _ => noop_fold_item_underscore(&*item, fld)
+ _ => noop_fold_item_underscore(item, fld)
}
}
// Support for item-position macro invocations, exactly the same
// logic as for expression-position macro invocations.
-fn expand_item_mac(it: Gc<ast::Item>, fld: &mut MacroExpander)
- -> SmallVector<Gc<ast::Item>>
-{
- let (pth, tts) = match it.node {
+pub fn expand_item_mac(it: P<ast::Item>, fld: &mut MacroExpander)
+ -> SmallVector<P<ast::Item>> {
+ let (extname, path_span, tts) = match it.node {
ItemMac(codemap::Spanned {
node: MacInvocTT(ref pth, ref tts, _),
..
}) => {
- (pth, (*tts).clone())
+ (pth.segments.get(0).identifier, pth.span, (*tts).clone())
}
_ => fld.cx.span_bug(it.span, "invalid item macro invocation")
};
- let extname = pth.segments.get(0).identifier;
let extnamestr = token::get_ident(extname);
let fm = fresh_mark();
let def_or_items = {
- let expanded = match fld.cx.syntax_env.find(&extname.name) {
+ let mut expanded = match fld.cx.syntax_env.find(&extname.name) {
None => {
- fld.cx.span_err(pth.span,
+ fld.cx.span_err(path_span,
format!("macro undefined: '{}!'",
extnamestr).as_slice());
// let compilation continue
NormalTT(ref expander, span) => {
if it.ident.name != parse::token::special_idents::invalid.name {
fld.cx
- .span_err(pth.span,
+ .span_err(path_span,
format!("macro {}! expects no ident argument, \
given '{}'",
extnamestr,
}
IdentTT(ref expander, span) => {
if it.ident.name == parse::token::special_idents::invalid.name {
- fld.cx.span_err(pth.span,
+ fld.cx.span_err(path_span,
format!("macro {}! expects an ident argument",
extnamestr.get()).as_slice());
return SmallVector::zero();
}
LetSyntaxTT(ref expander, span) => {
if it.ident.name == parse::token::special_idents::invalid.name {
- fld.cx.span_err(pth.span,
+ fld.cx.span_err(path_span,
format!("macro {}! expects an ident argument",
extnamestr.get()).as_slice());
return SmallVector::zero();
.collect()
}
Right(None) => {
- fld.cx.span_err(pth.span,
+ fld.cx.span_err(path_span,
format!("non-item macro in item position: {}",
extnamestr.get()).as_slice());
return SmallVector::zero();
};
fld.cx.bt_pop();
- return items;
+ items
}
/// Expand a stmt
//
// I don't understand why this returns a vector... it looks like we're
// half done adding machinery to allow macros to expand into multiple statements.
-fn expand_stmt(s: &Stmt, fld: &mut MacroExpander) -> SmallVector<Gc<Stmt>> {
+fn expand_stmt(s: Stmt, fld: &mut MacroExpander) -> SmallVector<P<Stmt>> {
let (mac, semi) = match s.node {
- StmtMac(ref mac, semi) => (mac, semi),
+ StmtMac(mac, semi) => (mac, semi),
_ => return expand_non_macro_stmt(s, fld)
};
- let expanded_stmt = match expand_mac_invoc(mac,&s.span,
- |r|{r.make_stmt()},
- |sts,mrk| {
- mark_stmt(&*sts,mrk)
- },
- fld) {
+ let expanded_stmt = match expand_mac_invoc(mac, s.span,
+ |r| r.make_stmt(),
+ mark_stmt, fld) {
Some(stmt) => stmt,
None => {
return SmallVector::zero();
};
// Keep going, outside-in.
- let fully_expanded = fld.fold_stmt(&*expanded_stmt);
+ let fully_expanded = fld.fold_stmt(expanded_stmt);
fld.cx.bt_pop();
- let fully_expanded: SmallVector<Gc<Stmt>> = fully_expanded.move_iter()
- .map(|s| box(GC) Spanned { span: s.span, node: s.node.clone() })
- .collect();
-
- fully_expanded.move_iter().map(|s| {
- match s.node {
- StmtExpr(e, stmt_id) if semi => {
- box(GC) Spanned {
- span: s.span,
- node: StmtSemi(e, stmt_id)
- }
+
+ if semi {
+ fully_expanded.move_iter().map(|s| s.map(|Spanned {node, span}| {
+ Spanned {
+ node: match node {
+ StmtExpr(e, stmt_id) => StmtSemi(e, stmt_id),
+ _ => node /* might already have a semi */
+ },
+ span: span
}
- _ => s /* might already have a semi */
- }
- }).collect()
+ })).collect()
+ } else {
+ fully_expanded
+ }
}
// expand a non-macro stmt. this is essentially the fallthrough for
// expand_stmt, above.
-fn expand_non_macro_stmt(s: &Stmt, fld: &mut MacroExpander)
- -> SmallVector<Gc<Stmt>> {
+fn expand_non_macro_stmt(Spanned {node, span: stmt_span}: Stmt, fld: &mut MacroExpander)
+ -> SmallVector<P<Stmt>> {
// is it a let?
- match s.node {
- StmtDecl(decl, node_id) => {
- match *decl {
- Spanned {
- node: DeclLocal(ref local),
- span: stmt_span
- } => {
- // take it apart:
- let Local {
- ty: ty,
- pat: pat,
- init: init,
- id: id,
- span: span,
- source: source,
- } = **local;
+ match node {
+ StmtDecl(decl, node_id) => decl.and_then(|Spanned {node: decl, span}| match decl {
+ DeclLocal(local) => {
+ // take it apart:
+ let rewritten_local = local.map(|Local {id, pat, ty, init, source, span}| {
// expand the ty since TyFixedLengthVec contains an Expr
// and thus may have a macro use
let expanded_ty = fld.fold_ty(ty);
};
// add them to the existing pending renames:
fld.cx.syntax_env.info().pending_renames.push_all_move(new_pending_renames);
- // also, don't forget to expand the init:
- let new_init_opt = init.map(|e| fld.fold_expr(e));
- let rewritten_local =
- box(GC) Local {
- ty: expanded_ty,
- pat: rewritten_pat,
- init: new_init_opt,
- id: id,
- span: span,
- source: source
- };
- SmallVector::one(box(GC) Spanned {
- node: StmtDecl(box(GC) Spanned {
- node: DeclLocal(rewritten_local),
- span: stmt_span
- },
- node_id),
+ Local {
+ id: id,
+ ty: expanded_ty,
+ pat: rewritten_pat,
+ // also, don't forget to expand the init:
+ init: init.map(|e| fld.fold_expr(e)),
+ source: source,
span: span
- })
- }
- _ => noop_fold_stmt(s, fld),
+ }
+ });
+ SmallVector::one(P(Spanned {
+ node: StmtDecl(P(Spanned {
+ node: DeclLocal(rewritten_local),
+ span: span
+ }),
+ node_id),
+ span: stmt_span
+ }))
}
- },
- _ => noop_fold_stmt(s, fld),
+ _ => {
+ noop_fold_stmt(Spanned {
+ node: StmtDecl(P(Spanned {
+ node: decl,
+ span: span
+ }),
+ node_id),
+ span: stmt_span
+ }, fld)
+ }
+ }),
+ _ => {
+ noop_fold_stmt(Spanned {
+ node: node,
+ span: stmt_span
+ }, fld)
+ }
}
}
// expand the arm of a 'match', renaming for macro hygiene
-fn expand_arm(arm: &ast::Arm, fld: &mut MacroExpander) -> ast::Arm {
+fn expand_arm(arm: ast::Arm, fld: &mut MacroExpander) -> ast::Arm {
// expand pats... they might contain macro uses:
- let expanded_pats : Vec<Gc<ast::Pat>> = arm.pats.iter().map(|pat| fld.fold_pat(*pat)).collect();
+ let expanded_pats = arm.pats.move_map(|pat| fld.fold_pat(pat));
if expanded_pats.len() == 0 {
fail!("encountered match arm with 0 patterns");
}
// all of the pats must have the same set of bindings, so use the
// first one to extract them and generate new names:
- let first_pat = expanded_pats.get(0);
- let idents = pattern_bindings(&**first_pat);
- let new_renames =
- idents.iter().map(|id| (*id,fresh_name(id))).collect();
+ let idents = pattern_bindings(&**expanded_pats.get(0));
+ let new_renames = idents.move_iter().map(|id| (id, fresh_name(&id))).collect();
// apply the renaming, but only to the PatIdents:
let mut rename_pats_fld = PatIdentRenamer{renames:&new_renames};
- let rewritten_pats =
- expanded_pats.iter().map(|pat| rename_pats_fld.fold_pat(*pat)).collect();
+ let rewritten_pats = expanded_pats.move_map(|pat| rename_pats_fld.fold_pat(pat));
// apply renaming and then expansion to the guard and the body:
let mut rename_fld = IdentRenamer{renames:&new_renames};
let rewritten_guard =
arm.guard.map(|g| fld.fold_expr(rename_fld.fold_expr(g)));
let rewritten_body = fld.fold_expr(rename_fld.fold_expr(arm.body));
ast::Arm {
- attrs: arm.attrs.iter().map(|x| fld.fold_attribute(*x)).collect(),
+ attrs: arm.attrs.move_map(|x| fld.fold_attribute(x)),
pats: rewritten_pats,
guard: rewritten_guard,
body: rewritten_body,
}
// expand a block. pushes a new exts_frame, then calls expand_block_elts
-fn expand_block(blk: &Block, fld: &mut MacroExpander) -> P<Block> {
+pub fn expand_block(blk: P<Block>, fld: &mut MacroExpander) -> P<Block> {
// see note below about treatment of exts table
with_exts_frame!(fld.cx.syntax_env,false,
expand_block_elts(blk, fld))
}
// expand the elements of a block.
-fn expand_block_elts(b: &Block, fld: &mut MacroExpander) -> P<Block> {
- let new_view_items = b.view_items.iter().map(|x| fld.fold_view_item(x)).collect();
- let new_stmts =
- b.stmts.iter().flat_map(|x| {
+pub fn expand_block_elts(b: P<Block>, fld: &mut MacroExpander) -> P<Block> {
+ b.map(|Block {id, view_items, stmts, expr, rules, span}| {
+ let new_view_items = view_items.move_iter().map(|x| fld.fold_view_item(x)).collect();
+ let new_stmts = stmts.move_iter().flat_map(|x| {
// perform all pending renames
let renamed_stmt = {
let pending_renames = &mut fld.cx.syntax_env.info().pending_renames;
let mut rename_fld = IdentRenamer{renames:pending_renames};
- rename_fld.fold_stmt(&**x).expect_one("rename_fold didn't return one value")
+ rename_fld.fold_stmt(x).expect_one("rename_fold didn't return one value")
};
// expand macros in the statement
- fld.fold_stmt(&*renamed_stmt).move_iter()
+ fld.fold_stmt(renamed_stmt).move_iter()
}).collect();
- let new_expr = b.expr.map(|x| {
- let expr = {
- let pending_renames = &mut fld.cx.syntax_env.info().pending_renames;
- let mut rename_fld = IdentRenamer{renames:pending_renames};
- rename_fld.fold_expr(x)
- };
- fld.fold_expr(expr)
- });
- P(Block {
- view_items: new_view_items,
- stmts: new_stmts,
- expr: new_expr,
- id: fld.new_id(b.id),
- rules: b.rules,
- span: b.span,
+ let new_expr = expr.map(|x| {
+ let expr = {
+ let pending_renames = &mut fld.cx.syntax_env.info().pending_renames;
+ let mut rename_fld = IdentRenamer{renames:pending_renames};
+ rename_fld.fold_expr(x)
+ };
+ fld.fold_expr(expr)
+ });
+ Block {
+ id: fld.new_id(id),
+ view_items: new_view_items,
+ stmts: new_stmts,
+ expr: new_expr,
+ rules: rules,
+ span: span
+ }
})
}
-fn expand_pat(p: Gc<ast::Pat>, fld: &mut MacroExpander) -> Gc<ast::Pat> {
- let (pth, tts) = match p.node {
- PatMac(ref mac) => {
- match mac.node {
- MacInvocTT(ref pth, ref tts, _) => {
- (pth, (*tts).clone())
- }
- }
- }
- _ => return noop_fold_pat(p, fld),
- };
- if pth.segments.len() > 1u {
- fld.cx.span_err(pth.span, "expected macro name without module separators");
- return DummyResult::raw_pat(p.span);
+fn expand_pat(p: P<ast::Pat>, fld: &mut MacroExpander) -> P<ast::Pat> {
+ match p.node {
+ PatMac(_) => {}
+ _ => return noop_fold_pat(p, fld)
}
- let extname = pth.segments.get(0).identifier;
- let extnamestr = token::get_ident(extname);
- let marked_after = match fld.cx.syntax_env.find(&extname.name) {
- None => {
- fld.cx.span_err(pth.span,
- format!("macro undefined: '{}!'",
- extnamestr).as_slice());
- // let compilation continue
- return DummyResult::raw_pat(p.span);
+ p.map(|ast::Pat {node, span, ..}| {
+ let (pth, tts) = match node {
+ PatMac(mac) => match mac.node {
+ MacInvocTT(pth, tts, _) => {
+ (pth, tts)
+ }
+ },
+ _ => unreachable!()
+ };
+ if pth.segments.len() > 1u {
+ fld.cx.span_err(pth.span, "expected macro name without module separators");
+ return DummyResult::raw_pat(span);
}
+ let extname = pth.segments.get(0).identifier;
+ let extnamestr = token::get_ident(extname);
+ let marked_after = match fld.cx.syntax_env.find(&extname.name) {
+ None => {
+ fld.cx.span_err(pth.span,
+ format!("macro undefined: '{}!'",
+ extnamestr).as_slice());
+ // let compilation continue
+ return DummyResult::raw_pat(span);
+ }
- Some(rc) => match *rc {
- NormalTT(ref expander, span) => {
- fld.cx.bt_push(ExpnInfo {
- call_site: p.span,
- callee: NameAndSpan {
- name: extnamestr.get().to_string(),
- format: MacroBang,
- span: span
- }
- });
+ Some(rc) => match *rc {
+ NormalTT(ref expander, tt_span) => {
+ fld.cx.bt_push(ExpnInfo {
+ call_site: span,
+ callee: NameAndSpan {
+ name: extnamestr.get().to_string(),
+ format: MacroBang,
+ span: tt_span
+ }
+ });
- let fm = fresh_mark();
- let marked_before = mark_tts(tts.as_slice(), fm);
- let mac_span = original_span(fld.cx);
- let expanded = match expander.expand(fld.cx,
- mac_span.call_site,
- marked_before.as_slice()).make_pat() {
- Some(e) => e,
- None => {
- fld.cx.span_err(
- pth.span,
- format!(
- "non-pattern macro in pattern position: {}",
- extnamestr.get()
- ).as_slice()
- );
- return DummyResult::raw_pat(p.span);
- }
- };
+ let fm = fresh_mark();
+ let marked_before = mark_tts(tts.as_slice(), fm);
+ let mac_span = original_span(fld.cx);
+ let expanded = match expander.expand(fld.cx,
+ mac_span.call_site,
+ marked_before.as_slice()).make_pat() {
+ Some(e) => e,
+ None => {
+ fld.cx.span_err(
+ pth.span,
+ format!(
+ "non-pattern macro in pattern position: {}",
+ extnamestr.get()
+ ).as_slice()
+ );
+ return DummyResult::raw_pat(span);
+ }
+ };
- // mark after:
- mark_pat(expanded,fm)
- }
- _ => {
- fld.cx.span_err(p.span,
- format!("{}! is not legal in pattern position",
- extnamestr.get()).as_slice());
- return DummyResult::raw_pat(p.span);
+ // mark after:
+ mark_pat(expanded,fm)
+ }
+ _ => {
+ fld.cx.span_err(span,
+ format!("{}! is not legal in pattern position",
+ extnamestr.get()).as_slice());
+ return DummyResult::raw_pat(span);
+ }
}
- }
- };
+ };
- let fully_expanded =
- fld.fold_pat(marked_after).node.clone();
- fld.cx.bt_pop();
+ let fully_expanded =
+ fld.fold_pat(marked_after).node.clone();
+ fld.cx.bt_pop();
- box(GC) ast::Pat {
- id: ast::DUMMY_NODE_ID,
- node: fully_expanded,
- span: p.span,
- }
+ ast::Pat {
+ id: ast::DUMMY_NODE_ID,
+ node: fully_expanded,
+ span: span
+ }
+ })
}
/// A tree-folder that applies every rename in its (mutable) list
ctxt: mtwt::apply_renames(self.renames, id.ctxt),
}
}
- fn fold_mac(&mut self, macro: &ast::Mac) -> ast::Mac {
+ fn fold_mac(&mut self, macro: ast::Mac) -> ast::Mac {
fold::noop_fold_mac(macro, self)
}
}
}
impl<'a> Folder for PatIdentRenamer<'a> {
- fn fold_pat(&mut self, pat:
Gc<ast::Pat>) -> Gc<ast::Pat> {
+ fn fold_pat(&mut self, pat:
P<ast::Pat>) -> P<ast::Pat> {
match pat.node {
- ast::PatIdent(binding_mode, Spanned{span: ref sp, node: id}, ref sub) => {
- let new_ident = Ident{name: id.name,
- ctxt: mtwt::apply_renames(self.renames, id.ctxt)};
+ ast::PatIdent(..) => {},
+ _ => return noop_fold_pat(pat, self)
+ }
+
+ pat.map(|ast::Pat {id, node, span}| match node {
+ ast::PatIdent(binding_mode, Spanned{span: sp, node: ident}, sub) => {
+ let new_ident = Ident{name: ident.name,
+ ctxt: mtwt::apply_renames(self.renames, ident.ctxt)};
let new_node =
ast::PatIdent(binding_mode,
- Spanned{span: self.new_span(*sp), node: new_ident},
+ Spanned{span: self.new_span(sp), node: new_ident},
sub.map(|p| self.fold_pat(p)));
- box(GC) ast::Pat {
- id: pat.id,
- span: self.new_span(pat.span),
+ ast::Pat {
+ id: id,
node: new_node,
+ span: self.new_span(span)
}
},
- _ => noop_fold_pat(pat, self)
- }
+ _ => unreachable!()
+ })
}
- fn fold_mac(&mut self, macro: &ast::Mac) -> ast::Mac {
+ fn fold_mac(&mut self, macro: ast::Mac) -> ast::Mac {
fold::noop_fold_mac(macro, self)
}
}
// expand a method
-fn expand_method(m: &ast::Method, fld: &mut MacroExpander) -> SmallVector<Gc<ast::Method>> {
- let id = fld.new_id(m.id);
- match m.node {
+fn expand_method(m: P<ast::Method>, fld: &mut MacroExpander) -> SmallVector<P<ast::Method>> {
+ m.and_then(|m| match m.node {
ast::MethDecl(ident,
- ref generics,
+ generics,
abi,
- ref explicit_self,
+ explicit_self,
fn_style,
decl,
body,
vis) => {
+ let id = fld.new_id(m.id);
let (rewritten_fn_decl, rewritten_body)
- = expand_and_rename_fn_decl_and_block(&*decl,body,fld);
- SmallVector::one(box(GC) ast::Method {
- attrs: m.attrs.iter().map(|a| fld.fold_attribute(*a)).collect(),
+ = expand_and_rename_fn_decl_and_block(decl,body,fld);
+ SmallVector::one(P(ast::Method {
+ attrs: m.attrs.move_map(|a| fld.fold_attribute(a)),
id: id,
span: fld.new_span(m.span),
node: ast::MethDecl(fld.fold_ident(ident),
rewritten_fn_decl,
rewritten_body,
vis)
- })
+ }))
},
- ast::MethMac(ref mac) => {
+ ast::MethMac(mac) => {
let maybe_new_methods =
- expand_mac_invoc(mac, &m.span,
- |r|{r.make_methods()},
- |meths,mark|{
- meths.move_iter().map(|m|{mark_method(m,mark)})
- .collect()},
+ expand_mac_invoc(mac, m.span,
+ |r| r.make_methods(),
+ |meths, mark| meths.move_map(|m| mark_method(m, mark)),
fld);
let new_methods = match maybe_new_methods {
// expand again if necessary
new_methods.move_iter().flat_map(|m| fld.fold_method(m).move_iter()).collect()
}
- }
+ })
}
/// Given a fn_decl and a block and a MacroExpander, expand the fn_decl, then use the
/// PatIdents in its arguments to perform renaming in the FnDecl and
/// the block, returning both the new FnDecl and the new Block.
-fn expand_and_rename_fn_decl_and_block(fn_decl:
&ast::FnDecl, block: Gc<ast::Block>,
+fn expand_and_rename_fn_decl_and_block(fn_decl:
P<ast::FnDecl>, block: P<ast::Block>,
fld: &mut MacroExpander)
- -> (
Gc<ast::FnDecl>, Gc<ast::Block>) {
+ -> (
P<ast::FnDecl>, P<ast::Block>) {
let expanded_decl = fld.fold_fn_decl(fn_decl);
let idents = fn_decl_arg_bindings(&*expanded_decl);
let renames =
idents.iter().map(|id : &ast::Ident| (*id,fresh_name(id))).collect();
// first, a renamer for the PatIdents, for the fn_decl:
let mut rename_pat_fld = PatIdentRenamer{renames: &renames};
- let rewritten_fn_decl = rename_pat_fld.fold_fn_decl(&*expanded_decl);
+ let rewritten_fn_decl = rename_pat_fld.fold_fn_decl(expanded_decl);
// now, a renamer for *all* idents, for the body:
let mut rename_fld = IdentRenamer{renames: &renames};
let rewritten_body = fld.fold_block(rename_fld.fold_block(block));
}
impl<'a, 'b> Folder for MacroExpander<'a, 'b> {
- fn fold_expr(&mut self, expr:
Gc<ast::Expr>) -> Gc<ast::Expr> {
+ fn fold_expr(&mut self, expr:
P<ast::Expr>) -> P<ast::Expr> {
expand_expr(expr, self)
}
- fn fold_pat(&mut self, pat:
Gc<ast::Pat>) -> Gc<ast::Pat> {
+ fn fold_pat(&mut self, pat:
P<ast::Pat>) -> P<ast::Pat> {
expand_pat(pat, self)
}
- fn fold_item(&mut self, item:
Gc<ast::Item>) -> SmallVector<Gc<ast::Item>> {
+ fn fold_item(&mut self, item:
P<ast::Item>) -> SmallVector<P<ast::Item>> {
expand_item(item, self)
}
- fn fold_item_underscore(&mut self, item: &ast::Item_) -> ast::Item_ {
+ fn fold_item_underscore(&mut self, item: ast::Item_) -> ast::Item_ {
expand_item_underscore(item, self)
}
- fn fold_stmt(&mut self, stmt:
&ast::Stmt) -> SmallVector<Gc<ast::Stmt>> {
- expand_stmt(stmt, self)
+ fn fold_stmt(&mut self, stmt:
P<ast::Stmt>) -> SmallVector<P<ast::Stmt>> {
+ stmt.and_then(|stmt| expand_stmt(stmt, self))
}
fn fold_block(&mut self, block: P<Block>) -> P<Block> {
- expand_block(&*block, self)
+ expand_block(block, self)
}
- fn fold_arm(&mut self, arm: &ast::Arm) -> ast::Arm {
+ fn fold_arm(&mut self, arm: ast::Arm) -> ast::Arm {
expand_arm(arm, self)
}
- fn fold_method(&mut self, method:
Gc<ast::Method>) -> SmallVector<Gc<ast::Method>> {
- expand_method(&*method, self)
+ fn fold_method(&mut self, method:
P<ast::Method>) -> SmallVector<P<ast::Method>> {
+ expand_method(method, self)
}
fn new_span(&mut self, span: Span) -> Span {
ctxt: mtwt::apply_mark(self.mark, id.ctxt)
}
}
- fn fold_mac(&mut self, m: &ast::Mac) -> ast::Mac {
- let macro = match m.node {
- MacInvocTT(ref path, ref tts, ctxt) => {
- MacInvocTT(self.fold_path(path),
- self.fold_tts(tts.as_slice()),
- mtwt::apply_mark(self.mark, ctxt))
- }
- };
+ fn fold_mac(&mut self, Spanned {node, span}: ast::Mac) -> ast::Mac {
Spanned {
- node: macro,
- span: m.span,
+ node: match node {
+ MacInvocTT(path, tts, ctxt) => {
+ MacInvocTT(self.fold_path(path),
+ self.fold_tts(tts.as_slice()),
+ mtwt::apply_mark(self.mark, ctxt))
+ }
+ },
+ span: span,
}
}
}
}
// apply a given mark to the given expr. Used following the expansion of a macro.
-fn mark_expr(expr:
Gc<ast::Expr>, m: Mrk) -> Gc<ast::Expr> {
+fn mark_expr(expr:
P<ast::Expr>, m: Mrk) -> P<ast::Expr> {
Marker{mark:m}.fold_expr(expr)
}
// apply a given mark to the given pattern. Used following the expansion of a macro.
-fn mark_pat(pat:
Gc<ast::Pat>, m: Mrk) -> Gc<ast::Pat> {
+fn mark_pat(pat:
P<ast::Pat>, m: Mrk) -> P<ast::Pat> {
Marker{mark:m}.fold_pat(pat)
}
// apply a given mark to the given stmt. Used following the expansion of a macro.
-fn mark_stmt(expr:
&ast::Stmt, m: Mrk) -> Gc<ast::Stmt> {
+fn mark_stmt(expr:
P<ast::Stmt>, m: Mrk) -> P<ast::Stmt> {
Marker{mark:m}.fold_stmt(expr)
.expect_one("marking a stmt didn't return exactly one stmt")
}
// apply a given mark to the given item. Used following the expansion of a macro.
-fn mark_item(expr:
Gc<ast::Item>, m: Mrk) -> Gc<ast::Item> {
+fn mark_item(expr:
P<ast::Item>, m: Mrk) -> P<ast::Item> {
Marker{mark:m}.fold_item(expr)
.expect_one("marking an item didn't return exactly one item")
}
// apply a given mark to the given item. Used following the expansion of a macro.
-fn mark_method(expr:
Gc<ast::Method>, m: Mrk) -> Gc<ast::Method> {
+fn mark_method(expr:
P<ast::Method>, m: Mrk) -> P<ast::Method> {
Marker{mark:m}.fold_method(expr)
.expect_one("marking an item didn't return exactly one method")
}
use visit;
use visit::Visitor;
- use std::gc::GC;
-
// a visitor that extracts the paths
// from a given thingy and puts them in a mutable
// array (passed in to the traversal)
node: Attribute_ {
id: attr::mk_attr_id(),
style: AttrOuter,
- value: box(GC) Spanned {
+ value: P(Spanned {
node: MetaWord(token::intern_and_get_ident(s)),
span: codemap::DUMMY_SP,
- },
+ }),
is_sugared_doc: false,
}
}
// except according to those terms.
use ast;
-use ast::P;
use codemap::{Span, respan};
use ext::base::*;
use ext::base;
use fmt_macros as parse;
use parse::token::InternedString;
use parse::token;
+use ptr::P;
use std::collections::HashMap;
-use std::gc::{Gc, GC};
#[deriving(PartialEq)]
enum ArgumentType {
/// Parsed argument expressions and the types that we've found so far for
/// them.
- args: Vec<
Gc<ast::Expr>>,
+ args: Vec<
P<ast::Expr>>,
arg_types: Vec<Option<ArgumentType>>,
/// Parsed named expressions and the types that we've found for them so far.
/// Note that we keep a side-array of the ordering of the named arguments
/// found to be sure that we can translate them in the same order that they
/// were declared in.
- names: HashMap<String,
Gc<ast::Expr>>,
+ names: HashMap<String,
P<ast::Expr>>,
name_types: HashMap<String, ArgumentType>,
name_ordering: Vec<String>,
literal: String,
/// Collection of the compiled `rt::Argument` structures
- pieces: Vec<
Gc<ast::Expr>>,
+ pieces: Vec<
P<ast::Expr>>,
/// Collection of string literals
- str_pieces: Vec<
Gc<ast::Expr>>,
+ str_pieces: Vec<
P<ast::Expr>>,
/// Stays `true` if all formatting parameters are default (as in "{}{}").
all_pieces_simple: bool,
name_positions: HashMap<String, uint>,
- method_statics: Vec<
Gc<ast::Item>>,
+ method_statics: Vec<
P<ast::Item>>,
/// Updated as arguments are consumed or methods are entered
nest_level: uint,
}
pub enum Invocation {
- MethodCall(
Gc<ast::Expr>, ast::Ident),
+ MethodCall(
P<ast::Expr>, ast::Ident),
}
/// Parses the arguments from the given list of tokens, returning None
/// named arguments))
fn parse_args(ecx: &mut ExtCtxt, sp: Span, allow_method: bool,
tts: &[ast::TokenTree])
- -> (Invocation, Option<(
Gc<ast::Expr>, Vec<Gc<ast::Expr>>, Vec<String>,
- HashMap<String,
Gc<ast::Expr>>)>) {
+ -> (Invocation, Option<(
P<ast::Expr>, Vec<P<ast::Expr>>, Vec<String>,
+ HashMap<String,
P<ast::Expr>>)>) {
let mut args = Vec::new();
- let mut names = HashMap::<String,
Gc<ast::Expr>>::new();
+ let mut names = HashMap::<String,
P<ast::Expr>>::new();
let mut order = Vec::new();
let mut p = ecx.new_parser_from_tts(tts);
/// These attributes are applied to all statics that this syntax extension
/// will generate.
- fn static_attrs(
&self) -> Vec<ast::Attribute> {
+ fn static_attrs(
ecx: &ExtCtxt, fmtsp: Span) -> Vec<ast::Attribute> {
// Flag statics as `inline` so LLVM can merge duplicate globals as much
// as possible (which we're generating a whole lot of).
- let unnamed = self.ecx.meta_word(self.fmtsp, InternedString::new("inline"));
- let unnamed = self.ecx.attribute(self.fmtsp, unnamed);
+ let unnamed = ecx.meta_word(fmtsp, InternedString::new("inline"));
+ let unnamed = ecx.attribute(fmtsp, unnamed);
// Do not warn format string as dead code
- let dead_code = self.ecx.meta_word(self.fmtsp,
- InternedString::new("dead_code"));
- let allow_dead_code = self.ecx.meta_list(self.fmtsp,
- InternedString::new("allow"),
- vec!(dead_code));
- let allow_dead_code = self.ecx.attribute(self.fmtsp, allow_dead_code);
- return vec!(unnamed, allow_dead_code);
+ let dead_code = ecx.meta_word(fmtsp, InternedString::new("dead_code"));
+ let allow_dead_code = ecx.meta_list(fmtsp,
+ InternedString::new("allow"),
+ vec![dead_code]);
+ let allow_dead_code = ecx.attribute(fmtsp, allow_dead_code);
+ vec![unnamed, allow_dead_code]
}
- fn rtpath(&self, s: &str) -> Vec<ast::Ident> {
- vec!(self.ecx.ident_of("std"), self.ecx.ident_of("fmt"),
- self.ecx.ident_of("rt"), self.ecx.ident_of(s))
+ fn rtpath(ecx: &ExtCtxt, s: &str) -> Vec<ast::Ident> {
+ vec![ecx.ident_of("std"), ecx.ident_of("fmt"), ecx.ident_of("rt"), ecx.ident_of(s)]
}
- fn trans_count(&self, c: parse::Count) ->
Gc<ast::Expr> {
+ fn trans_count(&self, c: parse::Count) ->
P<ast::Expr> {
let sp = self.fmtsp;
match c {
parse::CountIs(i) => {
- self.ecx.expr_call_global(sp, self.rtpath("CountIs"),
+ self.ecx.expr_call_global(sp, Context::rtpath(self.ecx, "CountIs"),
vec!(self.ecx.expr_uint(sp, i)))
}
parse::CountIsParam(i) => {
- self.ecx.expr_call_global(sp, self.rtpath("CountIsParam"),
+ self.ecx.expr_call_global(sp, Context::rtpath(self.ecx, "CountIsParam"),
vec!(self.ecx.expr_uint(sp, i)))
}
parse::CountImplied => {
- let path = self.ecx.path_global(sp, self.rtpath("CountImplied"));
+ let path = self.ecx.path_global(sp, Context::rtpath(self.ecx,
+ "CountImplied"));
self.ecx.expr_path(path)
}
parse::CountIsNextParam => {
- let path = self.ecx.path_global(sp, self.rtpath("CountIsNextParam"));
+ let path = self.ecx.path_global(sp, Context::rtpath(self.ecx,
+ "CountIsNextParam"));
self.ecx.expr_path(path)
}
parse::CountIsName(n) => {
None => 0, // error already emitted elsewhere
};
let i = i + self.args.len();
- self.ecx.expr_call_global(sp, self.rtpath("CountIsParam"),
+ self.ecx.expr_call_global(sp, Context::rtpath(self.ecx, "CountIsParam"),
vec!(self.ecx.expr_uint(sp, i)))
}
}
}
/// Translate the accumulated string literals to a literal expression
- fn trans_literal_string(&mut self) ->
Gc<ast::Expr> {
+ fn trans_literal_string(&mut self) ->
P<ast::Expr> {
let sp = self.fmtsp;
let s = token::intern_and_get_ident(self.literal.as_slice());
self.literal.clear();
/// Translate a `parse::Piece` to a static `rt::Argument` or append
/// to the `literal` string.
- fn trans_piece(&mut self, piece: &parse::Piece) -> Option<
Gc<ast::Expr>> {
+ fn trans_piece(&mut self, piece: &parse::Piece) -> Option<
P<ast::Expr>> {
let sp = self.fmtsp;
match *piece {
parse::String(s) => {
let pos = match arg.position {
// These two have a direct mapping
parse::ArgumentNext => {
- let path = self.ecx.path_global(sp,
- self.rtpath("ArgumentNext"));
+ let path = self.ecx.path_global(sp, Context::rtpath(self.ecx,
+ "ArgumentNext"));
self.ecx.expr_path(path)
}
parse::ArgumentIs(i) => {
- self.ecx.expr_call_global(sp, self.rtpath("ArgumentIs"),
+ self.ecx.expr_call_global(sp, Context::rtpath(self.ecx, "ArgumentIs"),
vec!(self.ecx.expr_uint(sp, i)))
}
// Named arguments are converted to positional arguments at
None => 0, // error already emitted elsewhere
};
let i = i + self.args.len();
- self.ecx.expr_call_global(sp, self.rtpath("ArgumentIs"),
+ self.ecx.expr_call_global(sp, Context::rtpath(self.ecx, "ArgumentIs"),
vec!(self.ecx.expr_uint(sp, i)))
}
};
let fill = self.ecx.expr_lit(sp, ast::LitChar(fill));
let align = match arg.format.align {
parse::AlignLeft => {
- self.ecx.path_global(sp, self.rtpath("AlignLeft"))
+ self.ecx.path_global(sp, Context::rtpath(self.ecx, "AlignLeft"))
}
parse::AlignRight => {
- self.ecx.path_global(sp, self.rtpath("AlignRight"))
+ self.ecx.path_global(sp, Context::rtpath(self.ecx, "AlignRight"))
}
parse::AlignCenter => {
- self.ecx.path_global(sp, self.rtpath("AlignCenter"))
+ self.ecx.path_global(sp, Context::rtpath(self.ecx, "AlignCenter"))
}
parse::AlignUnknown => {
- self.ecx.path_global(sp, self.rtpath("AlignUnknown"))
+ self.ecx.path_global(sp, Context::rtpath(self.ecx, "AlignUnknown"))
}
};
let align = self.ecx.expr_path(align);
let flags = self.ecx.expr_uint(sp, arg.format.flags);
let prec = self.trans_count(arg.format.precision);
let width = self.trans_count(arg.format.width);
- let path = self.ecx.path_global(sp, self.rtpath("FormatSpec"));
+ let path = self.ecx.path_global(sp, Context::rtpath(self.ecx, "FormatSpec"));
let fmt = self.ecx.expr_struct(sp, path, vec!(
self.ecx.field_imm(sp, self.ecx.ident_of("fill"), fill),
self.ecx.field_imm(sp, self.ecx.ident_of("align"), align),
self.ecx.field_imm(sp, self.ecx.ident_of("precision"), prec),
self.ecx.field_imm(sp, self.ecx.ident_of("width"), width)));
- let path = self.ecx.path_global(sp, self.rtpath("Argument"));
+ let path = self.ecx.path_global(sp, Context::rtpath(self.ecx, "Argument"));
Some(self.ecx.expr_struct(sp, path, vec!(
self.ecx.field_imm(sp, self.ecx.ident_of("position"), pos),
self.ecx.field_imm(sp, self.ecx.ident_of("format"), fmt))))
}
}
- fn item_static_array(&self,
+ fn item_static_array(ecx: &mut ExtCtxt,
name: ast::Ident,
- pieces: Vec<
Gc<ast::Expr>>)
- -> ast::Stmt
- {
- let pieces_len = self.ecx.expr_uint(self.fmtsp, pieces.len());
- let fmt = self.ecx.expr_vec(self.fmtsp, pieces);
+ pieces: Vec<
P<ast::Expr>>)
+ -> P<ast::Stmt> {
+ let fmtsp = piece_ty.span;
+ let pieces_len = ecx.expr_uint(fmtsp, pieces.len());
+ let fmt = ecx.expr_vec(fmtsp, pieces);
let ty = ast::TyFixedLengthVec(
piece_ty,
pieces_len
);
- let ty = self.ecx.ty(self.fmtsp, ty);
+ let ty = ecx.ty(fmtsp, ty);
let st = ast::ItemStatic(ty, ast::MutImmutable, fmt);
- let item = self.ecx.item(self.fmtsp, name,
- self.static_attrs(), st);
- let decl = respan(self.fmtsp, ast::DeclItem(item));
- respan(self.fmtsp, ast::StmtDecl(box(GC) decl, ast::DUMMY_NODE_ID))
+ let item = ecx.item(fmtsp, name, Context::static_attrs(ecx, fmtsp), st);
+ let decl = respan(fmtsp, ast::DeclItem(item));
+ P(respan(fmtsp, ast::StmtDecl(P(decl), ast::DUMMY_NODE_ID)))
}
/// Actually builds the expression which the iformat! block will be expanded
/// to
- fn to_expr(
&self, invocation: Invocation) -> Gc<ast::Expr> {
+ fn to_expr(
mut self, invocation: Invocation) -> P<ast::Expr> {
let mut lets = Vec::new();
let mut locals = Vec::new();
let mut names = Vec::from_fn(self.name_positions.len(), |_| None);
let mut heads = Vec::new();
// First, declare all of our methods that are statics
- for &method in self.method_statics.iter() {
+ for method in self.method_statics.move_iter() {
let decl = respan(self.fmtsp, ast::DeclItem(method));
- lets.push(box(GC) respan(self.fmtsp,
- ast::StmtDecl(box(GC) decl, ast::DUMMY_NODE_ID)));
+ lets.push(P(respan(self.fmtsp,
+ ast::StmtDecl(P(decl), ast::DUMMY_NODE_ID))));
}
// Next, build up the static array which will become our precompiled
self.ecx.ty_ident(self.fmtsp, self.ecx.ident_of("str")),
Some(static_lifetime),
ast::MutImmutable);
- lets.push(box(GC) self.item_static_array(static_str_name,
- piece_ty,
- self.str_pieces.clone()));
+ lets.push(Context::item_static_array(self.ecx,
+ static_str_name,
+ piece_ty,
+ self.str_pieces));
// Then, build up the static array which will store our precompiled
// nonstandard placeholders, if there are any.
if !self.all_pieces_simple {
let piece_ty = self.ecx.ty_path(self.ecx.path_all(
self.fmtsp,
- true, self.rtpath("Argument"),
+ true, Context::rtpath(self.ecx, "Argument"),
vec![static_lifetime],
vec![]
), None);
- lets.push(box(GC) self.item_static_array(static_args_name,
- piece_ty,
- self.pieces.clone()));
+ lets.push(Context::item_static_array(self.ecx,
+ static_args_name,
+ piece_ty,
+ self.pieces));
}
// Right now there is a bug such that for the expression:
// format! string are shoved into locals. Furthermore, we shove the address
// of each variable because we don't want to move out of the arguments
// passed to this function.
- for (i, &e) in self.args.iter().enumerate() {
- if self.arg_types.get(i).is_none() {
- continue // error already generated
- }
+ for (i, e) in self.args.move_iter().enumerate() {
+ let arg_ty = match self.arg_types.get(i).as_ref() {
+ Some(ty) => ty,
+ None => continue // error already generated
+ };
let name = self.ecx.ident_of(format!("__arg{}", i).as_slice());
pats.push(self.ecx.pat_ident(e.span, name));
+ locals.push(Context::format_arg(self.ecx, e.span, arg_ty,
+ self.ecx.expr_ident(e.span, name)));
heads.push(self.ecx.expr_addr_of(e.span, e));
- locals.push(self.format_arg(e.span, Exact(i),
- self.ecx.expr_ident(e.span, name)));
}
for name in self.name_ordering.iter() {
- let e = match self.names.find(name) {
- Some(&e) if self.name_types.contains_key(name) => e,
- Some(..) | None => continue
+ let e = match self.names.pop(name) {
+ Some(e) => e,
+ None => continue
+ };
+ let arg_ty = match self.name_types.find(name) {
+ Some(ty) => ty,
+ None => continue
};
let lname = self.ecx.ident_of(format!("__arg{}",
*name).as_slice());
pats.push(self.ecx.pat_ident(e.span, lname));
- heads.push(self.ecx.expr_addr_of(e.span, e));
*names.get_mut(*self.name_positions.get(name)) =
- Some(self.format_arg(e.span,
- Named((*name).clone()),
- self.ecx.expr_ident(e.span, lname)));
+ Some(Context::format_arg(self.ecx, e.span, arg_ty,
+ self.ecx.expr_ident(e.span, lname)));
+ heads.push(self.ecx.expr_addr_of(e.span, e));
}
// Now create a vector containing all the arguments
let res = self.ecx.expr_ident(self.fmtsp, resname);
let result = match invocation {
Call(e) => {
- self.ecx.expr_call(e.span, e,
- vec!(self.ecx.expr_addr_of(e.span, res)))
+ let span = e.span;
+ self.ecx.expr_call(span, e,
+ vec!(self.ecx.expr_addr_of(span, res)))
}
MethodCall(e, m) => {
- self.ecx.expr_method_call(e.span, e, m,
- vec!(self.ecx.expr_addr_of(e.span, res)))
+ let span = e.span;
+ self.ecx.expr_method_call(span, e, m,
+ vec!(self.ecx.expr_addr_of(span, res)))
}
};
let body = self.ecx.expr_block(self.ecx.block(self.fmtsp, lets,
self.ecx.expr_match(self.fmtsp, head, vec!(arm))
}
- fn format_arg(&self, sp: Span, argno: Position, arg: Gc<ast::Expr>)
- -> Gc<ast::Expr> {
- let ty = match argno {
- Exact(ref i) => self.arg_types.get(*i).get_ref(),
- Named(ref s) => self.name_types.get(s)
- };
-
+ fn format_arg(ecx: &ExtCtxt, sp: Span,
+ ty: &ArgumentType, arg: P<ast::Expr>)
+ -> P<ast::Expr> {
let (krate, fmt_fn) = match *ty {
Known(ref tyname) => {
match tyname.as_slice() {
"x" => ("std", "secret_lower_hex"),
"X" => ("std", "secret_upper_hex"),
_ => {
- self.ecx
- .span_err(sp,
- format!("unknown format trait `{}`",
- *tyname).as_slice());
+ ecx.span_err(sp,
+ format!("unknown format trait `{}`",
+ *tyname).as_slice());
("std", "dummy")
}
}
}
String => {
- return self.ecx.expr_call_global(sp, vec!(
- self.ecx.ident_of("std"),
- self.ecx.ident_of("fmt"),
- self.ecx.ident_of("argumentstr")), vec!(arg))
+ return ecx.expr_call_global(sp, vec![
+ ecx.ident_of("std"),
+ ecx.ident_of("fmt"),
+ ecx.ident_of("argumentstr")], vec![arg])
}
Unsigned => {
- return self.ecx.expr_call_global(sp, vec!(
- self.ecx.ident_of("std"),
- self.ecx.ident_of("fmt"),
- self.ecx.ident_of("argumentuint")), vec!(arg))
+ return ecx.expr_call_global(sp, vec![
+ ecx.ident_of("std"),
+ ecx.ident_of("fmt"),
+ ecx.ident_of("argumentuint")], vec![arg])
}
};
- let format_fn = self.ecx.path_global(sp, vec!(
- self.ecx.ident_of(krate),
- self.ecx.ident_of("fmt"),
- self.ecx.ident_of(fmt_fn)));
- self.ecx.expr_call_global(sp, vec!(
- self.ecx.ident_of("std"),
- self.ecx.ident_of("fmt"),
- self.ecx.ident_of("argument")), vec!(self.ecx.expr_path(format_fn), arg))
+ let format_fn = ecx.path_global(sp, vec![
+ ecx.ident_of(krate),
+ ecx.ident_of("fmt"),
+ ecx.ident_of(fmt_fn)]);
+ ecx.expr_call_global(sp, vec![
+ ecx.ident_of("std"),
+ ecx.ident_of("fmt"),
+ ecx.ident_of("argument")], vec![ecx.expr_path(format_fn), arg])
}
}
/// expression.
pub fn expand_preparsed_format_args(ecx: &mut ExtCtxt, sp: Span,
invocation: Invocation,
- args: Vec<
Gc<ast::Expr>>,
+ args: Vec<
P<ast::Expr>>,
name_ordering: Vec<String>,
- names: HashMap<String, Gc<ast::Expr>>)
- -> Gc<ast::Expr>
-{
+ names: HashMap<String, P<ast::Expr>>)
+ -> P<ast::Expr> {
let arg_types = Vec::from_fn(args.len(), |_| None);
let mut cx = Context {
ecx: ecx,
}
match parser.errors.shift() {
Some(error) => {
- cx.ecx.span_err(efmt.span,
+ cx.ecx.span_err(cx.fmtsp,
format!("invalid format string: {}",
error).as_slice());
return DummyResult::raw_expr(sp);
use ext::build::AstBuilder;
use parse::token::*;
use parse::token;
-
-use std::gc::Gc;
+use ptr::P;
/**
*
use parse::token;
use parse;
use print::pprust;
+ use ptr::P;
use ast::{TokenTree, Generics, Expr};
pub use parse::new_parser_from_tts;
pub use codemap::{BytePos, Span, dummy_spanned};
- use std::gc::Gc;
-
pub trait ToTokens {
fn to_tokens(&self, _cx: &ExtCtxt) -> Vec<TokenTree> ;
}
}
macro_rules! impl_to_source(
- (Gc<$t:ty>, $pp:ident) => (
- impl ToSource for Gc<$t> {
+ (P<$t:ty>, $pp:ident) => (
+ impl ToSource for P<$t> {
fn to_source(&self) -> String {
pprust::$pp(&**self)
}
}
- impl ToSourceWithHygiene for Gc<$t> {
+ impl ToSourceWithHygiene for P<$t> {
fn to_source_with_hygiene(&self) -> String {
pprust::with_hygiene::$pp(&**self)
}
impl_to_source!(ast::Block, block_to_string)
impl_to_source!(ast::Arg, arg_to_string)
impl_to_source!(Generics, generics_to_string)
- impl_to_source!(
Gc<ast::Item>, item_to_string)
- impl_to_source!(
Gc<ast::Method>, method_to_string)
- impl_to_source!(
Gc<ast::Stmt>, stmt_to_string)
- impl_to_source!(
Gc<ast::Expr>, expr_to_string)
- impl_to_source!(
Gc<ast::Pat>, pat_to_string)
+ impl_to_source!(
P<ast::Item>, item_to_string)
+ impl_to_source!(
P<ast::Method>, method_to_string)
+ impl_to_source!(
P<ast::Stmt>, stmt_to_string)
+ impl_to_source!(
P<ast::Expr>, expr_to_string)
+ impl_to_source!(
P<ast::Pat>, pat_to_string)
impl_to_source!(ast::Arm, arm_to_string)
impl_to_source_slice!(ast::Ty, ", ")
- impl_to_source_slice!(
Gc<ast::Item>, "\n\n")
+ impl_to_source_slice!(
P<ast::Item>, "\n\n")
impl ToSource for ast::Attribute_ {
fn to_source(&self) -> String {
- pprust::attribute_to_string(&dummy_spanned(*self))
+ pprust::attribute_to_string(&dummy_spanned(self.clone()))
}
}
impl ToSourceWithHygiene for ast::Attribute_ {
)
impl_to_tokens!(ast::Ident)
- impl_to_tokens!(
Gc<ast::Item>)
- impl_to_tokens!(
Gc<ast::Pat>)
+ impl_to_tokens!(
P<ast::Item>)
+ impl_to_tokens!(
P<ast::Pat>)
impl_to_tokens!(ast::Arm)
- impl_to_tokens!(
Gc<ast::Method>)
- impl_to_tokens_lifetime!(&'a [
Gc<ast::Item>])
+ impl_to_tokens!(
P<ast::Method>)
+ impl_to_tokens_lifetime!(&'a [
P<ast::Item>])
impl_to_tokens!(ast::Ty)
impl_to_tokens_lifetime!(&'a [ast::Ty])
impl_to_tokens!(Generics)
- impl_to_tokens!(
Gc<ast::Stmt>)
- impl_to_tokens!(
Gc<ast::Expr>)
+ impl_to_tokens!(
P<ast::Stmt>)
+ impl_to_tokens!(
P<ast::Expr>)
impl_to_tokens!(ast::Block)
impl_to_tokens!(ast::Arg)
impl_to_tokens!(ast::Attribute_)
impl_to_tokens!(u64)
pub trait ExtParseUtils {
- fn parse_item(&self, s: String) ->
Gc<ast::Item>;
- fn parse_expr(&self, s: String) ->
Gc<ast::Expr>;
- fn parse_stmt(&self, s: String) ->
Gc<ast::Stmt>;
+ fn parse_item(&self, s: String) ->
P<ast::Item>;
+ fn parse_expr(&self, s: String) ->
P<ast::Expr>;
+ fn parse_stmt(&self, s: String) ->
P<ast::Stmt>;
fn parse_tts(&self, s: String) -> Vec<ast::TokenTree>;
}
impl<'a> ExtParseUtils for ExtCtxt<'a> {
- fn parse_item(&self, s: String) ->
Gc<ast::Item> {
+ fn parse_item(&self, s: String) ->
P<ast::Item> {
let res = parse::parse_item_from_source_str(
"<quote expansion>".to_string(),
s,
}
}
- fn parse_stmt(&self, s: String) ->
Gc<ast::Stmt> {
+ fn parse_stmt(&self, s: String) ->
P<ast::Stmt> {
parse::parse_stmt_from_source_str("<quote expansion>".to_string(),
s,
self.cfg(),
self.parse_sess())
}
- fn parse_expr(&self, s: String) ->
Gc<ast::Expr> {
+ fn parse_expr(&self, s: String) ->
P<ast::Expr> {
parse::parse_expr_from_source_str("<quote expansion>".to_string(),
s,
self.cfg(),
}
// Lift an ident to the expr that evaluates to that ident.
-fn mk_ident(cx: &ExtCtxt, sp: Span, ident: ast::Ident) ->
Gc<ast::Expr> {
+fn mk_ident(cx: &ExtCtxt, sp: Span, ident: ast::Ident) ->
P<ast::Expr> {
let e_str = cx.expr_str(sp, token::get_ident(ident));
cx.expr_method_call(sp,
cx.expr_ident(sp, id_ext("ext_cx")),
}
// Lift a name to the expr that evaluates to that name
-fn mk_name(cx: &ExtCtxt, sp: Span, ident: ast::Ident) ->
Gc<ast::Expr> {
+fn mk_name(cx: &ExtCtxt, sp: Span, ident: ast::Ident) ->
P<ast::Expr> {
let e_str = cx.expr_str(sp, token::get_ident(ident));
cx.expr_method_call(sp,
cx.expr_ident(sp, id_ext("ext_cx")),
vec!(e_str))
}
-fn mk_ast_path(cx: &ExtCtxt, sp: Span, name: &str) ->
Gc<ast::Expr> {
+fn mk_ast_path(cx: &ExtCtxt, sp: Span, name: &str) ->
P<ast::Expr> {
let idents = vec!(id_ext("syntax"), id_ext("ast"), id_ext(name));
cx.expr_path(cx.path_global(sp, idents))
}
-fn mk_token_path(cx: &ExtCtxt, sp: Span, name: &str) ->
Gc<ast::Expr> {
+fn mk_token_path(cx: &ExtCtxt, sp: Span, name: &str) ->
P<ast::Expr> {
let idents = vec!(id_ext("syntax"), id_ext("parse"), id_ext("token"), id_ext(name));
cx.expr_path(cx.path_global(sp, idents))
}
-fn mk_binop(cx: &ExtCtxt, sp: Span, bop: token::BinOp) ->
Gc<ast::Expr> {
+fn mk_binop(cx: &ExtCtxt, sp: Span, bop: token::BinOp) ->
P<ast::Expr> {
let name = match bop {
PLUS => "PLUS",
MINUS => "MINUS",
mk_token_path(cx, sp, name)
}
-fn mk_token(cx: &ExtCtxt, sp: Span, tok: &token::Token) ->
Gc<ast::Expr> {
+fn mk_token(cx: &ExtCtxt, sp: Span, tok: &token::Token) ->
P<ast::Expr> {
match *tok {
BINOP(binop) => {
}
-fn mk_tt(cx: &ExtCtxt, sp: Span, tt: &ast::TokenTree) -> Vec<
Gc<ast::Stmt>> {
+fn mk_tt(cx: &ExtCtxt, sp: Span, tt: &ast::TokenTree) -> Vec<
P<ast::Stmt>> {
match *tt {
ast::TTTok(sp, ref tok) => {
let e_sp = cx.expr_ident(sp, id_ext("_sp"));
}
fn mk_tts(cx: &ExtCtxt, sp: Span, tts: &[ast::TokenTree])
- -> Vec<
Gc<ast::Stmt>> {
let mut ss = Vec::new();
for tt in tts.iter() {
ss.push_all_move(mk_tt(cx, sp, tt));
}
fn expand_tts(cx: &ExtCtxt, sp: Span, tts: &[ast::TokenTree])
- -> (
Gc<ast::Expr>, Gc<ast::Expr>) {
+ -> (
P<ast::Expr>, P<ast::Expr>) {
// NB: It appears that the main parser loses its mind if we consider
// $foo as a TTNonterminal during the main parse, so we have to re-parse
// under quote_depth > 0. This is silly and should go away; the _guess_ is
fn expand_wrapper(cx: &ExtCtxt,
sp: Span,
- cx_expr:
Gc<ast::Expr>,
- expr:
Gc<ast::Expr>) -> Gc<ast::Expr> {
+ expr:
P<ast::Expr>) -> P<ast::Expr> {
let uses = [
&["syntax", "ext", "quote", "rt"],
].iter().map(|path| {
fn expand_parse_call(cx: &ExtCtxt,
sp: Span,
parse_method: &str,
- arg_exprs: Vec<Gc<ast::Expr>>,
- tts: &[ast::TokenTree]) ->
Gc<ast::Expr> {
+ arg_exprs: Vec<P<ast::Expr>> ,
+ tts: &[ast::TokenTree]) ->
P<ast::Expr> {
let (cx_expr, tts_expr) = expand_tts(cx, sp, tts);
let cfg_call = || cx.expr_method_call(
use parse::parser::{LifetimeAndTypesWithoutColons, Parser};
use parse::token::{Token, EOF, Nonterminal};
use parse::token;
+use ptr::P;
use std::rc::Rc;
-use std::gc::GC;
use std::collections::HashMap;
/* to avoid costly uniqueness checks, we require that `MatchSeq` always has a
"meta" => token::NtMeta(p.parse_meta_item()),
"tt" => {
p.quote_depth += 1u; //but in theory, non-quoted tts might be useful
- let res = token::NtTT(box(GC) p.parse_token_tree());
+ let res = token::NtTT(P(p.parse_token_tree()));
p.quote_depth -= 1u;
res
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use ast::{Ident, Matcher_, Matcher, MatchTok, MatchNonterminal, MatchSeq};
-use ast::{TTDelim};
+use ast::{Ident, Matcher_, Matcher, MatchTok, MatchNonterminal, MatchSeq, TTDelim};
use ast;
use codemap::{Span, Spanned, DUMMY_SP};
use ext::base::{ExtCtxt, MacResult, MacroDef};
use parse::token::{FAT_ARROW, SEMI, NtMatchers, NtTT, EOF};
use parse::token;
use print;
+use ptr::P;
+
use util::small_vector::SmallVector;
use std::cell::RefCell;
use std::rc::Rc;
-use std::gc::Gc;
struct ParserAnyMacro<'a> {
parser: RefCell<Parser<'a>>,
}
impl<'a> MacResult for ParserAnyMacro<'a> {
- fn make_expr(
&self) -> Option<Gc<ast::Expr>> {
+ fn make_expr(
self: Box<ParserAnyMacro<'a>>) -> Option<P<ast::Expr>> {
let ret = self.parser.borrow_mut().parse_expr();
self.ensure_complete_parse(true);
Some(ret)
}
- fn make_pat(
&self) -> Option<Gc<ast::Pat>> {
+ fn make_pat(
self: Box<ParserAnyMacro<'a>>) -> Option<P<ast::Pat>> {
let ret = self.parser.borrow_mut().parse_pat();
self.ensure_complete_parse(false);
Some(ret)
}
- fn make_items(
&self) -> Option<SmallVector<Gc<ast::Item>>> {
+ fn make_items(
self: Box<ParserAnyMacro<'a>>) -> Option<SmallVector<P<ast::Item>>> {
let mut ret = SmallVector::zero();
loop {
let mut parser = self.parser.borrow_mut();
Some(ret)
}
- fn make_methods(
&self) -> Option<SmallVector<Gc<ast::Method>>> {
+ fn make_methods(
self: Box<ParserAnyMacro<'a>>) -> Option<SmallVector<P<ast::Method>>> {
let mut ret = SmallVector::zero();
loop {
let mut parser = self.parser.borrow_mut();
Some(ret)
}
- fn make_stmt(
&self) -> Option<Gc<ast::Stmt>> {
+ fn make_stmt(
self: Box<ParserAnyMacro<'a>>) -> Option<P<ast::Stmt>> {
let attrs = self.parser.borrow_mut().parse_outer_attributes();
let ret = self.parser.borrow_mut().parse_stmt(attrs);
self.ensure_complete_parse(true);
}
struct MacroRulesDefiner {
- def: RefCell<Option<MacroDef>>
+ def: Option<MacroDef>
}
impl MacResult for MacroRulesDefiner {
- fn make_def(&self) -> Option<MacroDef> {
- Some(self.def.borrow_mut().take().expect("MacroRulesDefiner expanded twice"))
+ fn make_def(&mut self) -> Option<MacroDef> {
+ Some(self.def.take().expect("empty MacroRulesDefiner"))
}
}
Success(named_matches) => {
let rhs = match *rhses[i] {
// okay, what's your transcriber?
- MatchedNonterminal(NtTT(tt)) => {
- match *tt {
+ MatchedNonterminal(NtTT(ref tt)) => {
+ match **tt {
// cut off delimiters; don't parse 'em
TTDelim(ref tts) => {
(*tts).slice(1u,(*tts).len()-1u)
};
box MacroRulesDefiner {
- def: RefCell::new(Some(MacroDef {
+ def: Some(MacroDef {
name: token::get_ident(name).to_string(),
ext: NormalTT(exp, Some(sp))
- }))
+ })
} as Box<MacResult+'cx>
}
use std::fmt;
use std::default::Default;
use std::hash;
-use std::{mem, raw, ptr, slice};
+use std::{mem, raw, ptr, slice, vec};
use serialize::{Encodable, Decodable, Encoder, Decoder};
/// A non-growable owned slice. This would preferably become `~[T]`
self.as_slice().iter()
}
+ pub fn move_iter(self) -> vec::MoveItems<T> {
+ self.into_vec().move_iter()
+ }
+
pub fn map<U>(&self, f: |&T| -> U) -> OwnedSlice<U> {
self.iter().map(f).collect()
}
use parse::token;
use parse::parser::Parser;
use parse::token::INTERPOLATED;
-
-use std::gc::{Gc, GC};
+use ptr::P;
/// A parser that can parse attributes.
pub trait ParserAttr {
fn parse_attribute(&mut self, permit_inner: bool) -> ast::Attribute;
fn parse_inner_attrs_and_next(&mut self)
-> (Vec<ast::Attribute>, Vec<ast::Attribute>);
- fn parse_meta_item(&mut self) ->
Gc<ast::MetaItem>;
- fn parse_meta_seq(&mut self) -> Vec<
Gc<ast::MetaItem>>;
- fn parse_optional_meta(&mut self) -> Vec<
Gc<ast::MetaItem>>;
+ fn parse_meta_item(&mut self) ->
P<ast::MetaItem>;
+ fn parse_meta_seq(&mut self) -> Vec<
P<ast::MetaItem>>;
+ fn parse_optional_meta(&mut self) -> Vec<
P<ast::MetaItem>>;
}
impl<'a> ParserAttr for Parser<'a> {
/// matches meta_item = IDENT
/// | IDENT = lit
/// | IDENT meta_seq
- fn parse_meta_item(&mut self) -> Gc<ast::MetaItem> {
- match self.token {
- token::INTERPOLATED(token::NtMeta(e)) => {
+ fn parse_meta_item(&mut self) -> P<ast::MetaItem> {
+ let nt_meta = match self.token {
+ token::INTERPOLATED(token::NtMeta(ref e)) => {
+ Some(e.clone())
+ }
+ _ => None
+ };
+
+ match nt_meta {
+ Some(meta) => {
self.bump();
- return e
+ return meta;
}
- _ => {}
+ None => {}
}
let lo = self.span.lo;
}
}
let hi = self.span.hi;
- box(GC) spanned(lo, hi, ast::MetaNameValue(name, lit))
+ P(spanned(lo, hi, ast::MetaNameValue(name, lit)))
}
token::LPAREN => {
let inner_items = self.parse_meta_seq();
let hi = self.span.hi;
- box(GC) spanned(lo, hi, ast::MetaList(name, inner_items))
+ P(spanned(lo, hi, ast::MetaList(name, inner_items)))
}
_ => {
let hi = self.last_span.hi;
- box(GC) spanned(lo, hi, ast::MetaWord(name))
+ P(spanned(lo, hi, ast::MetaWord(name)))
}
}
}
/// matches meta_seq = ( COMMASEP(meta_item) )
- fn parse_meta_seq(&mut self) -> Vec<
Gc<ast::MetaItem>> {
+ fn parse_meta_seq(&mut self) -> Vec<
P<ast::MetaItem>> {
self.parse_seq(&token::LPAREN,
&token::RPAREN,
seq_sep_trailing_disallowed(token::COMMA),
|p| p.parse_meta_item()).node
}
- fn parse_optional_meta(&mut self) -> Vec<
Gc<ast::MetaItem>> {
+ fn parse_optional_meta(&mut self) -> Vec<
P<ast::MetaItem>> {
match self.token {
token::LPAREN => self.parse_meta_seq(),
_ => Vec::new()
// Predicates on exprs and stmts that the pretty-printer and parser use
use ast;
-use std::gc::Gc;
/// Does this expression require a semicolon to be treated
/// as a statement? The negation of this: 'can this expression
/// if true {...} else {...}
/// |x| 5
/// isn't parsed as (if true {...} else {...} | x) | 5
-pub fn expr_requires_semi_to_be_stmt(e: Gc<ast::Expr>) -> bool {
+pub fn expr_requires_semi_to_be_stmt(e: &ast::Expr) -> bool {
match e.node {
ast::ExprIf(..)
| ast::ExprMatch(..)
}
}
-pub fn expr_is_simple_block(e: Gc<ast::Expr>) -> bool {
+pub fn expr_is_simple_block(e: &ast::Expr) -> bool {
match e.node {
- ast::ExprBlock(block) => block.rules == ast::DefaultBlock,
- _ => false
+ ast::ExprBlock(ref block) => block.rules == ast::DefaultBlock,
+ _ => false
}
}
/// this statement requires a semicolon after it.
/// note that in one case (stmt_semi), we've already
/// seen the semicolon, and thus don't need another.
-pub fn stmt_ends_with_semi(stmt: &ast::Stmt) -> bool {
- return match stmt.node {
- ast::StmtDecl(d, _) => {
+pub fn stmt_ends_with_semi(stmt: &ast::Stmt_) -> bool {
+ match *stmt {
+ ast::StmtDecl(ref d, _) => {
match d.node {
ast::DeclLocal(_) => true,
ast::DeclItem(_) => false
}
}
- ast::StmtExpr(e, _) => { expr_requires_semi_to_be_stmt(e) }
+ ast::StmtExpr(ref e, _) => { expr_requires_semi_to_be_stmt(&**e) }
ast::StmtSemi(..) => { false }
ast::StmtMac(..) => { false }
}
use diagnostic::{SpanHandler, mk_span_handler, default_handler, Auto};
use parse::attr::ParserAttr;
use parse::parser::Parser;
+use ptr::P;
use std::cell::RefCell;
-use std::gc::Gc;
use std::io::File;
use std::rc::Rc;
use std::str;
source: String,
cfg: ast::CrateConfig,
sess: &ParseSess)
let mut p = new_parser_from_source_str(sess, cfg, name, source);
maybe_aborted(p.parse_expr(), p)
}
source: String,
cfg: ast::CrateConfig,
sess: &ParseSess)
- -> Option<
Gc<ast::Item>> {
+ -> Option<
P<ast::Item>> {
let mut p = new_parser_from_source_str(sess, cfg, name, source);
maybe_aborted(p.parse_item_with_outer_attributes(),p)
}
source: String,
cfg: ast::CrateConfig,
sess: &ParseSess)
let mut p = new_parser_from_source_str(sess, cfg, name, source);
maybe_aborted(p.parse_meta_item(),p)
}
cfg: ast::CrateConfig,
attrs: Vec<ast::Attribute> ,
sess: &ParseSess)
let mut p = new_parser_from_source_str(
sess,
cfg,
#[test] fn path_exprs_1() {
assert!(string_to_expr("a".to_string()) ==
- box(GC) ast::Expr{
+ P(ast::Expr{
id: ast::DUMMY_NODE_ID,
node: ast::ExprPath(ast::Path {
span: sp(0, 1),
),
}),
span: sp(0, 1)
- })
+ }))
}
#[test] fn path_exprs_2 () {
assert!(string_to_expr("::a::b".to_string()) ==
- box(GC) ast::Expr {
+ P(ast::Expr {
id: ast::DUMMY_NODE_ID,
node: ast::ExprPath(ast::Path {
span: sp(0, 6),
)
}),
span: sp(0, 6)
- })
+ }))
}
#[should_fail]
#[test] fn ret_expr() {
assert!(string_to_expr("return d".to_string()) ==
- box(GC) ast::Expr{
+ P(ast::Expr{
id: ast::DUMMY_NODE_ID,
- node:ast::ExprRet(Some(box(GC) ast::Expr{
+ node:ast::ExprRet(Some(P(ast::Expr{
id: ast::DUMMY_NODE_ID,
node:ast::ExprPath(ast::Path{
span: sp(7, 8),
),
}),
span:sp(7,8)
- })),
+ }))),
span:sp(0,8)
- })
+ }))
}
#[test] fn parse_stmt_1 () {
assert!(string_to_stmt("b;".to_string()) ==
- box(GC) Spanned{
- node: ast::StmtExpr(box(GC) ast::Expr {
+ P(Spanned{
+ node: ast::StmtExpr(P(ast::Expr {
id: ast::DUMMY_NODE_ID,
node: ast::ExprPath(ast::Path {
span:sp(0,1),
}
),
}),
- span: sp(0,1)},
+ span: sp(0,1)}),
ast::DUMMY_NODE_ID),
- span: sp(0,1)})
+ span: sp(0,1)}))
}
let sess = new_parse_sess();
let mut parser = string_to_parser(&sess, "b".to_string());
assert!(parser.parse_pat()
- == box(GC) ast::Pat{
+ == P(ast::Pat{
id: ast::DUMMY_NODE_ID,
node: ast::PatIdent(ast::BindByValue(ast::MutImmutable),
Spanned{ span:sp(0, 1),
node: str_to_ident("b")
},
None),
- span: sp(0,1)});
+ span: sp(0,1)}));
parser_done(parser);
}
// this test depends on the intern order of "fn" and "int"
assert!(string_to_item("fn a (b : int) { b; }".to_string()) ==
Some(
- box(GC) ast::Item{ident:str_to_ident("a"),
+ P(ast::Item{ident:str_to_ident("a"),
attrs:Vec::new(),
id: ast::DUMMY_NODE_ID,
node: ast::ItemFn(ast::P(ast::FnDecl {
}, None, ast::DUMMY_NODE_ID),
span:sp(10,13)
}),
- pat: box(GC) ast::Pat {
+ pat: P(ast::Pat {
id: ast::DUMMY_NODE_ID,
node: ast::PatIdent(
ast::BindByValue(ast::MutImmutable),
None
),
span: sp(6,7)
- },
+ }),
id: ast::DUMMY_NODE_ID
}),
output: ast::P(ast::Ty{id: ast::DUMMY_NODE_ID,
},
ast::P(ast::Block {
view_items: Vec::new(),
- stmts: vec!(box(GC) Spanned{
- node: ast::StmtSemi(box(GC) ast::Expr{
+ stmts: vec!(P(Spanned{
+ node: ast::StmtSemi(P(ast::Expr{
id: ast::DUMMY_NODE_ID,
node: ast::ExprPath(
ast::Path{
}
),
}),
- span: sp(17,18)},
+ span: sp(17,18)}),
ast::DUMMY_NODE_ID),
- span: sp(17,19)}),
+ span: sp(17,19)})),
expr: None,
id: ast::DUMMY_NODE_ID,
rules: ast::DefaultBlock, // no idea
span: sp(15,21),
})),
vis: ast::Inherited,
- span: sp(0,21)}));
+ span: sp(0,21)})));
}
#[test] fn parse_exprs () {
// just make sure that they parse....
string_to_expr("3 + 4".to_string());
- string_to_expr("a::z.froob(b,box(GC)(987+3))".to_string());
+ string_to_expr("a::z.froob(b,&(987+3))".to_string());
}
#[test] fn attrs_fix_bug () {
string_to_item("pub fn mk_file_writer(path: &Path, flags: &[FileFlag])
- -> Result<Gc<Writer>, String> {
+ -> Result<Box<Writer>, String> {
#[cfg(windows)]
fn wb() -> c_int {
(O_WRONLY | libc::consts::os::extra::O_BINARY) as c_int
use codemap::{Span, respan};
use parse::parser;
use parse::token;
-
-use std::gc::{Gc, GC};
+use ptr::P;
/// The specific types of unsupported syntax
#[deriving(PartialEq, Eq, Hash)]
fn obsolete(&mut self, sp: Span, kind: ObsoleteSyntax);
/// Reports an obsolete syntax non-fatal error, and returns
/// a placeholder expression
- fn obsolete_expr(&mut self, sp: Span, kind: ObsoleteSyntax) -> Gc<Expr>;
+ fn obsolete_expr(&mut self, sp: Span, kind: ObsoleteSyntax) -> P<Expr>;
fn report(&mut self,
sp: Span,
kind: ObsoleteSyntax,
/// Reports an obsolete syntax non-fatal error, and returns
/// a placeholder expression
- fn obsolete_expr(&mut self, sp: Span, kind: ObsoleteSyntax) -> Gc<Expr> {
+ fn obsolete_expr(&mut self, sp: Span, kind: ObsoleteSyntax) -> P<Expr> {
self.obsolete(sp, kind);
- self.mk_expr(sp.lo, sp.hi, ExprLit(box(GC) respan(sp, LitNil)))
+ self.mk_expr(sp.lo, sp.hi, ExprLit(P(respan(sp, LitNil))))
}
fn report(&mut self,
use ast::{LitNil, LitStr, LitInt, Local, LocalLet};
use ast::{MutImmutable, MutMutable, Mac_, MacInvocTT, Matcher, MatchNonterminal};
use ast::{MatchSeq, MatchTok, Method, MutTy, BiMul, Mutability};
-use ast::{MethodImplItem};
-use ast::{NamedField, UnNeg, NoReturn, UnNot, P, Pat, PatEnum};
-use ast::{PatIdent, PatLit, PatRange, PatRegion, PatStruct};
+use ast::{MethodImplItem, NamedField, UnNeg, NoReturn, UnNot};
+use ast::{Pat, PatEnum, PatIdent, PatLit, PatRange, PatRegion, PatStruct};
use ast::{PatTup, PatBox, PatWild, PatWildMulti, PatWildSingle};
use ast::{BiRem, RequiredMethod};
use ast::{RetStyle, Return, BiShl, BiShr, Stmt, StmtDecl};
use parse::token::{keywords, special_idents, token_to_binop};
use parse::token;
use parse::{new_sub_parser_from_file, ParseSess};
+use ptr::P;
use owned_slice::OwnedSlice;
use std::collections::HashSet;
use std::mem::replace;
+use std::mem;
use std::rc::Rc;
-use std::gc::{Gc, GC};
use std::iter;
#[allow(non_camel_case_types)]
/// Indicates a failure to parse any kind of item. The attributes are
/// returned.
IoviNone(Vec<Attribute>),
- IoviItem(Gc<Item>),
- IoviForeignItem(Gc<ForeignItem>),
+ IoviItem(P<Item>),
+ IoviForeignItem(P<ForeignItem>),
IoviViewItem(ViewItem)
}
($p:expr) => (
{
let found = match $p.token {
- INTERPOLATED(token::NtExpr(e)) => {
- Some(e)
+ INTERPOLATED(token::NtExpr(ref e)) => {
+ Some((*e).clone())
}
INTERPOLATED(token::NtPath(_)) => {
// FIXME: The following avoids an issue with lexical borrowck scopes,
let span = $p.span;
Some($p.mk_expr(span.lo, span.hi, ExprPath(pt)))
}
- INTERPOLATED(token::NtBlock(b)) => {
+ INTERPOLATED(token::NtBlock(_)) => {
+ // FIXME: The following avoids an issue with lexical borrowck scopes,
+ // but the clone is unfortunate.
+ let b = match $p.token {
+ INTERPOLATED(token::NtBlock(ref b)) => (*b).clone(),
+ _ => unreachable!()
+ };
let span = $p.span;
Some($p.mk_expr(span.lo, span.hi, ExprBlock(b)))
}
struct ParsedItemsAndViewItems {
attrs_remaining: Vec<Attribute>,
view_items: Vec<ViewItem>,
- items: Vec<Gc<Item>>,
- foreign_items: Vec<Gc<ForeignItem>>
+ items: Vec<P<Item>> ,
+ foreign_items: Vec<P<ForeignItem>>
}
/* ident is handled by common.rs */
/// Commit to parsing a complete expression `e` expected to be
/// followed by some token from the set edible + inedible. Recover
/// from anticipated input errors, discarding erroneous characters.
- pub fn commit_expr(&mut self, e: Gc<Expr>, edible: &[token::Token],
- inedible: &[token::Token]) {
+ pub fn commit_expr(&mut self, e: &Expr, edible: &[token::Token], inedible: &[token::Token]) {
debug!("commit_expr {:?}", e);
match e.node {
ExprPath(..) => {
self.expect_one_of(edible, inedible)
}
- pub fn commit_expr_expecting(&mut self, e: Gc<Expr>, edible: token::Token) {
+ pub fn commit_expr_expecting(&mut self, e: &Expr, edible: token::Token) {
self.commit_expr(e, &[edible], &[])
}
/// Commit to parsing a complete statement `s`, which expects to be
/// followed by some token from the set edible + inedible. Check
/// for recoverable input errors, discarding erroneous characters.
- pub fn commit_stmt(&mut self, s: Gc<Stmt>, edible: &[token::Token],
- inedible: &[token::Token]) {
- debug!("commit_stmt {:?}", s);
- let _s = s; // unused, but future checks might want to inspect `s`.
+ pub fn commit_stmt(&mut self, edible: &[token::Token], inedible: &[token::Token]) {
if self.last_token
.as_ref()
.map_or(false, |t| is_ident_or_path(&**t)) {
self.expect_one_of(edible, inedible)
}
- pub fn commit_stmt_expecting(&mut self, s: Gc<Stmt>, edible: token::Token) {
- self.commit_stmt(s, &[edible], &[])
+ pub fn commit_stmt_expecting(&mut self, edible: token::Token) {
+ self.commit_stmt(&[edible], &[])
}
pub fn parse_ident(&mut self) -> ast::Ident {
self.expect_keyword(keywords::Fn);
let (decl, lifetimes) = self.parse_ty_fn_decl(true);
- return TyBareFn(box(GC) BareFnTy {
+ TyBareFn(P(BareFnTy {
abi: abi,
fn_style: fn_style,
lifetimes: lifetimes,
decl: decl
- });
+ }))
}
/// Parses a procedure type (`proc`). The initial `proc` keyword must
cf: ret_style,
variadic: variadic
});
- TyProc(box(GC) ClosureTy {
+ TyProc(P(ClosureTy {
fn_style: NormalFn,
onceness: Once,
bounds: bounds,
decl: decl,
lifetimes: lifetime_defs,
- })
+ }))
}
/// Parses an optional unboxed closure kind (`&:`, `&mut:`, or `:`).
match optional_unboxed_closure_kind {
Some(unboxed_closure_kind) => {
- TyUnboxedFn(box(GC) UnboxedFnTy {
+ TyUnboxedFn(P(UnboxedFnTy {
kind: unboxed_closure_kind,
decl: decl,
- })
+ }))
}
None => {
- TyClosure(box(GC) ClosureTy {
+ TyClosure(P(ClosureTy {
fn_style: fn_style,
onceness: onceness,
bounds: bounds,
decl: decl,
lifetimes: lifetime_defs,
- })
+ }))
}
}
}
debug!("parse_trait_methods(): parsing provided method");
let (inner_attrs, body) =
p.parse_inner_attrs_and_block();
- let attrs = attrs.append(inner_attrs.as_slice());
- ProvidedMethod(box(GC) ast::Method {
+ let mut attrs = attrs;
+ attrs.extend(inner_attrs.move_iter());
+ ProvidedMethod(P(ast::Method {
attrs: attrs,
id: ast::DUMMY_NODE_ID,
span: mk_sp(lo, hi),
d,
body,
vis)
- })
+ }))
}
_ => {
if ts.len() == 1 && !one_tuple {
self.expect(&token::RPAREN);
- TyParen(*ts.get(0))
+ TyParen(ts.move_iter().nth(0).unwrap())
} else {
let t = TyTup(ts);
self.expect(&token::RPAREN);
}
}
- pub fn maybe_parse_fixed_vstore(&mut self) -> Option<
Gc<ast::Expr>> {
+ pub fn maybe_parse_fixed_vstore(&mut self) -> Option<
P<ast::Expr>> {
if self.token == token::COMMA &&
self.look_ahead(1, |t| *t == token::DOTDOT) {
self.bump();
}
/// matches '-' lit | lit
- pub fn parse_literal_maybe_minus(&mut self) -> Gc<Expr> {
+ pub fn parse_literal_maybe_minus(&mut self) -> P<Expr> {
let minus_lo = self.span.lo;
let minus_present = self.eat(&token::BINOP(token::MINUS));
let lo = self.span.lo;
- let literal = box(GC) self.parse_lit();
+ let literal = P(self.parse_lit());
let hi = self.span.hi;
let expr = self.mk_expr(lo, hi, ExprLit(literal));
let e = self.parse_expr();
ast::Field {
ident: spanned(lo, hi, i),
- expr: e,
span: mk_sp(lo, e.span.hi),
+ expr: e,
}
}
- pub fn mk_expr(&mut self, lo: BytePos, hi: BytePos, node: Expr_) -> Gc<Expr> {
- box(GC) Expr {
+ pub fn mk_expr(&mut self, lo: BytePos, hi: BytePos, node: Expr_) -> P<Expr> {
+ P(Expr {
id: ast::DUMMY_NODE_ID,
node: node,
span: mk_sp(lo, hi),
- }
+ })
}
- pub fn mk_unary(&mut self, unop: ast::UnOp, expr: Gc<Expr>) -> ast::Expr_ {
+ pub fn mk_unary(&mut self, unop: ast::UnOp, expr: P<Expr>) -> ast::Expr_ {
ExprUnary(unop, expr)
}
- pub fn mk_binary(&mut self, binop: ast::BinOp,
- lhs: Gc<Expr>, rhs: Gc<Expr>) -> ast::Expr_ {
+ pub fn mk_binary(&mut self, binop: ast::BinOp, lhs: P<Expr>, rhs: P<Expr>) -> ast::Expr_ {
ExprBinary(binop, lhs, rhs)
}
- pub fn mk_call(&mut self, f: Gc<Expr>, args: Vec<Gc<Expr>>) -> ast::Expr_ {
+ pub fn mk_call(&mut self, f: P<Expr>, args: Vec<P<Expr>>) -> ast::Expr_ {
ExprCall(f, args)
}
fn mk_method_call(&mut self,
ident: ast::SpannedIdent,
tps: Vec<P<Ty>>,
- args: Vec<Gc<Expr>>)
+ args: Vec<P<Expr>>)
-> ast::Expr_ {
ExprMethodCall(ident, tps, args)
}
- pub fn mk_index(&mut self, expr: Gc<Expr>, idx: Gc<Expr>) -> ast::Expr_ {
+ pub fn mk_index(&mut self, expr: P<Expr>, idx: P<Expr>) -> ast::Expr_ {
ExprIndex(expr, idx)
}
- pub fn mk_field(&mut self, expr: Gc<Expr>, ident: ast::SpannedIdent,
+ pub fn mk_field(&mut self, expr: P<Expr>, ident: ast::SpannedIdent,
tys: Vec<P<Ty>>) -> ast::Expr_ {
ExprField(expr, ident, tys)
}
- pub fn mk_tup_field(&mut self, expr: Gc<Expr>, idx: codemap::Spanned<uint>,
+ pub fn mk_tup_field(&mut self, expr: P<Expr>, idx: codemap::Spanned<uint>,
tys: Vec<P<Ty>>) -> ast::Expr_ {
ExprTupField(expr, idx, tys)
}
pub fn mk_assign_op(&mut self, binop: ast::BinOp,
- lhs: Gc<Expr>, rhs: Gc<Expr>) -> ast::Expr_ {
+ lhs: P<Expr>, rhs: P<Expr>) -> ast::Expr_ {
ExprAssignOp(binop, lhs, rhs)
}
- pub fn mk_mac_expr(&mut self, lo: BytePos, hi: BytePos, m: Mac_) -> Gc<Expr> {
- box(GC) Expr {
+ pub fn mk_mac_expr(&mut self, lo: BytePos, hi: BytePos, m: Mac_) -> P<Expr> {
+ P(Expr {
id: ast::DUMMY_NODE_ID,
node: ExprMac(codemap::Spanned {node: m, span: mk_sp(lo, hi)}),
span: mk_sp(lo, hi),
- }
+ })
}
- pub fn mk_lit_u32(&mut self, i: u32) -> Gc<Expr> {
+ pub fn mk_lit_u32(&mut self, i: u32) -> P<Expr> {
let span = &self.span;
- let lv_lit = box(GC) codemap::Spanned {
+ let lv_lit = P(codemap::Spanned {
node: LitInt(i as u64, ast::UnsignedIntLit(TyU32)),
span: *span
- };
+ });
- box(GC) Expr {
+ P(Expr {
id: ast::DUMMY_NODE_ID,
node: ExprLit(lv_lit),
span: *span,
- }
+ })
}
/// At the bottom (top?) of the precedence hierarchy,
/// parse things like parenthesized exprs,
/// macros, return, etc.
- pub fn parse_bottom_expr(&mut self) -> Gc<Expr> {
+ pub fn parse_bottom_expr(&mut self) -> P<Expr> {
maybe_whole_expr!(self);
let lo = self.span.lo;
if self.token == token::RPAREN {
hi = self.span.hi;
self.bump();
- let lit = box(GC) spanned(lo, hi, LitNil);
+ let lit = P(spanned(lo, hi, LitNil));
return self.mk_expr(lo, hi, ExprLit(lit));
}
let mut es = vec!(self.parse_expr());
- self.commit_expr(*es.last().unwrap(), &[], &[token::COMMA, token::RPAREN]);
+ self.commit_expr(&**es.last().unwrap(), &[], &[token::COMMA, token::RPAREN]);
while self.token == token::COMMA {
self.bump();
if self.token != token::RPAREN {
es.push(self.parse_expr());
- self.commit_expr(*es.last().unwrap(), &[], &[token::COMMA, token::RPAREN]);
- }
- else {
+ self.commit_expr(&**es.last().unwrap(), &[],
+ &[token::COMMA, token::RPAREN]);
+ } else {
trailing_comma = true;
}
}
hi = self.span.hi;
- self.commit_expr_expecting(*es.last().unwrap(), token::RPAREN);
+ self.commit_expr_expecting(&**es.last().unwrap(), token::RPAREN);
return if es.len() == 1 && !trailing_comma {
- self.mk_expr(lo, hi, ExprParen(*es.get(0)))
- }
- else {
+ self.mk_expr(lo, hi, ExprParen(es.move_iter().nth(0).unwrap()))
+ } else {
self.mk_expr(lo, hi, ExprTup(es))
}
},
let decl = self.parse_proc_decl();
let body = self.parse_expr();
let fakeblock = P(ast::Block {
+ id: ast::DUMMY_NODE_ID,
view_items: Vec::new(),
stmts: Vec::new(),
- expr: Some(body),
- id: ast::DUMMY_NODE_ID,
rules: DefaultBlock,
span: body.span,
+ expr: Some(body),
});
- return self.mk_expr(lo, body.span.hi, ExprProc(decl, fakeblock));
+ return self.mk_expr(lo, fakeblock.span.hi, ExprProc(decl, fakeblock));
}
if self.eat_keyword(keywords::If) {
return self.parse_if_expr();
}
fields.push(self.parse_field());
- self.commit_expr(fields.last().unwrap().expr,
+ self.commit_expr(&*fields.last().unwrap().expr,
&[token::COMMA],
&[token::RBRACE]);
}
// other literal expression
let lit = self.parse_lit();
hi = lit.span.hi;
- ex = ExprLit(box(GC) lit);
+ ex = ExprLit(P(lit));
}
}
}
/// Parse a block or unsafe block
pub fn parse_block_expr(&mut self, lo: BytePos, blk_mode: BlockCheckMode)
- -> Gc<Expr> {
+ -> P<Expr> {
self.expect(&token::LBRACE);
let blk = self.parse_block_tail(lo, blk_mode);
return self.mk_expr(blk.span.lo, blk.span.hi, ExprBlock(blk));
}
/// parse a.b or a(13) or a[4] or just a
- pub fn parse_dot_or_call_expr(&mut self) -> Gc<Expr> {
+ pub fn parse_dot_or_call_expr(&mut self) -> P<Expr> {
let b = self.parse_bottom_expr();
self.parse_dot_or_call_expr_with(b)
}
- pub fn parse_dot_or_call_expr_with(&mut self, e0: Gc<Expr>) -> Gc<Expr> {
+ pub fn parse_dot_or_call_expr_with(&mut self, e0: P<Expr>) -> P<Expr> {
let mut e = e0;
let lo = e.span.lo;
let mut hi;
}
continue;
}
- if self.expr_is_complete(e) { break; }
+ if self.expr_is_complete(&*e) { break; }
match self.token {
// expr(...)
token::LPAREN => {
self.bump();
let ix = self.parse_expr();
hi = self.span.hi;
- self.commit_expr_expecting(ix, token::RBRACKET);
+ self.commit_expr_expecting(&*ix, token::RBRACKET);
let index = self.mk_index(e, ix);
e = self.mk_expr(lo, hi, index)
}
}
/// Parse a prefix-operator expr
- pub fn parse_prefix_expr(&mut self) -> Gc<Expr> {
+ pub fn parse_prefix_expr(&mut self) -> P<Expr> {
let lo = self.span.lo;
let hi;
}
/// Parse an expression of binops
- pub fn parse_binops(&mut self) -> Gc<Expr> {
+ pub fn parse_binops(&mut self) -> P<Expr> {
let prefix_expr = self.parse_prefix_expr();
self.parse_more_binops(prefix_expr, 0)
}
/// Parse an expression of binops of at least min_prec precedence
- pub fn parse_more_binops(&mut self, lhs: Gc<Expr>,
- min_prec: uint) -> Gc<Expr> {
- if self.expr_is_complete(lhs) { return lhs; }
+ pub fn parse_more_binops(&mut self, lhs: P<Expr>, min_prec: uint) -> P<Expr> {
+ if self.expr_is_complete(&*lhs) { return lhs; }
// Prevent dynamic borrow errors later on by limiting the
// scope of the borrows.
- {
- let token: &token::Token = &self.token;
- let restriction: &restriction = &self.restriction;
- match (token, restriction) {
- (&token::BINOP(token::OR), &RESTRICT_NO_BAR_OP) => return lhs,
- (&token::BINOP(token::OR),
- &RESTRICT_NO_BAR_OR_DOUBLEBAR_OP) => return lhs,
- (&token::OROR, &RESTRICT_NO_BAR_OR_DOUBLEBAR_OP) => return lhs,
- _ => { }
- }
+ match (&self.token, &self.restriction) {
+ (&token::BINOP(token::OR), &RESTRICT_NO_BAR_OP) => return lhs,
+ (&token::BINOP(token::OR),
+ &RESTRICT_NO_BAR_OR_DOUBLEBAR_OP) => return lhs,
+ (&token::OROR, &RESTRICT_NO_BAR_OR_DOUBLEBAR_OP) => return lhs,
+ _ => { }
}
let cur_opt = token_to_binop(&self.token);
self.bump();
let expr = self.parse_prefix_expr();
let rhs = self.parse_more_binops(expr, cur_prec);
+ let lhs_span = lhs.span;
+ let rhs_span = rhs.span;
let binary = self.mk_binary(cur_op, lhs, rhs);
- let bin = self.mk_expr(lhs.span.lo, rhs.span.hi, binary);
+ let bin = self.mk_expr(lhs_span.lo, rhs_span.hi, binary);
self.parse_more_binops(bin, min_prec)
} else {
lhs
/// Parse an assignment expression....
/// actually, this seems to be the main entry point for
/// parsing an arbitrary expression.
- pub fn parse_assign_expr(&mut self) -> Gc<Expr> {
+ pub fn parse_assign_expr(&mut self) -> P<Expr> {
let lo = self.span.lo;
let lhs = self.parse_binops();
match self.token {
token::SHL => BiShl,
token::SHR => BiShr
};
+ let rhs_span = rhs.span;
let assign_op = self.mk_assign_op(aop, lhs, rhs);
- self.mk_expr(lo, rhs.span.hi, assign_op)
+ self.mk_expr(lo, rhs_span.hi, assign_op)
}
_ => {
lhs
}
/// Parse an 'if' expression ('if' token already eaten)
- pub fn parse_if_expr(&mut self) -> Gc<Expr> {
+ pub fn parse_if_expr(&mut self) -> P<Expr> {
let lo = self.last_span.lo;
let cond = self.parse_expr_res(RESTRICT_NO_STRUCT_LITERAL);
let thn = self.parse_block();
- let mut els: Option<Gc<Expr>> = None;
+ let mut els: Option<P<Expr>> = None;
let mut hi = thn.span.hi;
if self.eat_keyword(keywords::Else) {
let elexpr = self.parse_else_expr();
- els = Some(elexpr);
hi = elexpr.span.hi;
+ els = Some(elexpr);
}
self.mk_expr(lo, hi, ExprIf(cond, thn, els))
}
// `|args| expr`
pub fn parse_lambda_expr(&mut self, capture_clause: CaptureClause)
- -> Gc<Expr> {
+ -> P<Expr> {
let lo = self.span.lo;
let (decl, optional_unboxed_closure_kind) =
self.parse_fn_block_decl();
let body = self.parse_expr();
let fakeblock = P(ast::Block {
+ id: ast::DUMMY_NODE_ID,
view_items: Vec::new(),
stmts: Vec::new(),
+ span: body.span,
expr: Some(body),
- id: ast::DUMMY_NODE_ID,
rules: DefaultBlock,
- span: body.span,
});
match optional_unboxed_closure_kind {
Some(unboxed_closure_kind) => {
self.mk_expr(lo,
- body.span.hi,
+ fakeblock.span.hi,
ExprUnboxedFn(capture_clause,
unboxed_closure_kind,
decl,
}
None => {
self.mk_expr(lo,
- body.span.hi,
+ fakeblock.span.hi,
ExprFnBlock(capture_clause, decl, fakeblock))
}
}
}
- pub fn parse_else_expr(&mut self) -> Gc<Expr> {
+ pub fn parse_else_expr(&mut self) -> P<Expr> {
if self.eat_keyword(keywords::If) {
return self.parse_if_expr();
} else {
}
/// Parse a 'for' .. 'in' expression ('for' token already eaten)
- pub fn parse_for_expr(&mut self, opt_ident: Option<ast::Ident>) -> Gc<Expr> {
+ pub fn parse_for_expr(&mut self, opt_ident: Option<ast::Ident>) -> P<Expr> {
// Parse: `for <src_pat> in <src_expr> <src_loop_block>`
let lo = self.last_span.lo;
self.mk_expr(lo, hi, ExprForLoop(pat, expr, loop_block, opt_ident))
}
- pub fn parse_while_expr(&mut self, opt_ident: Option<ast::Ident>) -> Gc<Expr> {
+ pub fn parse_while_expr(&mut self, opt_ident: Option<ast::Ident>) -> P<Expr> {
let lo = self.last_span.lo;
let cond = self.parse_expr_res(RESTRICT_NO_STRUCT_LITERAL);
let body = self.parse_block();
return self.mk_expr(lo, hi, ExprWhile(cond, body, opt_ident));
}
- pub fn parse_loop_expr(&mut self, opt_ident: Option<ast::Ident>) -> Gc<Expr> {
+ pub fn parse_loop_expr(&mut self, opt_ident: Option<ast::Ident>) -> P<Expr> {
let lo = self.last_span.lo;
let body = self.parse_block();
let hi = body.span.hi;
self.mk_expr(lo, hi, ExprLoop(body, opt_ident))
}
- fn parse_match_expr(&mut self) -> Gc<Expr> {
+ fn parse_match_expr(&mut self) -> P<Expr> {
let lo = self.last_span.lo;
let discriminant = self.parse_expr_res(RESTRICT_NO_STRUCT_LITERAL);
- self.commit_expr_expecting(discriminant, token::LBRACE);
+ self.commit_expr_expecting(&*discriminant, token::LBRACE);
let mut arms: Vec<Arm> = Vec::new();
while self.token != token::RBRACE {
arms.push(self.parse_arm());
let expr = self.parse_expr_res(RESTRICT_STMT_EXPR);
let require_comma =
- !classify::expr_is_simple_block(expr)
+ !classify::expr_is_simple_block(&*expr)
&& self.token != token::RBRACE;
if require_comma {
- self.commit_expr(expr, &[token::COMMA], &[token::RBRACE]);
+ self.commit_expr(&*expr, &[token::COMMA], &[token::RBRACE]);
} else {
self.eat(&token::COMMA);
}
}
/// Parse an expression
- pub fn parse_expr(&mut self) -> Gc<Expr> {
+ pub fn parse_expr(&mut self) -> P<Expr> {
return self.parse_expr_res(UNRESTRICTED);
}
/// Parse an expression, subject to the given restriction
- pub fn parse_expr_res(&mut self, r: restriction) -> Gc<Expr> {
+ pub fn parse_expr_res(&mut self, r: restriction) -> P<Expr> {
let old = self.restriction;
self.restriction = r;
let e = self.parse_assign_expr();
}
/// Parse the RHS of a local variable declaration (e.g. '= 14;')
- fn parse_initializer(&mut self) -> Option<Gc<Expr>> {
+ fn parse_initializer(&mut self) -> Option<P<Expr>> {
if self.token == token::EQ {
self.bump();
Some(self.parse_expr())
}
/// Parse patterns, separated by '|' s
- fn parse_pats(&mut self) -> Vec<
Gc<Pat>> {
+ fn parse_pats(&mut self) -> Vec<
P<Pat>> {
let mut pats = Vec::new();
loop {
pats.push(self.parse_pat());
fn parse_pat_vec_elements(
&mut self,
- ) -> (Vec<Gc<Pat>> , Option<Gc<Pat>>, Vec<Gc<Pat>> ) {
+ ) -> (Vec<P<Pat>>, Option<P<Pat>>, Vec<P<Pat>>) {
let mut before = Vec::new();
let mut slice = None;
let mut after = Vec::new();
if self.token == token::COMMA ||
self.token == token::RBRACKET {
- slice = Some(box(GC) ast::Pat {
+ slice = Some(P(ast::Pat {
id: ast::DUMMY_NODE_ID,
node: PatWild(PatWildMulti),
span: self.span,
- });
+ }));
before_slice = false;
} else {
let _ = self.parse_pat();
self.parse_pat()
} else {
let fieldpath = codemap::Spanned{span:self.last_span, node: fieldname};
- box(GC) ast::Pat {
+ P(ast::Pat {
id: ast::DUMMY_NODE_ID,
node: PatIdent(bind_type, fieldpath, None),
span: self.last_span
- }
+ })
};
fields.push(ast::FieldPat { ident: fieldname, pat: subpat });
}
}
/// Parse a pattern.
- pub fn parse_pat(&mut self) ->
Gc<Pat> {
+ pub fn parse_pat(&mut self) ->
P<Pat> {
maybe_whole!(self, NtPat);
let lo = self.span.lo;
self.bump();
pat = PatWild(PatWildSingle);
hi = self.last_span.hi;
- return box(GC) ast::Pat {
+ return P(ast::Pat {
id: ast::DUMMY_NODE_ID,
node: pat,
span: mk_sp(lo, hi)
- }
+ })
}
token::TILDE => {
// parse ~pat
let last_span = self.last_span;
hi = last_span.hi;
self.obsolete(last_span, ObsoleteOwnedPattern);
- return box(GC) ast::Pat {
+ return P(ast::Pat {
id: ast::DUMMY_NODE_ID,
node: pat,
span: mk_sp(lo, hi)
- }
+ })
}
token::BINOP(token::AND) | token::ANDAND => {
// parse &pat
let sub = self.parse_pat();
pat = PatRegion(sub);
hi = self.last_span.hi;
- return box(GC) ast::Pat {
+ return P(ast::Pat {
id: ast::DUMMY_NODE_ID,
node: pat,
span: mk_sp(lo, hi)
- }
+ })
}
token::LPAREN => {
// parse (pat,pat,pat,...) as tuple
if self.token == token::RPAREN {
hi = self.span.hi;
self.bump();
- let lit = box(GC) codemap::Spanned {
+ let lit = P(codemap::Spanned {
node: LitNil,
- span: mk_sp(lo, hi)};
+ span: mk_sp(lo, hi)});
let expr = self.mk_expr(lo, hi, ExprLit(lit));
pat = PatLit(expr);
} else {
pat = PatTup(fields);
}
hi = self.last_span.hi;
- return box(GC) ast::Pat {
+ return P(ast::Pat {
id: ast::DUMMY_NODE_ID,
node: pat,
span: mk_sp(lo, hi)
- }
+ })
}
token::LBRACKET => {
// parse [pat,pat,...] as vector pattern
self.expect(&token::RBRACKET);
pat = ast::PatVec(before, slice, after);
hi = self.last_span.hi;
- return box(GC) ast::Pat {
+ return P(ast::Pat {
id: ast::DUMMY_NODE_ID,
node: pat,
span: mk_sp(lo, hi)
- }
+ })
}
_ => {}
}
let sub = self.parse_pat();
pat = PatBox(sub);
hi = self.last_span.hi;
- return box(GC) ast::Pat {
+ return P(ast::Pat {
id: ast::DUMMY_NODE_ID,
node: pat,
span: mk_sp(lo, hi)
- }
+ })
} else {
let can_be_enum_or_struct = self.look_ahead(1, |t| {
match *t {
pat = PatStruct(enum_path, fields, etc);
}
_ => {
- let mut args: Vec<
Gc<Pat>> = Vec::new();
+ let mut args: Vec<
P<Pat>> = Vec::new();
match self.token {
token::LPAREN => {
let is_dotdot = self.look_ahead(1, |t| {
}
}
hi = self.last_span.hi;
- box(GC) ast::Pat {
+ P(ast::Pat {
id: ast::DUMMY_NODE_ID,
node: pat,
span: mk_sp(lo, hi),
- }
+ })
}
/// Parse ident or ident @ pat
}
/// Parse a local variable declaration
- fn parse_local(&mut self) -> Gc<Local> {
+ fn parse_local(&mut self) -> P<Local> {
let lo = self.span.lo;
let pat = self.parse_pat();
ty = self.parse_ty(true);
}
let init = self.parse_initializer();
- box(GC) ast::Local {
+ P(ast::Local {
ty: ty,
pat: pat,
init: init,
id: ast::DUMMY_NODE_ID,
span: mk_sp(lo, self.last_span.hi),
source: LocalLet,
- }
+ })
}
/// Parse a "let" stmt
- fn parse_let(&mut self) -> Gc<Decl> {
+ fn parse_let(&mut self) -> P<Decl> {
let lo = self.span.lo;
let local = self.parse_local();
- box(GC) spanned(lo, self.last_span.hi, DeclLocal(local))
+ P(spanned(lo, self.last_span.hi, DeclLocal(local)))
}
/// Parse a structure field
/// Parse a statement. may include decl.
/// Precondition: any attributes are parsed already
- pub fn parse_stmt(&mut self, item_attrs: Vec<Attribute>) -> Gc<Stmt> {
+ pub fn parse_stmt(&mut self, item_attrs: Vec<Attribute>) -> P<Stmt> {
maybe_whole!(self, NtStmt);
fn check_expected_item(p: &mut Parser, found_attrs: bool) {
check_expected_item(self, !item_attrs.is_empty());
self.expect_keyword(keywords::Let);
let decl = self.parse_let();
- return box(GC) spanned(lo, decl.span.hi, StmtDecl(decl, ast::DUMMY_NODE_ID));
+ P(spanned(lo, decl.span.hi, StmtDecl(decl, ast::DUMMY_NODE_ID)))
} else if is_ident(&self.token)
&& !token::is_any_keyword(&self.token)
&& self.look_ahead(1, |t| *t == token::NOT) {
let hi = self.span.hi;
if id.name == token::special_idents::invalid.name {
- return box(GC) spanned(lo, hi, StmtMac(
- spanned(lo, hi, MacInvocTT(pth, tts, EMPTY_CTXT)), false));
+ P(spanned(lo, hi, StmtMac(
+ spanned(lo, hi, MacInvocTT(pth, tts, EMPTY_CTXT)), false)))
} else {
// if it has a special ident, it's definitely an item
- return box(GC) spanned(lo, hi, StmtDecl(
- box(GC) spanned(lo, hi, DeclItem(
+ P(spanned(lo, hi, StmtDecl(
+ P(spanned(lo, hi, DeclItem(
self.mk_item(
lo, hi, id /*id is good here*/,
ItemMac(spanned(lo, hi, MacInvocTT(pth, tts, EMPTY_CTXT))),
- Inherited, Vec::new(/*no attrs*/)))),
- ast::DUMMY_NODE_ID));
+ Inherited, Vec::new(/*no attrs*/))))),
+ ast::DUMMY_NODE_ID)))
}
} else {
match self.parse_item_or_view_item(item_attrs, false) {
IoviItem(i) => {
let hi = i.span.hi;
- let decl = box(GC) spanned(lo, hi, DeclItem(i));
- return box(GC) spanned(lo, hi, StmtDecl(decl, ast::DUMMY_NODE_ID));
+ let decl = P(spanned(lo, hi, DeclItem(i)));
+ P(spanned(lo, hi, StmtDecl(decl, ast::DUMMY_NODE_ID)))
}
IoviViewItem(vi) => {
self.span_fatal(vi.span,
IoviForeignItem(_) => {
self.fatal("foreign items are not allowed here");
}
- IoviNone(_) => { /* fallthrough */ }
- }
+ IoviNone(_) => {
+ check_expected_item(self, found_attrs);
- check_expected_item(self, found_attrs);
-
- // Remainder are line-expr stmts.
- let e = self.parse_expr_res(RESTRICT_STMT_EXPR);
- return box(GC) spanned(lo, e.span.hi, StmtExpr(e, ast::DUMMY_NODE_ID));
+ // Remainder are line-expr stmts.
+ let e = self.parse_expr_res(RESTRICT_STMT_EXPR);
+ P(spanned(lo, e.span.hi, StmtExpr(e, ast::DUMMY_NODE_ID)))
+ }
+ }
}
}
/// Is this expression a successfully-parsed statement?
- fn expr_is_complete(&mut self, e: Gc<Expr>) -> bool {
- return self.restriction == RESTRICT_STMT_EXPR &&
- !classify::expr_requires_semi_to_be_stmt(e);
+ fn expr_is_complete(&mut self, e: &Expr) -> bool {
+ self.restriction == RESTRICT_STMT_EXPR &&
+ !classify::expr_requires_semi_to_be_stmt(e)
}
/// Parse a block. No inner attrs are allowed.
} = self.parse_items_and_view_items(first_item_attrs,
false, false);
- for item in items.iter() {
- let decl = box(GC) spanned(item.span.lo, item.span.hi, DeclItem(*item));
- stmts.push(box(GC) spanned(item.span.lo, item.span.hi,
- StmtDecl(decl, ast::DUMMY_NODE_ID)));
+ for item in items.move_iter() {
+ let span = item.span;
+ let decl = P(spanned(span.lo, span.hi, DeclItem(item)));
+ stmts.push(P(spanned(span.lo, span.hi, StmtDecl(decl, ast::DUMMY_NODE_ID))));
}
let mut attributes_box = attrs_remaining;
_ => {
let stmt = self.parse_stmt(attributes_box);
attributes_box = Vec::new();
- match stmt.node {
+ stmt.and_then(|Spanned {node, span}| match node {
StmtExpr(e, stmt_id) => {
// expression without semicolon
- if classify::stmt_ends_with_semi(&*stmt) {
+ if classify::expr_requires_semi_to_be_stmt(&*e) {
// Just check for errors and recover; do not eat semicolon yet.
- self.commit_stmt(stmt, &[], &[token::SEMI, token::RBRACE]);
+ self.commit_stmt(&[], &[token::SEMI, token::RBRACE]);
}
match self.token {
token::SEMI => {
self.bump();
let span_with_semi = Span {
- lo: stmt.span.lo,
+ lo: span.lo,
hi: self.last_span.hi,
- expn_info: stmt.span.expn_info,
+ expn_info: span.expn_info,
};
- stmts.push(box(GC) codemap::Spanned {
+ stmts.push(P(Spanned {
node: StmtSemi(e, stmt_id),
span: span_with_semi,
- });
+ }));
}
token::RBRACE => {
expr = Some(e);
}
_ => {
- stmts.push(stmt);
+ stmts.push(P(Spanned {
+ node: StmtExpr(e, stmt_id),
+ span: span
+ }));
}
}
}
- StmtMac(ref m, _) => {
+ StmtMac(m, semi) => {
// statement macro; might be an expr
match self.token {
token::SEMI => {
+ stmts.push(P(Spanned {
+ node: StmtMac(m, true),
+ span: span,
+ }));
self.bump();
- stmts.push(box(GC) codemap::Spanned {
- node: StmtMac((*m).clone(), true),
- span: stmt.span,
- });
}
token::RBRACE => {
// if a block ends in `m!(arg)` without
// a `;`, it must be an expr
expr = Some(
- self.mk_mac_expr(stmt.span.lo,
- stmt.span.hi,
- m.node.clone()));
+ self.mk_mac_expr(span.lo,
+ span.hi,
+ m.node));
}
_ => {
- stmts.push(stmt);
+ stmts.push(P(Spanned {
+ node: StmtMac(m, semi),
+ span: span
+ }));
}
}
}
_ => { // all other kinds of statements:
- stmts.push(stmt.clone());
-
- if classify::stmt_ends_with_semi(&*stmt) {
- self.commit_stmt_expecting(stmt, token::SEMI);
+ if classify::stmt_ends_with_semi(&node) {
+ self.commit_stmt_expecting(token::SEMI);
}
+
+ stmts.push(P(Spanned {
+ node: node,
+ span: span
+ }));
}
- }
+ })
}
}
}
fn mk_item(&mut self, lo: BytePos, hi: BytePos, ident: Ident,
node: Item_, vis: Visibility,
- attrs: Vec<Attribute>) -> Gc<Item> {
- box(GC) Item {
+ attrs: Vec<Attribute>) -> P<Item> {
+ P(Item {
ident: ident,
attrs: attrs,
id: ast::DUMMY_NODE_ID,
node: node,
vis: vis,
span: mk_sp(lo, hi)
- }
+ })
}
/// Parse an item-position function declaration.
/// Parse a method in a trait impl, starting with `attrs` attributes.
pub fn parse_method(&mut self,
already_parsed_attrs: Option<Vec<Attribute>>)
- -> Gc<Method> {
+ -> P<Method> {
let next_attrs = self.parse_outer_attributes();
let attrs = match already_parsed_attrs {
Some(mut a) => { a.push_all_move(next_attrs); a }
});
self.parse_where_clause(&mut generics);
let (inner_attrs, body) = self.parse_inner_attrs_and_block();
+ let body_span = body.span;
let new_attrs = attrs.append(inner_attrs.as_slice());
(ast::MethDecl(ident,
generics,
decl,
body,
visa),
- body.span.hi, new_attrs)
+ body_span.hi, new_attrs)
}
};
- box(GC) ast::Method {
+ P(ast::Method {
attrs: new_attrs,
id: ast::DUMMY_NODE_ID,
span: mk_sp(lo, hi),
node: method_,
- }
+ })
}
/// Parse trait Foo { ... }
let _ = ast::DUMMY_NODE_ID; // FIXME: Workaround for crazy bug.
let new_id = ast::DUMMY_NODE_ID;
(class_name,
- ItemStruct(box(GC) ast::StructDef {
+ ItemStruct(P(ast::StructDef {
fields: fields,
ctor_id: if is_tuple_like { Some(new_id) } else { None },
super_struct: super_struct,
is_virtual: is_virtual,
- }, generics),
+ }), generics),
None)
}
items: starting_items,
..
} = self.parse_items_and_view_items(first_item_attrs, true, true);
- let mut items: Vec<Gc<Item>> = starting_items;
+ let mut items: Vec<P<Item>> = starting_items;
let attrs_remaining_len = attrs_remaining.len();
// don't think this other loop is even necessary....
let ty = self.parse_ty(true);
self.expect(&token::EQ);
let e = self.parse_expr();
- self.commit_expr_expecting(e, token::SEMI);
+ self.commit_expr_expecting(&*e, token::SEMI);
(id, ItemStatic(ty, m, e), None)
}
/// Parse a function declaration from a foreign module
fn parse_item_foreign_fn(&mut self, vis: ast::Visibility,
- attrs: Vec<Attribute>) -> Gc<ForeignItem> {
+ attrs: Vec<Attribute>) -> P<ForeignItem> {
let lo = self.span.lo;
self.expect_keyword(keywords::Fn);
self.parse_where_clause(&mut generics);
let hi = self.span.hi;
self.expect(&token::SEMI);
- box(GC) ast::ForeignItem { ident: ident,
- attrs: attrs,
- node: ForeignItemFn(decl, generics),
- id: ast::DUMMY_NODE_ID,
- span: mk_sp(lo, hi),
- vis: vis }
+ P(ast::ForeignItem {
+ ident: ident,
+ attrs: attrs,
+ node: ForeignItemFn(decl, generics),
+ id: ast::DUMMY_NODE_ID,
+ span: mk_sp(lo, hi),
+ vis: vis
+ })
}
/// Parse a static item from a foreign module
fn parse_item_foreign_static(&mut self, vis: ast::Visibility,
- attrs: Vec<Attribute> ) -> Gc<ForeignItem> {
+ attrs: Vec<Attribute>) -> P<ForeignItem> {
let lo = self.span.lo;
self.expect_keyword(keywords::Static);
let ty = self.parse_ty(true);
let hi = self.span.hi;
self.expect(&token::SEMI);
- box(GC) ast::ForeignItem {
+ P(ForeignItem {
ident: ident,
attrs: attrs,
node: ForeignItemStatic(ty, mutbl),
id: ast::DUMMY_NODE_ID,
span: mk_sp(lo, hi),
- vis: vis,
- }
+ vis: vis
+ })
}
/// Parse safe/unsafe and fn
/// Parse a structure-like enum variant definition
/// this should probably be renamed or refactored...
- fn parse_struct_def(&mut self) -> Gc<StructDef> {
+ fn parse_struct_def(&mut self) -> P<StructDef> {
let mut fields: Vec<StructField> = Vec::new();
while self.token != token::RBRACE {
fields.push(self.parse_struct_decl_field());
}
self.bump();
- return box(GC) ast::StructDef {
+ P(StructDef {
fields: fields,
ctor_id: None,
super_struct: None,
is_virtual: false,
- };
+ })
}
/// Parse the part of an "enum" decl following the '{'
attrs: Vec<Attribute> ,
macros_allowed: bool)
-> ItemOrViewItem {
- match self.token {
- INTERPOLATED(token::NtItem(item)) => {
+ let nt_item = match self.token {
+ INTERPOLATED(token::NtItem(ref item)) => {
+ Some((**item).clone())
+ }
+ _ => None
+ };
+ match nt_item {
+ Some(mut item) => {
self.bump();
- let new_attrs = attrs.append(item.attrs.as_slice());
- return IoviItem(box(GC) Item {
- attrs: new_attrs,
- ..(*item).clone()
- });
+ let mut attrs = attrs;
+ mem::swap(&mut item.attrs, &mut attrs);
+ item.attrs.extend(attrs.move_iter());
+ return IoviItem(P(item));
}
- _ => {}
+ None => {}
}
let lo = self.span.lo;
return IoviNone(attrs);
}
- pub fn parse_item_with_outer_attributes(&mut self) -> Option<Gc<Item>> {
+ pub fn parse_item_with_outer_attributes(&mut self) -> Option<P<Item>> {
let attrs = self.parse_outer_attributes();
self.parse_item(attrs)
}
- pub fn parse_item(&mut self, attrs: Vec<Attribute> ) -> Option<Gc<Item>> {
+ pub fn parse_item(&mut self, attrs: Vec<Attribute>) -> Option<P<Item>> {
match self.parse_item_or_view_item(attrs, true) {
IoviNone(_) => None,
IoviViewItem(_) =>
/// | MOD? non_global_path MOD_SEP LBRACE ident_seq RBRACE
/// | MOD? non_global_path MOD_SEP STAR
/// | MOD? non_global_path
- fn parse_view_path(&mut self) -> Gc<ViewPath> {
+ fn parse_view_path(&mut self) -> P<ViewPath> {
let lo = self.span.lo;
if self.token == token::LBRACE {
global: false,
segments: Vec::new()
};
- return box(GC) spanned(lo, self.span.hi,
- ViewPathList(path, idents, ast::DUMMY_NODE_ID));
+ return P(spanned(lo, self.span.hi,
+ ViewPathList(path, idents, ast::DUMMY_NODE_ID)));
}
let first_ident = self.parse_ident();
}
}).collect()
};
- return box(GC) spanned(lo, self.span.hi,
- ViewPathSimple(first_ident, path,
- ast::DUMMY_NODE_ID));
+ return P(spanned(lo, self.span.hi,
+ ViewPathSimple(first_ident, path,
+ ast::DUMMY_NODE_ID)));
}
token::MOD_SEP => {
}
}).collect()
};
- return box(GC) spanned(lo, self.span.hi,
- ViewPathList(path, idents, ast::DUMMY_NODE_ID));
+ return P(spanned(lo, self.span.hi,
+ ViewPathList(path, idents, ast::DUMMY_NODE_ID)));
}
// foo::bar::*
}
}).collect()
};
- return box(GC) spanned(lo, self.span.hi,
- ViewPathGlob(path, ast::DUMMY_NODE_ID));
+ return P(spanned(lo, self.span.hi,
+ ViewPathGlob(path, ast::DUMMY_NODE_ID)));
}
_ => break
if self.eat_keyword(keywords::As) {
rename_to = self.parse_ident()
}
- return box(GC) spanned(lo,
- self.last_span.hi,
- ViewPathSimple(rename_to, path, ast::DUMMY_NODE_ID));
+ P(spanned(lo, self.last_span.hi,
+ ViewPathSimple(rename_to, path, ast::DUMMY_NODE_ID)))
}
/// Parses a sequence of items. Stops when it finds program
// except according to those terms.
use ast;
-use ast::{P, Ident, Name, Mrk};
+use ast::{Ident, Name, Mrk};
use ext::mtwt;
use parse::token;
+use ptr::P;
use util::interner::{RcStr, StrInterner};
use util::interner;
use serialize::{Decodable, Decoder, Encodable, Encoder};
use std::fmt;
-use std::gc::Gc;
use std::mem;
use std::path::BytesContainer;
use std::rc::Rc;
#[deriving(Clone, Encodable, Decodable, PartialEq, Eq, Hash)]
/// For interpolation during macro expansion.
pub enum Nonterminal {
NtBlock(P<ast::Block>),
- NtTy( P<ast::Ty>),
/// See IDENT, above, for meaning of bool in NtIdent:
NtIdent(Box<Ident>, bool),
/// Stuff inside brackets for attributes
- NtMeta(
Gc<ast::MetaItem>),
+ NtMeta(
P<ast::MetaItem>),
NtPath(Box<ast::Path>),
- NtTT( Gc<ast::TokenTree>), // needs Gc'd to break a circularity
- NtMatchers(Vec<ast::Matcher> )
+ NtTT( P<ast::TokenTree>), // needs P'ed to break a circularity
+ NtMatchers(Vec<ast::Matcher>)
}
impl fmt::Show for Nonterminal {
use abi;
use ast::{FnMutUnboxedClosureKind, FnOnceUnboxedClosureKind};
-use ast::{FnUnboxedClosureKind, MethodImplItem, P};
+use ast::{FnUnboxedClosureKind, MethodImplItem};
use ast::{RegionTyParamBound, TraitTyParamBound, UnboxedClosureKind};
use ast::{UnboxedFnTyParamBound, RequiredMethod, ProvidedMethod};
use ast;
use print::pp::{break_offset, word, space, zerobreak, hardbreak};
use print::pp::{Breaks, Consistent, Inconsistent, eof};
use print::pp;
+use ptr::P;
-use std::gc::Gc;
use std::io::{IoResult, MemWriter};
use std::io;
use std::mem;
}
pub fn fun_to_string(decl: &ast::FnDecl, fn_style: ast::FnStyle, name: ast::Ident,
- opt_explicit_self: Option<ast::ExplicitSelf_>,
+ opt_explicit_self: Option<&ast::ExplicitSelf_>,
generics: &ast::Generics) -> String {
$to_string(|s| {
try!(s.print_fn(decl, Some(fn_style), abi::Rust,
$to_string(|s| s.print_literal(l))
}
-pub fn explicit_self_to_string(explicit_self: ast::ExplicitSelf_) -> String {
+pub fn explicit_self_to_string(explicit_self: &ast::ExplicitSelf_) -> String {
$to_string(|s| s.print_explicit_self(explicit_self, ast::MutImmutable).map(|_| {}))
}
}
pub fn commasep_exprs(&mut self, b: Breaks,
- exprs: &[
Gc<ast::Expr>]) -> IoResult<()> {
+ exprs: &[
P<ast::Expr>]) -> IoResult<()> {
self.commasep_cmnt(b, exprs, |s, e| s.print_expr(&**e), |e| e.span)
}
ast::TyTup(ref elts) => {
try!(self.popen());
try!(self.commasep(Inconsistent, elts.as_slice(),
- |s, ty| s.print_type_ref(ty)));
+ |s, ty| s.print_type(&**ty)));
if elts.len() == 1 {
try!(word(&mut self.s, ","));
}
try!(self.print_type(&**typ));
try!(self.pclose());
}
- ast::TyBareFn(f) => {
+ ast::TyBareFn(ref f) => {
let generics = ast::Generics {
lifetimes: f.lifetimes.clone(),
ty_params: OwnedSlice::empty(),
None,
None));
}
- ast::TyClosure(f) => {
+ ast::TyClosure(ref f) => {
let generics = ast::Generics {
lifetimes: f.lifetimes.clone(),
ty_params: OwnedSlice::empty(),
None,
None));
}
- ast::TyUnboxedFn(f) => {
+ ast::TyUnboxedFn(ref f) => {
try!(self.print_ty_fn(None,
None,
ast::NormalFn,
self.end()
}
- pub fn print_type_ref(&mut self, ty: &P<ast::Ty>) -> IoResult<()> {
- self.print_type(&**ty)
- }
-
pub fn print_foreign_item(&mut self,
item: &ast::ForeignItem) -> IoResult<()> {
try!(self.hardbreak_if_not_bol());
if struct_def.is_virtual {
try!(self.word_space("virtual"));
}
- try!(self.head(visibility_qualified(item.vis,
- "struct").as_slice()));
- try!(self.print_struct(&**struct_def, generics, item.ident,
- item.span));
+ try!(self.head(visibility_qualified(item.vis,"struct").as_slice()));
+ try!(self.print_struct(&**struct_def, generics, item.ident, item.span));
}
ast::ItemImpl(ref generics,
try!(self.print_inner_attributes(item.attrs.as_slice()));
for impl_item in impl_items.iter() {
match *impl_item {
- ast::MethodImplItem(meth) => {
- try!(self.print_method(&*meth));
+ ast::MethodImplItem(ref meth) => {
+ try!(self.print_method(&**meth));
}
}
}
Some(m.ident),
&OwnedSlice::empty(),
Some(&m.generics),
- Some(m.explicit_self.node),
+ Some(&m.explicit_self.node),
None));
word(&mut self.s, ";")
}
abi,
ref explicit_self,
fn_style,
- decl,
- body,
+ ref decl,
+ ref body,
vis) => {
- try!(self.print_fn(&*decl,
+ try!(self.print_fn(&**decl,
Some(fn_style),
abi,
ident,
generics,
- Some(explicit_self.node),
+ Some(&explicit_self.node),
vis));
try!(word(&mut self.s, " "));
- self.print_block_with_attrs(&*body, meth.attrs.as_slice())
+ self.print_block_with_attrs(&**body, meth.attrs.as_slice())
},
ast::MethMac(codemap::Spanned { node: ast::MacInvocTT(ref pth, ref tts, _),
..}) => {
}
}
}
- if parse::classify::stmt_ends_with_semi(st) {
+ if parse::classify::stmt_ends_with_semi(&st.node) {
try!(word(&mut self.s, ";"));
}
self.maybe_print_trailing_comment(st.span, None)
self.ann.post(self, NodeBlock(blk))
}
- fn print_else(&mut self, els: Option<Gc<ast::Expr>>) -> IoResult<()> {
+ fn print_else(&mut self, els: Option<&ast::Expr>) -> IoResult<()> {
match els {
Some(_else) => {
match _else.node {
// "another else-if"
- ast::ExprIf(ref i, ref t, e) => {
+ ast::ExprIf(ref i, ref then, ref e) => {
try!(self.cbox(indent_unit - 1u));
try!(self.ibox(0u));
try!(word(&mut self.s, " else if "));
try!(self.print_expr(&**i));
try!(space(&mut self.s));
- try!(self.print_block(&**t));
- self.print_else(e)
+ try!(self.print_block(&**then));
+ self.print_else(e.as_ref().map(|e| &**e))
}
// "final else"
ast::ExprBlock(ref b) => {
}
pub fn print_if(&mut self, test: &ast::Expr, blk: &ast::Block,
- elseopt: Option<Gc<ast::Expr>>, chk: bool) -> IoResult<()> {
+ elseopt: Option<&ast::Expr>, chk: bool) -> IoResult<()> {
try!(self.head("if"));
if chk { try!(self.word_nbsp("check")); }
try!(self.print_expr(test));
}
- fn print_call_post(&mut self, args: &[
Gc<ast::Expr>]) -> IoResult<()> {
+ fn print_call_post(&mut self, args: &[
P<ast::Expr>]) -> IoResult<()> {
try!(self.popen());
try!(self.commasep_exprs(Inconsistent, args));
self.pclose()
try!(self.end());
}
- ast::ExprStruct(ref path, ref fields, wth) => {
+ ast::ExprStruct(ref path, ref fields, ref wth) => {
try!(self.print_path(path, true));
try!(word(&mut self.s, "{"));
try!(self.commasep_cmnt(
s.end()
},
|f| f.span));
- match wth {
+ match *wth {
Some(ref expr) => {
try!(self.ibox(indent_unit));
if !fields.is_empty() {
if tys.len() > 0u {
try!(word(&mut self.s, "::<"));
try!(self.commasep(Inconsistent, tys.as_slice(),
- |s, ty| s.print_type_ref(ty)));
+ |s, ty| s.print_type(&**ty)));
try!(word(&mut self.s, ">"));
}
try!(self.print_call_post(base_args));
try!(self.word_space("as"));
try!(self.print_type(&**ty));
}
- ast::ExprIf(ref test, ref blk, elseopt) => {
- try!(self.print_if(&**test, &**blk, elseopt, false));
+ ast::ExprIf(ref test, ref blk, ref elseopt) => {
+ try!(self.print_if(&**test, &**blk, elseopt.as_ref().map(|e| &**e), false));
}
ast::ExprWhile(ref test, ref blk, opt_ident) => {
for ident in opt_ident.iter() {
try!(self.print_block_unclosed(&**body));
} else {
// we extract the block, so as not to create another set of boxes
- match body.expr.unwrap().node {
- ast::ExprBlock(blk) => {
- try!(self.print_block_unclosed(&*blk));
+ match body.expr.as_ref().unwrap().node {
+ ast::ExprBlock(ref blk) => {
+ try!(self.print_block_unclosed(&**blk));
}
_ => {
// this is a bare expression
- try!(self.print_expr(&*body.expr.unwrap()));
+ try!(self.print_expr(&**body.expr.as_ref().unwrap()));
try!(self.end()); // need to close a box
}
}
try!(self.print_block_unclosed(&**body));
} else {
// we extract the block, so as not to create another set of boxes
- match body.expr.unwrap().node {
+ match body.expr.as_ref().unwrap().node {
ast::ExprBlock(ref blk) => {
try!(self.print_block_unclosed(&**blk));
}
_ => {
// this is a bare expression
- try!(self.print_expr(&*body.expr.unwrap()));
+ try!(self.print_expr(body.expr.as_ref().map(|e| &**e).unwrap()));
try!(self.end()); // need to close a box
}
}
assert!(body.stmts.is_empty());
assert!(body.expr.is_some());
// we extract the block, so as not to create another set of boxes
- match body.expr.unwrap().node {
+ match body.expr.as_ref().unwrap().node {
ast::ExprBlock(ref blk) => {
try!(self.print_block_unclosed(&**blk));
}
_ => {
// this is a bare expression
- try!(self.print_expr(&*body.expr.unwrap()));
+ try!(self.print_expr(body.expr.as_ref().map(|e| &**e).unwrap()));
try!(self.end()); // need to close a box
}
}
try!(word(&mut self.s, "::<"));
try!(self.commasep(
Inconsistent, tys.as_slice(),
- |s, ty| s.print_type_ref(ty)));
+ |s, ty| s.print_type(&**ty)));
try!(word(&mut self.s, ">"));
}
}
try!(word(&mut self.s, "::<"));
try!(self.commasep(
Inconsistent, tys.as_slice(),
- |s, ty| s.print_type_ref(ty)));
+ |s, ty| s.print_type(&**ty)));
try!(word(&mut self.s, ">"));
}
}
try!(self.commasep(
Inconsistent,
segment.types.as_slice(),
- |s, ty| s.print_type_ref(ty)));
+ |s, ty| s.print_type(&**ty)));
}
try!(word(&mut self.s, ">"))
match pat.node {
ast::PatWild(ast::PatWildSingle) => try!(word(&mut self.s, "_")),
ast::PatWild(ast::PatWildMulti) => try!(word(&mut self.s, "..")),
- ast::PatIdent(binding_mode, ref path1, sub) => {
+ ast::PatIdent(binding_mode, ref path1, ref sub) => {
match binding_mode {
ast::BindByRef(mutbl) => {
try!(self.word_nbsp("ref"));
}
}
try!(self.print_ident(path1.node));
- match sub {
+ match *sub {
Some(ref p) => {
try!(word(&mut self.s, "@"));
try!(self.print_pat(&**p));
try!(word(&mut self.s, ".."));
try!(self.print_expr(&**end));
}
- ast::PatVec(ref before, slice, ref after) => {
+ ast::PatVec(ref before, ref slice, ref after) => {
try!(word(&mut self.s, "["));
try!(self.commasep(Inconsistent,
before.as_slice(),
// Returns whether it printed anything
fn print_explicit_self(&mut self,
- explicit_self: ast::ExplicitSelf_,
+ explicit_self: &ast::ExplicitSelf_,
mutbl: ast::Mutability) -> IoResult<bool> {
try!(self.print_mutability(mutbl));
- match explicit_self {
+ match *explicit_self {
ast::SelfStatic => { return Ok(false); }
ast::SelfValue(_) => {
try!(word(&mut self.s, "self"));
abi: abi::Abi,
name: ast::Ident,
generics: &ast::Generics,
- opt_explicit_self: Option<ast::ExplicitSelf_>,
+ opt_explicit_self: Option<&ast::ExplicitSelf_>,
vis: ast::Visibility) -> IoResult<()> {
try!(self.head(""));
try!(self.print_fn_header_info(opt_explicit_self, fn_style, abi, vis));
}
pub fn print_fn_args(&mut self, decl: &ast::FnDecl,
- opt_explicit_self: Option<ast::ExplicitSelf_>)
+ opt_explicit_self: Option<&ast::ExplicitSelf_>)
-> IoResult<()> {
// It is unfortunate to duplicate the commasep logic, but we want the
// self type and the args all in the same box.
let mut first = true;
for &explicit_self in opt_explicit_self.iter() {
let m = match explicit_self {
- ast::SelfStatic => ast::MutImmutable,
+ &ast::SelfStatic => ast::MutImmutable,
_ => match decl.inputs.get(0).pat.node {
ast::PatIdent(ast::BindByValue(m), _, _) => m,
_ => ast::MutImmutable
}
pub fn print_fn_args_and_ret(&mut self, decl: &ast::FnDecl,
- opt_explicit_self: Option<ast::ExplicitSelf_>)
+ opt_explicit_self: Option<&ast::ExplicitSelf_>)
-> IoResult<()> {
try!(self.popen());
try!(self.print_fn_args(decl, opt_explicit_self));
id: Option<ast::Ident>,
bounds: &OwnedSlice<ast::TyParamBound>,
generics: Option<&ast::Generics>,
- opt_explicit_self: Option<ast::ExplicitSelf_>,
+ opt_explicit_self: Option<&ast::ExplicitSelf_>,
opt_unboxed_closure_kind:
Option<ast::UnboxedClosureKind>)
-> IoResult<()> {
}
pub fn print_fn_header_info(&mut self,
- _opt_explicit_self: Option<ast::ExplicitSelf_>,
+ _opt_explicit_self: Option<&ast::ExplicitSelf_>,
opt_fn_style: Option<ast::FnStyle>,
abi: abi::Abi,
vis: ast::Visibility) -> IoResult<()> {
// except according to those terms.
use ast;
+use ast::P;
use parse::{new_parse_sess};
use parse::{ParseSess,string_to_filemap,filemap_to_tts};
use parse::{new_parser_from_source_str};
}
/// Parse a string, return an expr
-pub fn string_to_expr (source_str : String) ->
Gc<ast::Expr> {
+pub fn string_to_expr (source_str : String) ->
P<ast::Expr> {
with_error_checking_parse(source_str, |p| {
p.parse_expr()
})
}
/// Parse a string, return an item
-pub fn string_to_item (source_str : String) -> Option<
Gc<ast::Item>> {
+pub fn string_to_item (source_str : String) -> Option<
P<ast::Item>> {
with_error_checking_parse(source_str, |p| {
p.parse_item(Vec::new())
})
}
/// Parse a string, return a stmt
-pub fn string_to_stmt(source_str : String) ->
Gc<ast::Stmt> {
+pub fn string_to_stmt(source_str : String) ->
P<ast::Stmt> {
with_error_checking_parse(source_str, |p| {
p.parse_stmt(Vec::new())
})
/// Parse a string, return a pat. Uses "irrefutable"... which doesn't
/// (currently) affect parsing.
-pub fn string_to_pat(source_str: String) ->
Gc<ast::Pat> {
+pub fn string_to_pat(source_str: String) ->
P<ast::Pat> {
string_to_parser(&new_parse_sess(), source_str).parse_pat()
}
use ast::*;
use ast;
use codemap::Span;
+use ptr::P;
use owned_slice::OwnedSlice;
-use std::gc::Gc;
-
pub enum FnKind<'a> {
/// fn foo() or extern "Abi" fn foo()
FkItemFn(Ident, &'a Generics, FnStyle, Abi),
match *item {
IIItem(ref i) => visitor.visit_item(&**i),
IIForeign(ref i) => visitor.visit_foreign_item(&**i),
- IITraitItem(_, ref iti) => {
- match *iti {
- ProvidedInlinedTraitItem(ref m) => {
- walk_method_helper(visitor, &**m)
- }
- RequiredInlinedTraitItem(ref m) => {
- walk_method_helper(visitor, &**m)
- }
- }
- }
+ IITraitItem(_, ref ti) => visitor.visit_trait_item(ti),
+ IIImplItem(_, MethodImplItem(ref m)) => walk_method_helper(visitor, &**m)
}
}
}
pub fn walk_expr_opt<'v, V: Visitor<'v>>(visitor: &mut V,
- optional_expression: &'v Option<Gc<Expr>>) {
+ optional_expression: &'v Option<P<Expr>>) {
match *optional_expression {
None => {}
Some(ref expression) => visitor.visit_expr(&**expression),
}
}
-pub fn walk_exprs<'v, V: Visitor<'v>>(visitor: &mut V, expressions: &'v [Gc<Expr>]) {
+pub fn walk_exprs<'v, V: Visitor<'v>>(visitor: &mut V, expressions: &'v [P<Expr>]) {
for expression in expressions.iter() {
visitor.visit_expr(&**expression)
}
projects / rust.git / commitdiff