syntax: Move the AST from @T to Gc<T>
This commit is contained in:
Alex Crichton
parent
531ed3d599
commit
53ad426e92
41 changed files with 1269 additions and 1158 deletions
|
|
@ -21,6 +21,8 @@ use parse::token::special_idents;
|
|||
use parse::token::InternedString;
|
||||
use parse::token;
|
||||
|
||||
use std::gc::Gc;
|
||||
|
||||
// Transitional reexports so qquote can find the paths it is looking for
|
||||
mod syntax {
|
||||
pub use ext;
|
||||
|
|
@ -73,115 +75,129 @@ pub trait AstBuilder {
|
|||
fn lifetime(&self, span: Span, ident: ast::Name) -> ast::Lifetime;
|
||||
|
||||
// statements
|
||||
fn stmt_expr(&self, expr: @ast::Expr) -> @ast::Stmt;
|
||||
fn stmt_let(&self, sp: Span, mutbl: bool, ident: ast::Ident, ex: @ast::Expr) -> @ast::Stmt;
|
||||
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_let_typed(&self,
|
||||
sp: Span,
|
||||
mutbl: bool,
|
||||
ident: ast::Ident,
|
||||
typ: P<ast::Ty>,
|
||||
ex: @ast::Expr)
|
||||
-> @ast::Stmt;
|
||||
ex: Gc<ast::Expr>)
|
||||
-> Gc<ast::Stmt>;
|
||||
|
||||
// blocks
|
||||
fn block(&self, span: Span, stmts: Vec<@ast::Stmt> , expr: Option<@ast::Expr>) -> P<ast::Block>;
|
||||
fn block_expr(&self, expr: @ast::Expr) -> P<ast::Block>;
|
||||
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_all(&self, span: Span,
|
||||
view_items: Vec<ast::ViewItem> ,
|
||||
stmts: Vec<@ast::Stmt> ,
|
||||
expr: Option<@ast::Expr>) -> P<ast::Block>;
|
||||
stmts: Vec<Gc<ast::Stmt>> ,
|
||||
expr: Option<Gc<ast::Expr>>) -> P<ast::Block>;
|
||||
|
||||
// expressions
|
||||
fn expr(&self, span: Span, node: ast::Expr_) -> @ast::Expr;
|
||||
fn expr_path(&self, path: ast::Path) -> @ast::Expr;
|
||||
fn expr_ident(&self, span: Span, id: ast::Ident) -> @ast::Expr;
|
||||
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(&self, span: Span) -> @ast::Expr;
|
||||
fn expr_self(&self, span: Span) -> Gc<ast::Expr>;
|
||||
fn expr_binary(&self, sp: Span, op: ast::BinOp,
|
||||
lhs: @ast::Expr, rhs: @ast::Expr) -> @ast::Expr;
|
||||
fn expr_deref(&self, sp: Span, e: @ast::Expr) -> @ast::Expr;
|
||||
fn expr_unary(&self, sp: Span, op: ast::UnOp, e: @ast::Expr) -> @ast::Expr;
|
||||
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: @ast::Expr) -> @ast::Expr;
|
||||
fn expr_addr_of(&self, sp: Span, e: @ast::Expr) -> @ast::Expr;
|
||||
fn expr_mut_addr_of(&self, sp: Span, e: @ast::Expr) -> @ast::Expr;
|
||||
fn expr_field_access(&self, span: Span, expr: @ast::Expr, ident: ast::Ident) -> @ast::Expr;
|
||||
fn expr_call(&self, span: Span, expr: @ast::Expr, args: Vec<@ast::Expr> ) -> @ast::Expr;
|
||||
fn expr_call_ident(&self, span: Span, id: ast::Ident, args: Vec<@ast::Expr> ) -> @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_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<@ast::Expr> ) -> @ast::Expr;
|
||||
args: Vec<Gc<ast::Expr>>) -> Gc<ast::Expr>;
|
||||
fn expr_method_call(&self, span: Span,
|
||||
expr: @ast::Expr, ident: ast::Ident,
|
||||
args: Vec<@ast::Expr> ) -> @ast::Expr;
|
||||
fn expr_block(&self, b: P<ast::Block>) -> @ast::Expr;
|
||||
fn expr_cast(&self, sp: Span, expr: @ast::Expr, ty: P<ast::Ty>) -> @ast::Expr;
|
||||
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: @ast::Expr) -> ast::Field;
|
||||
fn expr_struct(&self, span: Span, path: ast::Path, fields: Vec<ast::Field> ) -> @ast::Expr;
|
||||
fn expr_struct_ident(&self, span: Span, id: ast::Ident, fields: Vec<ast::Field> ) -> @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>;
|
||||
fn expr_struct_ident(&self, span: Span, id: ast::Ident,
|
||||
fields: Vec<ast::Field> ) -> Gc<ast::Expr>;
|
||||
|
||||
fn expr_lit(&self, sp: Span, lit: ast::Lit_) -> @ast::Expr;
|
||||
fn expr_lit(&self, sp: Span, lit: ast::Lit_) -> Gc<ast::Expr>;
|
||||
|
||||
fn expr_uint(&self, span: Span, i: uint) -> @ast::Expr;
|
||||
fn expr_int(&self, sp: Span, i: int) -> @ast::Expr;
|
||||
fn expr_u8(&self, sp: Span, u: u8) -> @ast::Expr;
|
||||
fn expr_bool(&self, sp: Span, value: bool) -> @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_vstore(&self, sp: Span, expr: @ast::Expr, vst: ast::ExprVstore) -> @ast::Expr;
|
||||
fn expr_vec(&self, sp: Span, exprs: Vec<@ast::Expr> ) -> @ast::Expr;
|
||||
fn expr_vec_ng(&self, sp: Span) -> @ast::Expr;
|
||||
fn expr_vec_slice(&self, sp: Span, exprs: Vec<@ast::Expr> ) -> @ast::Expr;
|
||||
fn expr_str(&self, sp: Span, s: InternedString) -> @ast::Expr;
|
||||
fn expr_str_uniq(&self, sp: Span, s: InternedString) -> @ast::Expr;
|
||||
fn expr_vstore(&self, sp: Span, expr: Gc<ast::Expr>, vst: ast::ExprVstore) -> Gc<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_str_uniq(&self, sp: Span, s: InternedString) -> Gc<ast::Expr>;
|
||||
|
||||
fn expr_some(&self, sp: Span, expr: @ast::Expr) -> @ast::Expr;
|
||||
fn expr_none(&self, sp: Span) -> @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_fail(&self, span: Span, msg: InternedString) -> @ast::Expr;
|
||||
fn expr_unreachable(&self, span: Span) -> @ast::Expr;
|
||||
fn expr_fail(&self, span: Span, msg: InternedString) -> Gc<ast::Expr>;
|
||||
fn expr_unreachable(&self, span: Span) -> Gc<ast::Expr>;
|
||||
|
||||
fn expr_ok(&self, span: Span, expr: @ast::Expr) -> @ast::Expr;
|
||||
fn expr_err(&self, span: Span, expr: @ast::Expr) -> @ast::Expr;
|
||||
fn expr_try(&self, span: Span, head: @ast::Expr) -> @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 pat(&self, span: Span, pat: ast::Pat_) -> @ast::Pat;
|
||||
fn pat_wild(&self, span: Span) -> @ast::Pat;
|
||||
fn pat_lit(&self, span: Span, expr: @ast::Expr) -> @ast::Pat;
|
||||
fn pat_ident(&self, span: Span, ident: ast::Ident) -> @ast::Pat;
|
||||
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_ident_binding_mode(&self,
|
||||
span: Span,
|
||||
ident: ast::Ident,
|
||||
bm: ast::BindingMode) -> @ast::Pat;
|
||||
fn pat_enum(&self, span: Span, path: ast::Path, subpats: Vec<@ast::Pat> ) -> @ast::Pat;
|
||||
bm: ast::BindingMode) -> Gc<ast::Pat>;
|
||||
fn pat_enum(&self, span: Span, path: ast::Path,
|
||||
subpats: Vec<Gc<ast::Pat>>) -> Gc<ast::Pat>;
|
||||
fn pat_struct(&self, span: Span,
|
||||
path: ast::Path, field_pats: Vec<ast::FieldPat> ) -> @ast::Pat;
|
||||
path: ast::Path, field_pats: Vec<ast::FieldPat> ) -> Gc<ast::Pat>;
|
||||
|
||||
fn arm(&self, span: Span, pats: Vec<@ast::Pat> , expr: @ast::Expr) -> ast::Arm;
|
||||
fn arm(&self, span: Span, pats: Vec<Gc<ast::Pat>> , expr: Gc<ast::Expr>) -> ast::Arm;
|
||||
fn arm_unreachable(&self, span: Span) -> ast::Arm;
|
||||
|
||||
fn expr_match(&self, span: Span, arg: @ast::Expr, arms: Vec<ast::Arm> ) -> @ast::Expr;
|
||||
fn expr_match(&self, span: Span, arg: Gc<ast::Expr>, arms: Vec<ast::Arm> ) -> Gc<ast::Expr>;
|
||||
fn expr_if(&self, span: Span,
|
||||
cond: @ast::Expr, then: @ast::Expr, els: Option<@ast::Expr>) -> @ast::Expr;
|
||||
cond: Gc<ast::Expr>, then: Gc<ast::Expr>,
|
||||
els: Option<Gc<ast::Expr>>) -> Gc<ast::Expr>;
|
||||
|
||||
fn lambda_fn_decl(&self, span: Span,
|
||||
fn_decl: P<ast::FnDecl>, blk: P<ast::Block>) -> @ast::Expr;
|
||||
fn_decl: P<ast::FnDecl>, blk: P<ast::Block>) -> Gc<ast::Expr>;
|
||||
|
||||
fn lambda(&self, span: Span, ids: Vec<ast::Ident> , blk: P<ast::Block>) -> @ast::Expr;
|
||||
fn lambda0(&self, span: Span, blk: P<ast::Block>) -> @ast::Expr;
|
||||
fn lambda1(&self, span: Span, blk: P<ast::Block>, ident: ast::Ident) -> @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_expr(&self, span: Span, ids: Vec<ast::Ident> , blk: @ast::Expr) -> @ast::Expr;
|
||||
fn lambda_expr_0(&self, span: Span, expr: @ast::Expr) -> @ast::Expr;
|
||||
fn lambda_expr_1(&self, span: Span, expr: @ast::Expr, ident: ast::Ident) -> @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_stmts(&self, span: Span, ids: Vec<ast::Ident> , blk: Vec<@ast::Stmt> ) -> @ast::Expr;
|
||||
fn lambda_stmts_0(&self, span: Span, stmts: Vec<@ast::Stmt> ) -> @ast::Expr;
|
||||
fn lambda_stmts_1(&self, span: Span, stmts: Vec<@ast::Stmt> , ident: ast::Ident) -> @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>;
|
||||
|
||||
// items
|
||||
fn item(&self, span: Span,
|
||||
name: Ident, attrs: Vec<ast::Attribute> , node: ast::Item_) -> @ast::Item;
|
||||
name: Ident, attrs: Vec<ast::Attribute>,
|
||||
node: ast::Item_) -> Gc<ast::Item>;
|
||||
|
||||
fn arg(&self, span: Span, name: Ident, ty: P<ast::Ty>) -> ast::Arg;
|
||||
// FIXME unused self
|
||||
|
|
@ -193,56 +209,59 @@ pub trait AstBuilder {
|
|||
inputs: Vec<ast::Arg> ,
|
||||
output: P<ast::Ty>,
|
||||
generics: Generics,
|
||||
body: P<ast::Block>) -> @ast::Item;
|
||||
body: P<ast::Block>) -> Gc<ast::Item>;
|
||||
fn item_fn(&self,
|
||||
span: Span,
|
||||
name: Ident,
|
||||
inputs: Vec<ast::Arg> ,
|
||||
output: P<ast::Ty>,
|
||||
body: P<ast::Block>) -> @ast::Item;
|
||||
body: P<ast::Block>) -> Gc<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) -> @ast::Item;
|
||||
fn item_enum(&self, span: Span, name: Ident, enum_def: ast::EnumDef) -> @ast::Item;
|
||||
generics: Generics) -> Gc<ast::Item>;
|
||||
fn item_enum(&self, span: Span, name: Ident,
|
||||
enum_def: ast::EnumDef) -> Gc<ast::Item>;
|
||||
|
||||
fn item_struct_poly(&self,
|
||||
span: Span,
|
||||
name: Ident,
|
||||
struct_def: ast::StructDef,
|
||||
generics: Generics) -> @ast::Item;
|
||||
fn item_struct(&self, span: Span, name: Ident, struct_def: ast::StructDef) -> @ast::Item;
|
||||
generics: Generics) -> Gc<ast::Item>;
|
||||
fn item_struct(&self, span: Span, name: Ident,
|
||||
struct_def: ast::StructDef) -> Gc<ast::Item>;
|
||||
|
||||
fn item_mod(&self, span: Span, inner_span: Span,
|
||||
name: Ident, attrs: Vec<ast::Attribute> ,
|
||||
vi: Vec<ast::ViewItem> , items: Vec<@ast::Item> ) -> @ast::Item;
|
||||
name: Ident, attrs: Vec<ast::Attribute>,
|
||||
vi: Vec<ast::ViewItem>,
|
||||
items: Vec<Gc<ast::Item>>) -> Gc<ast::Item>;
|
||||
|
||||
fn item_ty_poly(&self,
|
||||
span: Span,
|
||||
name: Ident,
|
||||
ty: P<ast::Ty>,
|
||||
generics: Generics) -> @ast::Item;
|
||||
fn item_ty(&self, span: Span, name: Ident, ty: P<ast::Ty>) -> @ast::Item;
|
||||
generics: Generics) -> Gc<ast::Item>;
|
||||
fn item_ty(&self, span: Span, name: Ident, ty: P<ast::Ty>) -> Gc<ast::Item>;
|
||||
|
||||
fn attribute(&self, sp: Span, mi: @ast::MetaItem) -> ast::Attribute;
|
||||
fn attribute(&self, sp: Span, mi: Gc<ast::MetaItem>) -> ast::Attribute;
|
||||
|
||||
fn meta_word(&self, sp: Span, w: InternedString) -> @ast::MetaItem;
|
||||
fn meta_word(&self, sp: Span, w: InternedString) -> Gc<ast::MetaItem>;
|
||||
fn meta_list(&self,
|
||||
sp: Span,
|
||||
name: InternedString,
|
||||
mis: Vec<@ast::MetaItem> )
|
||||
-> @ast::MetaItem;
|
||||
mis: Vec<Gc<ast::MetaItem>>)
|
||||
-> Gc<ast::MetaItem>;
|
||||
fn meta_name_value(&self,
|
||||
sp: Span,
|
||||
name: InternedString,
|
||||
value: ast::Lit_)
|
||||
-> @ast::MetaItem;
|
||||
-> Gc<ast::MetaItem>;
|
||||
|
||||
fn view_use(&self, sp: Span,
|
||||
vis: ast::Visibility, vp: @ast::ViewPath) -> ast::ViewItem;
|
||||
vis: ast::Visibility, vp: Gc<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;
|
||||
|
|
@ -418,17 +437,18 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
|
|||
ast::Lifetime { id: ast::DUMMY_NODE_ID, span: span, name: name }
|
||||
}
|
||||
|
||||
fn stmt_expr(&self, expr: @ast::Expr) -> @ast::Stmt {
|
||||
@respan(expr.span, ast::StmtSemi(expr, ast::DUMMY_NODE_ID))
|
||||
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_let(&self, sp: Span, mutbl: bool, ident: ast::Ident, ex: @ast::Expr) -> @ast::Stmt {
|
||||
fn stmt_let(&self, sp: Span, mutbl: bool, ident: ast::Ident,
|
||||
ex: Gc<ast::Expr>) -> Gc<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 = @ast::Local {
|
||||
let local = box(GC) ast::Local {
|
||||
ty: self.ty_infer(sp),
|
||||
pat: pat,
|
||||
init: Some(ex),
|
||||
|
|
@ -437,7 +457,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
|
|||
source: ast::LocalLet,
|
||||
};
|
||||
let decl = respan(sp, ast::DeclLocal(local));
|
||||
@respan(sp, ast::StmtDecl(@decl, ast::DUMMY_NODE_ID))
|
||||
box(GC) respan(sp, ast::StmtDecl(box(GC) decl, ast::DUMMY_NODE_ID))
|
||||
}
|
||||
|
||||
fn stmt_let_typed(&self,
|
||||
|
|
@ -445,14 +465,14 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
|
|||
mutbl: bool,
|
||||
ident: ast::Ident,
|
||||
typ: P<ast::Ty>,
|
||||
ex: @ast::Expr)
|
||||
-> @ast::Stmt {
|
||||
ex: Gc<ast::Expr>)
|
||||
-> Gc<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 = @ast::Local {
|
||||
let local = box(GC) ast::Local {
|
||||
ty: typ,
|
||||
pat: pat,
|
||||
init: Some(ex),
|
||||
|
|
@ -461,21 +481,22 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
|
|||
source: ast::LocalLet,
|
||||
};
|
||||
let decl = respan(sp, ast::DeclLocal(local));
|
||||
@respan(sp, ast::StmtDecl(@decl, ast::DUMMY_NODE_ID))
|
||||
box(GC) respan(sp, ast::StmtDecl(box(GC) decl, ast::DUMMY_NODE_ID))
|
||||
}
|
||||
|
||||
fn block(&self, span: Span, stmts: Vec<@ast::Stmt> , expr: Option<@Expr>) -> P<ast::Block> {
|
||||
fn block(&self, span: Span, stmts: Vec<Gc<ast::Stmt>>,
|
||||
expr: Option<Gc<Expr>>) -> P<ast::Block> {
|
||||
self.block_all(span, Vec::new(), stmts, expr)
|
||||
}
|
||||
|
||||
fn block_expr(&self, expr: @ast::Expr) -> P<ast::Block> {
|
||||
fn block_expr(&self, expr: Gc<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<@ast::Stmt> ,
|
||||
expr: Option<@ast::Expr>) -> P<ast::Block> {
|
||||
stmts: Vec<Gc<ast::Stmt>>,
|
||||
expr: Option<Gc<ast::Expr>>) -> P<ast::Block> {
|
||||
P(ast::Block {
|
||||
view_items: view_items,
|
||||
stmts: stmts,
|
||||
|
|
@ -486,107 +507,109 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
|
|||
})
|
||||
}
|
||||
|
||||
fn expr(&self, span: Span, node: ast::Expr_) -> @ast::Expr {
|
||||
@ast::Expr {
|
||||
fn expr(&self, span: Span, node: ast::Expr_) -> Gc<ast::Expr> {
|
||||
box(GC) ast::Expr {
|
||||
id: ast::DUMMY_NODE_ID,
|
||||
node: node,
|
||||
span: span,
|
||||
}
|
||||
}
|
||||
|
||||
fn expr_path(&self, path: ast::Path) -> @ast::Expr {
|
||||
fn expr_path(&self, path: ast::Path) -> Gc<ast::Expr> {
|
||||
self.expr(path.span, ast::ExprPath(path))
|
||||
}
|
||||
|
||||
fn expr_ident(&self, span: Span, id: ast::Ident) -> @ast::Expr {
|
||||
fn expr_ident(&self, span: Span, id: ast::Ident) -> Gc<ast::Expr> {
|
||||
self.expr_path(self.path_ident(span, id))
|
||||
}
|
||||
fn expr_self(&self, span: Span) -> @ast::Expr {
|
||||
fn expr_self(&self, span: Span) -> Gc<ast::Expr> {
|
||||
self.expr_ident(span, special_idents::self_)
|
||||
}
|
||||
|
||||
fn expr_binary(&self, sp: Span, op: ast::BinOp,
|
||||
lhs: @ast::Expr, rhs: @ast::Expr) -> @ast::Expr {
|
||||
lhs: Gc<ast::Expr>, rhs: Gc<ast::Expr>) -> Gc<ast::Expr> {
|
||||
self.expr(sp, ast::ExprBinary(op, lhs, rhs))
|
||||
}
|
||||
|
||||
fn expr_deref(&self, sp: Span, e: @ast::Expr) -> @ast::Expr {
|
||||
fn expr_deref(&self, sp: Span, e: Gc<ast::Expr>) -> Gc<ast::Expr> {
|
||||
self.expr_unary(sp, ast::UnDeref, e)
|
||||
}
|
||||
fn expr_unary(&self, sp: Span, op: ast::UnOp, e: @ast::Expr) -> @ast::Expr {
|
||||
fn expr_unary(&self, sp: Span, op: ast::UnOp, e: Gc<ast::Expr>) -> Gc<ast::Expr> {
|
||||
self.expr(sp, ast::ExprUnary(op, e))
|
||||
}
|
||||
|
||||
fn expr_managed(&self, sp: Span, e: @ast::Expr) -> @ast::Expr {
|
||||
fn expr_managed(&self, sp: Span, e: Gc<ast::Expr>) -> Gc<ast::Expr> {
|
||||
self.expr_unary(sp, ast::UnBox, e)
|
||||
}
|
||||
|
||||
fn expr_field_access(&self, sp: Span, expr: @ast::Expr, ident: ast::Ident) -> @ast::Expr {
|
||||
fn expr_field_access(&self, sp: Span, expr: Gc<ast::Expr>, ident: ast::Ident) -> Gc<ast::Expr> {
|
||||
self.expr(sp, ast::ExprField(expr, ident, Vec::new()))
|
||||
}
|
||||
fn expr_addr_of(&self, sp: Span, e: @ast::Expr) -> @ast::Expr {
|
||||
fn expr_addr_of(&self, sp: Span, e: Gc<ast::Expr>) -> Gc<ast::Expr> {
|
||||
self.expr(sp, ast::ExprAddrOf(ast::MutImmutable, e))
|
||||
}
|
||||
fn expr_mut_addr_of(&self, sp: Span, e: @ast::Expr) -> @ast::Expr {
|
||||
fn expr_mut_addr_of(&self, sp: Span, e: Gc<ast::Expr>) -> Gc<ast::Expr> {
|
||||
self.expr(sp, ast::ExprAddrOf(ast::MutMutable, e))
|
||||
}
|
||||
|
||||
fn expr_call(&self, span: Span, expr: @ast::Expr, args: Vec<@ast::Expr> ) -> @ast::Expr {
|
||||
fn expr_call(&self, span: Span, expr: Gc<ast::Expr>,
|
||||
args: Vec<Gc<ast::Expr>>) -> Gc<ast::Expr> {
|
||||
self.expr(span, ast::ExprCall(expr, args))
|
||||
}
|
||||
fn expr_call_ident(&self, span: Span, id: ast::Ident, args: Vec<@ast::Expr> ) -> @ast::Expr {
|
||||
fn expr_call_ident(&self, span: Span, id: ast::Ident,
|
||||
args: Vec<Gc<ast::Expr>>) -> Gc<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<@ast::Expr> ) -> @ast::Expr {
|
||||
args: Vec<Gc<ast::Expr>> ) -> Gc<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,
|
||||
expr: @ast::Expr,
|
||||
expr: Gc<ast::Expr>,
|
||||
ident: ast::Ident,
|
||||
mut args: Vec<@ast::Expr> ) -> @ast::Expr {
|
||||
mut args: Vec<Gc<ast::Expr>> ) -> Gc<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>) -> @ast::Expr {
|
||||
fn expr_block(&self, b: P<ast::Block>) -> Gc<ast::Expr> {
|
||||
self.expr(b.span, ast::ExprBlock(b))
|
||||
}
|
||||
fn field_imm(&self, span: Span, name: Ident, e: @ast::Expr) -> ast::Field {
|
||||
fn field_imm(&self, span: Span, name: Ident, e: Gc<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> ) -> @ast::Expr {
|
||||
fn expr_struct(&self, span: Span, path: ast::Path, fields: Vec<ast::Field> ) -> Gc<ast::Expr> {
|
||||
self.expr(span, ast::ExprStruct(path, fields, None))
|
||||
}
|
||||
fn expr_struct_ident(&self, span: Span,
|
||||
id: ast::Ident, fields: Vec<ast::Field> ) -> @ast::Expr {
|
||||
id: ast::Ident, fields: Vec<ast::Field> ) -> Gc<ast::Expr> {
|
||||
self.expr_struct(span, self.path_ident(span, id), fields)
|
||||
}
|
||||
|
||||
fn expr_lit(&self, sp: Span, lit: ast::Lit_) -> @ast::Expr {
|
||||
self.expr(sp, ast::ExprLit(@respan(sp, lit)))
|
||||
fn expr_lit(&self, sp: Span, lit: ast::Lit_) -> Gc<ast::Expr> {
|
||||
self.expr(sp, ast::ExprLit(box(GC) respan(sp, lit)))
|
||||
}
|
||||
fn expr_uint(&self, span: Span, i: uint) -> @ast::Expr {
|
||||
fn expr_uint(&self, span: Span, i: uint) -> Gc<ast::Expr> {
|
||||
self.expr_lit(span, ast::LitUint(i as u64, ast::TyU))
|
||||
}
|
||||
fn expr_int(&self, sp: Span, i: int) -> @ast::Expr {
|
||||
fn expr_int(&self, sp: Span, i: int) -> Gc<ast::Expr> {
|
||||
self.expr_lit(sp, ast::LitInt(i as i64, ast::TyI))
|
||||
}
|
||||
fn expr_u8(&self, sp: Span, u: u8) -> @ast::Expr {
|
||||
fn expr_u8(&self, sp: Span, u: u8) -> Gc<ast::Expr> {
|
||||
self.expr_lit(sp, ast::LitUint(u as u64, ast::TyU8))
|
||||
}
|
||||
fn expr_bool(&self, sp: Span, value: bool) -> @ast::Expr {
|
||||
fn expr_bool(&self, sp: Span, value: bool) -> Gc<ast::Expr> {
|
||||
self.expr_lit(sp, ast::LitBool(value))
|
||||
}
|
||||
|
||||
fn expr_vstore(&self, sp: Span, expr: @ast::Expr, vst: ast::ExprVstore) -> @ast::Expr {
|
||||
fn expr_vstore(&self, sp: Span, expr: Gc<ast::Expr>, vst: ast::ExprVstore) -> Gc<ast::Expr> {
|
||||
self.expr(sp, ast::ExprVstore(expr, vst))
|
||||
}
|
||||
fn expr_vec(&self, sp: Span, exprs: Vec<@ast::Expr> ) -> @ast::Expr {
|
||||
fn expr_vec(&self, sp: Span, exprs: Vec<Gc<ast::Expr>> ) -> Gc<ast::Expr> {
|
||||
self.expr(sp, ast::ExprVec(exprs))
|
||||
}
|
||||
fn expr_vec_ng(&self, sp: Span) -> @ast::Expr {
|
||||
fn expr_vec_ng(&self, sp: Span) -> Gc<ast::Expr> {
|
||||
self.expr_call_global(sp,
|
||||
vec!(self.ident_of("std"),
|
||||
self.ident_of("vec"),
|
||||
|
|
@ -594,23 +617,23 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
|
|||
self.ident_of("new")),
|
||||
Vec::new())
|
||||
}
|
||||
fn expr_vec_slice(&self, sp: Span, exprs: Vec<@ast::Expr> ) -> @ast::Expr {
|
||||
fn expr_vec_slice(&self, sp: Span, exprs: Vec<Gc<ast::Expr>> ) -> Gc<ast::Expr> {
|
||||
self.expr_vstore(sp, self.expr_vec(sp, exprs), ast::ExprVstoreSlice)
|
||||
}
|
||||
fn expr_str(&self, sp: Span, s: InternedString) -> @ast::Expr {
|
||||
fn expr_str(&self, sp: Span, s: InternedString) -> Gc<ast::Expr> {
|
||||
self.expr_lit(sp, ast::LitStr(s, ast::CookedStr))
|
||||
}
|
||||
fn expr_str_uniq(&self, sp: Span, s: InternedString) -> @ast::Expr {
|
||||
fn expr_str_uniq(&self, sp: Span, s: InternedString) -> Gc<ast::Expr> {
|
||||
self.expr_vstore(sp, self.expr_str(sp, s), ast::ExprVstoreUniq)
|
||||
}
|
||||
|
||||
|
||||
fn expr_cast(&self, sp: Span, expr: @ast::Expr, ty: P<ast::Ty>) -> @ast::Expr {
|
||||
fn expr_cast(&self, sp: Span, expr: Gc<ast::Expr>, ty: P<ast::Ty>) -> Gc<ast::Expr> {
|
||||
self.expr(sp, ast::ExprCast(expr, ty))
|
||||
}
|
||||
|
||||
|
||||
fn expr_some(&self, sp: Span, expr: @ast::Expr) -> @ast::Expr {
|
||||
fn expr_some(&self, sp: Span, expr: Gc<ast::Expr>) -> Gc<ast::Expr> {
|
||||
let some = vec!(
|
||||
self.ident_of("std"),
|
||||
self.ident_of("option"),
|
||||
|
|
@ -618,7 +641,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
|
|||
self.expr_call_global(sp, some, vec!(expr))
|
||||
}
|
||||
|
||||
fn expr_none(&self, sp: Span) -> @ast::Expr {
|
||||
fn expr_none(&self, sp: Span) -> Gc<ast::Expr> {
|
||||
let none = self.path_global(sp, vec!(
|
||||
self.ident_of("std"),
|
||||
self.ident_of("option"),
|
||||
|
|
@ -626,7 +649,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
|
|||
self.expr_path(none)
|
||||
}
|
||||
|
||||
fn expr_fail(&self, span: Span, msg: InternedString) -> @ast::Expr {
|
||||
fn expr_fail(&self, span: Span, msg: InternedString) -> Gc<ast::Expr> {
|
||||
let loc = self.codemap().lookup_char_pos(span.lo);
|
||||
self.expr_call_global(
|
||||
span,
|
||||
|
|
@ -643,13 +666,13 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
|
|||
self.expr_uint(span, loc.line)))
|
||||
}
|
||||
|
||||
fn expr_unreachable(&self, span: Span) -> @ast::Expr {
|
||||
fn expr_unreachable(&self, span: Span) -> Gc<ast::Expr> {
|
||||
self.expr_fail(span,
|
||||
InternedString::new(
|
||||
"internal error: entered unreachable code"))
|
||||
}
|
||||
|
||||
fn expr_ok(&self, sp: Span, expr: @ast::Expr) -> @ast::Expr {
|
||||
fn expr_ok(&self, sp: Span, expr: Gc<ast::Expr>) -> Gc<ast::Expr> {
|
||||
let ok = vec!(
|
||||
self.ident_of("std"),
|
||||
self.ident_of("result"),
|
||||
|
|
@ -657,7 +680,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
|
|||
self.expr_call_global(sp, ok, vec!(expr))
|
||||
}
|
||||
|
||||
fn expr_err(&self, sp: Span, expr: @ast::Expr) -> @ast::Expr {
|
||||
fn expr_err(&self, sp: Span, expr: Gc<ast::Expr>) -> Gc<ast::Expr> {
|
||||
let err = vec!(
|
||||
self.ident_of("std"),
|
||||
self.ident_of("result"),
|
||||
|
|
@ -665,7 +688,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
|
|||
self.expr_call_global(sp, err, vec!(expr))
|
||||
}
|
||||
|
||||
fn expr_try(&self, sp: Span, head: @ast::Expr) -> @ast::Expr {
|
||||
fn expr_try(&self, sp: Span, head: Gc<ast::Expr>) -> Gc<ast::Expr> {
|
||||
let ok = self.ident_of("Ok");
|
||||
let ok_path = self.path_ident(sp, ok);
|
||||
let err = self.ident_of("Err");
|
||||
|
|
@ -694,38 +717,38 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
|
|||
}
|
||||
|
||||
|
||||
fn pat(&self, span: Span, pat: ast::Pat_) -> @ast::Pat {
|
||||
@ast::Pat { id: ast::DUMMY_NODE_ID, node: pat, span: span }
|
||||
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_wild(&self, span: Span) -> @ast::Pat {
|
||||
fn pat_wild(&self, span: Span) -> Gc<ast::Pat> {
|
||||
self.pat(span, ast::PatWild)
|
||||
}
|
||||
fn pat_lit(&self, span: Span, expr: @ast::Expr) -> @ast::Pat {
|
||||
fn pat_lit(&self, span: Span, expr: Gc<ast::Expr>) -> Gc<ast::Pat> {
|
||||
self.pat(span, ast::PatLit(expr))
|
||||
}
|
||||
fn pat_ident(&self, span: Span, ident: ast::Ident) -> @ast::Pat {
|
||||
fn pat_ident(&self, span: Span, ident: ast::Ident) -> Gc<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) -> @ast::Pat {
|
||||
bm: ast::BindingMode) -> Gc<ast::Pat> {
|
||||
let path = self.path_ident(span, ident);
|
||||
let pat = ast::PatIdent(bm, path, None);
|
||||
self.pat(span, pat)
|
||||
}
|
||||
fn pat_enum(&self, span: Span, path: ast::Path, subpats: Vec<@ast::Pat> ) -> @ast::Pat {
|
||||
fn pat_enum(&self, span: Span, path: ast::Path, subpats: Vec<Gc<ast::Pat>> ) -> Gc<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> ) -> @ast::Pat {
|
||||
path: ast::Path, field_pats: Vec<ast::FieldPat> ) -> Gc<ast::Pat> {
|
||||
let pat = ast::PatStruct(path, field_pats, false);
|
||||
self.pat(span, pat)
|
||||
}
|
||||
|
||||
fn arm(&self, _span: Span, pats: Vec<@ast::Pat> , expr: @ast::Expr) -> ast::Arm {
|
||||
fn arm(&self, _span: Span, pats: Vec<Gc<ast::Pat>> , expr: Gc<ast::Expr>) -> ast::Arm {
|
||||
ast::Arm {
|
||||
attrs: vec!(),
|
||||
pats: pats,
|
||||
|
|
@ -738,56 +761,60 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
|
|||
self.arm(span, vec!(self.pat_wild(span)), self.expr_unreachable(span))
|
||||
}
|
||||
|
||||
fn expr_match(&self, span: Span, arg: @ast::Expr, arms: Vec<ast::Arm> ) -> @Expr {
|
||||
fn expr_match(&self, span: Span, arg: Gc<ast::Expr>,
|
||||
arms: Vec<ast::Arm>) -> Gc<Expr> {
|
||||
self.expr(span, ast::ExprMatch(arg, arms))
|
||||
}
|
||||
|
||||
fn expr_if(&self, span: Span,
|
||||
cond: @ast::Expr, then: @ast::Expr, els: Option<@ast::Expr>) -> @ast::Expr {
|
||||
cond: Gc<ast::Expr>, then: Gc<ast::Expr>,
|
||||
els: Option<Gc<ast::Expr>>) -> Gc<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 lambda_fn_decl(&self, span: Span,
|
||||
fn_decl: P<ast::FnDecl>, blk: P<ast::Block>) -> @ast::Expr {
|
||||
fn_decl: P<ast::FnDecl>, blk: P<ast::Block>) -> Gc<ast::Expr> {
|
||||
self.expr(span, ast::ExprFnBlock(fn_decl, blk))
|
||||
}
|
||||
fn lambda(&self, span: Span, ids: Vec<ast::Ident> , blk: P<ast::Block>) -> @ast::Expr {
|
||||
fn lambda(&self, span: Span, ids: Vec<ast::Ident> , blk: P<ast::Block>) -> Gc<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(fn_decl, blk))
|
||||
}
|
||||
fn lambda0(&self, span: Span, blk: P<ast::Block>) -> @ast::Expr {
|
||||
fn lambda0(&self, span: Span, blk: P<ast::Block>) -> Gc<ast::Expr> {
|
||||
self.lambda(span, Vec::new(), blk)
|
||||
}
|
||||
|
||||
fn lambda1(&self, span: Span, blk: P<ast::Block>, ident: ast::Ident) -> @ast::Expr {
|
||||
fn lambda1(&self, span: Span, blk: P<ast::Block>, ident: ast::Ident) -> Gc<ast::Expr> {
|
||||
self.lambda(span, vec!(ident), blk)
|
||||
}
|
||||
|
||||
fn lambda_expr(&self, span: Span, ids: Vec<ast::Ident> , expr: @ast::Expr) -> @ast::Expr {
|
||||
fn lambda_expr(&self, span: Span, ids: Vec<ast::Ident> , expr: Gc<ast::Expr>) -> Gc<ast::Expr> {
|
||||
self.lambda(span, ids, self.block_expr(expr))
|
||||
}
|
||||
fn lambda_expr_0(&self, span: Span, expr: @ast::Expr) -> @ast::Expr {
|
||||
fn lambda_expr_0(&self, span: Span, expr: Gc<ast::Expr>) -> Gc<ast::Expr> {
|
||||
self.lambda0(span, self.block_expr(expr))
|
||||
}
|
||||
fn lambda_expr_1(&self, span: Span, expr: @ast::Expr, ident: ast::Ident) -> @ast::Expr {
|
||||
fn lambda_expr_1(&self, span: Span, expr: Gc<ast::Expr>, ident: ast::Ident) -> Gc<ast::Expr> {
|
||||
self.lambda1(span, self.block_expr(expr), ident)
|
||||
}
|
||||
|
||||
fn lambda_stmts(&self,
|
||||
span: Span,
|
||||
ids: Vec<ast::Ident>,
|
||||
stmts: Vec<@ast::Stmt>)
|
||||
-> @ast::Expr {
|
||||
stmts: Vec<Gc<ast::Stmt>>)
|
||||
-> Gc<ast::Expr> {
|
||||
self.lambda(span, ids, self.block(span, stmts, None))
|
||||
}
|
||||
fn lambda_stmts_0(&self, span: Span, stmts: Vec<@ast::Stmt> ) -> @ast::Expr {
|
||||
fn lambda_stmts_0(&self, span: Span,
|
||||
stmts: Vec<Gc<ast::Stmt>>) -> Gc<ast::Expr> {
|
||||
self.lambda0(span, self.block(span, stmts, None))
|
||||
}
|
||||
fn lambda_stmts_1(&self, span: Span, stmts: Vec<@ast::Stmt> , ident: ast::Ident) -> @ast::Expr {
|
||||
fn lambda_stmts_1(&self, span: Span, stmts: Vec<Gc<ast::Stmt>>,
|
||||
ident: ast::Ident) -> Gc<ast::Expr> {
|
||||
self.lambda1(span, self.block(span, stmts, None), ident)
|
||||
}
|
||||
|
||||
|
|
@ -811,10 +838,11 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
|
|||
}
|
||||
|
||||
fn item(&self, span: Span,
|
||||
name: Ident, attrs: Vec<ast::Attribute> , node: ast::Item_) -> @ast::Item {
|
||||
name: Ident, attrs: Vec<ast::Attribute>,
|
||||
node: ast::Item_) -> Gc<ast::Item> {
|
||||
// FIXME: Would be nice if our generated code didn't violate
|
||||
// Rust coding conventions
|
||||
@ast::Item { ident: name,
|
||||
box(GC) ast::Item { ident: name,
|
||||
attrs: attrs,
|
||||
id: ast::DUMMY_NODE_ID,
|
||||
node: node,
|
||||
|
|
@ -828,7 +856,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
|
|||
inputs: Vec<ast::Arg> ,
|
||||
output: P<ast::Ty>,
|
||||
generics: Generics,
|
||||
body: P<ast::Block>) -> @ast::Item {
|
||||
body: P<ast::Block>) -> Gc<ast::Item> {
|
||||
self.item(span,
|
||||
name,
|
||||
Vec::new(),
|
||||
|
|
@ -845,7 +873,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
|
|||
inputs: Vec<ast::Arg> ,
|
||||
output: P<ast::Ty>,
|
||||
body: P<ast::Block>
|
||||
) -> @ast::Item {
|
||||
) -> Gc<ast::Item> {
|
||||
self.item_fn_poly(
|
||||
span,
|
||||
name,
|
||||
|
|
@ -873,18 +901,18 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
|
|||
|
||||
fn item_enum_poly(&self, span: Span, name: Ident,
|
||||
enum_definition: ast::EnumDef,
|
||||
generics: Generics) -> @ast::Item {
|
||||
generics: Generics) -> Gc<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) -> @ast::Item {
|
||||
enum_definition: ast::EnumDef) -> Gc<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) -> @ast::Item {
|
||||
struct_def: ast::StructDef) -> Gc<ast::Item> {
|
||||
self.item_struct_poly(
|
||||
span,
|
||||
name,
|
||||
|
|
@ -894,14 +922,14 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
|
|||
}
|
||||
|
||||
fn item_struct_poly(&self, span: Span, name: Ident,
|
||||
struct_def: ast::StructDef, generics: Generics) -> @ast::Item {
|
||||
self.item(span, name, Vec::new(), ast::ItemStruct(@struct_def, generics))
|
||||
struct_def: ast::StructDef, generics: Generics) -> Gc<ast::Item> {
|
||||
self.item(span, name, Vec::new(), ast::ItemStruct(box(GC) struct_def, generics))
|
||||
}
|
||||
|
||||
fn item_mod(&self, span: Span, inner_span: Span, name: Ident,
|
||||
attrs: Vec<ast::Attribute> ,
|
||||
vi: Vec<ast::ViewItem> ,
|
||||
items: Vec<@ast::Item> ) -> @ast::Item {
|
||||
items: Vec<Gc<ast::Item>>) -> Gc<ast::Item> {
|
||||
self.item(
|
||||
span,
|
||||
name,
|
||||
|
|
@ -915,15 +943,15 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
|
|||
}
|
||||
|
||||
fn item_ty_poly(&self, span: Span, name: Ident, ty: P<ast::Ty>,
|
||||
generics: Generics) -> @ast::Item {
|
||||
generics: Generics) -> Gc<ast::Item> {
|
||||
self.item(span, name, Vec::new(), ast::ItemTy(ty, generics))
|
||||
}
|
||||
|
||||
fn item_ty(&self, span: Span, name: Ident, ty: P<ast::Ty>) -> @ast::Item {
|
||||
fn item_ty(&self, span: Span, name: Ident, ty: P<ast::Ty>) -> Gc<ast::Item> {
|
||||
self.item_ty_poly(span, name, ty, ast_util::empty_generics())
|
||||
}
|
||||
|
||||
fn attribute(&self, sp: Span, mi: @ast::MetaItem) -> ast::Attribute {
|
||||
fn attribute(&self, sp: Span, mi: Gc<ast::MetaItem>) -> ast::Attribute {
|
||||
respan(sp, ast::Attribute_ {
|
||||
id: attr::mk_attr_id(),
|
||||
style: ast::AttrOuter,
|
||||
|
|
@ -932,26 +960,26 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
|
|||
})
|
||||
}
|
||||
|
||||
fn meta_word(&self, sp: Span, w: InternedString) -> @ast::MetaItem {
|
||||
@respan(sp, ast::MetaWord(w))
|
||||
fn meta_word(&self, sp: Span, w: InternedString) -> Gc<ast::MetaItem> {
|
||||
box(GC) respan(sp, ast::MetaWord(w))
|
||||
}
|
||||
fn meta_list(&self,
|
||||
sp: Span,
|
||||
name: InternedString,
|
||||
mis: Vec<@ast::MetaItem> )
|
||||
-> @ast::MetaItem {
|
||||
@respan(sp, ast::MetaList(name, mis))
|
||||
mis: Vec<Gc<ast::MetaItem>> )
|
||||
-> Gc<ast::MetaItem> {
|
||||
box(GC) respan(sp, ast::MetaList(name, mis))
|
||||
}
|
||||
fn meta_name_value(&self,
|
||||
sp: Span,
|
||||
name: InternedString,
|
||||
value: ast::Lit_)
|
||||
-> @ast::MetaItem {
|
||||
@respan(sp, ast::MetaNameValue(name, respan(sp, value)))
|
||||
-> Gc<ast::MetaItem> {
|
||||
box(GC) respan(sp, ast::MetaNameValue(name, respan(sp, value)))
|
||||
}
|
||||
|
||||
fn view_use(&self, sp: Span,
|
||||
vis: ast::Visibility, vp: @ast::ViewPath) -> ast::ViewItem {
|
||||
vis: ast::Visibility, vp: Gc<ast::ViewPath>) -> ast::ViewItem {
|
||||
ast::ViewItem {
|
||||
node: ast::ViewItemUse(vp),
|
||||
attrs: Vec::new(),
|
||||
|
|
@ -968,7 +996,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
|
|||
fn view_use_simple_(&self, sp: Span, vis: ast::Visibility,
|
||||
ident: ast::Ident, path: ast::Path) -> ast::ViewItem {
|
||||
self.view_use(sp, vis,
|
||||
@respan(sp,
|
||||
box(GC) respan(sp,
|
||||
ast::ViewPathSimple(ident,
|
||||
path,
|
||||
ast::DUMMY_NODE_ID)))
|
||||
|
|
@ -981,7 +1009,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
|
|||
}).collect();
|
||||
|
||||
self.view_use(sp, vis,
|
||||
@respan(sp,
|
||||
box(GC) respan(sp,
|
||||
ast::ViewPathList(self.path(sp, path),
|
||||
imports,
|
||||
ast::DUMMY_NODE_ID)))
|
||||
|
|
@ -990,7 +1018,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
|
|||
fn view_use_glob(&self, sp: Span,
|
||||
vis: ast::Visibility, path: Vec<ast::Ident> ) -> ast::ViewItem {
|
||||
self.view_use(sp, vis,
|
||||
@respan(sp,
|
||||
box(GC) respan(sp,
|
||||
ast::ViewPathGlob(self.path(sp, path), ast::DUMMY_NODE_ID)))
|
||||
}
|
||||
}
|
||||
|
|
@ -1013,8 +1041,8 @@ pub trait Duplicate {
|
|||
fn duplicate(&self, cx: &ExtCtxt) -> Self;
|
||||
}
|
||||
|
||||
impl Duplicate for @ast::Expr {
|
||||
fn duplicate(&self, _: &ExtCtxt) -> @ast::Expr {
|
||||
impl Duplicate for Gc<ast::Expr> {
|
||||
fn duplicate(&self, _: &ExtCtxt) -> Gc<ast::Expr> {
|
||||
let mut folder = Duplicator;
|
||||
folder.fold_expr(*self)
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue