user0/rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Modernized a few more types in syntax::ast

Browse source
This commit is contained in:
Marvin Löbel 2013-09-02 03:45:37 +02:00
parent 58decdd7a1
commit 7419085337
114 changed files with 3795 additions and 3790 deletions
Download patch file Download diff file Expand all files Collapse all files

8
src/libsyntax/ext/asm.rs
View file

@ -75,10 +75,10 @@ pub fn expand_asm(cx: @ExtCtxt, sp: Span, tts: &[ast::token_tree])
let out = p.parse_expr();
p.expect(&token::RPAREN);
let out = @ast::expr {
let out = @ast::Expr {
id: cx.next_id(),
span: out.span,
node: ast::expr_addr_of(ast::m_mutbl, out)
node: ast::ExprAddrOf(ast::MutMutable, out)
};
outputs.push((constraint, out));
@ -171,9 +171,9 @@ pub fn expand_asm(cx: @ExtCtxt, sp: Span, tts: &[ast::token_tree])
}
}
MRExpr(@ast::expr {
MRExpr(@ast::Expr {
id: cx.next_id(),
node: ast::expr_inline_asm(ast::inline_asm {
node: ast::ExprInlineAsm(ast::inline_asm {
asm: asm,
clobbers: cons.to_managed(),
inputs: inputs,

12
src/libsyntax/ext/base.rs
View file

@ -62,11 +62,11 @@ pub type SyntaxExpanderTTItemFun = @fn(@ExtCtxt,
-> MacResult;
pub enum MacResult {
MRExpr(@ast::expr),
MRExpr(@ast::Expr),
MRItem(@ast::item),
MRAny(@fn() -> @ast::expr,
MRAny(@fn() -> @ast::Expr,
@fn() -> Option<@ast::item>,
@fn() -> @ast::stmt),
@fn() -> @ast::Stmt),
MRDef(MacroDef)
}
@ -319,9 +319,9 @@ impl ExtCtxt {
}
}
pub fn expr_to_str(cx: @ExtCtxt, expr: @ast::expr, err_msg: &str) -> @str {
pub fn expr_to_str(cx: @ExtCtxt, expr: @ast::Expr, err_msg: &str) -> @str {
match expr.node {
ast::expr_lit(l) => match l.node {
ast::ExprLit(l) => match l.node {
ast::lit_str(s) => s,
_ => cx.span_fatal(l.span, err_msg)
},
@ -353,7 +353,7 @@ pub fn get_single_str_from_tts(cx: @ExtCtxt,
pub fn get_exprs_from_tts(cx: @ExtCtxt,
sp: Span,
tts: &[ast::token_tree]) -> ~[@ast::expr] {
tts: &[ast::token_tree]) -> ~[@ast::Expr] {
let p = parse::new_parser_from_tts(cx.parse_sess(),
cx.cfg(),
tts.to_owned());

360
src/libsyntax/ext/build.rs
View file

@ -21,7 +21,7 @@ use opt_vec::OptVec;
pub struct Field {
ident: ast::Ident,
ex: @ast::expr
ex: @ast::Expr
}
// Transitional reexports so qquote can find the paths it is looking for
@ -43,7 +43,7 @@ pub trait AstBuilder {
-> ast::Path;
// types
fn ty_mt(&self, ty: ast::Ty, mutbl: ast::mutability) -> ast::mt;
fn ty_mt(&self, ty: ast::Ty, mutbl: ast::Mutability) -> ast::mt;
fn ty(&self, span: Span, ty: ast::ty_) -> ast::Ty;
fn ty_path(&self, ast::Path, Option<OptVec<ast::TyParamBound>>) -> ast::Ty;
@ -52,9 +52,9 @@ pub trait AstBuilder {
fn ty_rptr(&self, span: Span,
ty: ast::Ty,
lifetime: Option<ast::Lifetime>,
mutbl: ast::mutability) -> ast::Ty;
mutbl: ast::Mutability) -> ast::Ty;
fn ty_uniq(&self, span: Span, ty: ast::Ty) -> ast::Ty;
fn ty_box(&self, span: Span, ty: ast::Ty, mutbl: ast::mutability) -> ast::Ty;
fn ty_box(&self, span: Span, ty: ast::Ty, mutbl: ast::Mutability) -> ast::Ty;
fn ty_option(&self, ty: ast::Ty) -> ast::Ty;
fn ty_infer(&self, sp: Span) -> ast::Ty;
@ -72,101 +72,101 @@ pub trait AstBuilder {
fn lifetime(&self, span: Span, ident: ast::Ident) -> 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: @ast::Expr) -> @ast::Stmt;
fn stmt_let(&self, sp: Span, mutbl: bool, ident: ast::Ident, ex: @ast::Expr) -> @ast::Stmt;
fn stmt_let_typed(&self,
sp: Span,
mutbl: bool,
ident: ast::Ident,
typ: ast::Ty,
ex: @ast::expr)
-> @ast::stmt;
ex: @ast::Expr)
-> @ast::Stmt;
// blocks
fn block(&self, span: Span, stmts: ~[@ast::stmt], expr: Option<@ast::expr>) -> ast::Block;
fn block_expr(&self, expr: @ast::expr) -> ast::Block;
fn block(&self, span: Span, stmts: ~[@ast::Stmt], expr: Option<@ast::Expr>) -> ast::Block;
fn block_expr(&self, expr: @ast::Expr) -> ast::Block;
fn block_all(&self, span: Span,
view_items: ~[ast::view_item],
stmts: ~[@ast::stmt],
expr: Option<@ast::expr>) -> ast::Block;
stmts: ~[@ast::Stmt],
expr: Option<@ast::Expr>) -> 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_) -> @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(&self, span: Span) -> @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;
fn expr_self(&self, span: Span) -> @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;
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: ~[@ast::expr]) -> @ast::expr;
fn expr_call_ident(&self, span: Span, id: ast::Ident, args: ~[@ast::expr]) -> @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: ~[@ast::Expr]) -> @ast::Expr;
fn expr_call_ident(&self, span: Span, id: ast::Ident, args: ~[@ast::Expr]) -> @ast::Expr;
fn expr_call_global(&self, sp: Span, fn_path: ~[ast::Ident],
args: ~[@ast::expr]) -> @ast::expr;
args: ~[@ast::Expr]) -> @ast::Expr;
fn expr_method_call(&self, span: Span,
expr: @ast::expr, ident: ast::Ident,
args: ~[@ast::expr]) -> @ast::expr;
fn expr_block(&self, b: ast::Block) -> @ast::expr;
expr: @ast::Expr, ident: ast::Ident,
args: ~[@ast::Expr]) -> @ast::Expr;
fn expr_block(&self, b: ast::Block) -> @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: ~[ast::Field]) -> @ast::expr;
fn expr_struct_ident(&self, span: Span, id: ast::Ident, fields: ~[ast::Field]) -> @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: ~[ast::Field]) -> @ast::Expr;
fn expr_struct_ident(&self, span: Span, id: ast::Ident, fields: ~[ast::Field]) -> @ast::Expr;
fn expr_lit(&self, sp: Span, lit: ast::lit_) -> @ast::expr;
fn expr_lit(&self, sp: Span, lit: ast::lit_) -> @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) -> @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_vstore(&self, sp: Span, expr: @ast::expr, vst: ast::expr_vstore) -> @ast::expr;
fn expr_vec(&self, sp: Span, exprs: ~[@ast::expr]) -> @ast::expr;
fn expr_vec_uniq(&self, sp: Span, exprs: ~[@ast::expr]) -> @ast::expr;
fn expr_vec_slice(&self, sp: Span, exprs: ~[@ast::expr]) -> @ast::expr;
fn expr_str(&self, sp: Span, s: @str) -> @ast::expr;
fn expr_str_uniq(&self, sp: Span, s: @str) -> @ast::expr;
fn expr_vstore(&self, sp: Span, expr: @ast::Expr, vst: ast::ExprVstore) -> @ast::Expr;
fn expr_vec(&self, sp: Span, exprs: ~[@ast::Expr]) -> @ast::Expr;
fn expr_vec_uniq(&self, sp: Span, exprs: ~[@ast::Expr]) -> @ast::Expr;
fn expr_vec_slice(&self, sp: Span, exprs: ~[@ast::Expr]) -> @ast::Expr;
fn expr_str(&self, sp: Span, s: @str) -> @ast::Expr;
fn expr_str_uniq(&self, sp: Span, s: @str) -> @ast::Expr;
fn expr_unreachable(&self, span: Span) -> @ast::expr;
fn expr_unreachable(&self, span: Span) -> @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_) -> @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_ident_binding_mode(&self,
span: Span,
ident: ast::Ident,
bm: ast::binding_mode) -> @ast::pat;
fn pat_enum(&self, span: Span, path: ast::Path, subpats: ~[@ast::pat]) -> @ast::pat;
bm: ast::BindingMode) -> @ast::Pat;
fn pat_enum(&self, span: Span, path: ast::Path, subpats: ~[@ast::Pat]) -> @ast::Pat;
fn pat_struct(&self, span: Span,
path: ast::Path, field_pats: ~[ast::field_pat]) -> @ast::pat;
path: ast::Path, field_pats: ~[ast::FieldPat]) -> @ast::Pat;
fn arm(&self, span: Span, pats: ~[@ast::pat], expr: @ast::expr) -> ast::arm;
fn arm_unreachable(&self, span: Span) -> ast::arm;
fn arm(&self, span: Span, pats: ~[@ast::Pat], expr: @ast::Expr) -> ast::Arm;
fn arm_unreachable(&self, span: Span) -> ast::Arm;
fn expr_match(&self, span: Span, arg: @ast::expr, arms: ~[ast::arm]) -> @ast::expr;
fn expr_match(&self, span: Span, arg: @ast::Expr, arms: ~[ast::Arm]) -> @ast::Expr;
fn expr_if(&self, span: Span,
cond: @ast::expr, then: @ast::expr, els: Option<@ast::expr>) -> @ast::expr;
cond: @ast::Expr, then: @ast::Expr, els: Option<@ast::Expr>) -> @ast::Expr;
fn lambda_fn_decl(&self, span: Span, fn_decl: ast::fn_decl, blk: ast::Block) -> @ast::expr;
fn lambda_fn_decl(&self, span: Span, fn_decl: ast::fn_decl, blk: ast::Block) -> @ast::Expr;
fn lambda(&self, span: Span, ids: ~[ast::Ident], blk: ast::Block) -> @ast::expr;
fn lambda0(&self, span: Span, blk: ast::Block) -> @ast::expr;
fn lambda1(&self, span: Span, blk: ast::Block, ident: ast::Ident) -> @ast::expr;
fn lambda(&self, span: Span, ids: ~[ast::Ident], blk: ast::Block) -> @ast::Expr;
fn lambda0(&self, span: Span, blk: ast::Block) -> @ast::Expr;
fn lambda1(&self, span: Span, blk: ast::Block, ident: ast::Ident) -> @ast::Expr;
fn lambda_expr(&self, span: Span, ids: ~[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: ~[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_stmts(&self, span: Span, ids: ~[ast::Ident], blk: ~[@ast::stmt]) -> @ast::expr;
fn lambda_stmts_0(&self, span: Span, stmts: ~[@ast::stmt]) -> @ast::expr;
fn lambda_stmts_1(&self, span: Span, stmts: ~[@ast::stmt], ident: ast::Ident) -> @ast::expr;
fn lambda_stmts(&self, span: Span, ids: ~[ast::Ident], blk: ~[@ast::Stmt]) -> @ast::Expr;
fn lambda_stmts_0(&self, span: Span, stmts: ~[@ast::Stmt]) -> @ast::Expr;
fn lambda_stmts_1(&self, span: Span, stmts: ~[@ast::Stmt], ident: ast::Ident) -> @ast::Expr;
// items
fn item(&self, span: Span,
@ -268,7 +268,7 @@ impl AstBuilder for @ExtCtxt {
}
}
fn ty_mt(&self, ty: ast::Ty, mutbl: ast::mutability) -> ast::mt {
fn ty_mt(&self, ty: ast::Ty, mutbl: ast::Mutability) -> ast::mt {
ast::mt {
ty: ~ty,
mutbl: mutbl
@ -300,16 +300,16 @@ impl AstBuilder for @ExtCtxt {
span: Span,
ty: ast::Ty,
lifetime: Option<ast::Lifetime>,
mutbl: ast::mutability)
mutbl: ast::Mutability)
-> ast::Ty {
self.ty(span,
ast::ty_rptr(lifetime, self.ty_mt(ty, mutbl)))
}
fn ty_uniq(&self, span: Span, ty: ast::Ty) -> ast::Ty {
self.ty(span, ast::ty_uniq(self.ty_mt(ty, ast::m_imm)))
self.ty(span, ast::ty_uniq(self.ty_mt(ty, ast::MutImmutable)))
}
fn ty_box(&self, span: Span,
ty: ast::Ty, mutbl: ast::mutability) -> ast::Ty {
ty: ast::Ty, mutbl: ast::Mutability) -> ast::Ty {
self.ty(span, ast::ty_box(self.ty_mt(ty, mutbl)))
}
@ -329,7 +329,7 @@ impl AstBuilder for @ExtCtxt {
fn ty_field_imm(&self, span: Span, name: Ident, ty: ast::Ty) -> ast::TypeField {
ast::TypeField {
ident: name,
mt: ast::mt { ty: ~ty, mutbl: ast::m_imm },
mt: ast::mt { ty: ~ty, mutbl: ast::MutImmutable },
span: span,
}
}
@ -389,11 +389,11 @@ impl AstBuilder for @ExtCtxt {
ast::Lifetime { id: self.next_id(), span: span, ident: ident }
}
fn stmt_expr(&self, expr: @ast::expr) -> @ast::stmt {
@respan(expr.span, ast::stmt_semi(expr, self.next_id()))
fn stmt_expr(&self, expr: @ast::Expr) -> @ast::Stmt {
@respan(expr.span, ast::StmtSemi(expr, self.next_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: @ast::Expr) -> @ast::Stmt {
let pat = self.pat_ident(sp, ident);
let local = @ast::Local {
is_mutbl: mutbl,
@ -403,8 +403,8 @@ impl AstBuilder for @ExtCtxt {
id: self.next_id(),
span: sp,
};
let decl = respan(sp, ast::decl_local(local));
@respan(sp, ast::stmt_decl(@decl, self.next_id()))
let decl = respan(sp, ast::DeclLocal(local));
@respan(sp, ast::StmtDecl(@decl, self.next_id()))
}
fn stmt_let_typed(&self,
@ -412,8 +412,8 @@ impl AstBuilder for @ExtCtxt {
mutbl: bool,
ident: ast::Ident,
typ: ast::Ty,
ex: @ast::expr)
-> @ast::stmt {
ex: @ast::Expr)
-> @ast::Stmt {
let pat = self.pat_ident(sp, ident);
let local = @ast::Local {
is_mutbl: mutbl,
@ -423,22 +423,22 @@ impl AstBuilder for @ExtCtxt {
id: self.next_id(),
span: sp,
};
let decl = respan(sp, ast::decl_local(local));
@respan(sp, ast::stmt_decl(@decl, self.next_id()))
let decl = respan(sp, ast::DeclLocal(local));
@respan(sp, ast::StmtDecl(@decl, self.next_id()))
}
fn block(&self, span: Span, stmts: ~[@ast::stmt], expr: Option<@expr>) -> ast::Block {
fn block(&self, span: Span, stmts: ~[@ast::Stmt], expr: Option<@Expr>) -> ast::Block {
self.block_all(span, ~[], stmts, expr)
}
fn block_expr(&self, expr: @ast::expr) -> ast::Block {
fn block_expr(&self, expr: @ast::Expr) -> ast::Block {
self.block_all(expr.span, ~[], ~[], Some(expr))
}
fn block_all(&self,
span: Span,
view_items: ~[ast::view_item],
stmts: ~[@ast::stmt],
expr: Option<@ast::expr>) -> ast::Block {
stmts: ~[@ast::Stmt],
expr: Option<@ast::Expr>) -> ast::Block {
ast::Block {
view_items: view_items,
stmts: stmts,
@ -449,122 +449,122 @@ impl AstBuilder for @ExtCtxt {
}
}
fn expr(&self, span: Span, node: ast::expr_) -> @ast::expr {
@ast::expr {
fn expr(&self, span: Span, node: ast::Expr_) -> @ast::Expr {
@ast::Expr {
id: self.next_id(),
node: node,
span: span,
}
}
fn expr_path(&self, path: ast::Path) -> @ast::expr {
self.expr(path.span, ast::expr_path(path))
fn expr_path(&self, path: ast::Path) -> @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) -> @ast::Expr {
self.expr_path(self.path_ident(span, id))
}
fn expr_self(&self, span: Span) -> @ast::expr {
self.expr(span, ast::expr_self)
fn expr_self(&self, span: Span) -> @ast::Expr {
self.expr(span, ast::ExprSelf)
}
fn expr_binary(&self, sp: Span, op: ast::binop,
lhs: @ast::expr, rhs: @ast::expr) -> @ast::expr {
self.expr(sp, ast::expr_binary(self.next_id(), op, lhs, rhs))
fn expr_binary(&self, sp: Span, op: ast::BinOp,
lhs: @ast::Expr, rhs: @ast::Expr) -> @ast::Expr {
self.expr(sp, ast::ExprBinary(self.next_id(), op, lhs, rhs))
}
fn expr_deref(&self, sp: Span, e: @ast::expr) -> @ast::expr {
self.expr_unary(sp, ast::deref, e)
fn expr_deref(&self, sp: Span, e: @ast::Expr) -> @ast::Expr {
self.expr_unary(sp, ast::UnDeref, e)
}
fn expr_unary(&self, sp: Span, op: ast::unop, e: @ast::expr)
-> @ast::expr {
self.expr(sp, ast::expr_unary(self.next_id(), op, e))
fn expr_unary(&self, sp: Span, op: ast::UnOp, e: @ast::Expr)
-> @ast::Expr {
self.expr(sp, ast::ExprUnary(self.next_id(), op, e))
}
fn expr_managed(&self, sp: Span, e: @ast::expr) -> @ast::expr {
self.expr_unary(sp, ast::box(ast::m_imm), e)
fn expr_managed(&self, sp: Span, e: @ast::Expr) -> @ast::Expr {
self.expr_unary(sp, ast::UnBox(ast::MutImmutable), e)
}
fn expr_field_access(&self, sp: Span, expr: @ast::expr, ident: ast::Ident) -> @ast::expr {
self.expr(sp, ast::expr_field(expr, ident, ~[]))
fn expr_field_access(&self, sp: Span, expr: @ast::Expr, ident: ast::Ident) -> @ast::Expr {
self.expr(sp, ast::ExprField(expr, ident, ~[]))
}
fn expr_addr_of(&self, sp: Span, e: @ast::expr) -> @ast::expr {
self.expr(sp, ast::expr_addr_of(ast::m_imm, e))
fn expr_addr_of(&self, sp: Span, e: @ast::Expr) -> @ast::Expr {
self.expr(sp, ast::ExprAddrOf(ast::MutImmutable, e))
}
fn expr_mut_addr_of(&self, sp: Span, e: @ast::expr) -> @ast::expr {
self.expr(sp, ast::expr_addr_of(ast::m_mutbl, e))
fn expr_mut_addr_of(&self, sp: Span, e: @ast::Expr) -> @ast::Expr {
self.expr(sp, ast::ExprAddrOf(ast::MutMutable, e))
}
fn expr_call(&self, span: Span, expr: @ast::expr, args: ~[@ast::expr]) -> @ast::expr {
self.expr(span, ast::expr_call(expr, args, ast::NoSugar))
fn expr_call(&self, span: Span, expr: @ast::Expr, args: ~[@ast::Expr]) -> @ast::Expr {
self.expr(span, ast::ExprCall(expr, args, ast::NoSugar))
}
fn expr_call_ident(&self, span: Span, id: ast::Ident, args: ~[@ast::expr]) -> @ast::expr {
fn expr_call_ident(&self, span: Span, id: ast::Ident, args: ~[@ast::Expr]) -> @ast::Expr {
self.expr(span,
ast::expr_call(self.expr_ident(span, id), args, ast::NoSugar))
ast::ExprCall(self.expr_ident(span, id), args, ast::NoSugar))
}
fn expr_call_global(&self, sp: Span, fn_path: ~[ast::Ident],
args: ~[@ast::expr]) -> @ast::expr {
args: ~[@ast::Expr]) -> @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: @ast::Expr,
ident: ast::Ident,
args: ~[@ast::expr]) -> @ast::expr {
args: ~[@ast::Expr]) -> @ast::Expr {
self.expr(span,
ast::expr_method_call(self.next_id(), expr, ident, ~[], args, ast::NoSugar))
ast::ExprMethodCall(self.next_id(), expr, ident, ~[], args, ast::NoSugar))
}
fn expr_block(&self, b: ast::Block) -> @ast::expr {
self.expr(b.span, ast::expr_block(b))
fn expr_block(&self, b: ast::Block) -> @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: @ast::Expr) -> ast::Field {
ast::Field { ident: name, expr: e, span: span }
}
fn expr_struct(&self, span: Span, path: ast::Path, fields: ~[ast::Field]) -> @ast::expr {
self.expr(span, ast::expr_struct(path, fields, None))
fn expr_struct(&self, span: Span, path: ast::Path, fields: ~[ast::Field]) -> @ast::Expr {
self.expr(span, ast::ExprStruct(path, fields, None))
}
fn expr_struct_ident(&self, span: Span,
id: ast::Ident, fields: ~[ast::Field]) -> @ast::expr {
id: ast::Ident, fields: ~[ast::Field]) -> @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::expr_lit(@respan(sp, lit)))
fn expr_lit(&self, sp: Span, lit: ast::lit_) -> @ast::Expr {
self.expr(sp, ast::ExprLit(@respan(sp, lit)))
}
fn expr_uint(&self, span: Span, i: uint) -> @ast::expr {
fn expr_uint(&self, span: Span, i: uint) -> @ast::Expr {
self.expr_lit(span, ast::lit_uint(i as u64, ast::ty_u))
}
fn expr_int(&self, sp: Span, i: int) -> @ast::expr {
fn expr_int(&self, sp: Span, i: int) -> @ast::Expr {
self.expr_lit(sp, ast::lit_int(i as i64, ast::ty_i))
}
fn expr_u8(&self, sp: Span, u: u8) -> @ast::expr {
fn expr_u8(&self, sp: Span, u: u8) -> @ast::Expr {
self.expr_lit(sp, ast::lit_uint(u as u64, ast::ty_u8))
}
fn expr_bool(&self, sp: Span, value: bool) -> @ast::expr {
fn expr_bool(&self, sp: Span, value: bool) -> @ast::Expr {
self.expr_lit(sp, ast::lit_bool(value))
}
fn expr_vstore(&self, sp: Span, expr: @ast::expr, vst: ast::expr_vstore) -> @ast::expr {
self.expr(sp, ast::expr_vstore(expr, vst))
fn expr_vstore(&self, sp: Span, expr: @ast::Expr, vst: ast::ExprVstore) -> @ast::Expr {
self.expr(sp, ast::ExprVstore(expr, vst))
}
fn expr_vec(&self, sp: Span, exprs: ~[@ast::expr]) -> @ast::expr {
self.expr(sp, ast::expr_vec(exprs, ast::m_imm))
fn expr_vec(&self, sp: Span, exprs: ~[@ast::Expr]) -> @ast::Expr {
self.expr(sp, ast::ExprVec(exprs, ast::MutImmutable))
}
fn expr_vec_uniq(&self, sp: Span, exprs: ~[@ast::expr]) -> @ast::expr {
self.expr_vstore(sp, self.expr_vec(sp, exprs), ast::expr_vstore_uniq)
fn expr_vec_uniq(&self, sp: Span, exprs: ~[@ast::Expr]) -> @ast::Expr {
self.expr_vstore(sp, self.expr_vec(sp, exprs), ast::ExprVstoreUniq)
}
fn expr_vec_slice(&self, sp: Span, exprs: ~[@ast::expr]) -> @ast::expr {
self.expr_vstore(sp, self.expr_vec(sp, exprs), ast::expr_vstore_slice)
fn expr_vec_slice(&self, sp: Span, exprs: ~[@ast::Expr]) -> @ast::Expr {
self.expr_vstore(sp, self.expr_vec(sp, exprs), ast::ExprVstoreSlice)
}
fn expr_str(&self, sp: Span, s: @str) -> @ast::expr {
fn expr_str(&self, sp: Span, s: @str) -> @ast::Expr {
self.expr_lit(sp, ast::lit_str(s))
}
fn expr_str_uniq(&self, sp: Span, s: @str) -> @ast::expr {
self.expr_vstore(sp, self.expr_str(sp, s), ast::expr_vstore_uniq)
fn expr_str_uniq(&self, sp: Span, s: @str) -> @ast::Expr {
self.expr_vstore(sp, self.expr_str(sp, s), ast::ExprVstoreUniq)
}
fn expr_unreachable(&self, span: Span) -> @ast::expr {
fn expr_unreachable(&self, span: Span) -> @ast::Expr {
let loc = self.codemap().lookup_char_pos(span.lo);
self.expr_call_global(
span,
@ -582,110 +582,110 @@ impl AstBuilder for @ExtCtxt {
}
fn pat(&self, span: Span, pat: ast::pat_) -> @ast::pat {
@ast::pat { id: self.next_id(), node: pat, span: span }
fn pat(&self, span: Span, pat: ast::Pat_) -> @ast::Pat {
@ast::Pat { id: self.next_id(), node: pat, span: span }
}
fn pat_wild(&self, span: Span) -> @ast::pat {
self.pat(span, ast::pat_wild)
fn pat_wild(&self, span: Span) -> @ast::Pat {
self.pat(span, ast::PatWild)
}
fn pat_lit(&self, span: Span, expr: @ast::expr) -> @ast::pat {
self.pat(span, ast::pat_lit(expr))
fn pat_lit(&self, span: Span, expr: @ast::Expr) -> @ast::Pat {
self.pat(span, ast::PatLit(expr))
}
fn pat_ident(&self, span: Span, ident: ast::Ident) -> @ast::pat {
self.pat_ident_binding_mode(span, ident, ast::bind_infer)
fn pat_ident(&self, span: Span, ident: ast::Ident) -> @ast::Pat {
self.pat_ident_binding_mode(span, ident, ast::BindInfer)
}
fn pat_ident_binding_mode(&self,
span: Span,
ident: ast::Ident,
bm: ast::binding_mode) -> @ast::pat {
bm: ast::BindingMode) -> @ast::Pat {
let path = self.path_ident(span, ident);
let pat = ast::pat_ident(bm, path, None);
let pat = ast::PatIdent(bm, path, None);
self.pat(span, pat)
}
fn pat_enum(&self, span: Span, path: ast::Path, subpats: ~[@ast::pat]) -> @ast::pat {
let pat = ast::pat_enum(path, Some(subpats));
fn pat_enum(&self, span: Span, path: ast::Path, subpats: ~[@ast::Pat]) -> @ast::Pat {
let pat = ast::PatEnum(path, Some(subpats));
self.pat(span, pat)
}
fn pat_struct(&self, span: Span,
path: ast::Path, field_pats: ~[ast::field_pat]) -> @ast::pat {
let pat = ast::pat_struct(path, field_pats, false);
path: ast::Path, field_pats: ~[ast::FieldPat]) -> @ast::Pat {
let pat = ast::PatStruct(path, field_pats, false);
self.pat(span, pat)
}
fn arm(&self, _span: Span, pats: ~[@ast::pat], expr: @ast::expr) -> ast::arm {
ast::arm {
fn arm(&self, _span: Span, pats: ~[@ast::Pat], expr: @ast::Expr) -> ast::Arm {
ast::Arm {
pats: pats,
guard: None,
body: self.block_expr(expr)
}
}
fn arm_unreachable(&self, span: Span) -> ast::arm {
fn arm_unreachable(&self, span: Span) -> ast::Arm {
self.arm(span, ~[self.pat_wild(span)], self.expr_unreachable(span))
}
fn expr_match(&self, span: Span, arg: @ast::expr, arms: ~[ast::arm]) -> @expr {
self.expr(span, ast::expr_match(arg, arms))
fn expr_match(&self, span: Span, arg: @ast::Expr, arms: ~[ast::Arm]) -> @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: @ast::Expr, then: @ast::Expr, els: Option<@ast::Expr>) -> @ast::Expr {
let els = els.map_move(|x| self.expr_block(self.block_expr(x)));
self.expr(span, ast::expr_if(cond, self.block_expr(then), els))
self.expr(span, ast::ExprIf(cond, self.block_expr(then), els))
}
fn lambda_fn_decl(&self, span: Span, fn_decl: ast::fn_decl, blk: ast::Block) -> @ast::expr {
self.expr(span, ast::expr_fn_block(fn_decl, blk))
fn lambda_fn_decl(&self, span: Span, fn_decl: ast::fn_decl, blk: ast::Block) -> @ast::Expr {
self.expr(span, ast::ExprFnBlock(fn_decl, blk))
}
fn lambda(&self, span: Span, ids: ~[ast::Ident], blk: ast::Block) -> @ast::expr {
fn lambda(&self, span: Span, ids: ~[ast::Ident], blk: ast::Block) -> @ast::Expr {
let fn_decl = self.fn_decl(
ids.map(|id| self.arg(span, *id, self.ty_infer(span))),
self.ty_infer(span));
self.expr(span, ast::expr_fn_block(fn_decl, blk))
self.expr(span, ast::ExprFnBlock(fn_decl, blk))
}
#[cfg(stage0)]
fn lambda0(&self, _span: Span, blk: ast::Block) -> @ast::expr {
fn lambda0(&self, _span: Span, blk: ast::Block) -> @ast::Expr {
let ext_cx = *self;
let blk_e = self.expr(blk.span, ast::expr_block(blk.clone()));
let blk_e = self.expr(blk.span, ast::ExprBlock(blk.clone()));
quote_expr!(|| $blk_e )
}
#[cfg(not(stage0))]
fn lambda0(&self, _span: Span, blk: ast::Block) -> @ast::expr {
let blk_e = self.expr(blk.span, ast::expr_block(blk.clone()));
fn lambda0(&self, _span: Span, blk: ast::Block) -> @ast::Expr {
let blk_e = self.expr(blk.span, ast::ExprBlock(blk.clone()));
quote_expr!(*self, || $blk_e )
}
#[cfg(stage0)]
fn lambda1(&self, _span: Span, blk: ast::Block, ident: ast::Ident) -> @ast::expr {
fn lambda1(&self, _span: Span, blk: ast::Block, ident: ast::Ident) -> @ast::Expr {
let ext_cx = *self;
let blk_e = self.expr(blk.span, ast::expr_block(blk.clone()));
let blk_e = self.expr(blk.span, ast::ExprBlock(blk.clone()));
quote_expr!(|$ident| $blk_e )
}
#[cfg(not(stage0))]
fn lambda1(&self, _span: Span, blk: ast::Block, ident: ast::Ident) -> @ast::expr {
let blk_e = self.expr(blk.span, ast::expr_block(blk.clone()));
fn lambda1(&self, _span: Span, blk: ast::Block, ident: ast::Ident) -> @ast::Expr {
let blk_e = self.expr(blk.span, ast::ExprBlock(blk.clone()));
quote_expr!(*self, |$ident| $blk_e )
}
fn lambda_expr(&self, span: Span, ids: ~[ast::Ident], expr: @ast::expr) -> @ast::expr {
fn lambda_expr(&self, span: Span, ids: ~[ast::Ident], expr: @ast::Expr) -> @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: @ast::Expr) -> @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: @ast::Expr, ident: ast::Ident) -> @ast::Expr {
self.lambda1(span, self.block_expr(expr), ident)
}
fn lambda_stmts(&self, span: Span, ids: ~[ast::Ident], stmts: ~[@ast::stmt]) -> @ast::expr {
fn lambda_stmts(&self, span: Span, ids: ~[ast::Ident], stmts: ~[@ast::Stmt]) -> @ast::Expr {
self.lambda(span, ids, self.block(span, stmts, None))
}
fn lambda_stmts_0(&self, span: Span, stmts: ~[@ast::stmt]) -> @ast::expr {
fn lambda_stmts_0(&self, span: Span, stmts: ~[@ast::Stmt]) -> @ast::Expr {
self.lambda0(span, self.block(span, stmts, None))
}
fn lambda_stmts_1(&self, span: Span, stmts: ~[@ast::stmt], ident: ast::Ident) -> @ast::expr {
fn lambda_stmts_1(&self, span: Span, stmts: ~[@ast::Stmt], ident: ast::Ident) -> @ast::Expr {
self.lambda1(span, self.block(span, stmts, None), ident)
}
@ -889,8 +889,8 @@ pub trait Duplicate {
fn duplicate(&self, cx: @ExtCtxt) -> Self;
}
impl Duplicate for @ast::expr {
fn duplicate(&self, cx: @ExtCtxt) -> @ast::expr {
impl Duplicate for @ast::Expr {
fn duplicate(&self, cx: @ExtCtxt) -> @ast::Expr {
let folder = fold::default_ast_fold();
let folder = @fold::AstFoldFns {
new_id: |_| cx.next_id(),

2
src/libsyntax/ext/bytes.rs
View file

@ -24,7 +24,7 @@ pub fn expand_syntax_ext(cx: @ExtCtxt, sp: Span, tts: &[ast::token_tree]) -> bas
for expr in exprs.iter() {
match expr.node {
// expression is a literal
ast::expr_lit(lit) => match lit.node {
ast::ExprLit(lit) => match lit.node {
// string literal, push each byte to vector expression
ast::lit_str(s) => {
for byte in s.byte_iter() {

4
src/libsyntax/ext/concat_idents.rs
View file

@ -34,9 +34,9 @@ pub fn expand_syntax_ext(cx: @ExtCtxt, sp: Span, tts: &[ast::token_tree])
}
let res = str_to_ident(res_str);
let e = @ast::expr {
let e = @ast::Expr {
id: cx.next_id(),
node: ast::expr_path(
node: ast::ExprPath(
ast::Path {
span: sp,
global: false,

4
src/libsyntax/ext/deriving/clone.rs
View file

@ -8,7 +8,7 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
use ast::{MetaItem, item, expr};
use ast::{MetaItem, item, Expr};
use codemap::Span;
use ext::base::ExtCtxt;
use ext::build::AstBuilder;
@ -69,7 +69,7 @@ pub fn expand_deriving_deep_clone(cx: @ExtCtxt,
fn cs_clone(
name: &str,
cx: @ExtCtxt, span: Span,
substr: &Substructure) -> @expr {
substr: &Substructure) -> @Expr {
let clone_ident = substr.method_ident;
let ctor_ident;
let all_fields;

6
src/libsyntax/ext/deriving/cmp/eq.rs
View file

@ -8,7 +8,7 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
use ast::{MetaItem, item, expr};
use ast::{MetaItem, item, Expr};
use codemap::Span;
use ext::base::ExtCtxt;
use ext::build::AstBuilder;
@ -20,11 +20,11 @@ pub fn expand_deriving_eq(cx: @ExtCtxt,
in_items: ~[@item]) -> ~[@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: @ExtCtxt, span: Span, substr: &Substructure) -> @expr {
fn cs_eq(cx: @ExtCtxt, span: Span, substr: &Substructure) -> @Expr {
cs_and(|cx, span, _, _| cx.expr_bool(span, false),
cx, span, substr)
}
fn cs_ne(cx: @ExtCtxt, span: Span, substr: &Substructure) -> @expr {
fn cs_ne(cx: @ExtCtxt, span: Span, substr: &Substructure) -> @Expr {
cs_or(|cx, span, _, _| cx.expr_bool(span, true),
cx, span, substr)
}

12
src/libsyntax/ext/deriving/cmp/ord.rs
View file

@ -9,7 +9,7 @@
// except according to those terms.
use ast;
use ast::{MetaItem, item, expr};
use ast::{MetaItem, item, Expr};
use codemap::Span;
use ext::base::ExtCtxt;
use ext::build::AstBuilder;
@ -48,8 +48,8 @@ pub fn expand_deriving_ord(cx: @ExtCtxt,
}
/// Strict inequality.
fn cs_op(less: bool, equal: bool, cx: @ExtCtxt, span: Span, substr: &Substructure) -> @expr {
let op = if less {ast::lt} else {ast::gt};
fn cs_op(less: bool, equal: bool, cx: @ExtCtxt, span: Span, substr: &Substructure) -> @Expr {
let op = if less {ast::BiLt} else {ast::BiGt};
cs_fold(
false, // need foldr,
|cx, span, subexpr, self_f, other_fs| {
@ -79,13 +79,13 @@ fn cs_op(less: bool, equal: bool, cx: @ExtCtxt, span: Span, substr: &Substructur
cx.expr_deref(span, self_f),
cx.expr_deref(span, other_f));
let not_cmp = cx.expr_unary(span, ast::not,
let not_cmp = cx.expr_unary(span, ast::UnNot,
cx.expr_binary(span, op,
cx.expr_deref(span, other_f),
cx.expr_deref(span, self_f)));
let and = cx.expr_binary(span, ast::and, not_cmp, subexpr);
cx.expr_binary(span, ast::or, cmp, and)
let and = cx.expr_binary(span, ast::BiAnd, not_cmp, subexpr);
cx.expr_binary(span, ast::BiOr, cmp, and)
},
cx.expr_bool(span, equal),
|cx, span, args, _| {

4
src/libsyntax/ext/deriving/cmp/totaleq.rs
View file

@ -8,7 +8,7 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
use ast::{MetaItem, item, expr};
use ast::{MetaItem, item, Expr};
use codemap::Span;
use ext::base::ExtCtxt;
use ext::build::AstBuilder;
@ -18,7 +18,7 @@ pub fn expand_deriving_totaleq(cx: @ExtCtxt,
span: Span,
mitem: @MetaItem,
in_items: ~[@item]) -> ~[@item] {
fn cs_equals(cx: @ExtCtxt, span: Span, substr: &Substructure) -> @expr {
fn cs_equals(cx: @ExtCtxt, span: Span, substr: &Substructure) -> @Expr {
cs_and(|cx, span, _, _| cx.expr_bool(span, false),
cx, span, substr)
}

6
src/libsyntax/ext/deriving/cmp/totalord.rs
View file

@ -9,7 +9,7 @@
// except according to those terms.
use ast;
use ast::{MetaItem, item, expr};
use ast::{MetaItem, item, Expr};
use codemap::Span;
use ext::base::ExtCtxt;
use ext::build::AstBuilder;
@ -54,7 +54,7 @@ pub fn ordering_const(cx: @ExtCtxt, span: Span, cnst: Ordering) -> ast::Path {
}
pub fn cs_cmp(cx: @ExtCtxt, span: Span,
substr: &Substructure) -> @expr {
substr: &Substructure) -> @Expr {
let test_id = cx.ident_of("__test");
let equals_path = ordering_const(cx, span, Equal);
@ -89,7 +89,7 @@ pub fn cs_cmp(cx: @ExtCtxt, span: Span,
let assign = cx.stmt_let(span, false, test_id, new);
let cond = cx.expr_binary(span, ast::eq,
let cond = cx.expr_binary(span, ast::BiEq,
cx.expr_ident(span, test_id),
cx.expr_path(equals_path.clone()));
let if_ = cx.expr_if(span,

6
src/libsyntax/ext/deriving/decodable.rs
View file

@ -15,7 +15,7 @@ encodable.rs for more.
use std::vec;
use ast::{MetaItem, item, expr, m_mutbl};
use ast::{MetaItem, item, Expr, MutMutable};
use codemap::Span;
use ext::base::ExtCtxt;
use ext::build::AstBuilder;
@ -39,7 +39,7 @@ pub fn expand_deriving_decodable(cx: @ExtCtxt,
generics: LifetimeBounds::empty(),
explicit_self: None,
args: ~[Ptr(~Literal(Path::new_local("__D")),
Borrowed(None, m_mutbl))],
Borrowed(None, MutMutable))],
ret_ty: Self,
const_nonmatching: true,
combine_substructure: decodable_substructure,
@ -51,7 +51,7 @@ pub fn expand_deriving_decodable(cx: @ExtCtxt,
}
fn decodable_substructure(cx: @ExtCtxt, span: Span,
substr: &Substructure) -> @expr {
substr: &Substructure) -> @Expr {
let decoder = substr.nonself_args[0];
let recurse = ~[cx.ident_of("extra"),
cx.ident_of("serialize"),

8
src/libsyntax/ext/deriving/encodable.rs
View file

@ -75,7 +75,7 @@ would yield functions like:
}
*/
use ast::{MetaItem, item, expr, m_imm, m_mutbl};
use ast::{MetaItem, item, Expr, MutImmutable, MutMutable};
use codemap::Span;
use ext::base::ExtCtxt;
use ext::build::AstBuilder;
@ -97,9 +97,9 @@ pub fn expand_deriving_encodable(cx: @ExtCtxt,
MethodDef {
name: "encode",
generics: LifetimeBounds::empty(),
explicit_self: Some(Some(Borrowed(None, m_imm))),
explicit_self: Some(Some(Borrowed(None, MutImmutable))),
args: ~[Ptr(~Literal(Path::new_local("__E")),
Borrowed(None, m_mutbl))],
Borrowed(None, MutMutable))],
ret_ty: nil_ty(),
const_nonmatching: true,
combine_substructure: encodable_substructure,
@ -111,7 +111,7 @@ pub fn expand_deriving_encodable(cx: @ExtCtxt,
}
fn encodable_substructure(cx: @ExtCtxt, span: Span,
substr: &Substructure) -> @expr {
substr: &Substructure) -> @Expr {
let encoder = substr.nonself_args[0];
// throw an underscore in front to suppress unused variable warnings
let blkarg = cx.ident_of("_e");

118
src/libsyntax/ext/deriving/generic.rs
View file

@ -163,7 +163,7 @@ StaticEnum(<ast::enum_def of C>, ~[(<ident of C0>, Left(1)),
*/
use ast;
use ast::{enum_def, expr, Ident, Generics, struct_def};
use ast::{enum_def, Expr, Ident, Generics, struct_def};
use ext::base::ExtCtxt;
use ext::build::AstBuilder;
@ -220,9 +220,9 @@ pub struct Substructure<'self> {
/// ident of the method
method_ident: Ident,
/// dereferenced access to any Self or Ptr(Self, _) arguments
self_args: &'self [@expr],
self_args: &'self [@Expr],
/// verbatim access to any other arguments
nonself_args: &'self [@expr],
nonself_args: &'self [@Expr],
fields: &'self SubstructureFields<'self>
}
@ -234,21 +234,21 @@ pub enum SubstructureFields<'self> {
ident is the ident of the current field (`None` for all fields in tuple
structs).
*/
Struct(~[(Option<Ident>, @expr, ~[@expr])]),
Struct(~[(Option<Ident>, @Expr, ~[@Expr])]),
/**
Matching variants of the enum: variant index, ast::variant,
fields: `(field ident, self, [others])`, where the field ident is
only non-`None` in the case of a struct variant.
*/
EnumMatching(uint, &'self ast::variant, ~[(Option<Ident>, @expr, ~[@expr])]),
EnumMatching(uint, &'self ast::variant, ~[(Option<Ident>, @Expr, ~[@Expr])]),
/**
non-matching variants of the enum, [(variant index, ast::variant,
[field ident, fields])] (i.e. all fields for self are in the
first tuple, for other1 are in the second tuple, etc.)
*/
EnumNonMatching(&'self [(uint, ast::variant, ~[(Option<Ident>, @expr)])]),
EnumNonMatching(&'self [(uint, ast::variant, ~[(Option<Ident>, @Expr)])]),
/// A static method where Self is a struct
StaticStruct(&'self ast::struct_def, Either<uint, ~[Ident]>),
@ -263,7 +263,7 @@ Combine the values of all the fields together. The last argument is
all the fields of all the structures, see above for details.
*/
pub type CombineSubstructureFunc<'self> =
&'self fn(@ExtCtxt, Span, &Substructure) -> @expr;
&'self fn(@ExtCtxt, Span, &Substructure) -> @Expr;
/**
Deal with non-matching enum variants, the arguments are a list
@ -273,8 +273,8 @@ representing each variant: (variant index, ast::variant instance,
pub type EnumNonMatchFunc<'self> =
&'self fn(@ExtCtxt, Span,
&[(uint, ast::variant,
~[(Option<Ident>, @expr)])],
&[@expr]) -> @expr;
~[(Option<Ident>, @Expr)])],
&[@Expr]) -> @Expr;
impl<'self> TraitDef<'self> {
@ -440,10 +440,10 @@ impl<'self> MethodDef<'self> {
cx: @ExtCtxt,
span: Span,
type_ident: Ident,
self_args: &[@expr],
nonself_args: &[@expr],
self_args: &[@Expr],
nonself_args: &[@Expr],
fields: &SubstructureFields)
-> @expr {
-> @Expr {
let substructure = Substructure {
type_ident: type_ident,
method_ident: cx.ident_of(self.name),
@ -466,7 +466,7 @@ impl<'self> MethodDef<'self> {
fn split_self_nonself_args(&self, cx: @ExtCtxt, span: Span,
type_ident: Ident, generics: &Generics)
-> (ast::explicit_self, ~[@expr], ~[@expr], ~[(Ident, ast::Ty)]) {
-> (ast::explicit_self, ~[@Expr], ~[@Expr], ~[(Ident, ast::Ty)]) {
let mut self_args = ~[];
let mut nonself_args = ~[];
@ -515,7 +515,7 @@ impl<'self> MethodDef<'self> {
generics: &Generics,
explicit_self: ast::explicit_self,
arg_types: ~[(Ident, ast::Ty)],
body: @expr) -> @ast::method {
body: @Expr) -> @ast::method {
// create the generics that aren't for Self
let fn_generics = self.generics.to_generics(cx, span, type_ident, generics);
@ -572,9 +572,9 @@ impl<'self> MethodDef<'self> {
span: Span,
struct_def: &struct_def,
type_ident: Ident,
self_args: &[@expr],
nonself_args: &[@expr])
-> @expr {
self_args: &[@Expr],
nonself_args: &[@Expr])
-> @Expr {
let mut raw_fields = ~[]; // ~[[fields of self],
// [fields of next Self arg], [etc]]
@ -582,7 +582,7 @@ impl<'self> MethodDef<'self> {
for i in range(0u, self_args.len()) {
let (pat, ident_expr) = create_struct_pattern(cx, span,
type_ident, struct_def,
fmt!("__self_%u", i), ast::m_imm);
fmt!("__self_%u", i), ast::MutImmutable);
patterns.push(pat);
raw_fields.push(ident_expr);
}
@ -626,9 +626,9 @@ impl<'self> MethodDef<'self> {
span: Span,
struct_def: &struct_def,
type_ident: Ident,
self_args: &[@expr],
nonself_args: &[@expr])
-> @expr {
self_args: &[@Expr],
nonself_args: &[@Expr])
-> @Expr {
let summary = summarise_struct(cx, span, struct_def);
self.call_substructure_method(cx, span,
@ -668,9 +668,9 @@ impl<'self> MethodDef<'self> {
span: Span,
enum_def: &enum_def,
type_ident: Ident,
self_args: &[@expr],
nonself_args: &[@expr])
-> @expr {
self_args: &[@Expr],
nonself_args: &[@Expr])
-> @Expr {
let mut matches = ~[];
self.build_enum_match(cx, span, enum_def, type_ident,
self_args, nonself_args,
@ -703,12 +703,12 @@ impl<'self> MethodDef<'self> {
cx: @ExtCtxt, span: Span,
enum_def: &enum_def,
type_ident: Ident,
self_args: &[@expr],
nonself_args: &[@expr],
self_args: &[@Expr],
nonself_args: &[@Expr],
matching: Option<uint>,
matches_so_far: &mut ~[(uint, ast::variant,
~[(Option<Ident>, @expr)])],
match_count: uint) -> @expr {
~[(Option<Ident>, @Expr)])],
match_count: uint) -> @Expr {
if match_count == self_args.len() {
// we've matched against all arguments, so make the final
// expression at the bottom of the match tree
@ -787,7 +787,7 @@ impl<'self> MethodDef<'self> {
let (pattern, idents) = create_enum_variant_pattern(cx, span,
variant,
current_match_str,
ast::m_imm);
ast::MutImmutable);
matches_so_far.push((index,
/*bad*/ (*variant).clone(),
@ -818,7 +818,7 @@ impl<'self> MethodDef<'self> {
let (pattern, idents) = create_enum_variant_pattern(cx, span,
variant,
current_match_str,
ast::m_imm);
ast::MutImmutable);
matches_so_far.push((index,
/*bad*/ (*variant).clone(),
@ -853,9 +853,9 @@ impl<'self> MethodDef<'self> {
span: Span,
enum_def: &enum_def,
type_ident: Ident,
self_args: &[@expr],
nonself_args: &[@expr])
-> @expr {
self_args: &[@Expr],
nonself_args: &[@Expr])
-> @Expr {
let summary = do enum_def.variants.map |v| {
let ident = v.node.name;
let summary = match v.node.kind {
@ -898,11 +898,11 @@ fn summarise_struct(cx: @ExtCtxt, span: Span,
pub fn create_subpatterns(cx: @ExtCtxt,
span: Span,
field_paths: ~[ast::Path],
mutbl: ast::mutability)
-> ~[@ast::pat] {
mutbl: ast::Mutability)
-> ~[@ast::Pat] {
do field_paths.map |path| {
cx.pat(span,
ast::pat_ident(ast::bind_by_ref(mutbl), (*path).clone(), None))
ast::PatIdent(ast::BindByRef(mutbl), (*path).clone(), None))
}
}
@ -916,12 +916,12 @@ fn create_struct_pattern(cx: @ExtCtxt,
struct_ident: Ident,
struct_def: &struct_def,
prefix: &str,
mutbl: ast::mutability)
-> (@ast::pat, ~[(Option<Ident>, @expr)]) {
mutbl: ast::Mutability)
-> (@ast::Pat, ~[(Option<Ident>, @Expr)]) {
if struct_def.fields.is_empty() {
return (
cx.pat_ident_binding_mode(
span, struct_ident, ast::bind_infer),
span, struct_ident, ast::BindInfer),
~[]);
}
@ -961,7 +961,7 @@ fn create_struct_pattern(cx: @ExtCtxt,
let field_pats = do vec::build |push| {
for (&pat, &(id, _)) in subpats.iter().zip(ident_expr.iter()) {
// id is guaranteed to be Some
push(ast::field_pat { ident: id.unwrap(), pat: pat })
push(ast::FieldPat { ident: id.unwrap(), pat: pat })
}
};
cx.pat_struct(span, matching_path, field_pats)
@ -976,15 +976,15 @@ fn create_enum_variant_pattern(cx: @ExtCtxt,
span: Span,
variant: &ast::variant,
prefix: &str,
mutbl: ast::mutability)
-> (@ast::pat, ~[(Option<Ident>, @expr)]) {
mutbl: ast::Mutability)
-> (@ast::Pat, ~[(Option<Ident>, @Expr)]) {
let variant_ident = variant.node.name;
match variant.node.kind {
ast::tuple_variant_kind(ref variant_args) => {
if variant_args.is_empty() {
return (cx.pat_ident_binding_mode(
span, variant_ident, ast::bind_infer), ~[]);
span, variant_ident, ast::BindInfer), ~[]);
}
let matching_path = cx.path_ident(span, variant_ident);
@ -1023,13 +1023,13 @@ left-to-right (`true`) or right-to-left (`false`).
*/
pub fn cs_fold(use_foldl: bool,
f: &fn(@ExtCtxt, Span,
old: @expr,
self_f: @expr,
other_fs: &[@expr]) -> @expr,
base: @expr,
old: @Expr,
self_f: @Expr,
other_fs: &[@Expr]) -> @Expr,
base: @Expr,
enum_nonmatch_f: EnumNonMatchFunc,
cx: @ExtCtxt, span: Span,
substructure: &Substructure) -> @expr {
substructure: &Substructure) -> @Expr {
match *substructure.fields {
EnumMatching(_, _, ref all_fields) | Struct(ref all_fields) => {
if use_foldl {
@ -1064,10 +1064,10 @@ f(cx, span, ~[self_1.method(__arg_1_1, __arg_2_1),
~~~
*/
#[inline]
pub fn cs_same_method(f: &fn(@ExtCtxt, Span, ~[@expr]) -> @expr,
pub fn cs_same_method(f: &fn(@ExtCtxt, Span, ~[@Expr]) -> @Expr,
enum_nonmatch_f: EnumNonMatchFunc,
cx: @ExtCtxt, span: Span,
substructure: &Substructure) -> @expr {
substructure: &Substructure) -> @Expr {
match *substructure.fields {
EnumMatching(_, _, ref all_fields) | Struct(ref all_fields) => {
// call self_n.method(other_1_n, other_2_n, ...)
@ -1097,11 +1097,11 @@ fields. `use_foldl` controls whether this is done left-to-right
*/
#[inline]
pub fn cs_same_method_fold(use_foldl: bool,
f: &fn(@ExtCtxt, Span, @expr, @expr) -> @expr,
base: @expr,
f: &fn(@ExtCtxt, Span, @Expr, @Expr) -> @Expr,
base: @Expr,
enum_nonmatch_f: EnumNonMatchFunc,
cx: @ExtCtxt, span: Span,
substructure: &Substructure) -> @expr {
substructure: &Substructure) -> @Expr {
cs_same_method(
|cx, span, vals| {
if use_foldl {
@ -1124,10 +1124,10 @@ Use a given binop to combine the result of calling the derived method
on all the fields.
*/
#[inline]
pub fn cs_binop(binop: ast::binop, base: @expr,
pub fn cs_binop(binop: ast::BinOp, base: @Expr,
enum_nonmatch_f: EnumNonMatchFunc,
cx: @ExtCtxt, span: Span,
substructure: &Substructure) -> @expr {
substructure: &Substructure) -> @Expr {
cs_same_method_fold(
true, // foldl is good enough
|cx, span, old, new| {
@ -1145,8 +1145,8 @@ pub fn cs_binop(binop: ast::binop, base: @expr,
#[inline]
pub fn cs_or(enum_nonmatch_f: EnumNonMatchFunc,
cx: @ExtCtxt, span: Span,
substructure: &Substructure) -> @expr {
cs_binop(ast::or, cx.expr_bool(span, false),
substructure: &Substructure) -> @Expr {
cs_binop(ast::BiOr, cx.expr_bool(span, false),
enum_nonmatch_f,
cx, span, substructure)
}
@ -1154,8 +1154,8 @@ pub fn cs_or(enum_nonmatch_f: EnumNonMatchFunc,
#[inline]
pub fn cs_and(enum_nonmatch_f: EnumNonMatchFunc,
cx: @ExtCtxt, span: Span,
substructure: &Substructure) -> @expr {
cs_binop(ast::and, cx.expr_bool(span, true),
substructure: &Substructure) -> @Expr {
cs_binop(ast::BiAnd, cx.expr_bool(span, true),
enum_nonmatch_f,
cx, span, substructure)
}

6
src/libsyntax/ext/deriving/iter_bytes.rs
View file

@ -8,7 +8,7 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
use ast::{MetaItem, item, expr, and};
use ast::{MetaItem, item, Expr, BiAnd};
use codemap::Span;
use ext::base::ExtCtxt;
use ext::build::AstBuilder;
@ -42,7 +42,7 @@ pub fn expand_deriving_iter_bytes(cx: @ExtCtxt,
trait_def.expand(cx, span, mitem, in_items)
}
fn iter_bytes_substructure(cx: @ExtCtxt, span: Span, substr: &Substructure) -> @expr {
fn iter_bytes_substructure(cx: @ExtCtxt, span: Span, substr: &Substructure) -> @Expr {
let (lsb0, f)= match substr.nonself_args {
[l, f] => (l, f),
_ => cx.span_bug(span, "Incorrect number of arguments in `deriving(IterBytes)`")
@ -90,6 +90,6 @@ fn iter_bytes_substructure(cx: @ExtCtxt, span: Span, substr: &Substructure) -> @
}
do exprs.slice(1, exprs.len()).iter().fold(exprs[0]) |prev, me| {
cx.expr_binary(span, and, prev, *me)
cx.expr_binary(span, BiAnd, prev, *me)
}
}

12
src/libsyntax/ext/deriving/rand.rs
View file

@ -9,7 +9,7 @@
// except according to those terms.
use ast;
use ast::{MetaItem, item, expr, Ident};
use ast::{MetaItem, item, Expr, Ident};
use codemap::Span;
use ext::base::ExtCtxt;
use ext::build::{AstBuilder, Duplicate};
@ -37,7 +37,7 @@ pub fn expand_deriving_rand(cx: @ExtCtxt,
explicit_self: None,
args: ~[
Ptr(~Literal(Path::new_local("R")),
Borrowed(None, ast::m_mutbl))
Borrowed(None, ast::MutMutable))
],
ret_ty: Self,
const_nonmatching: false,
@ -48,7 +48,7 @@ pub fn expand_deriving_rand(cx: @ExtCtxt,
trait_def.expand(cx, span, mitem, in_items)
}
fn rand_substructure(cx: @ExtCtxt, span: Span, substr: &Substructure) -> @expr {
fn rand_substructure(cx: @ExtCtxt, span: Span, substr: &Substructure) -> @Expr {
let rng = match substr.nonself_args {
[rng] => ~[ rng ],
_ => cx.bug("Incorrect number of arguments to `rand` in `deriving(Rand)`")
@ -100,7 +100,7 @@ fn rand_substructure(cx: @ExtCtxt, span: Span, substr: &Substructure) -> @expr {
// rand() % variants.len()
let value_ref = cx.expr_ident(span, value_ident);
let rand_variant = cx.expr_binary(span,
ast::rem,
ast::BiRem,
value_ref,
variant_count);
@ -115,7 +115,7 @@ fn rand_substructure(cx: @ExtCtxt, span: Span, substr: &Substructure) -> @expr {
rand_thing(cx, span, ident, summary, || rand_call()))
}
}
}.collect::<~[ast::arm]>();
}.collect::<~[ast::Arm]>();
// _ => {} at the end. Should never occur
arms.push(cx.arm_unreachable(span));
@ -131,7 +131,7 @@ fn rand_substructure(cx: @ExtCtxt, span: Span, substr: &Substructure) -> @expr {
fn rand_thing(cx: @ExtCtxt, span: Span,
ctor_ident: Ident,
summary: &Either<uint, ~[Ident]>,
rand_call: &fn() -> @expr) -> @expr {
rand_call: &fn() -> @Expr) -> @Expr {
match *summary {
Left(count) => {
if count == 0 {

8
src/libsyntax/ext/deriving/to_str.rs
View file

@ -9,7 +9,7 @@
// except according to those terms.
use ast;
use ast::{MetaItem, item, expr};
use ast::{MetaItem, item, Expr};
use codemap::Span;
use ext::base::ExtCtxt;
use ext::build::AstBuilder;
@ -44,11 +44,11 @@ pub fn expand_deriving_to_str(cx: @ExtCtxt,
// to_str() method on each field. Hence we mirror the logic of the log_str()
// method, but with tweaks to call to_str() on sub-fields.
fn to_str_substructure(cx: @ExtCtxt, span: Span,
substr: &Substructure) -> @expr {
substr: &Substructure) -> @Expr {
let to_str = cx.ident_of("to_str");
let doit = |start: &str, end: @str, name: ast::Ident,
fields: &[(Option<ast::Ident>, @expr, ~[@expr])]| {
fields: &[(Option<ast::Ident>, @Expr, ~[@Expr])]| {
if fields.len() == 0 {
cx.expr_str_uniq(span, cx.str_of(name))
} else {
@ -58,7 +58,7 @@ fn to_str_substructure(cx: @ExtCtxt, span: Span,
let mut stmts = ~[cx.stmt_let(span, true, buf, init)];
let push_str = cx.ident_of("push_str");
let push = |s: @expr| {
let push = |s: @Expr| {
let ebuf = cx.expr_ident(span, buf);
let call = cx.expr_method_call(span, ebuf, push_str, ~[s]);
stmts.push(cx.stmt_expr(call));

10
src/libsyntax/ext/deriving/ty.rs
View file

@ -14,7 +14,7 @@ explicit `Self` type to use when specifying impls to be derived.
*/
use ast;
use ast::{expr,Generics,Ident};
use ast::{Expr,Generics,Ident};
use ext::base::ExtCtxt;
use ext::build::AstBuilder;
use codemap::{Span,respan};
@ -23,8 +23,8 @@ use opt_vec;
/// The types of pointers
pub enum PtrTy<'self> {
Send, // ~
Managed(ast::mutability), // @[mut]
Borrowed(Option<&'self str>, ast::mutability), // &['lifetime] [mut]
Managed(ast::Mutability), // @[mut]
Borrowed(Option<&'self str>, ast::Mutability), // &['lifetime] [mut]
}
/// A path, e.g. `::std::option::Option::<int>` (global). Has support
@ -91,7 +91,7 @@ pub enum Ty<'self> {
}
pub fn borrowed_ptrty<'r>() -> PtrTy<'r> {
Borrowed(None, ast::m_imm)
Borrowed(None, ast::MutImmutable)
}
pub fn borrowed<'r>(ty: ~Ty<'r>) -> Ty<'r> {
Ptr(ty, borrowed_ptrty())
@ -236,7 +236,7 @@ impl<'self> LifetimeBounds<'self> {
pub fn get_explicit_self(cx: @ExtCtxt, span: Span, self_ptr: &Option<PtrTy>)
-> (@expr, ast::explicit_self) {
-> (@Expr, ast::explicit_self) {
let self_path = cx.expr_self(span);
match *self_ptr {
None => {

4
src/libsyntax/ext/deriving/zero.rs
View file

@ -8,7 +8,7 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
use ast::{MetaItem, item, expr};
use ast::{MetaItem, item, Expr};
use codemap::Span;
use ext::base::ExtCtxt;
use ext::build::AstBuilder;
@ -55,7 +55,7 @@ pub fn expand_deriving_zero(cx: @ExtCtxt,
trait_def.expand(cx, span, mitem, in_items)
}
fn zero_substructure(cx: @ExtCtxt, span: Span, substr: &Substructure) -> @expr {
fn zero_substructure(cx: @ExtCtxt, span: Span, substr: &Substructure) -> @Expr {
let zero_ident = ~[
cx.ident_of("std"),
cx.ident_of("num"),

102
src/libsyntax/ext/expand.rs
View file

@ -8,9 +8,9 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
use ast::{Block, Crate, NodeId, expr_, expr_mac, Ident, mac_invoc_tt};
use ast::{item_mac, stmt_, stmt_mac, stmt_expr, stmt_semi};
use ast::{illegal_ctxt};
use ast::{Block, Crate, NodeId, Expr_, ExprMac, Ident, mac_invoc_tt};
use ast::{item_mac, Stmt_, StmtMac, StmtExpr, StmtSemi};
use ast::{ILLEGAL_CTXT};
use ast;
use ast_util::{new_rename, new_mark, resolve};
use attr;
@ -31,15 +31,15 @@ use std::vec;
pub fn expand_expr(extsbox: @mut SyntaxEnv,
cx: @ExtCtxt,
e: &expr_,
e: &Expr_,
s: Span,
fld: @ast_fold,
orig: @fn(&expr_, Span, @ast_fold) -> (expr_, Span))
-> (expr_, Span) {
orig: @fn(&Expr_, Span, @ast_fold) -> (Expr_, Span))
-> (Expr_, Span) {
match *e {
// expr_mac should really be expr_ext or something; it's the
// entry-point for all syntax extensions.
expr_mac(ref mac) => {
ExprMac(ref mac) => {
match (*mac).node {
// Token-tree macros:
mac_invoc_tt(ref pth, ref tts) => {
@ -104,7 +104,7 @@ pub fn expand_expr(extsbox: @mut SyntaxEnv,
// Desugar expr_for_loop
// From: `for <src_pat> in <src_expr> <src_loop_block>`
ast::expr_for_loop(src_pat, src_expr, ref src_loop_block) => {
ast::ExprForLoop(src_pat, src_expr, ref src_loop_block) => {
let src_pat = src_pat.clone();
let src_expr = src_expr.clone();
@ -118,8 +118,8 @@ pub fn expand_expr(extsbox: @mut SyntaxEnv,
let hi = s.hi;
pub fn mk_expr(cx: @ExtCtxt, span: Span,
node: expr_) -> @ast::expr {
@ast::expr {
node: Expr_) -> @ast::Expr {
@ast::Expr {
id: cx.next_id(),
node: node,
span: span,
@ -127,8 +127,8 @@ pub fn expand_expr(extsbox: @mut SyntaxEnv,
}
fn mk_block(cx: @ExtCtxt,
stmts: &[@ast::stmt],
expr: Option<@ast::expr>,
stmts: &[@ast::Stmt],
expr: Option<@ast::Expr>,
span: Span) -> ast::Block {
ast::Block {
view_items: ~[],
@ -186,33 +186,33 @@ pub fn expand_expr(extsbox: @mut SyntaxEnv,
let local = @ast::Local {
is_mutbl: false,
ty: ty,
pat: @ast::pat {
pat: @ast::Pat {
id: cx.next_id(),
node: ast::pat_ident(ast::bind_infer, local_path_1, None),
node: ast::PatIdent(ast::BindInfer, local_path_1, None),
span: src_expr.span
},
init: Some(mk_expr(cx, src_expr.span,
ast::expr_addr_of(ast::m_mutbl, src_expr))),
ast::ExprAddrOf(ast::MutMutable, src_expr))),
id: cx.next_id(),
span: src_expr.span,
};
let e = @spanned(src_expr.span.lo,
src_expr.span.hi,
ast::decl_local(local));
@spanned(lo, hi, ast::stmt_decl(e, cx.next_id()))
ast::DeclLocal(local));
@spanned(lo, hi, ast::StmtDecl(e, cx.next_id()))
};
// `None => break;`
let none_arm = {
let break_expr = mk_expr(cx, span, ast::expr_break(None));
let break_stmt = @spanned(lo, hi, ast::stmt_expr(break_expr, cx.next_id()));
let break_expr = mk_expr(cx, span, ast::ExprBreak(None));
let break_stmt = @spanned(lo, hi, ast::StmtExpr(break_expr, cx.next_id()));
let none_block = mk_block(cx, [break_stmt], None, span);
let none_pat = @ast::pat {
let none_pat = @ast::Pat {
id: cx.next_id(),
node: ast::pat_ident(ast::bind_infer, none_path, None),
node: ast::PatIdent(ast::BindInfer, none_path, None),
span: span
};
ast::arm {
ast::Arm {
pats: ~[none_pat],
guard: None,
body: none_block
@ -221,12 +221,12 @@ pub fn expand_expr(extsbox: @mut SyntaxEnv,
// `Some(<src_pat>) => <src_loop_block>`
let some_arm = {
let pat = @ast::pat {
let pat = @ast::Pat {
id: cx.next_id(),
node: ast::pat_enum(some_path, Some(~[src_pat])),
node: ast::PatEnum(some_path, Some(~[src_pat])),
span: src_pat.span
};
ast::arm {
ast::Arm {
pats: ~[pat],
guard: None,
body: src_loop_block
@ -235,27 +235,27 @@ pub fn expand_expr(extsbox: @mut SyntaxEnv,
// `match i.next() { ... }`
let match_stmt = {
let local_expr = mk_expr(cx, span, ast::expr_path(local_path_2));
let local_expr = mk_expr(cx, span, ast::ExprPath(local_path_2));
let next_call_expr = mk_expr(cx, span,
ast::expr_method_call(cx.next_id(),
ast::ExprMethodCall(cx.next_id(),
local_expr, next_ident,
~[], ~[], ast::NoSugar));
let match_expr = mk_expr(cx, span, ast::expr_match(next_call_expr,
let match_expr = mk_expr(cx, span, ast::ExprMatch(next_call_expr,
~[none_arm, some_arm]));
@spanned(lo, hi, ast::stmt_expr(match_expr, cx.next_id()))
@spanned(lo, hi, ast::StmtExpr(match_expr, cx.next_id()))
};
// `loop { ... }`
let loop_block = {
let loop_body_block = mk_block(cx, [match_stmt], None, span);
let loop_body_expr = mk_expr(cx, span, ast::expr_loop(loop_body_block, None));
let loop_body_stmt = @spanned(lo, hi, ast::stmt_expr(loop_body_expr, cx.next_id()));
let loop_body_expr = mk_expr(cx, span, ast::ExprLoop(loop_body_block, None));
let loop_body_stmt = @spanned(lo, hi, ast::StmtExpr(loop_body_expr, cx.next_id()));
mk_block(cx, [iter_decl_stmt,
loop_body_stmt],
None, span)
};
(ast::expr_block(loop_block), span)
(ast::ExprBlock(loop_block), span)
}
_ => orig(e, s, fld)
@ -448,14 +448,14 @@ fn insert_macro(exts: SyntaxEnv, name: ast::Name, transformer: @Transformer) {
// expand a stmt
pub fn expand_stmt(extsbox: @mut SyntaxEnv,
cx: @ExtCtxt,
s: &stmt_,
s: &Stmt_,
sp: Span,
fld: @ast_fold,
orig: @fn(&stmt_, Span, @ast_fold)
-> (Option<stmt_>, Span))
-> (Option<stmt_>, Span) {
orig: @fn(&Stmt_, Span, @ast_fold)
-> (Option<Stmt_>, Span))
-> (Option<Stmt_>, Span) {
let (mac, pth, tts, semi) = match *s {
stmt_mac(ref mac, semi) => {
StmtMac(ref mac, semi) => {
match mac.node {
mac_invoc_tt(ref pth, ref tts) => {
((*mac).clone(), pth, (*tts).clone(), semi)
@ -484,7 +484,7 @@ pub fn expand_stmt(extsbox: @mut SyntaxEnv,
});
let expanded = match exp(cx, mac.span, tts) {
MRExpr(e) =>
@codemap::Spanned { node: stmt_expr(e, cx.next_id()),
@codemap::Spanned { node: StmtExpr(e, cx.next_id()),
span: e.span},
MRAny(_,_,stmt_mkr) => stmt_mkr(),
_ => cx.span_fatal(
@ -515,7 +515,7 @@ pub fn expand_stmt(extsbox: @mut SyntaxEnv,
};
(match fully_expanded {
stmt_expr(e, stmt_id) if semi => Some(stmt_semi(e, stmt_id)),
StmtExpr(e, stmt_id) if semi => Some(StmtSemi(e, stmt_id)),
_ => { Some(fully_expanded) } /* might already have a semi */
}, sp)
@ -527,12 +527,12 @@ struct NewNameFinderContext {
}
impl Visitor<()> for NewNameFinderContext {
fn visit_pat(&mut self, pattern: @ast::pat, _: ()) {
fn visit_pat(&mut self, pattern: @ast::Pat, _: ()) {
match *pattern {
// we found a pat_ident!
ast::pat {
ast::Pat {
id: _,
node: ast::pat_ident(_, ref path, ref inner),
node: ast::PatIdent(_, ref path, ref inner),
span: _
} => {
match path {
@ -589,23 +589,23 @@ impl Visitor<()> for NewNameFinderContext {
visit::walk_block(self, block, ())
}
fn visit_stmt(&mut self, stmt: @ast::stmt, _: ()) {
fn visit_stmt(&mut self, stmt: @ast::Stmt, _: ()) {
visit::walk_stmt(self, stmt, ())
}
fn visit_arm(&mut self, arm: &ast::arm, _: ()) {
fn visit_arm(&mut self, arm: &ast::Arm, _: ()) {
visit::walk_arm(self, arm, ())
}
fn visit_decl(&mut self, decl: @ast::decl, _: ()) {
fn visit_decl(&mut self, decl: @ast::Decl, _: ()) {
visit::walk_decl(self, decl, ())
}
fn visit_expr(&mut self, expr: @ast::expr, _: ()) {
fn visit_expr(&mut self, expr: @ast::Expr, _: ()) {
visit::walk_expr(self, expr, ())
}
fn visit_expr_post(&mut self, _: @ast::expr, _: ()) {
fn visit_expr_post(&mut self, _: @ast::Expr, _: ()) {
// Empty!
}
@ -714,7 +714,7 @@ fn renames_to_fold(renames : @mut ~[(ast::Ident,ast::Name)]) -> @ast_fold {
}
// perform a bunch of renames
fn apply_pending_renames(folder : @ast_fold, stmt : ast::stmt) -> @ast::stmt {
fn apply_pending_renames(folder : @ast_fold, stmt : ast::Stmt) -> @ast::Stmt {
match folder.fold_stmt(&stmt) {
Some(s) => s,
None => fail!(fmt!("renaming of stmt produced None"))
@ -1182,7 +1182,7 @@ pub fn new_ident_resolver() ->
|id : ast::Ident|
ast::Ident {
name : resolve(id),
ctxt : illegal_ctxt
ctxt : ILLEGAL_CTXT
}
}
@ -1191,7 +1191,7 @@ pub fn new_ident_resolver() ->
mod test {
use super::*;
use ast;
use ast::{Attribute_, AttrOuter, MetaWord, empty_ctxt};
use ast::{Attribute_, AttrOuter, MetaWord, EMPTY_CTXT};
use codemap;
use codemap::Spanned;
use parse;
@ -1304,7 +1304,7 @@ mod test {
};
let a_name = intern("a");
let a2_name = intern("a2");
let renamer = new_ident_renamer(ast::Ident{name:a_name,ctxt:empty_ctxt},
let renamer = new_ident_renamer(ast::Ident{name:a_name,ctxt:EMPTY_CTXT},
a2_name);
let renamed_ast = fun_to_ident_folder(renamer).fold_item(item_ast).unwrap();
let resolver = new_ident_resolver();

26
src/libsyntax/ext/fmt.rs
View file

@ -48,8 +48,8 @@ pub fn expand_syntax_ext(cx: @ExtCtxt, sp: Span, tts: &[ast::token_tree])
// expressions. Also: Cleanup the naming of these functions.
// Note: Moved many of the common ones to build.rs --kevina
fn pieces_to_expr(cx: @ExtCtxt, sp: Span,
pieces: ~[Piece], args: ~[@ast::expr])
-> @ast::expr {
pieces: ~[Piece], args: ~[@ast::Expr])
-> @ast::Expr {
fn make_path_vec(ident: &str) -> ~[ast::Ident] {
return ~[str_to_ident("std"),
str_to_ident("unstable"),
@ -57,15 +57,15 @@ fn pieces_to_expr(cx: @ExtCtxt, sp: Span,
str_to_ident("rt"),
str_to_ident(ident)];
}
fn make_rt_path_expr(cx: @ExtCtxt, sp: Span, nm: &str) -> @ast::expr {
fn make_rt_path_expr(cx: @ExtCtxt, sp: Span, nm: &str) -> @ast::Expr {
let path = make_path_vec(nm);
cx.expr_path(cx.path_global(sp, path))
}
// Produces an AST expression that represents a RT::conv record,
// which tells the RT::conv* functions how to perform the conversion
fn make_rt_conv_expr(cx: @ExtCtxt, sp: Span, cnv: &Conv) -> @ast::expr {
fn make_flags(cx: @ExtCtxt, sp: Span, flags: &[Flag]) -> @ast::expr {
fn make_rt_conv_expr(cx: @ExtCtxt, sp: Span, cnv: &Conv) -> @ast::Expr {
fn make_flags(cx: @ExtCtxt, sp: Span, flags: &[Flag]) -> @ast::Expr {
let mut tmp_expr = make_rt_path_expr(cx, sp, "flag_none");
for f in flags.iter() {
let fstr = match *f {
@ -75,12 +75,12 @@ fn pieces_to_expr(cx: @ExtCtxt, sp: Span,
FlagSignAlways => "flag_sign_always",
FlagAlternate => "flag_alternate"
};
tmp_expr = cx.expr_binary(sp, ast::bitor, tmp_expr,
tmp_expr = cx.expr_binary(sp, ast::BiBitOr, tmp_expr,
make_rt_path_expr(cx, sp, fstr));
}
return tmp_expr;
}
fn make_count(cx: @ExtCtxt, sp: Span, cnt: Count) -> @ast::expr {
fn make_count(cx: @ExtCtxt, sp: Span, cnt: Count) -> @ast::Expr {
match cnt {
CountImplied => {
return make_rt_path_expr(cx, sp, "CountImplied");
@ -94,7 +94,7 @@ fn pieces_to_expr(cx: @ExtCtxt, sp: Span,
_ => cx.span_unimpl(sp, "unimplemented fmt! conversion")
}
}
fn make_ty(cx: @ExtCtxt, sp: Span, t: Ty) -> @ast::expr {
fn make_ty(cx: @ExtCtxt, sp: Span, t: Ty) -> @ast::Expr {
let rt_type = match t {
TyHex(c) => match c {
CaseUpper => "TyHexUpper",
@ -106,9 +106,9 @@ fn pieces_to_expr(cx: @ExtCtxt, sp: Span,
};
return make_rt_path_expr(cx, sp, rt_type);
}
fn make_conv_struct(cx: @ExtCtxt, sp: Span, flags_expr: @ast::expr,
width_expr: @ast::expr, precision_expr: @ast::expr,
ty_expr: @ast::expr) -> @ast::expr {
fn make_conv_struct(cx: @ExtCtxt, sp: Span, flags_expr: @ast::Expr,
width_expr: @ast::Expr, precision_expr: @ast::Expr,
ty_expr: @ast::Expr) -> @ast::Expr {
cx.expr_struct(
sp,
cx.path_global(sp, make_path_vec("Conv")),
@ -128,7 +128,7 @@ fn pieces_to_expr(cx: @ExtCtxt, sp: Span,
rt_conv_precision, rt_conv_ty)
}
fn make_conv_call(cx: @ExtCtxt, sp: Span, conv_type: &str, cnv: &Conv,
arg: @ast::expr, buf: @ast::expr) -> @ast::expr {
arg: @ast::Expr, buf: @ast::Expr) -> @ast::Expr {
let fname = ~"conv_" + conv_type;
let path = make_path_vec(fname);
let cnv_expr = make_rt_conv_expr(cx, sp, cnv);
@ -137,7 +137,7 @@ fn pieces_to_expr(cx: @ExtCtxt, sp: Span,
}
fn make_new_conv(cx: @ExtCtxt, sp: Span, cnv: &Conv,
arg: @ast::expr, buf: @ast::expr) -> @ast::expr {
arg: @ast::Expr, buf: @ast::Expr) -> @ast::Expr {
fn is_signed_type(cnv: &Conv) -> bool {
match cnv.ty {
TyInt(s) => match s {

32
src/libsyntax/ext/ifmt.rs
View file

@ -34,14 +34,14 @@ struct Context {
// Parsed argument expressions and the types that we've found so far for
// them.
args: ~[@ast::expr],
args: ~[@ast::Expr],
arg_types: ~[Option<ArgumentType>],
// Parsed named expressions and the types that we've found for them so far
names: HashMap<@str, @ast::expr>,
names: HashMap<@str, @ast::Expr>,
name_types: HashMap<@str, ArgumentType>,
// Collection of the compiled `rt::Piece` structures
pieces: ~[@ast::expr],
pieces: ~[@ast::Expr],
name_positions: HashMap<@str, uint>,
method_statics: ~[@ast::item],
@ -55,8 +55,8 @@ impl Context {
/// there's a parse error so we can continue parsing other fmt! expressions.
fn parse_args(&mut self, sp: Span,
leading_expr: bool,
tts: &[ast::token_tree]) -> (Option<@ast::expr>,
Option<@ast::expr>) {
tts: &[ast::token_tree]) -> (Option<@ast::Expr>,
Option<@ast::Expr>) {
let p = rsparse::new_parser_from_tts(self.ecx.parse_sess(),
self.ecx.cfg(),
tts.to_owned());
@ -327,7 +327,7 @@ impl Context {
}
/// Translate a `parse::Piece` to a static `rt::Piece`
fn trans_piece(&mut self, piece: &parse::Piece) -> @ast::expr {
fn trans_piece(&mut self, piece: &parse::Piece) -> @ast::Expr {
let sp = self.fmtsp;
let parsepath = |s: &str| {
~[self.ecx.ident_of("std"), self.ecx.ident_of("fmt"),
@ -345,7 +345,7 @@ impl Context {
let p = self.ecx.path(sp, ~[self.ecx.ident_of("None")]);
self.ecx.expr_path(p)
};
let some = |e: @ast::expr| {
let some = |e: @ast::Expr| {
self.ecx.expr_call_ident(sp, self.ecx.ident_of("Some"), ~[e])
};
let trans_count = |c: parse::Count| {
@ -444,7 +444,7 @@ impl Context {
Some(life),
~[]
), None);
let st = ast::item_static(ty, ast::m_imm, method);
let st = ast::item_static(ty, ast::MutImmutable, method);
let static_name = self.ecx.ident_of(fmt!("__static_method_%u",
self.method_statics.len()));
// Flag these statics as `address_insignificant` so LLVM can
@ -542,16 +542,16 @@ impl Context {
/// Actually builds the expression which the ifmt! block will be expanded
/// to
fn to_expr(&self, extra: Option<@ast::expr>, f: &str) -> @ast::expr {
fn to_expr(&self, extra: Option<@ast::Expr>, f: &str) -> @ast::Expr {
let mut lets = ~[];
let mut locals = ~[];
let mut names = vec::from_fn(self.name_positions.len(), |_| None);
// First, declare all of our methods that are statics
for &method in self.method_statics.iter() {
let decl = respan(self.fmtsp, ast::decl_item(method));
let decl = respan(self.fmtsp, ast::DeclItem(method));
lets.push(@respan(self.fmtsp,
ast::stmt_decl(@decl, self.ecx.next_id())));
ast::StmtDecl(@decl, self.ecx.next_id())));
}
// Next, build up the static array which will become our precompiled
@ -570,19 +570,19 @@ impl Context {
Some(self.ecx.lifetime(self.fmtsp, self.ecx.ident_of("static"))),
~[]
), None),
ast::m_imm
ast::MutImmutable
),
self.ecx.expr_uint(self.fmtsp, self.pieces.len())
);
let ty = self.ecx.ty(self.fmtsp, ty);
let st = ast::item_static(ty, ast::m_imm, fmt);
let st = ast::item_static(ty, ast::MutImmutable, fmt);
let static_name = self.ecx.ident_of("__static_fmtstr");
// see above comment for `address_insignificant` and why we do it
let unnamed = self.ecx.meta_word(self.fmtsp, @"address_insignificant");
let unnamed = self.ecx.attribute(self.fmtsp, unnamed);
let item = self.ecx.item(self.fmtsp, static_name, ~[unnamed], st);
let decl = respan(self.fmtsp, ast::decl_item(item));
lets.push(@respan(self.fmtsp, ast::stmt_decl(@decl, self.ecx.next_id())));
let decl = respan(self.fmtsp, ast::DeclItem(item));
lets.push(@respan(self.fmtsp, ast::StmtDecl(@decl, self.ecx.next_id())));
// Right now there is a bug such that for the expression:
// foo(bar(&1))
@ -637,7 +637,7 @@ impl Context {
}
fn format_arg(&self, sp: Span, arg: Either<uint, @str>,
ident: ast::Ident) -> @ast::expr {
ident: ast::Ident) -> @ast::Expr {
let ty = match arg {
Left(i) => self.arg_types[i].unwrap(),
Right(s) => *self.name_types.get(&s)

4
src/libsyntax/ext/log_syntax.rs
View file

@ -29,9 +29,9 @@ pub fn expand_syntax_ext(cx: @ExtCtxt,
get_ident_interner()));
//trivial expression
MRExpr(@ast::expr {
MRExpr(@ast::Expr {
id: cx.next_id(),
node: ast::expr_lit(@codemap::Spanned {
node: ast::ExprLit(@codemap::Spanned {
node: ast::lit_nil,
span: sp
}),

34
src/libsyntax/ext/quote.rs
View file

@ -104,7 +104,7 @@ pub mod rt {
}
}
impl ToSource for @ast::expr {
impl ToSource for @ast::Expr {
fn to_source(&self) -> @str {
pprust::expr_to_str(*self, get_ident_interner()).to_managed()
}
@ -222,7 +222,7 @@ pub mod rt {
impl_to_tokens!(ast::Ty)
impl_to_tokens_self!(&'self [ast::Ty])
impl_to_tokens!(Generics)
impl_to_tokens!(@ast::expr)
impl_to_tokens!(@ast::Expr)
impl_to_tokens!(ast::Block)
impl_to_tokens_self!(&'self str)
impl_to_tokens!(int)
@ -238,8 +238,8 @@ pub mod rt {
pub trait ExtParseUtils {
fn parse_item(&self, s: @str) -> @ast::item;
fn parse_expr(&self, s: @str) -> @ast::expr;
fn parse_stmt(&self, s: @str) -> @ast::stmt;
fn parse_expr(&self, s: @str) -> @ast::Expr;
fn parse_stmt(&self, s: @str) -> @ast::Stmt;
fn parse_tts(&self, s: @str) -> ~[ast::token_tree];
}
@ -261,7 +261,7 @@ pub mod rt {
}
}
fn parse_stmt(&self, s: @str) -> @ast::stmt {
fn parse_stmt(&self, s: @str) -> @ast::Stmt {
parse::parse_stmt_from_source_str(
@"<quote expansion>",
s,
@ -270,7 +270,7 @@ pub mod rt {
self.parse_sess())
}
fn parse_expr(&self, s: @str) -> @ast::expr {
fn parse_expr(&self, s: @str) -> @ast::Expr {
parse::parse_expr_from_source_str(
@"<quote expansion>",
s,
@ -343,7 +343,7 @@ fn id_ext(str: &str) -> ast::Ident {
}
// Lift an ident to the expr that evaluates to that ident.
fn mk_ident(cx: @ExtCtxt, sp: Span, ident: ast::Ident) -> @ast::expr {
fn mk_ident(cx: @ExtCtxt, sp: Span, ident: ast::Ident) -> @ast::Expr {
let e_str = cx.expr_str(sp, cx.str_of(ident));
cx.expr_method_call(sp,
cx.expr_ident(sp, id_ext("ext_cx")),
@ -351,13 +351,13 @@ fn mk_ident(cx: @ExtCtxt, sp: Span, ident: ast::Ident) -> @ast::expr {
~[e_str])
}
fn mk_bytepos(cx: @ExtCtxt, sp: Span, bpos: BytePos) -> @ast::expr {
fn mk_bytepos(cx: @ExtCtxt, sp: Span, bpos: BytePos) -> @ast::Expr {
let path = id_ext("BytePos");
let arg = cx.expr_uint(sp, bpos.to_uint());
cx.expr_call_ident(sp, path, ~[arg])
}
fn mk_binop(cx: @ExtCtxt, sp: Span, bop: token::binop) -> @ast::expr {
fn mk_binop(cx: @ExtCtxt, sp: Span, bop: token::binop) -> @ast::Expr {
let name = match bop {
PLUS => "PLUS",
MINUS => "MINUS",
@ -373,7 +373,7 @@ fn mk_binop(cx: @ExtCtxt, sp: Span, bop: token::binop) -> @ast::expr {
cx.expr_ident(sp, id_ext(name))
}
fn mk_token(cx: @ExtCtxt, sp: Span, tok: &token::Token) -> @ast::expr {
fn mk_token(cx: @ExtCtxt, sp: Span, tok: &token::Token) -> @ast::Expr {
match *tok {
BINOP(binop) => {
@ -515,7 +515,7 @@ fn mk_token(cx: @ExtCtxt, sp: Span, tok: &token::Token) -> @ast::expr {
fn mk_tt(cx: @ExtCtxt, sp: Span, tt: &ast::token_tree)
-> ~[@ast::stmt] {
-> ~[@ast::Stmt] {
match *tt {
@ -557,7 +557,7 @@ fn mk_tt(cx: @ExtCtxt, sp: Span, tt: &ast::token_tree)
}
fn mk_tts(cx: @ExtCtxt, sp: Span, tts: &[ast::token_tree])
-> ~[@ast::stmt] {
-> ~[@ast::Stmt] {
let mut ss = ~[];
for tt in tts.iter() {
ss.push_all_move(mk_tt(cx, sp, tt));
@ -567,7 +567,7 @@ fn mk_tts(cx: @ExtCtxt, sp: Span, tts: &[ast::token_tree])
fn expand_tts(cx: @ExtCtxt,
sp: Span,
tts: &[ast::token_tree]) -> (@ast::expr, @ast::expr) {
tts: &[ast::token_tree]) -> (@ast::Expr, @ast::Expr) {
// NB: It appears that the main parser loses its mind if we consider
// $foo as a tt_nonterminal during the main parse, so we have to re-parse
@ -640,8 +640,8 @@ fn expand_tts(cx: @ExtCtxt,
fn expand_wrapper(cx: @ExtCtxt,
sp: Span,
cx_expr: @ast::expr,
expr: @ast::expr) -> @ast::expr {
cx_expr: @ast::Expr,
expr: @ast::Expr) -> @ast::Expr {
let uses = ~[ cx.view_use_glob(sp, ast::public,
ids_ext(~[~"syntax",
~"ext",
@ -656,8 +656,8 @@ fn expand_wrapper(cx: @ExtCtxt,
fn expand_parse_call(cx: @ExtCtxt,
sp: Span,
parse_method: &str,
arg_exprs: ~[@ast::expr],
tts: &[ast::token_tree]) -> @ast::expr {
arg_exprs: ~[@ast::Expr],
tts: &[ast::token_tree]) -> @ast::Expr {
let (cx_expr, tts_expr) = expand_tts(cx, sp, tts);
let cfg_call = || cx.expr_method_call(

2
src/libsyntax/ext/source_util.rs
View file

@ -105,7 +105,7 @@ pub fn expand_include_bin(cx: @ExtCtxt, sp: Span, tts: &[ast::token_tree])
let file = get_single_str_from_tts(cx, sp, tts, "include_bin!");
match io::read_whole_file(&res_rel_file(cx, sp, &Path(file))) {
result::Ok(src) => {
let u8_exprs: ~[@ast::expr] = src.iter().map(|char| cx.expr_u8(sp, *char)).collect();
let u8_exprs: ~[@ast::Expr] = src.iter().map(|char| cx.expr_u8(sp, *char)).collect();
base::MRExpr(cx.expr_vec(sp, u8_exprs))
}
result::Err(ref e) => {