bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

syntax/ext: convert all AstBuilder methods to a uniform syntax.

Browse source
This commit is contained in:
Huon Wilson 2013-05-19 15:53:42 +10:00
parent 6e50515530
commit a59bec43e3
21 changed files with 1121 additions and 1809 deletions
Download patch file Download diff file Expand all files Collapse all files

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

File diff suppressed because it is too large Load diff

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

@ -28,7 +28,7 @@ pub fn expand_syntax_ext(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree]) -> bas
// string literal, push each byte to vector expression // string literal, push each byte to vector expression
ast::lit_str(s) => { ast::lit_str(s) => {
for s.each |byte| { for s.each |byte| {
bytes.push(cx.mk_u8(sp, byte)); bytes.push(cx.expr_u8(sp, byte));
} }
} }
@ -37,7 +37,7 @@ pub fn expand_syntax_ext(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree]) -> bas
if v > 0xFF { if v > 0xFF {
cx.span_err(sp, "Too large u8 literal in bytes!") cx.span_err(sp, "Too large u8 literal in bytes!")
} else { } else {
bytes.push(cx.mk_u8(sp, v as u8)); bytes.push(cx.expr_u8(sp, v as u8));
} }
} }
@ -48,14 +48,14 @@ pub fn expand_syntax_ext(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree]) -> bas
} else if v < 0 { } else if v < 0 {
cx.span_err(sp, "Negative integer literal in bytes!") cx.span_err(sp, "Negative integer literal in bytes!")
} else { } else {
bytes.push(cx.mk_u8(sp, v as u8)); bytes.push(cx.expr_u8(sp, v as u8));
} }
} }
// char literal, push to vector expression // char literal, push to vector expression
ast::lit_int(v, ast::ty_char) => { ast::lit_int(v, ast::ty_char) => {
if (v as char).is_ascii() { if (v as char).is_ascii() {
bytes.push(cx.mk_u8(sp, v as u8)); bytes.push(cx.expr_u8(sp, v as u8));
} else { } else {
cx.span_err(sp, "Non-ascii char literal in bytes!") cx.span_err(sp, "Non-ascii char literal in bytes!")
} }
@ -68,6 +68,6 @@ pub fn expand_syntax_ext(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree]) -> bas
} }
} }
let e = cx.mk_slice_vec_e(sp, bytes); let e = cx.expr_vec_slice(sp, bytes);
MRExpr(e) MRExpr(e)
} }

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

@ -11,7 +11,6 @@
use ast::{meta_item, item, expr}; use ast::{meta_item, item, expr};
use codemap::span; use codemap::span;
use ext::base::ExtCtxt; use ext::base::ExtCtxt;
use ext::build;
use ext::build::AstBuilder; use ext::build::AstBuilder;
use ext::deriving::generic::*; use ext::deriving::generic::*;
@ -80,15 +79,15 @@ fn cs_clone(
let ctor_ident; let ctor_ident;
let all_fields; let all_fields;
let subcall = |field| let subcall = |field|
cx.mk_method_call(span, field, clone_ident, ~[]); cx.expr_method_call(span, field, clone_ident, ~[]);
match *substr.fields { match *substr.fields {
Struct(ref af) => { Struct(ref af) => {
ctor_ident = ~[ substr.type_ident ]; ctor_ident = substr.type_ident;
all_fields = af; all_fields = af;
} }
EnumMatching(_, variant, ref af) => { EnumMatching(_, variant, ref af) => {
ctor_ident = ~[ variant.node.name ]; ctor_ident = variant.node.name;
all_fields = af; all_fields = af;
}, },
EnumNonMatching(*) => cx.span_bug(span, EnumNonMatching(*) => cx.span_bug(span,
@ -103,7 +102,7 @@ fn cs_clone(
[(None, _, _), .. _] => { [(None, _, _), .. _] => {
// enum-like // enum-like
let subcalls = all_fields.map(|&(_, self_f, _)| subcall(self_f)); let subcalls = all_fields.map(|&(_, self_f, _)| subcall(self_f));
cx.mk_call(span, ctor_ident, subcalls) cx.expr_call_ident(span, ctor_ident, subcalls)
}, },
_ => { _ => {
// struct-like // struct-like
@ -114,16 +113,14 @@ fn cs_clone(
fmt!("unnamed field in normal struct in `deriving(%s)`", fmt!("unnamed field in normal struct in `deriving(%s)`",
name)) name))
}; };
build::Field { ident: ident, ex: subcall(self_f) } cx.field_imm(span, ident, subcall(self_f))
}; };
if fields.is_empty() { if fields.is_empty() {
// no fields, so construct like `None` // no fields, so construct like `None`
cx.mk_path(span, ctor_ident) cx.expr_ident(span, ctor_ident)
} else { } else {
cx.mk_struct_e(span, cx.expr_struct_ident(span, ctor_ident, fields)
ctor_ident,
fields)
} }
} }
} }

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

@ -21,11 +21,11 @@ pub fn expand_deriving_eq(cx: @ExtCtxt,
// structures are equal if all fields are equal, and non equal, if // structures are equal if all fields are equal, and non equal, if
// any fields are not equal or if the enum variants are different // 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.mk_bool(span, false), cs_and(|cx, span, _, _| cx.expr_bool(span, false),
cx, span, substr) 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.mk_bool(span, true), cs_or(|cx, span, _, _| cx.expr_bool(span, true),
cx, span, substr) cx, span, substr)
} }

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

@ -9,7 +9,7 @@
// except according to those terms. // except according to those terms.
use ast::{meta_item, item, expr_if, expr}; use ast::{meta_item, item, expr};
use codemap::span; use codemap::span;
use ext::base::ExtCtxt; use ext::base::ExtCtxt;
use ext::build::AstBuilder; use ext::build::AstBuilder;
@ -62,10 +62,7 @@ fn cs_ord(less: bool, equal: bool,
} else { } else {
cx.ident_of("gt") cx.ident_of("gt")
}; };
let false_blk_expr = cx.mk_block(span, let base = cx.expr_bool(span, equal);
~[], ~[],
Some(cx.mk_bool(span, false)));
let base = cx.mk_bool(span, equal);
cs_fold( cs_fold(
false, // need foldr, false, // need foldr,
@ -98,19 +95,15 @@ fn cs_ord(less: bool, equal: bool,
cx.span_bug(span, "Not exactly 2 arguments in `deriving(Ord)`"); cx.span_bug(span, "Not exactly 2 arguments in `deriving(Ord)`");
} }
let cmp = cx.mk_method_call(span, let cmp = cx.expr_method_call(span,
self_f, cx.ident_of("eq"), other_fs.to_owned()); self_f, cx.ident_of("eq"), other_fs.to_owned());
let subexpr = cx.mk_simple_block(span, subexpr); let elseif = cx.expr_if(span, cmp,
let elseif = expr_if(cmp, subexpr, Some(false_blk_expr)); subexpr, Some(cx.expr_bool(span, false)));
let elseif = cx.mk_expr(span, elseif);
let cmp = cx.mk_method_call(span, let cmp = cx.expr_method_call(span,
self_f, binop, other_fs.to_owned()); self_f, binop, other_fs.to_owned());
let true_blk = cx.mk_simple_block(span, cx.expr_if(span, cmp,
cx.mk_bool(span, true)); cx.expr_bool(span, true), Some(elseif))
let if_ = expr_if(cmp, true_blk, Some(elseif));
cx.mk_expr(span, if_)
}, },
base, base,
|cx, span, args, _| { |cx, span, args, _| {
@ -119,7 +112,7 @@ fn cs_ord(less: bool, equal: bool,
match args { match args {
[(self_var, _, _), [(self_var, _, _),
(other_var, _, _)] => (other_var, _, _)] =>
cx.mk_bool(span, cx.expr_bool(span,
if less { if less {
self_var < other_var self_var < other_var
} else { } else {

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

@ -21,7 +21,7 @@ pub fn expand_deriving_totaleq(cx: @ExtCtxt,
in_items: ~[@item]) -> ~[@item] { 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.mk_bool(span, false), cs_and(|cx, span, _, _| cx.expr_bool(span, false),
cx, span, substr) cx, span, substr)
} }

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

@ -47,10 +47,11 @@ pub fn ordering_const(cx: @ExtCtxt, span: span, cnst: Ordering) -> @expr {
Equal => "Equal", Equal => "Equal",
Greater => "Greater" Greater => "Greater"
}; };
cx.mk_path_global(span, cx.expr_path(
~[cx.ident_of("core"), cx.path_global(span,
cx.ident_of("cmp"), ~[cx.ident_of("core"),
cx.ident_of(cnst)]) cx.ident_of("cmp"),
cx.ident_of(cnst)]))
} }
pub fn cs_cmp(cx: @ExtCtxt, span: span, pub fn cs_cmp(cx: @ExtCtxt, span: span,
@ -60,11 +61,11 @@ pub fn cs_cmp(cx: @ExtCtxt, span: span,
// foldr (possibly) nests the matches in lexical_ordering better // foldr (possibly) nests the matches in lexical_ordering better
false, false,
|cx, span, old, new| { |cx, span, old, new| {
cx.mk_call_global(span, cx.expr_call_global(span,
~[cx.ident_of("core"), ~[cx.ident_of("core"),
cx.ident_of("cmp"), cx.ident_of("cmp"),
cx.ident_of("lexical_ordering")], cx.ident_of("lexical_ordering")],
~[old, new]) ~[old, new])
}, },
ordering_const(cx, span, Equal), ordering_const(cx, span, Equal),
|cx, span, list, _| { |cx, span, list, _| {

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

@ -16,7 +16,6 @@ encodable.rs for more.
use ast; use ast;
use ast::*; use ast::*;
use ext::base::ExtCtxt; use ext::base::ExtCtxt;
use ext::build::Field;
use ext::build::AstBuilder; use ext::build::AstBuilder;
use ext::deriving::*; use ext::deriving::*;
use codemap::{span, spanned}; use codemap::{span, spanned};
@ -45,26 +44,25 @@ fn create_derived_decodable_impl(
generics: &Generics, generics: &Generics,
method: @method method: @method
) -> @item { ) -> @item {
let decoder_ty_param = cx.mk_ty_param( let decoder_ty_param = cx.typaram(
cx.ident_of("__D"), cx.ident_of("__D"),
@opt_vec::with( @opt_vec::with(
cx.mk_trait_ty_param_bound_global( cx.typarambound(
span, cx.path_global(
~[ span,
cx.ident_of("std"), ~[
cx.ident_of("serialize"), cx.ident_of("std"),
cx.ident_of("Decoder"), cx.ident_of("serialize"),
] cx.ident_of("Decoder"),
) ]))));
)
);
// All the type parameters need to bound to the trait. // All the type parameters need to bound to the trait.
let generic_ty_params = opt_vec::with(decoder_ty_param); let generic_ty_params = opt_vec::with(decoder_ty_param);
let methods = [method]; let methods = [method];
let trait_path = cx.mk_raw_path_global_( let trait_path = cx.path_all(
span, span,
true,
~[ ~[
cx.ident_of("std"), cx.ident_of("std"),
cx.ident_of("serialize"), cx.ident_of("serialize"),
@ -72,7 +70,7 @@ fn create_derived_decodable_impl(
], ],
None, None,
~[ ~[
cx.mk_simple_ty_path(span, cx.ident_of("__D")) cx.ty_ident(span, cx.ident_of("__D"))
] ]
); );
create_derived_impl( create_derived_impl(
@ -97,14 +95,14 @@ fn create_decode_method(
expr: @ast::expr expr: @ast::expr
) -> @method { ) -> @method {
// Create the `e` parameter. // Create the `e` parameter.
let d_arg_type = cx.mk_ty_rptr( let d_arg_type = cx.ty_rptr(
span, span,
cx.mk_simple_ty_path(span, cx.ident_of("__D")), cx.ty_ident(span, cx.ident_of("__D")),
None, None,
ast::m_mutbl ast::m_mutbl
); );
let d_ident = cx.ident_of("__d"); let d_ident = cx.ident_of("__d");
let d_arg = cx.mk_arg(span, d_ident, d_arg_type); let d_arg = cx.arg(span, d_ident, d_arg_type);
// Create the type of the return value. // Create the type of the return value.
let output_type = create_self_type_with_params( let output_type = create_self_type_with_params(
@ -116,10 +114,10 @@ fn create_decode_method(
// Create the function declaration. // Create the function declaration.
let inputs = ~[d_arg]; let inputs = ~[d_arg];
let fn_decl = cx.mk_fn_decl(inputs, output_type); let fn_decl = cx.fn_decl(inputs, output_type);
// Create the body block. // Create the body block.
let body_block = cx.mk_simple_block(span, expr); let body_block = cx.blk_expr(expr);
// Create the method. // Create the method.
let explicit_self = spanned { node: sty_static, span: span }; let explicit_self = spanned { node: sty_static, span: span };
@ -144,19 +142,21 @@ fn call_substructure_decode_method(
span: span span: span
) -> @ast::expr { ) -> @ast::expr {
// Call the substructure method. // Call the substructure method.
cx.mk_call_( cx.expr_call(
span, span,
cx.mk_path_global( cx.expr_path(
span, cx.path_global(
~[ span,
cx.ident_of("std"), ~[
cx.ident_of("serialize"), cx.ident_of("std"),
cx.ident_of("Decodable"), cx.ident_of("serialize"),
cx.ident_of("decode"), cx.ident_of("Decodable"),
] cx.ident_of("decode"),
]
)
), ),
~[ ~[
cx.mk_path(span, ~[cx.ident_of("__d")]) cx.expr_ident(span, cx.ident_of("__d"))
] ]
) )
} }
@ -218,31 +218,24 @@ fn create_read_struct_field(
span: span, span: span,
idx: uint, idx: uint,
ident: ident ident: ident
) -> Field { ) -> ast::field {
// Call the substructure method. // Call the substructure method.
let decode_expr = call_substructure_decode_method(cx, span); let decode_expr = call_substructure_decode_method(cx, span);
let d_arg = cx.mk_arg( let d_id = cx.ident_of("__d");
span,
cx.ident_of("__d"),
cx.mk_ty_infer(span));
let call_expr = cx.mk_method_call( let call_expr = cx.expr_method_call(
span, span,
cx.mk_path(span, ~[cx.ident_of("__d")]), cx.expr_ident(span, d_id),
cx.ident_of("read_struct_field"), cx.ident_of("read_struct_field"),
~[ ~[
cx.mk_base_str(span, cx.str_of(ident)), cx.expr_str(span, cx.str_of(ident)),
cx.mk_uint(span, idx), cx.expr_uint(span, idx),
cx.mk_lambda( cx.lambda_expr_1(span, decode_expr, d_id)
span,
cx.mk_fn_decl(~[d_arg],
cx.mk_ty_infer(span)),
decode_expr),
] ]
); );
Field { ident: ident, ex: call_expr } cx.field_imm(span, ident, call_expr)
} }
fn create_read_struct_arg( fn create_read_struct_arg(
@ -250,21 +243,21 @@ fn create_read_struct_arg(
span: span, span: span,
idx: uint, idx: uint,
ident: ident ident: ident
) -> Field { ) -> ast::field {
// Call the substructure method. // Call the substructure method.
let decode_expr = call_substructure_decode_method(cx, span); let decode_expr = call_substructure_decode_method(cx, span);
let call_expr = cx.mk_method_call( let call_expr = cx.expr_method_call(
span, span,
cx.mk_path(span, ~[cx.ident_of("__d")]), cx.expr_ident(span, cx.ident_of("__d")),
cx.ident_of("read_struct_arg"), cx.ident_of("read_struct_arg"),
~[ ~[
cx.mk_uint(span, idx), cx.expr_uint(span, idx),
cx.mk_lambda_no_args(span, decode_expr), cx.lambda_expr_0(span, decode_expr),
] ]
); );
Field { ident: ident, ex: call_expr } cx.field_imm(span, ident, call_expr)
} }
fn expand_deriving_decodable_struct_method( fn expand_deriving_decodable_struct_method(
@ -292,30 +285,19 @@ fn expand_deriving_decodable_struct_method(
i += 1; i += 1;
} }
let d_arg = cx.mk_arg( let d_id = cx.ident_of("__d");
span,
cx.ident_of("__d"),
cx.mk_ty_infer(span));
let read_struct_expr = cx.mk_method_call( let read_struct_expr = cx.expr_method_call(
span, span,
cx.mk_path( cx.expr_ident(span, d_id),
span,
~[cx.ident_of("__d")]
),
cx.ident_of("read_struct"), cx.ident_of("read_struct"),
~[ ~[
cx.mk_base_str(span, cx.str_of(type_ident)), cx.expr_str(span, cx.str_of(type_ident)),
cx.mk_uint(span, fields.len()), cx.expr_uint(span, fields.len()),
cx.mk_lambda( cx.lambda_expr_1(
span, span,
cx.mk_fn_decl(~[d_arg], cx.mk_ty_infer(span)), cx.expr_struct_ident(span, type_ident, fields),
cx.mk_struct_e( d_id)
span,
~[type_ident],
fields
)
),
] ]
); );
@ -330,14 +312,14 @@ fn create_read_variant_arg(
variant: &ast::variant variant: &ast::variant
) -> ast::arm { ) -> ast::arm {
// Create the matching pattern. // Create the matching pattern.
let pat = cx.mk_pat_lit(span, cx.mk_uint(span, idx)); let pat = cx.pat_lit(span, cx.expr_uint(span, idx));
// Feed each argument in this variant to the decode function // Feed each argument in this variant to the decode function
// as well. // as well.
let variant_arg_len = variant_arg_count(cx, span, variant); let variant_arg_len = variant_arg_count(cx, span, variant);
let expr = if variant_arg_len == 0 { let expr = if variant_arg_len == 0 {
cx.mk_path(span, ~[variant.node.name]) cx.expr_ident(span, variant.node.name)
} else { } else {
// Feed the discriminant to the decode function. // Feed the discriminant to the decode function.
let mut args = ~[]; let mut args = ~[];
@ -346,37 +328,26 @@ fn create_read_variant_arg(
// Call the substructure method. // Call the substructure method.
let expr = call_substructure_decode_method(cx, span); let expr = call_substructure_decode_method(cx, span);
let d_arg = cx.mk_arg( let d_id = cx.ident_of("__d");
span,
cx.ident_of("__d"),
cx.mk_ty_infer(span));
let t_infer = cx.mk_ty_infer(span);
let call_expr = cx.mk_method_call( let call_expr = cx.expr_method_call(
span, span,
cx.mk_path(span, ~[cx.ident_of("__d")]), cx.expr_ident(span, d_id),
cx.ident_of("read_enum_variant_arg"), cx.ident_of("read_enum_variant_arg"),
~[ ~[
cx.mk_uint(span, j), cx.expr_uint(span, j),
cx.mk_lambda( cx.lambda_expr_1(span, expr, d_id),
span,
cx.mk_fn_decl(~[d_arg], t_infer),
expr),
] ]
); );
args.push(call_expr); args.push(call_expr);
} }
cx.mk_call( cx.expr_call_ident(span, variant.node.name, args)
span,
~[variant.node.name],
args
)
}; };
// Create the arm. // Create the arm.
cx.mk_arm(span, ~[pat], expr) cx.arm(span, ~[pat], expr)
} }
fn create_read_enum_variant( fn create_read_enum_variant(
@ -385,10 +356,10 @@ fn create_read_enum_variant(
enum_definition: &enum_def enum_definition: &enum_def
) -> @expr { ) -> @expr {
// Create a vector that contains all the variant names. // Create a vector that contains all the variant names.
let expr_arm_names = cx.mk_base_vec_e( let expr_arm_names = cx.expr_vec(
span, span,
do enum_definition.variants.map |variant| { do enum_definition.variants.map |variant| {
cx.mk_base_str( cx.expr_str(
span, span,
cx.str_of(variant.node.name) cx.str_of(variant.node.name)
) )
@ -401,40 +372,18 @@ fn create_read_enum_variant(
}; };
// Add the impossible case arm. // Add the impossible case arm.
arms.push(cx.mk_unreachable_arm(span)); arms.push(cx.arm_unreachable(span));
// Create the read_enum_variant expression. // Create the read_enum_variant expression.
cx.mk_method_call( cx.expr_method_call(
span, span,
cx.mk_path(span, ~[cx.ident_of("__d")]), cx.expr_ident(span, cx.ident_of("__d")),
cx.ident_of("read_enum_variant"), cx.ident_of("read_enum_variant"),
~[ ~[
expr_arm_names, expr_arm_names,
cx.mk_lambda( cx.lambda_expr(span,
span, ~[cx.ident_of("__d"), cx.ident_of("__i")],
cx.mk_fn_decl( cx.expr_match(span, cx.expr_ident(span, cx.ident_of("__i")), arms))
~[
cx.mk_arg(
span,
cx.ident_of("__d"),
cx.mk_ty_infer(span)
),
cx.mk_arg(
span,
cx.ident_of("__i"),
cx.mk_ty_infer(span)
)
],
cx.mk_ty_infer(span)
),
cx.mk_expr(
span,
ast::expr_match(
cx.mk_path(span, ~[cx.ident_of("__i")]),
arms
)
)
)
] ]
) )
} }
@ -452,23 +401,16 @@ fn expand_deriving_decodable_enum_method(
enum_definition enum_definition
); );
let d_arg = cx.mk_arg( let d_id = cx.ident_of("__d");
span,
cx.ident_of("__d"),
cx.mk_ty_infer(span));
// Create the read_enum expression // Create the read_enum expression
let read_enum_expr = cx.mk_method_call( let read_enum_expr = cx.expr_method_call(
span, span,
cx.mk_path(span, ~[cx.ident_of("__d")]), cx.expr_ident(span, d_id),
cx.ident_of("read_enum"), cx.ident_of("read_enum"),
~[ ~[
cx.mk_base_str(span, cx.str_of(type_ident)), cx.expr_str(span, cx.str_of(type_ident)),
cx.mk_lambda( cx.lambda_expr_1(span, read_enum_variant_expr, d_id)
span,
cx.mk_fn_decl(~[d_arg],
cx.mk_ty_infer(span)),
read_enum_variant_expr),
] ]
); );

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

@ -107,26 +107,25 @@ fn create_derived_encodable_impl(
generics: &Generics, generics: &Generics,
method: @method method: @method
) -> @item { ) -> @item {
let encoder_ty_param = cx.mk_ty_param( let encoder_ty_param = cx.typaram(
cx.ident_of("__E"), cx.ident_of("__E"),
@opt_vec::with( @opt_vec::with(
cx.mk_trait_ty_param_bound_global( cx.typarambound(
span, cx.path_global(
~[ span,
cx.ident_of("std"), ~[
cx.ident_of("serialize"), cx.ident_of("std"),
cx.ident_of("Encoder"), cx.ident_of("serialize"),
] cx.ident_of("Encoder"),
) ]))));
)
);
// All the type parameters need to bound to the trait. // All the type parameters need to bound to the trait.
let generic_ty_params = opt_vec::with(encoder_ty_param); let generic_ty_params = opt_vec::with(encoder_ty_param);
let methods = [method]; let methods = [method];
let trait_path = cx.mk_raw_path_global_( let trait_path = cx.path_all(
span, span,
true,
~[ ~[
cx.ident_of("std"), cx.ident_of("std"),
cx.ident_of("serialize"), cx.ident_of("serialize"),
@ -134,7 +133,7 @@ fn create_derived_encodable_impl(
], ],
None, None,
~[ ~[
cx.mk_simple_ty_path(span, cx.ident_of("__E")) cx.ty_ident(span, cx.ident_of("__E"))
] ]
); );
create_derived_impl( create_derived_impl(
@ -157,23 +156,23 @@ fn create_encode_method(
statements: ~[@stmt] statements: ~[@stmt]
) -> @method { ) -> @method {
// Create the `e` parameter. // Create the `e` parameter.
let e_arg_type = cx.mk_ty_rptr( let e_arg_type = cx.ty_rptr(
span, span,
cx.mk_simple_ty_path(span, cx.ident_of("__E")), cx.ty_ident(span, cx.ident_of("__E")),
None, None,
ast::m_mutbl ast::m_mutbl
); );
let e_arg = cx.mk_arg(span, cx.ident_of("__e"), e_arg_type); let e_arg = cx.arg(span, cx.ident_of("__e"), e_arg_type);
// Create the type of the return value. // Create the type of the return value.
let output_type = @ast::Ty { id: cx.next_id(), node: ty_nil, span: span }; let output_type = cx.ty_nil();
// Create the function declaration. // Create the function declaration.
let inputs = ~[e_arg]; let inputs = ~[e_arg];
let fn_decl = cx.mk_fn_decl(inputs, output_type); let fn_decl = cx.fn_decl(inputs, output_type);
// Create the body block. // Create the body block.
let body_block = cx.mk_block_(span, statements); let body_block = cx.blk(span, statements, None);
// Create the method. // Create the method.
let explicit_self = spanned { node: sty_region(None, m_imm), span: span }; let explicit_self = spanned { node: sty_region(None, m_imm), span: span };
@ -200,11 +199,11 @@ fn call_substructure_encode_method(
) -> @ast::expr { ) -> @ast::expr {
// Gather up the parameters we want to chain along. // Gather up the parameters we want to chain along.
let e_ident = cx.ident_of("__e"); let e_ident = cx.ident_of("__e");
let e_expr = cx.mk_path(span, ~[e_ident]); let e_expr = cx.expr_ident(span, e_ident);
// Call the substructure method. // Call the substructure method.
let encode_ident = cx.ident_of("encode"); let encode_ident = cx.ident_of("encode");
cx.mk_method_call( cx.expr_method_call(
span, span,
self_field, self_field,
encode_ident, encode_ident,
@ -275,10 +274,9 @@ fn expand_deriving_encodable_struct_method(
match struct_field.node.kind { match struct_field.node.kind {
named_field(ident, _) => { named_field(ident, _) => {
// Create the accessor for this field. // Create the accessor for this field.
let self_field = cx.mk_access_( let self_field = cx.expr_field_access(span,
span, cx.expr_self(span),
cx.make_self(span), ident);
ident);
// Call the substructure method. // Call the substructure method.
let encode_expr = call_substructure_encode_method( let encode_expr = call_substructure_encode_method(
@ -288,29 +286,19 @@ fn expand_deriving_encodable_struct_method(
); );
let e_ident = cx.ident_of("__e"); let e_ident = cx.ident_of("__e");
let e_arg = cx.mk_arg(
span,
e_ident,
cx.mk_ty_infer(span));
let blk_expr = cx.mk_lambda( let call_expr = cx.expr_method_call(
span, span,
cx.mk_fn_decl(~[e_arg], cx.mk_ty_infer(span)), cx.expr_ident(span, e_ident),
encode_expr
);
let call_expr = cx.mk_method_call(
span,
cx.mk_path(span, ~[cx.ident_of("__e")]),
cx.ident_of("emit_struct_field"), cx.ident_of("emit_struct_field"),
~[ ~[
cx.mk_base_str(span, cx.str_of(ident)), cx.expr_str(span, cx.str_of(ident)),
cx.mk_uint(span, idx), cx.expr_uint(span, idx),
blk_expr cx.lambda_expr_1(span, encode_expr, e_ident)
] ]
); );
statements.push(cx.mk_stmt(span, call_expr)); statements.push(cx.stmt_expr(call_expr));
} }
unnamed_field => { unnamed_field => {
cx.span_unimpl( cx.span_unimpl(
@ -322,30 +310,19 @@ fn expand_deriving_encodable_struct_method(
idx += 1; idx += 1;
} }
let e_arg = cx.mk_arg( let e_id = cx.ident_of("__e");
span, let emit_struct_stmt = cx.expr_method_call(
cx.ident_of("__e"),
cx.mk_ty_infer(span));
let emit_struct_stmt = cx.mk_method_call(
span, span,
cx.mk_path( cx.expr_ident(span, e_id),
span,
~[cx.ident_of("__e")]
),
cx.ident_of("emit_struct"), cx.ident_of("emit_struct"),
~[ ~[
cx.mk_base_str(span, cx.str_of(type_ident)), cx.expr_str(span, cx.str_of(type_ident)),
cx.mk_uint(span, statements.len()), cx.expr_uint(span, statements.len()),
cx.mk_lambda_stmts( cx.lambda_stmts_1(span, statements, e_id),
span,
cx.mk_fn_decl(~[e_arg], cx.mk_ty_infer(span)),
statements
),
] ]
); );
let statements = ~[cx.mk_stmt(span, emit_struct_stmt)]; let statements = ~[cx.stmt_expr(emit_struct_stmt)];
// Create the method itself. // Create the method itself.
return create_encode_method(cx, span, statements); return create_encode_method(cx, span, statements);
@ -373,85 +350,59 @@ fn expand_deriving_encodable_enum_method(
let expr = call_substructure_encode_method(cx, span, field); let expr = call_substructure_encode_method(cx, span, field);
let e_ident = cx.ident_of("__e"); let e_ident = cx.ident_of("__e");
let e_arg = cx.mk_arg( let call_expr = cx.expr_method_call(
span,
e_ident,
cx.mk_ty_infer(span));
let blk_expr = cx.mk_lambda(
span, span,
cx.mk_fn_decl(~[e_arg], cx.mk_ty_infer(span)), cx.expr_ident(span, e_ident),
expr
);
let call_expr = cx.mk_method_call(
span,
cx.mk_path(span, ~[cx.ident_of("__e")]),
cx.ident_of("emit_enum_variant_arg"), cx.ident_of("emit_enum_variant_arg"),
~[ ~[
cx.mk_uint(span, j), cx.expr_uint(span, j),
blk_expr, cx.lambda_expr_1(span, expr, e_ident),
] ]
); );
stmts.push(cx.mk_stmt(span, call_expr)); stmts.push(cx.stmt_expr(call_expr));
} }
// Create the pattern body. // Create the pattern body.
let e_arg = cx.mk_arg( let e_id = cx.ident_of("__e");
span,
cx.ident_of("__e"), let call_expr = cx.expr_method_call(
cx.mk_ty_infer(span));
let call_expr = cx.mk_method_call(
span, span,
cx.mk_path(span, ~[cx.ident_of("__e")]), cx.expr_ident(span, e_id),
cx.ident_of("emit_enum_variant"), cx.ident_of("emit_enum_variant"),
~[ ~[
cx.mk_base_str(span, cx.str_of(variant.node.name)), cx.expr_str(span, cx.str_of(variant.node.name)),
cx.mk_uint(span, i), cx.expr_uint(span, i),
cx.mk_uint(span, variant_arg_len), cx.expr_uint(span, variant_arg_len),
cx.mk_lambda_stmts( cx.lambda_stmts_1(span, stmts, e_id)
span,
cx.mk_fn_decl(~[e_arg], cx.mk_ty_infer(span)),
stmts
)
] ]
); );
let match_body_block = cx.mk_simple_block(span, call_expr); //let match_body_block = cx.blk_expr(call_expr);
// Create the arm. // Create the arm.
ast::arm { cx.arm(span, ~[pat], call_expr) //match_body_block)
pats: ~[pat],
guard: None,
body: match_body_block,
}
}; };
let e_ident = cx.ident_of("__e"); let e_ident = cx.ident_of("__e");
let e_arg = cx.mk_arg(
span,
e_ident,
cx.mk_ty_infer(span));
// Create the method body. // Create the method body.
let lambda_expr = cx.mk_lambda( let lambda_expr = cx.lambda_expr_1(
span, span,
cx.mk_fn_decl(~[e_arg], cx.mk_ty_infer(span)), expand_enum_or_struct_match(cx, span, arms),
expand_enum_or_struct_match(cx, span, arms) e_ident);
);
let call_expr = cx.mk_method_call( let call_expr = cx.expr_method_call(
span, span,
cx.mk_path(span, ~[cx.ident_of("__e")]), cx.expr_ident(span, e_ident),
cx.ident_of("emit_enum"), cx.ident_of("emit_enum"),
~[ ~[
cx.mk_base_str(span, cx.str_of(type_ident)), cx.expr_str(span, cx.str_of(type_ident)),
lambda_expr, lambda_expr,
] ]
); );
let stmt = cx.mk_stmt(span, call_expr); let stmt = cx.stmt_expr(call_expr);
// Create the method. // Create the method.
create_encode_method(cx, span, ~[stmt]) create_encode_method(cx, span, ~[stmt])

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

@ -431,7 +431,7 @@ impl<'self> MethodDef<'self> {
let ident = cx.ident_of(fmt!("__arg_%u", i)); let ident = cx.ident_of(fmt!("__arg_%u", i));
arg_tys.push((ident, ast_ty)); arg_tys.push((ident, ast_ty));
let arg_expr = cx.mk_path(span, ~[ident]); let arg_expr = cx.expr_ident(span, ident);
match *ty { match *ty {
// for static methods, just treat any Self // for static methods, just treat any Self
@ -440,7 +440,7 @@ impl<'self> MethodDef<'self> {
self_args.push(arg_expr); self_args.push(arg_expr);
} }
Ptr(~Self, _) if nonstatic => { Ptr(~Self, _) if nonstatic => {
self_args.push(cx.mk_deref(span, arg_expr)) self_args.push(cx.expr_deref(span, arg_expr))
} }
_ => { _ => {
nonself_args.push(arg_expr); nonself_args.push(arg_expr);
@ -461,14 +461,14 @@ impl<'self> MethodDef<'self> {
let fn_generics = self.generics.to_generics(cx, span, type_ident, generics); let fn_generics = self.generics.to_generics(cx, span, type_ident, generics);
let args = do arg_types.map |&(id, ty)| { let args = do arg_types.map |&(id, ty)| {
cx.mk_arg(span, id, ty) cx.arg(span, id, ty)
}; };
let ret_type = self.get_ret_ty(cx, span, generics, type_ident); let ret_type = self.get_ret_ty(cx, span, generics, type_ident);
let method_ident = cx.ident_of(self.name); let method_ident = cx.ident_of(self.name);
let fn_decl = cx.mk_fn_decl(args, ret_type); let fn_decl = cx.fn_decl(args, ret_type);
let body_block = cx.mk_simple_block(span, body); let body_block = cx.blk_expr(body);
// Create the method. // Create the method.
@ -555,13 +555,8 @@ impl<'self> MethodDef<'self> {
// structs. This is actually right-to-left, but it shoudn't // structs. This is actually right-to-left, but it shoudn't
// matter. // matter.
for vec::each2(self_args, patterns) |&arg_expr, &pat| { for vec::each2(self_args, patterns) |&arg_expr, &pat| {
let match_arm = ast::arm { body = cx.expr_match(span, arg_expr,
pats: ~[ pat ], ~[ cx.arm(span, ~[pat], body) ])
guard: None,
body: cx.mk_simple_block(span, body)
};
body = cx.mk_expr(span, ast::expr_match(arg_expr, ~[match_arm]))
} }
body body
} }
@ -690,7 +685,7 @@ impl<'self> MethodDef<'self> {
} }
let field_tuples = let field_tuples =
do vec::map_zip(*self_vec, do vec::map_zip(*self_vec,
enum_matching_fields) |&(id, self_f), &other| { enum_matching_fields) |&(id, self_f), &other| {
(id, self_f, other) (id, self_f, other)
}; };
substructure = EnumMatching(variant_index, variant, field_tuples); substructure = EnumMatching(variant_index, variant, field_tuples);
@ -738,16 +733,16 @@ impl<'self> MethodDef<'self> {
matches_so_far, matches_so_far,
match_count + 1); match_count + 1);
matches_so_far.pop(); matches_so_far.pop();
arms.push(cx.mk_arm(span, ~[ pattern ], arm_expr)); arms.push(cx.arm(span, ~[ pattern ], arm_expr));
if enum_def.variants.len() > 1 { if enum_def.variants.len() > 1 {
let e = &EnumNonMatching(&[]); let e = &EnumNonMatching(&[]);
let wild_expr = self.call_substructure_method(cx, span, type_ident, let wild_expr = self.call_substructure_method(cx, span, type_ident,
self_args, nonself_args, self_args, nonself_args,
e); e);
let wild_arm = cx.mk_arm(span, let wild_arm = cx.arm(span,
~[ cx.mk_pat_wild(span) ], ~[ cx.pat_wild(span) ],
wild_expr); wild_expr);
arms.push(wild_arm); arms.push(wild_arm);
} }
} else { } else {
@ -774,14 +769,13 @@ impl<'self> MethodDef<'self> {
match_count + 1); match_count + 1);
matches_so_far.pop(); matches_so_far.pop();
let arm = cx.mk_arm(span, ~[ pattern ], arm_expr); let arm = cx.arm(span, ~[ pattern ], arm_expr);
arms.push(arm); arms.push(arm);
} }
} }
// match foo { arm, arm, arm, ... } // match foo { arm, arm, arm, ... }
cx.mk_expr(span, cx.expr_match(span, self_args[match_count], arms)
ast::expr_match(self_args[match_count], arms))
} }
} }
@ -887,10 +881,10 @@ pub fn cs_same_method(f: &fn(@ExtCtxt, span, ~[@expr]) -> @expr,
EnumMatching(_, _, ref all_fields) | Struct(ref all_fields) => { EnumMatching(_, _, ref all_fields) | Struct(ref all_fields) => {
// call self_n.method(other_1_n, other_2_n, ...) // call self_n.method(other_1_n, other_2_n, ...)
let called = do all_fields.map |&(_, self_field, other_fields)| { let called = do all_fields.map |&(_, self_field, other_fields)| {
cx.mk_method_call(span, cx.expr_method_call(span,
self_field, self_field,
substructure.method_ident, substructure.method_ident,
other_fields) other_fields)
}; };
f(cx, span, called) f(cx, span, called)
@ -945,9 +939,9 @@ pub fn cs_binop(binop: ast::binop, base: @expr,
cs_same_method_fold( cs_same_method_fold(
true, // foldl is good enough true, // foldl is good enough
|cx, span, old, new| { |cx, span, old, new| {
cx.mk_binary(span, cx.expr_binary(span,
binop, binop,
old, new) old, new)
}, },
base, base,
@ -960,7 +954,7 @@ pub fn cs_binop(binop: ast::binop, base: @expr,
pub fn cs_or(enum_nonmatch_f: EnumNonMatchFunc, pub fn cs_or(enum_nonmatch_f: EnumNonMatchFunc,
cx: @ExtCtxt, span: span, cx: @ExtCtxt, span: span,
substructure: &Substructure) -> @expr { substructure: &Substructure) -> @expr {
cs_binop(ast::or, cx.mk_bool(span, false), cs_binop(ast::or, cx.expr_bool(span, false),
enum_nonmatch_f, enum_nonmatch_f,
cx, span, substructure) cx, span, substructure)
} }
@ -969,7 +963,7 @@ pub fn cs_or(enum_nonmatch_f: EnumNonMatchFunc,
pub fn cs_and(enum_nonmatch_f: EnumNonMatchFunc, pub fn cs_and(enum_nonmatch_f: EnumNonMatchFunc,
cx: @ExtCtxt, span: span, cx: @ExtCtxt, span: span,
substructure: &Substructure) -> @expr { substructure: &Substructure) -> @expr {
cs_binop(ast::and, cx.mk_bool(span, true), cs_binop(ast::and, cx.expr_bool(span, true),
enum_nonmatch_f, enum_nonmatch_f,
cx, span, substructure) cx, span, substructure)
} }

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

@ -48,7 +48,7 @@ fn iter_bytes_substructure(cx: @ExtCtxt, span: span, substr: &Substructure) -> @
}; };
let iter_bytes_ident = substr.method_ident; let iter_bytes_ident = substr.method_ident;
let call_iterbytes = |thing_expr| { let call_iterbytes = |thing_expr| {
cx.mk_method_call(span, cx.expr_method_call(span,
thing_expr, iter_bytes_ident, thing_expr, iter_bytes_ident,
copy lsb0_f) copy lsb0_f)
}; };
@ -63,7 +63,7 @@ fn iter_bytes_substructure(cx: @ExtCtxt, span: span, substr: &Substructure) -> @
// iteration function. // iteration function.
let discriminant = match variant.node.disr_expr { let discriminant = match variant.node.disr_expr {
Some(copy d)=> d, Some(copy d)=> d,
None => cx.mk_uint(span, index) None => cx.expr_uint(span, index)
}; };
exprs.push(call_iterbytes(discriminant)); exprs.push(call_iterbytes(discriminant));
@ -82,6 +82,6 @@ fn iter_bytes_substructure(cx: @ExtCtxt, span: span, substr: &Substructure) -> @
} }
do vec::foldl(exprs[0], exprs.slice(1, exprs.len())) |prev, me| { do vec::foldl(exprs[0], exprs.slice(1, exprs.len())) |prev, me| {
cx.mk_binary(span, and, prev, *me) cx.expr_binary(span, and, prev, *me)
} }
} }

102
src/libsyntax/ext/deriving/mod.rs
View file

@ -22,7 +22,7 @@ use ast;
use ast::{Ty, enum_def, expr, ident, item, Generics, meta_item, struct_def}; use ast::{Ty, enum_def, expr, ident, item, Generics, meta_item, struct_def};
use ext::base::ExtCtxt; use ext::base::ExtCtxt;
use ext::build::AstBuilder; use ext::build::AstBuilder;
use codemap::{span, respan}; use codemap::span;
use parse::token::special_idents::clownshoes_extensions; use parse::token::special_idents::clownshoes_extensions;
use opt_vec; use opt_vec;
@ -143,38 +143,15 @@ pub fn expand_deriving(cx: @ExtCtxt,
result result
} }
fn create_impl_item(cx: @ExtCtxt, span: span, item: ast::item_) -> @item {
let doc_attr = respan(span,
ast::lit_str(@~"Automatically derived."));
let doc_attr = respan(span, ast::meta_name_value(@~"doc", doc_attr));
let doc_attr = ast::attribute_ {
style: ast::attr_outer,
value: @doc_attr,
is_sugared_doc: false
};
let doc_attr = respan(span, doc_attr);
@ast::item {
ident: clownshoes_extensions,
attrs: ~[doc_attr],
id: cx.next_id(),
node: item,
vis: ast::public,
span: span,
}
}
pub fn create_self_type_with_params(cx: @ExtCtxt, pub fn create_self_type_with_params(cx: @ExtCtxt,
span: span, span: span,
type_ident: ident, type_ident: ident,
generics: &Generics) generics: &Generics)
-> @Ty { -> @Ty {
// Create the type parameters on the `self` path. // Create the type parameters on the `self` path.
let mut self_ty_params = ~[]; let mut self_ty_params = ~[];
for generics.ty_params.each |ty_param| { for generics.ty_params.each |ty_param| {
let self_ty_param = cx.mk_simple_ty_path( let self_ty_param = cx.ty_ident(span, ty_param.ident);
span,
ty_param.ident);
self_ty_params.push(self_ty_param); self_ty_params.push(self_ty_param);
} }
@ -186,11 +163,7 @@ pub fn create_self_type_with_params(cx: @ExtCtxt,
// Create the type of `self`. // Create the type of `self`.
let self_type = cx.mk_raw_path_(span, cx.ty_path(cx.path_all(span, false, ~[ type_ident ], lifetime, self_ty_params))
~[ type_ident ],
lifetime,
self_ty_params);
cx.mk_ty_path_path(span, self_type)
} }
pub fn create_derived_impl(cx: @ExtCtxt, pub fn create_derived_impl(cx: @ExtCtxt,
@ -222,18 +195,17 @@ pub fn create_derived_impl(cx: @ExtCtxt,
for generics.ty_params.each |ty_param| { for generics.ty_params.each |ty_param| {
// extra restrictions on the generics parameters to the type being derived upon // extra restrictions on the generics parameters to the type being derived upon
let mut bounds = do bounds_paths.map |&bound_path| { let mut bounds = do bounds_paths.map |&bound_path| {
cx.mk_trait_ty_param_bound_(bound_path) cx.typarambound(bound_path)
}; };
let this_trait_bound = let this_trait_bound = cx.typarambound(trait_path);
cx.mk_trait_ty_param_bound_(trait_path);
bounds.push(this_trait_bound); bounds.push(this_trait_bound);
impl_generics.ty_params.push(cx.mk_ty_param(ty_param.ident, @bounds)); impl_generics.ty_params.push(cx.typaram(ty_param.ident, @bounds));
} }
// Create the reference to the trait. // Create the reference to the trait.
let trait_ref = cx.mk_trait_ref_(trait_path); let trait_ref = cx.trait_ref(trait_path);
// Create the type of `self`. // Create the type of `self`.
let self_type = create_self_type_with_params(cx, let self_type = create_self_type_with_params(cx,
@ -241,12 +213,18 @@ pub fn create_derived_impl(cx: @ExtCtxt,
type_ident, type_ident,
generics); generics);
// Create the impl item. let doc_attr = cx.attribute(
let impl_item = ast::item_impl(impl_generics, span,
Some(trait_ref), cx.meta_name_value(span,
self_type, ~"doc", ast::lit_str(@~"Automatically derived.")));
methods.map(|x| *x)); cx.item(
return create_impl_item(cx, span, impl_item); span,
clownshoes_extensions,
~[doc_attr],
ast::item_impl(impl_generics,
Some(trait_ref),
self_type,
methods.map(|x| *x)))
} }
pub fn create_subpatterns(cx: @ExtCtxt, pub fn create_subpatterns(cx: @ExtCtxt,
@ -255,7 +233,7 @@ pub fn create_subpatterns(cx: @ExtCtxt,
mutbl: ast::mutability) mutbl: ast::mutability)
-> ~[@ast::pat] { -> ~[@ast::pat] {
do field_paths.map |&path| { do field_paths.map |&path| {
cx.mk_pat(span, cx.pat(span,
ast::pat_ident(ast::bind_by_ref(mutbl), path, None)) ast::pat_ident(ast::bind_by_ref(mutbl), path, None))
} }
} }
@ -274,12 +252,12 @@ pub fn create_struct_pattern(cx: @ExtCtxt,
-> (@ast::pat, ~[(Option<ident>, @expr)]) { -> (@ast::pat, ~[(Option<ident>, @expr)]) {
if struct_def.fields.is_empty() { if struct_def.fields.is_empty() {
return ( return (
cx.mk_pat_ident_with_binding_mode( cx.pat_ident_binding_mode(
span, struct_ident, ast::bind_infer), span, struct_ident, ast::bind_infer),
~[]); ~[]);
} }
let matching_path = cx.mk_raw_path(span, ~[ struct_ident ]); let matching_path = cx.path(span, ~[ struct_ident ]);
let mut paths = ~[], ident_expr = ~[]; let mut paths = ~[], ident_expr = ~[];
@ -301,10 +279,10 @@ pub fn create_struct_pattern(cx: @ExtCtxt,
cx.span_bug(span, "A struct with named and unnamed fields in `deriving`"); cx.span_bug(span, "A struct with named and unnamed fields in `deriving`");
} }
}; };
let path = cx.mk_raw_path(span, let path = cx.path_ident(span,
~[ cx.ident_of(fmt!("%s_%u", prefix, i)) ]); cx.ident_of(fmt!("%s_%u", prefix, i)));
paths.push(path); paths.push(path);
ident_expr.push((opt_id, cx.mk_path_raw(span, path))); ident_expr.push((opt_id, cx.expr_path(path)));
} }
let subpats = create_subpatterns(cx, span, paths, mutbl); let subpats = create_subpatterns(cx, span, paths, mutbl);
@ -318,9 +296,9 @@ pub fn create_struct_pattern(cx: @ExtCtxt,
push(ast::field_pat { ident: id.get(), pat: pat }) push(ast::field_pat { ident: id.get(), pat: pat })
} }
}; };
cx.mk_pat_struct(span, matching_path, field_pats) cx.pat_struct(span, matching_path, field_pats)
} else { } else {
cx.mk_pat_enum(span, matching_path, subpats) cx.pat_enum(span, matching_path, subpats)
}; };
(pattern, ident_expr) (pattern, ident_expr)
@ -337,24 +315,24 @@ pub fn create_enum_variant_pattern(cx: @ExtCtxt,
match variant.node.kind { match variant.node.kind {
ast::tuple_variant_kind(ref variant_args) => { ast::tuple_variant_kind(ref variant_args) => {
if variant_args.is_empty() { if variant_args.is_empty() {
return (cx.mk_pat_ident_with_binding_mode( return (cx.pat_ident_binding_mode(
span, variant_ident, ast::bind_infer), ~[]); span, variant_ident, ast::bind_infer), ~[]);
} }
let matching_path = cx.mk_raw_path(span, ~[ variant_ident ]); let matching_path = cx.path_ident(span, variant_ident);
let mut paths = ~[], ident_expr = ~[]; let mut paths = ~[], ident_expr = ~[];
for uint::range(0, variant_args.len()) |i| { for uint::range(0, variant_args.len()) |i| {
let path = cx.mk_raw_path(span, let path = cx.path_ident(span,
~[ cx.ident_of(fmt!("%s_%u", prefix, i)) ]); cx.ident_of(fmt!("%s_%u", prefix, i)));
paths.push(path); paths.push(path);
ident_expr.push((None, cx.mk_path_raw(span, path))); ident_expr.push((None, cx.expr_path(path)));
} }
let subpats = create_subpatterns(cx, span, paths, mutbl); let subpats = create_subpatterns(cx, span, paths, mutbl);
(cx.mk_pat_enum(span, matching_path, subpats), (cx.pat_enum(span, matching_path, subpats),
ident_expr) ident_expr)
} }
ast::struct_variant_kind(struct_def) => { ast::struct_variant_kind(struct_def) => {
@ -377,8 +355,6 @@ pub fn expand_enum_or_struct_match(cx: @ExtCtxt,
span: span, span: span,
arms: ~[ ast::arm ]) arms: ~[ ast::arm ])
-> @expr { -> @expr {
let self_expr = cx.make_self(span); let self_expr = cx.expr_deref(span, cx.expr_self(span));
let self_expr = cx.mk_unary(span, ast::deref, self_expr); cx.expr_match(span, self_expr, arms)
let self_match_expr = ast::expr_match(self_expr, arms);
cx.mk_expr(span, self_match_expr)
} }

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

@ -12,7 +12,7 @@ use ast;
use ast::{meta_item, item, expr, ident}; use ast::{meta_item, item, expr, ident};
use codemap::span; use codemap::span;
use ext::base::ExtCtxt; use ext::base::ExtCtxt;
use ext::build::{AstBuilder, Duplicate, Field}; use ext::build::{AstBuilder, Duplicate};
use ext::deriving::generic::*; use ext::deriving::generic::*;
pub fn expand_deriving_rand(cx: @ExtCtxt, pub fn expand_deriving_rand(cx: @ExtCtxt,
@ -59,10 +59,9 @@ fn rand_substructure(cx: @ExtCtxt, span: span, substr: &Substructure) -> @expr {
cx.ident_of("rand") cx.ident_of("rand")
]; ];
let rand_call = || { let rand_call = || {
cx.mk_call_global( cx.expr_call_global(span,
span, copy rand_ident,
copy rand_ident, ~[ rng[0].duplicate(cx) ])
~[ rng[0].duplicate(cx) ])
}; };
return match *substr.fields { return match *substr.fields {
@ -74,41 +73,39 @@ fn rand_substructure(cx: @ExtCtxt, span: span, substr: &Substructure) -> @expr {
cx.span_fatal(span, "`Rand` cannot be derived for enums with no variants"); cx.span_fatal(span, "`Rand` cannot be derived for enums with no variants");
} }
let variant_count = cx.mk_uint(span, variants.len()); let variant_count = cx.expr_uint(span, variants.len());
// need to specify the uint-ness of the random number // need to specify the uint-ness of the random number
let u32_ty = cx.mk_ty_path(span, ~[cx.ident_of("uint")]); let u32_ty = cx.ty_ident(span, cx.ident_of("uint"));
let r_ty = cx.mk_ty_path(span, ~[cx.ident_of("R")]); let r_ty = cx.ty_ident(span, cx.ident_of("R"));
let rand_name = cx.mk_raw_path_(span, copy rand_ident, None, ~[ u32_ty, r_ty ]); let rand_name = cx.path_all(span, false, copy rand_ident, None, ~[ u32_ty, r_ty ]);
let rand_name = cx.mk_path_raw(span, rand_name); let rand_name = cx.expr_path(rand_name);
let rv_call = cx.mk_call_( let rv_call = cx.expr_call(span,
span, rand_name,
rand_name, ~[ rng[0].duplicate(cx) ]);
~[ rng[0].duplicate(cx) ]);
// rand() % variants.len() // rand() % variants.len()
let rand_variant = cx.mk_binary(span, ast::rem, let rand_variant = cx.expr_binary(span, ast::rem,
rv_call, variant_count); rv_call, variant_count);
let mut arms = do variants.mapi |i, id_sum| { let mut arms = do variants.mapi |i, id_sum| {
let i_expr = cx.mk_uint(span, i); let i_expr = cx.expr_uint(span, i);
let pat = cx.mk_pat_lit(span, i_expr); let pat = cx.pat_lit(span, i_expr);
match *id_sum { match *id_sum {
(ident, ref summary) => { (ident, ref summary) => {
cx.mk_arm(span, cx.arm(span,
~[ pat ], ~[ pat ],
rand_thing(cx, span, ident, summary, rand_call)) rand_thing(cx, span, ident, summary, rand_call))
} }
} }
}; };
// _ => {} at the end. Should never occur // _ => {} at the end. Should never occur
arms.push(cx.mk_unreachable_arm(span)); arms.push(cx.arm_unreachable(span));
cx.mk_expr(span, cx.expr_match(span, rand_variant, arms)
ast::expr_match(rand_variant, arms))
} }
_ => cx.bug("Non-static method in `deriving(Rand)`") _ => cx.bug("Non-static method in `deriving(Rand)`")
}; };
@ -117,24 +114,20 @@ fn rand_substructure(cx: @ExtCtxt, span: span, substr: &Substructure) -> @expr {
ctor_ident: ident, ctor_ident: ident,
summary: &Either<uint, ~[ident]>, summary: &Either<uint, ~[ident]>,
rand_call: &fn() -> @expr) -> @expr { rand_call: &fn() -> @expr) -> @expr {
let ctor_ident = ~[ ctor_ident ];
match *summary { match *summary {
Left(copy count) => { Left(copy count) => {
if count == 0 { if count == 0 {
cx.mk_path(span, ctor_ident) cx.expr_ident(span, ctor_ident)
} else { } else {
let exprs = vec::from_fn(count, |_| rand_call()); let exprs = vec::from_fn(count, |_| rand_call());
cx.mk_call(span, ctor_ident, exprs) cx.expr_call_ident(span, ctor_ident, exprs)
} }
} }
Right(ref fields) => { Right(ref fields) => {
let rand_fields = do fields.map |ident| { let rand_fields = do fields.map |ident| {
Field { cx.field_imm(span, *ident, rand_call())
ident: *ident,
ex: rand_call()
}
}; };
cx.mk_struct_e(span, ctor_ident, rand_fields) cx.expr_struct_ident(span, ctor_ident, rand_fields)
} }
} }
} }

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

@ -42,12 +42,12 @@ pub fn expand_deriving_to_str(cx: @ExtCtxt,
fn to_str_substructure(cx: @ExtCtxt, span: span, substr: &Substructure) -> @expr { fn to_str_substructure(cx: @ExtCtxt, span: span, substr: &Substructure) -> @expr {
match substr.self_args { match substr.self_args {
[self_obj] => { [self_obj] => {
let self_addr = cx.mk_addr_of(span, self_obj); let self_addr = cx.expr_addr_of(span, self_obj);
cx.mk_call_global(span, cx.expr_call_global(span,
~[cx.ident_of("core"), ~[cx.ident_of("core"),
cx.ident_of("sys"), cx.ident_of("sys"),
cx.ident_of("log_str")], cx.ident_of("log_str")],
~[self_addr]) ~[self_addr])
} }
_ => cx.span_bug(span, "Invalid number of arguments in `deriving(ToStr)`") _ => cx.span_bug(span, "Invalid number of arguments in `deriving(ToStr)`")
} }

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

@ -55,9 +55,8 @@ pub impl<'self> Path<'self> {
fn to_ty(&self, cx: @ExtCtxt, span: span, fn to_ty(&self, cx: @ExtCtxt, span: span,
self_ty: ident, self_generics: &Generics) -> @ast::Ty { self_ty: ident, self_generics: &Generics) -> @ast::Ty {
cx.mk_ty_path_path(span, cx.ty_path(self.to_path(cx, span,
self.to_path(cx, span, self_ty, self_generics))
self_ty, self_generics))
} }
fn to_path(&self, cx: @ExtCtxt, span: span, fn to_path(&self, cx: @ExtCtxt, span: span,
self_ty: ident, self_generics: &Generics) -> @ast::Path { self_ty: ident, self_generics: &Generics) -> @ast::Path {
@ -65,11 +64,7 @@ pub impl<'self> Path<'self> {
let lt = mk_lifetime(cx, span, &self.lifetime); let lt = mk_lifetime(cx, span, &self.lifetime);
let tys = self.params.map(|t| t.to_ty(cx, span, self_ty, self_generics)); let tys = self.params.map(|t| t.to_ty(cx, span, self_ty, self_generics));
if self.global { cx.path_all(span, self.global, idents, lt, tys)
cx.mk_raw_path_global_(span, idents, lt, tys)
} else {
cx.mk_raw_path_(span, idents, lt, tys)
}
} }
} }
@ -106,7 +101,7 @@ pub fn nil_ty() -> Ty<'static> {
fn mk_lifetime(cx: @ExtCtxt, span: span, lt: &Option<&str>) -> Option<@ast::Lifetime> { fn mk_lifetime(cx: @ExtCtxt, span: span, lt: &Option<&str>) -> Option<@ast::Lifetime> {
match *lt { match *lt {
Some(ref s) => Some(@cx.mk_lifetime(span, cx.ident_of(*s))), Some(ref s) => Some(@cx.lifetime(span, cx.ident_of(*s))),
None => None None => None
} }
} }
@ -119,20 +114,20 @@ pub impl<'self> Ty<'self> {
let raw_ty = ty.to_ty(cx, span, self_ty, self_generics); let raw_ty = ty.to_ty(cx, span, self_ty, self_generics);
match *ptr { match *ptr {
Owned => { Owned => {
cx.mk_ty_uniq(span, raw_ty) cx.ty_uniq(span, raw_ty)
} }
Managed(mutbl) => { Managed(mutbl) => {
cx.mk_ty_box(span, raw_ty, mutbl) cx.ty_box(span, raw_ty, mutbl)
} }
Borrowed(ref lt, mutbl) => { Borrowed(ref lt, mutbl) => {
let lt = mk_lifetime(cx, span, lt); let lt = mk_lifetime(cx, span, lt);
cx.mk_ty_rptr(span, raw_ty, lt, mutbl) cx.ty_rptr(span, raw_ty, lt, mutbl)
} }
} }
} }
Literal(ref p) => { p.to_ty(cx, span, self_ty, self_generics) } Literal(ref p) => { p.to_ty(cx, span, self_ty, self_generics) }
Self => { Self => {
cx.mk_ty_path_path(span, self.to_path(cx, span, self_ty, self_generics)) cx.ty_path(self.to_path(cx, span, self_ty, self_generics))
} }
Tuple(ref fields) => { Tuple(ref fields) => {
let ty = if fields.is_empty() { let ty = if fields.is_empty() {
@ -141,7 +136,7 @@ pub impl<'self> Ty<'self> {
ast::ty_tup(fields.map(|f| f.to_ty(cx, span, self_ty, self_generics))) ast::ty_tup(fields.map(|f| f.to_ty(cx, span, self_ty, self_generics)))
}; };
cx.mk_ty(span, ty) cx.ty(span, ty)
} }
} }
} }
@ -151,7 +146,7 @@ pub impl<'self> Ty<'self> {
match *self { match *self {
Self => { Self => {
let self_params = do self_generics.ty_params.map |ty_param| { let self_params = do self_generics.ty_params.map |ty_param| {
cx.mk_ty_path(span, ~[ ty_param.ident ]) cx.ty_ident(span, ty_param.ident)
}; };
let lifetime = if self_generics.lifetimes.is_empty() { let lifetime = if self_generics.lifetimes.is_empty() {
None None
@ -159,8 +154,8 @@ pub impl<'self> Ty<'self> {
Some(@*self_generics.lifetimes.get(0)) Some(@*self_generics.lifetimes.get(0))
}; };
cx.mk_raw_path_(span, ~[self_ty], lifetime, cx.path_all(span, false, ~[self_ty], lifetime,
opt_vec::take_vec(self_params)) opt_vec::take_vec(self_params))
} }
Literal(ref p) => { Literal(ref p) => {
p.to_path(cx, span, self_ty, self_generics) p.to_path(cx, span, self_ty, self_generics)
@ -177,9 +172,9 @@ fn mk_ty_param(cx: @ExtCtxt, span: span, name: &str, bounds: &[Path],
let bounds = opt_vec::from( let bounds = opt_vec::from(
do bounds.map |b| { do bounds.map |b| {
let path = b.to_path(cx, span, self_ident, self_generics); let path = b.to_path(cx, span, self_ident, self_generics);
cx.mk_trait_ty_param_bound_(path) cx.typarambound(path)
}); });
cx.mk_ty_param(cx.ident_of(name), @bounds) cx.typaram(cx.ident_of(name), @bounds)
} }
fn mk_generics(lifetimes: ~[ast::Lifetime], ty_params: ~[ast::TyParam]) -> Generics { fn mk_generics(lifetimes: ~[ast::Lifetime], ty_params: ~[ast::TyParam]) -> Generics {
@ -204,7 +199,7 @@ pub impl<'self> LifetimeBounds<'self> {
fn to_generics(&self, cx: @ExtCtxt, span: span, fn to_generics(&self, cx: @ExtCtxt, span: span,
self_ty: ident, self_generics: &Generics) -> Generics { self_ty: ident, self_generics: &Generics) -> Generics {
let lifetimes = do self.lifetimes.map |lt| { let lifetimes = do self.lifetimes.map |lt| {
cx.mk_lifetime(span, cx.ident_of(*lt)) cx.lifetime(span, cx.ident_of(*lt))
}; };
let ty_params = do self.bounds.map |t| { let ty_params = do self.bounds.map |t| {
match t { match t {
@ -220,7 +215,7 @@ pub impl<'self> LifetimeBounds<'self> {
pub fn get_explicit_self(cx: @ExtCtxt, span: span, self_ptr: &Option<PtrTy>) 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.make_self(span); let self_path = cx.expr_self(span);
match *self_ptr { match *self_ptr {
None => { None => {
(self_path, respan(span, ast::sty_value)) (self_path, respan(span, ast::sty_value))
@ -232,12 +227,12 @@ pub fn get_explicit_self(cx: @ExtCtxt, span: span, self_ptr: &Option<PtrTy>)
Owned => ast::sty_uniq(ast::m_imm), Owned => ast::sty_uniq(ast::m_imm),
Managed(mutbl) => ast::sty_box(mutbl), Managed(mutbl) => ast::sty_box(mutbl),
Borrowed(ref lt, mutbl) => { Borrowed(ref lt, mutbl) => {
let lt = lt.map(|s| @cx.mk_lifetime(span, let lt = lt.map(|s| @cx.lifetime(span,
cx.ident_of(*s))); cx.ident_of(*s)));
ast::sty_region(lt, mutbl) ast::sty_region(lt, mutbl)
} }
}); });
let self_expr = cx.mk_deref(span, self_path); let self_expr = cx.expr_deref(span, self_path);
(self_expr, self_ty) (self_expr, self_ty)
} }
} }

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

@ -29,8 +29,8 @@ pub fn expand_syntax_ext(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree])
// Option<str> rather than just an maybe-empty string. // Option<str> rather than just an maybe-empty string.
let e = match os::getenv(var) { let e = match os::getenv(var) {
None => cx.mk_base_str(sp, ~""), None => cx.expr_str(sp, ~""),
Some(ref s) => cx.mk_base_str(sp, copy *s) Some(ref s) => cx.expr_str(sp, copy *s)
}; };
MRExpr(e) MRExpr(e)
} }

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

@ -18,7 +18,6 @@ use ast;
use codemap::span; use codemap::span;
use ext::base::*; use ext::base::*;
use ext::base; use ext::base;
use ext::build;
use ext::build::AstBuilder; use ext::build::AstBuilder;
use core::unstable::extfmt::ct::*; use core::unstable::extfmt::ct::*;
@ -56,7 +55,7 @@ fn pieces_to_expr(cx: @ExtCtxt, sp: span,
} }
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(cx, nm); let path = make_path_vec(cx, nm);
cx.mk_path_global(sp, path) cx.expr_path(cx.path_global(sp, path))
} }
// Produces an AST expression that represents a RT::conv record, // Produces an AST expression that represents a RT::conv record,
// which tells the RT::conv* functions how to perform the conversion // which tells the RT::conv* functions how to perform the conversion
@ -72,8 +71,8 @@ fn pieces_to_expr(cx: @ExtCtxt, sp: span,
FlagSignAlways => "flag_sign_always", FlagSignAlways => "flag_sign_always",
FlagAlternate => "flag_alternate" FlagAlternate => "flag_alternate"
}; };
tmp_expr = cx.mk_binary(sp, ast::bitor, tmp_expr, tmp_expr = cx.expr_binary(sp, ast::bitor, tmp_expr,
make_rt_path_expr(cx, sp, fstr)); make_rt_path_expr(cx, sp, fstr));
} }
return tmp_expr; return tmp_expr;
} }
@ -83,10 +82,10 @@ fn pieces_to_expr(cx: @ExtCtxt, sp: span,
return make_rt_path_expr(cx, sp, "CountImplied"); return make_rt_path_expr(cx, sp, "CountImplied");
} }
CountIs(c) => { CountIs(c) => {
let count_lit = cx.mk_uint(sp, c as uint); let count_lit = cx.expr_uint(sp, c as uint);
let count_is_path = make_path_vec(cx, "CountIs"); let count_is_path = make_path_vec(cx, "CountIs");
let count_is_args = ~[count_lit]; let count_is_args = ~[count_lit];
return cx.mk_call_global(sp, count_is_path, count_is_args); return cx.expr_call_global(sp, count_is_path, count_is_args);
} }
_ => cx.span_unimpl(sp, "unimplemented fmt! conversion") _ => cx.span_unimpl(sp, "unimplemented fmt! conversion")
} }
@ -107,22 +106,14 @@ fn pieces_to_expr(cx: @ExtCtxt, sp: span,
width_expr: @ast::expr, precision_expr: @ast::expr, width_expr: @ast::expr, precision_expr: @ast::expr,
ty_expr: @ast::expr) -> @ast::expr { ty_expr: @ast::expr) -> @ast::expr {
let intr = cx.parse_sess().interner; let intr = cx.parse_sess().interner;
cx.mk_global_struct_e( cx.expr_struct(
sp, sp,
make_path_vec(cx, "Conv"), cx.path_global(sp, make_path_vec(cx, "Conv")),
~[ ~[
build::Field { cx.field_imm(sp, intr.intern("flags"), flags_expr),
ident: intr.intern("flags"), ex: flags_expr cx.field_imm(sp, intr.intern("width"), width_expr),
}, cx.field_imm(sp, intr.intern("precision"), precision_expr),
build::Field { cx.field_imm(sp, intr.intern("ty"), ty_expr)
ident: intr.intern("width"), ex: width_expr
},
build::Field {
ident: intr.intern("precision"), ex: precision_expr
},
build::Field {
ident: intr.intern("ty"), ex: ty_expr
},
] ]
) )
} }
@ -139,7 +130,7 @@ fn pieces_to_expr(cx: @ExtCtxt, sp: span,
let path = make_path_vec(cx, fname); let path = make_path_vec(cx, fname);
let cnv_expr = make_rt_conv_expr(cx, sp, cnv); let cnv_expr = make_rt_conv_expr(cx, sp, cnv);
let args = ~[cnv_expr, arg, buf]; let args = ~[cnv_expr, arg, buf];
cx.mk_call_global(arg.span, path, args) cx.expr_call_global(arg.span, path, args)
} }
fn make_new_conv(cx: @ExtCtxt, sp: span, cnv: &Conv, fn make_new_conv(cx: @ExtCtxt, sp: span, cnv: &Conv,
@ -197,10 +188,10 @@ fn pieces_to_expr(cx: @ExtCtxt, sp: span,
TyChar => ("char", arg), TyChar => ("char", arg),
TyBits | TyOctal | TyHex(_) | TyInt(Unsigned) => ("uint", arg), TyBits | TyOctal | TyHex(_) | TyInt(Unsigned) => ("uint", arg),
TyFloat => ("float", arg), TyFloat => ("float", arg),
TyPoly => ("poly", cx.mk_addr_of(sp, arg)) TyPoly => ("poly", cx.expr_addr_of(sp, arg))
}; };
return make_conv_call(cx, arg.span, name, cnv, actual_arg, return make_conv_call(cx, arg.span, name, cnv, actual_arg,
cx.mk_mut_addr_of(arg.span, buf)); cx.expr_mut_addr_of(arg.span, buf));
} }
fn log_conv(c: &Conv) { fn log_conv(c: &Conv) {
debug!("Building conversion:"); debug!("Building conversion:");
@ -258,7 +249,7 @@ fn pieces_to_expr(cx: @ExtCtxt, sp: span,
/* 'ident' is the local buffer building up the result of fmt! */ /* 'ident' is the local buffer building up the result of fmt! */
let ident = cx.parse_sess().interner.intern("__fmtbuf"); let ident = cx.parse_sess().interner.intern("__fmtbuf");
let buf = || cx.mk_path(fmt_sp, ~[ident]); let buf = || cx.expr_ident(fmt_sp, ident);
let str_ident = cx.parse_sess().interner.intern("str"); let str_ident = cx.parse_sess().interner.intern("str");
let push_ident = cx.parse_sess().interner.intern("push_str"); let push_ident = cx.parse_sess().interner.intern("push_str");
let mut stms = ~[]; let mut stms = ~[];
@ -275,14 +266,14 @@ fn pieces_to_expr(cx: @ExtCtxt, sp: span,
buffer with it directly. If it's actually the only piece, buffer with it directly. If it's actually the only piece,
then there's no need for it to be mutable */ then there's no need for it to be mutable */
if i == 0 { if i == 0 {
stms.push(cx.mk_local(fmt_sp, npieces > 1, ident, cx.mk_uniq_str(fmt_sp, s))); stms.push(cx.stmt_let(fmt_sp, npieces > 1,
ident, cx.expr_str_uniq(fmt_sp, s)));
} else { } else {
let args = ~[cx.mk_mut_addr_of(fmt_sp, buf()), cx.mk_base_str(fmt_sp, s)]; let args = ~[cx.expr_mut_addr_of(fmt_sp, buf()), cx.expr_str(fmt_sp, s)];
let call = cx.mk_call_global( let call = cx.expr_call_global(fmt_sp,
fmt_sp, ~[str_ident, push_ident],
~[str_ident, push_ident], args);
args); stms.push(cx.stmt_expr(call));
stms.push(cx.mk_stmt(fmt_sp, call));
} }
} }
@ -299,12 +290,11 @@ fn pieces_to_expr(cx: @ExtCtxt, sp: span,
/* If the first portion is a conversion, then the local buffer /* If the first portion is a conversion, then the local buffer
must be initialized as an empty string */ must be initialized as an empty string */
if i == 0 { if i == 0 {
stms.push(cx.mk_local(fmt_sp, true, ident, stms.push(cx.stmt_let(fmt_sp, true, ident,
cx.mk_uniq_str(fmt_sp, ~""))); cx.expr_str_uniq(fmt_sp, ~"")));
} }
stms.push(cx.mk_stmt(fmt_sp, stms.push(cx.stmt_expr(make_new_conv(cx, fmt_sp, conv,
make_new_conv(cx, fmt_sp, conv, args[n], buf())));
args[n], buf())));
} }
} }
} }
@ -316,5 +306,5 @@ fn pieces_to_expr(cx: @ExtCtxt, sp: span,
nargs, expected_nargs)); nargs, expected_nargs));
} }
cx.mk_block(fmt_sp, ~[], stms, Some(buf())) cx.expr_blk(cx.blk(fmt_sp, stms, Some(buf())))
} }

2
src/libsyntax/ext/pipes/ast_builder.rs
View file

@ -16,7 +16,7 @@
use ast::ident; use ast::ident;
use ast; use ast;
use codemap::span; use codemap::span;
use ext::quote::rt::*; // use ext::quote::rt::*;
// Transitional reexports so qquote can find the paths it is looking for // Transitional reexports so qquote can find the paths it is looking for
mod syntax { mod syntax {

90
src/libsyntax/ext/pipes/pipec.rs
View file

@ -53,14 +53,13 @@ impl gen_send for message {
assert!(next_state.tys.len() == assert!(next_state.tys.len() ==
next.generics.ty_params.len()); next.generics.ty_params.len());
let arg_names = tys.mapi(|i, _ty| cx.ident_of(~"x_"+i.to_str())); let arg_names = tys.mapi(|i, _ty| cx.ident_of(~"x_"+i.to_str()));
let args_ast = vec::map_zip(arg_names, *tys, |n, t| cx.arg(*n, *t)); let args_ast = vec::map_zip(arg_names, *tys, |n, t| cx.arg(span, *n, *t));
let pipe_ty = cx.ty_path( let pipe_ty = cx.ty_path(
path(~[this.data_name()], span) path(~[this.data_name()], span)
.add_tys(cx.ty_vars_global(&this.generics.ty_params))); .add_tys(cx.ty_vars(&this.generics.ty_params)));
let args_ast = vec::append( let args_ast = vec::append(
~[cx.arg(cx.ident_of("pipe"), ~[cx.arg(span, cx.ident_of("pipe"), pipe_ty)],
pipe_ty)],
args_ast); args_ast);
let mut body = ~"{\n"; let mut body = ~"{\n";
@ -113,15 +112,16 @@ impl gen_send for message {
let body = cx.parse_expr(body); let body = cx.parse_expr(body);
let mut rty = cx.ty_path(path(~[next.data_name()], let mut rty = cx.ty_path(path(~[next.data_name()],
span) span)
.add_tys(copy next_state.tys)); .add_tys(copy next_state.tys));
if try { if try {
rty = cx.ty_option(rty); rty = cx.ty_option(rty);
} }
let name = cx.ident_of(if try { ~"try_" + name } else { name } ); let name = cx.ident_of(if try { ~"try_" + name } else { name } );
cx.item_fn_poly(name, cx.item_fn_poly(dummy_sp(),
name,
args_ast, args_ast,
rty, rty,
self.get_generics(), self.get_generics(),
@ -133,14 +133,15 @@ impl gen_send for message {
let arg_names = tys.mapi(|i, _ty| (~"x_" + i.to_str())); let arg_names = tys.mapi(|i, _ty| (~"x_" + i.to_str()));
let args_ast = do vec::map_zip(arg_names, *tys) |n, t| { let args_ast = do vec::map_zip(arg_names, *tys) |n, t| {
cx.arg(cx.ident_of(*n), *t) cx.arg(span, cx.ident_of(*n), *t)
}; };
let args_ast = vec::append( let args_ast = vec::append(
~[cx.arg(cx.ident_of("pipe"), ~[cx.arg(span,
cx.ident_of("pipe"),
cx.ty_path( cx.ty_path(
path(~[this.data_name()], span) path(~[this.data_name()], span)
.add_tys(cx.ty_vars_global( .add_tys(cx.ty_vars(
&this.generics.ty_params))))], &this.generics.ty_params))))],
args_ast); args_ast);
@ -172,12 +173,13 @@ impl gen_send for message {
let name = if try { ~"try_" + name } else { name }; let name = if try { ~"try_" + name } else { name };
cx.item_fn_poly(cx.ident_of(name), cx.item_fn_poly(dummy_sp(),
cx.ident_of(name),
args_ast, args_ast,
if try { if try {
cx.ty_option(cx.ty_nil_ast_builder()) cx.ty_option(cx.ty_nil())
} else { } else {
cx.ty_nil_ast_builder() cx.ty_nil()
}, },
self.get_generics(), self.get_generics(),
cx.blk_expr(body)) cx.blk_expr(body))
@ -187,7 +189,7 @@ impl gen_send for message {
fn to_ty(&mut self, cx: @ExtCtxt) -> @ast::Ty { fn to_ty(&mut self, cx: @ExtCtxt) -> @ast::Ty {
cx.ty_path(path(~[cx.ident_of(self.name())], self.span()) cx.ty_path(path(~[cx.ident_of(self.name())], self.span())
.add_tys(cx.ty_vars_global(&self.get_generics().ty_params))) .add_tys(cx.ty_vars(&self.get_generics().ty_params)))
} }
} }
@ -226,15 +228,15 @@ impl to_type_decls for state {
None => tys None => tys
}; };
let v = cx.variant(cx.ident_of(name), span, tys); let v = cx.variant(span, cx.ident_of(name), tys);
items_msg.push(v); items_msg.push(v);
} }
~[ ~[
cx.item_enum_poly( cx.item_enum_poly(
name,
self.span, self.span,
name,
ast::enum_def { variants: items_msg }, ast::enum_def { variants: items_msg },
cx.strip_bounds(&self.generics) cx.strip_bounds(&self.generics)
) )
@ -263,8 +265,8 @@ impl to_type_decls for state {
if !self.proto.is_bounded() { if !self.proto.is_bounded() {
items.push( items.push(
cx.item_ty_poly( cx.item_ty_poly(
self.data_name(),
self.span, self.span,
self.data_name(),
cx.ty_path( cx.ty_path(
path_global(~[cx.ident_of("core"), path_global(~[cx.ident_of("core"),
cx.ident_of("pipes"), cx.ident_of("pipes"),
@ -274,15 +276,15 @@ impl to_type_decls for state {
path(~[cx.ident_of("super"), path(~[cx.ident_of("super"),
self.data_name()], self.data_name()],
dummy_sp()) dummy_sp())
.add_tys(cx.ty_vars_global( .add_tys(cx.ty_vars(
&self.generics.ty_params))))), &self.generics.ty_params))))),
cx.strip_bounds(&self.generics))); cx.strip_bounds(&self.generics)));
} }
else { else {
items.push( items.push(
cx.item_ty_poly( cx.item_ty_poly(
self.data_name(),
self.span, self.span,
self.data_name(),
cx.ty_path( cx.ty_path(
path_global(~[cx.ident_of("core"), path_global(~[cx.ident_of("core"),
cx.ident_of("pipes"), cx.ident_of("pipes"),
@ -342,15 +344,18 @@ impl gen_init for protocol {
} }
fn gen_buffer_init(&self, ext_cx: @ExtCtxt) -> @ast::expr { fn gen_buffer_init(&self, ext_cx: @ExtCtxt) -> @ast::expr {
ext_cx.expr_struct(path(~[ext_cx.ident_of("__Buffer")], ext_cx.expr_struct(
dummy_sp()), dummy_sp(),
self.states.map_to_vec(|s| { path(~[ext_cx.ident_of("__Buffer")],
let fty = s.to_ty(ext_cx); dummy_sp()),
ext_cx.field_imm(ext_cx.ident_of(s.name), self.states.map_to_vec(|s| {
quote_expr!( let fty = s.to_ty(ext_cx);
::core::pipes::mk_packet::<$fty>() ext_cx.field_imm(dummy_sp(),
)) ext_cx.ident_of(s.name),
})) quote_expr!(
::core::pipes::mk_packet::<$fty>()
))
}))
} }
fn gen_init_bounded(&self, ext_cx: @ExtCtxt) -> @ast::expr { fn gen_init_bounded(&self, ext_cx: @ExtCtxt) -> @ast::expr {
@ -392,9 +397,9 @@ impl gen_init for protocol {
} }
cx.ty_path(path(~[cx.ident_of("super"), cx.ty_path(path(~[cx.ident_of("super"),
cx.ident_of("__Buffer")], cx.ident_of("__Buffer")],
copy self.span) copy self.span)
.add_tys(cx.ty_vars_global(&params))) .add_tys(cx.ty_vars_global(&params)))
} }
fn gen_buffer_type(&self, cx: @ExtCtxt) -> @ast::item { fn gen_buffer_type(&self, cx: @ExtCtxt) -> @ast::item {
@ -429,8 +434,8 @@ impl gen_init for protocol {
}; };
cx.item_struct_poly( cx.item_struct_poly(
cx.ident_of("__Buffer"),
dummy_sp(), dummy_sp(),
cx.ident_of("__Buffer"),
ast::struct_def { ast::struct_def {
fields: fields, fields: fields,
ctor_id: None ctor_id: None
@ -454,13 +459,24 @@ impl gen_init for protocol {
items.push(self.gen_buffer_type(cx)) items.push(self.gen_buffer_type(cx))
} }
items.push(cx.item_mod(cx.ident_of("client"), items.push(cx.item_mod(copy self.span,
copy self.span, cx.ident_of("client"),
~[], ~[],
client_states)); client_states));
items.push(cx.item_mod(cx.ident_of("server"), items.push(cx.item_mod(copy self.span,
copy self.span, cx.ident_of("server"),
~[], ~[],
server_states)); server_states));
cx.item_mod(cx.ident_of(copy self.name), copy self.span, items) // XXX: Would be nice if our generated code didn't violate
// Rust coding conventions
let allows = cx.attribute(
copy self.span,
cx.meta_list(copy self.span,
~"allow",
~[cx.meta_word(copy self.span, ~"non_camel_case_types"),
cx.meta_word(copy self.span, ~"unused_mut")]));
cx.item_mod(copy self.span, cx.ident_of(copy self.name),
~[allows], ~[], items)
} }
} }

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

@ -382,7 +382,7 @@ pub fn expand_quote_expr(cx: @ExtCtxt,
pub fn expand_quote_item(cx: @ExtCtxt, pub fn expand_quote_item(cx: @ExtCtxt,
sp: span, sp: span,
tts: &[ast::token_tree]) -> base::MacResult { tts: &[ast::token_tree]) -> base::MacResult {
let e_attrs = cx.mk_uniq_vec_e(sp, ~[]); let e_attrs = cx.expr_vec_uniq(sp, ~[]);
base::MRExpr(expand_parse_call(cx, sp, "parse_item", base::MRExpr(expand_parse_call(cx, sp, "parse_item",
~[e_attrs], tts)) ~[e_attrs], tts))
} }
@ -390,7 +390,7 @@ pub fn expand_quote_item(cx: @ExtCtxt,
pub fn expand_quote_pat(cx: @ExtCtxt, pub fn expand_quote_pat(cx: @ExtCtxt,
sp: span, sp: span,
tts: &[ast::token_tree]) -> base::MacResult { tts: &[ast::token_tree]) -> base::MacResult {
let e_refutable = cx.mk_lit(sp, ast::lit_bool(true)); let e_refutable = cx.expr_lit(sp, ast::lit_bool(true));
base::MRExpr(expand_parse_call(cx, sp, "parse_pat", base::MRExpr(expand_parse_call(cx, sp, "parse_pat",
~[e_refutable], tts)) ~[e_refutable], tts))
} }
@ -398,7 +398,7 @@ pub fn expand_quote_pat(cx: @ExtCtxt,
pub fn expand_quote_ty(cx: @ExtCtxt, pub fn expand_quote_ty(cx: @ExtCtxt,
sp: span, sp: span,
tts: &[ast::token_tree]) -> base::MacResult { tts: &[ast::token_tree]) -> base::MacResult {
let e_param_colons = cx.mk_lit(sp, ast::lit_bool(false)); let e_param_colons = cx.expr_lit(sp, ast::lit_bool(false));
base::MRExpr(expand_parse_call(cx, sp, "parse_ty", base::MRExpr(expand_parse_call(cx, sp, "parse_ty",
~[e_param_colons], tts)) ~[e_param_colons], tts))
} }
@ -406,7 +406,7 @@ pub fn expand_quote_ty(cx: @ExtCtxt,
pub fn expand_quote_stmt(cx: @ExtCtxt, pub fn expand_quote_stmt(cx: @ExtCtxt,
sp: span, sp: span,
tts: &[ast::token_tree]) -> base::MacResult { tts: &[ast::token_tree]) -> base::MacResult {
let e_attrs = cx.mk_uniq_vec_e(sp, ~[]); let e_attrs = cx.expr_vec_uniq(sp, ~[]);
base::MRExpr(expand_parse_call(cx, sp, "parse_stmt", base::MRExpr(expand_parse_call(cx, sp, "parse_stmt",
~[e_attrs], tts)) ~[e_attrs], tts))
} }
@ -421,17 +421,17 @@ fn id_ext(cx: @ExtCtxt, str: &str) -> ast::ident {
// Lift an ident to the expr that evaluates to that 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.mk_base_str(sp, cx.str_of(ident)); let e_str = cx.expr_str(sp, cx.str_of(ident));
cx.mk_method_call(sp, cx.expr_method_call(sp,
cx.mk_path(sp, ids_ext(cx, ~[~"ext_cx"])), cx.expr_ident(sp, id_ext(cx, "ext_cx")),
id_ext(cx, "ident_of"), id_ext(cx, "ident_of"),
~[e_str]) ~[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 = ids_ext(cx, ~[~"BytePos"]); let path = id_ext(cx, "BytePos");
let arg = cx.mk_uint(sp, bpos.to_uint()); let arg = cx.expr_uint(sp, bpos.to_uint());
cx.mk_call(sp, path, ~[arg]) 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 {
@ -447,22 +447,21 @@ fn mk_binop(cx: @ExtCtxt, sp: span, bop: token::binop) -> @ast::expr {
SHL => "SHL", SHL => "SHL",
SHR => "SHR" SHR => "SHR"
}; };
cx.mk_path(sp, cx.expr_ident(sp, id_ext(cx, name))
ids_ext(cx, ~[name.to_owned()]))
} }
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 { match *tok {
BINOP(binop) => { BINOP(binop) => {
return cx.mk_call(sp, return cx.expr_call_ident(sp,
ids_ext(cx, ~[~"BINOP"]), id_ext(cx, "BINOP"),
~[mk_binop(cx, sp, binop)]); ~[mk_binop(cx, sp, binop)]);
} }
BINOPEQ(binop) => { BINOPEQ(binop) => {
return cx.mk_call(sp, return cx.expr_call_ident(sp,
ids_ext(cx, ~[~"BINOPEQ"]), id_ext(cx, "BINOPEQ"),
~[mk_binop(cx, sp, binop)]); ~[mk_binop(cx, sp, binop)]);
} }
LIT_INT(i, ity) => { LIT_INT(i, ity) => {
@ -474,15 +473,13 @@ fn mk_token(cx: @ExtCtxt, sp: span, tok: &token::Token) -> @ast::expr {
ast::ty_i32 => ~"ty_i32", ast::ty_i32 => ~"ty_i32",
ast::ty_i64 => ~"ty_i64" ast::ty_i64 => ~"ty_i64"
}; };
let e_ity = let e_ity = cx.expr_ident(sp, id_ext(cx, s_ity));
cx.mk_path(sp,
ids_ext(cx, ~[s_ity]));
let e_i64 = cx.mk_lit(sp, ast::lit_int(i, ast::ty_i64)); let e_i64 = cx.expr_lit(sp, ast::lit_int(i, ast::ty_i64));
return cx.mk_call(sp, return cx.expr_call_ident(sp,
ids_ext(cx, ~[~"LIT_INT"]), id_ext(cx, "LIT_INT"),
~[e_i64, e_ity]); ~[e_i64, e_ity]);
} }
LIT_UINT(u, uty) => { LIT_UINT(u, uty) => {
@ -493,24 +490,21 @@ fn mk_token(cx: @ExtCtxt, sp: span, tok: &token::Token) -> @ast::expr {
ast::ty_u32 => ~"ty_u32", ast::ty_u32 => ~"ty_u32",
ast::ty_u64 => ~"ty_u64" ast::ty_u64 => ~"ty_u64"
}; };
let e_uty = let e_uty = cx.expr_ident(sp, id_ext(cx, s_uty));
cx.mk_path(sp,
ids_ext(cx, ~[s_uty]));
let e_u64 = cx.mk_lit(sp, ast::lit_uint(u, ast::ty_u64)); let e_u64 = cx.expr_lit(sp, ast::lit_uint(u, ast::ty_u64));
return cx.mk_call(sp, return cx.expr_call_ident(sp,
ids_ext(cx, ~[~"LIT_UINT"]), id_ext(cx, "LIT_UINT"),
~[e_u64, e_uty]); ~[e_u64, e_uty]);
} }
LIT_INT_UNSUFFIXED(i) => { LIT_INT_UNSUFFIXED(i) => {
let e_i64 = cx.mk_lit(sp, let e_i64 = cx.expr_lit(sp, ast::lit_int(i, ast::ty_i64));
ast::lit_int(i, ast::ty_i64));
return cx.mk_call(sp, return cx.expr_call_ident(sp,
ids_ext(cx, ~[~"LIT_INT_UNSUFFIXED"]), id_ext(cx, "LIT_INT_UNSUFFIXED"),
~[e_i64]); ~[e_i64]);
} }
LIT_FLOAT(fident, fty) => { LIT_FLOAT(fident, fty) => {
@ -519,40 +513,38 @@ fn mk_token(cx: @ExtCtxt, sp: span, tok: &token::Token) -> @ast::expr {
ast::ty_f32 => ~"ty_f32", ast::ty_f32 => ~"ty_f32",
ast::ty_f64 => ~"ty_f64" ast::ty_f64 => ~"ty_f64"
}; };
let e_fty = let e_fty = cx.expr_ident(sp, id_ext(cx, s_fty));
cx.mk_path(sp,
ids_ext(cx, ~[s_fty]));
let e_fident = mk_ident(cx, sp, fident); let e_fident = mk_ident(cx, sp, fident);
return cx.mk_call(sp, return cx.expr_call_ident(sp,
ids_ext(cx, ~[~"LIT_FLOAT"]), id_ext(cx, "LIT_FLOAT"),
~[e_fident, e_fty]); ~[e_fident, e_fty]);
} }
LIT_STR(ident) => { LIT_STR(ident) => {
return cx.mk_call(sp, return cx.expr_call_ident(sp,
ids_ext(cx, ~[~"LIT_STR"]), id_ext(cx, "LIT_STR"),
~[mk_ident(cx, sp, ident)]); ~[mk_ident(cx, sp, ident)]);
} }
IDENT(ident, b) => { IDENT(ident, b) => {
return cx.mk_call(sp, return cx.expr_call_ident(sp,
ids_ext(cx, ~[~"IDENT"]), id_ext(cx, "IDENT"),
~[mk_ident(cx, sp, ident), ~[mk_ident(cx, sp, ident),
cx.mk_lit(sp, ast::lit_bool(b))]); cx.expr_bool(sp, b)]);
} }
LIFETIME(ident) => { LIFETIME(ident) => {
return cx.mk_call(sp, return cx.expr_call_ident(sp,
ids_ext(cx, ~[~"LIFETIME"]), id_ext(cx, "LIFETIME"),
~[mk_ident(cx, sp, ident)]); ~[mk_ident(cx, sp, ident)]);
} }
DOC_COMMENT(ident) => { DOC_COMMENT(ident) => {
return cx.mk_call(sp, return cx.expr_call_ident(sp,
ids_ext(cx, ~[~"DOC_COMMENT"]), id_ext(cx, "DOC_COMMENT"),
~[mk_ident(cx, sp, ident)]); ~[mk_ident(cx, sp, ident)]);
} }
INTERPOLATED(_) => fail!("quote! with interpolated token"), INTERPOLATED(_) => fail!("quote! with interpolated token"),
@ -595,8 +587,7 @@ fn mk_token(cx: @ExtCtxt, sp: span, tok: &token::Token) -> @ast::expr {
EOF => "EOF", EOF => "EOF",
_ => fail!() _ => fail!()
}; };
cx.mk_path(sp, cx.expr_ident(sp, id_ext(cx, name))
ids_ext(cx, ~[name.to_owned()]))
} }
@ -606,19 +597,16 @@ fn mk_tt(cx: @ExtCtxt, sp: span, tt: &ast::token_tree)
match *tt { match *tt {
ast::tt_tok(sp, ref tok) => { ast::tt_tok(sp, ref tok) => {
let e_sp = cx.mk_path(sp, let e_sp = cx.expr_ident(sp, id_ext(cx, "sp"));
ids_ext(cx, ~[~"sp"])); let e_tok = cx.expr_call_ident(sp,
let e_tok = id_ext(cx, "tt_tok"),
cx.mk_call(sp, ~[e_sp, mk_token(cx, sp, tok)]);
ids_ext(cx, ~[~"tt_tok"]),
~[e_sp, mk_token(cx, sp, tok)]);
let e_push = let e_push =
cx.mk_method_call(sp, cx.expr_method_call(sp,
cx.mk_path(sp, ids_ext(cx, ~[~"tt"])), cx.expr_ident(sp, id_ext(cx, "tt")),
id_ext(cx, "push"), id_ext(cx, "push"),
~[e_tok]); ~[e_tok]);
~[cx.mk_stmt(sp, e_push)] ~[cx.stmt_expr(e_push)]
} }
ast::tt_delim(ref tts) => mk_tts(cx, sp, *tts), ast::tt_delim(ref tts) => mk_tts(cx, sp, *tts),
@ -629,19 +617,18 @@ fn mk_tt(cx: @ExtCtxt, sp: span, tt: &ast::token_tree)
// tt.push_all_move($ident.to_tokens(ext_cx)) // tt.push_all_move($ident.to_tokens(ext_cx))
let e_to_toks = let e_to_toks =
cx.mk_method_call(sp, cx.expr_method_call(sp,
cx.mk_path(sp, ~[ident]), cx.expr_ident(sp, ident),
id_ext(cx, "to_tokens"), id_ext(cx, "to_tokens"),
~[cx.mk_path(sp, ~[cx.expr_ident(sp, id_ext(cx, "ext_cx"))]);
ids_ext(cx, ~[~"ext_cx"]))]);
let e_push = let e_push =
cx.mk_method_call(sp, cx.expr_method_call(sp,
cx.mk_path(sp, ids_ext(cx, ~[~"tt"])), cx.expr_ident(sp, id_ext(cx, "tt")),
id_ext(cx, "push_all_move"), id_ext(cx, "push_all_move"),
~[e_to_toks]); ~[e_to_toks]);
~[cx.mk_stmt(sp, e_push)] ~[cx.stmt_expr(e_push)]
} }
} }
} }
@ -677,11 +664,11 @@ fn expand_tts(cx: @ExtCtxt,
// We want to emit a block expression that does a sequence of 'use's to // We want to emit a block expression that does a sequence of 'use's to
// import the runtime module, followed by a tt-building expression. // import the runtime module, followed by a tt-building expression.
let uses = ~[ cx.mk_glob_use(sp, ast::public, let uses = ~[ cx.view_use_glob(sp, ast::public,
ids_ext(cx, ~[~"syntax", ids_ext(cx, ~[~"syntax",
~"ext", ~"ext",
~"quote", ~"quote",
~"rt"])) ]; ~"rt"])) ];
// We also bind a single value, sp, to ext_cx.call_site() // We also bind a single value, sp, to ext_cx.call_site()
// //
@ -709,24 +696,24 @@ fn expand_tts(cx: @ExtCtxt,
// of quotes, for example) but at this point it seems not likely to be // of quotes, for example) but at this point it seems not likely to be
// worth the hassle. // worth the hassle.
let e_sp = cx.mk_method_call(sp, let e_sp = cx.expr_method_call(sp,
cx.mk_path(sp, ids_ext(cx, ~[~"ext_cx"])), cx.expr_ident(sp, id_ext(cx, "ext_cx")),
id_ext(cx, "call_site"), id_ext(cx, "call_site"),
~[]); ~[]);
let stmt_let_sp = cx.mk_local(sp, false, let stmt_let_sp = cx.stmt_let(sp, false,
id_ext(cx, "sp"), id_ext(cx, "sp"),
e_sp); e_sp);
let stmt_let_tt = cx.mk_local(sp, true, let stmt_let_tt = cx.stmt_let(sp, true,
id_ext(cx, "tt"), id_ext(cx, "tt"),
cx.mk_uniq_vec_e(sp, ~[])); cx.expr_vec_uniq(sp, ~[]));
cx.mk_block(sp, uses, cx.expr_blk(
~[stmt_let_sp, cx.blk_all(sp, uses,
stmt_let_tt] + mk_tts(cx, sp, tts), ~[stmt_let_sp,
Some(cx.mk_path(sp, stmt_let_tt] + mk_tts(cx, sp, tts),
ids_ext(cx, ~[~"tt"])))) Some(cx.expr_ident(sp, id_ext(cx, "tt")))))
} }
fn expand_parse_call(cx: @ExtCtxt, fn expand_parse_call(cx: @ExtCtxt,
@ -736,27 +723,26 @@ fn expand_parse_call(cx: @ExtCtxt,
tts: &[ast::token_tree]) -> @ast::expr { tts: &[ast::token_tree]) -> @ast::expr {
let tts_expr = expand_tts(cx, sp, tts); let tts_expr = expand_tts(cx, sp, tts);
let cfg_call = || cx.mk_method_call( let cfg_call = || cx.expr_method_call(
sp, cx.mk_path(sp, ids_ext(cx, ~[~"ext_cx"])), sp, cx.expr_ident(sp, id_ext(cx, "ext_cx")),
id_ext(cx, "cfg"), ~[]); id_ext(cx, "cfg"), ~[]);
let parse_sess_call = || cx.mk_method_call( let parse_sess_call = || cx.expr_method_call(
sp, cx.mk_path(sp, ids_ext(cx, ~[~"ext_cx"])), sp, cx.expr_ident(sp, id_ext(cx, "ext_cx")),
id_ext(cx, "parse_sess"), ~[]); id_ext(cx, "parse_sess"), ~[]);
let new_parser_call = let new_parser_call =
cx.mk_call_global(sp, cx.expr_call_global(sp,
ids_ext(cx, ~[~"syntax", ids_ext(cx, ~[~"syntax",
~"ext", ~"ext",
~"quote", ~"quote",
~"rt", ~"rt",
~"new_parser_from_tts"]), ~"new_parser_from_tts"]),
~[parse_sess_call(), ~[parse_sess_call(),
cfg_call(), cfg_call(),
tts_expr]); tts_expr]);
cx.mk_method_call(sp, cx.expr_method_call(sp, new_parser_call,
new_parser_call, id_ext(cx, parse_method),
id_ext(cx, parse_method), arg_exprs)
arg_exprs)
} }

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

@ -30,7 +30,7 @@ pub fn expand_line(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree])
let topmost = topmost_expn_info(cx.backtrace().get()); let topmost = topmost_expn_info(cx.backtrace().get());
let loc = cx.codemap().lookup_char_pos(topmost.call_site.lo); let loc = cx.codemap().lookup_char_pos(topmost.call_site.lo);
base::MRExpr(cx.mk_uint(topmost.call_site, loc.line)) base::MRExpr(cx.expr_uint(topmost.call_site, loc.line))
} }
/* col!(): expands to the current column number */ /* col!(): expands to the current column number */
@ -40,7 +40,7 @@ pub fn expand_col(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree])
let topmost = topmost_expn_info(cx.backtrace().get()); let topmost = topmost_expn_info(cx.backtrace().get());
let loc = cx.codemap().lookup_char_pos(topmost.call_site.lo); let loc = cx.codemap().lookup_char_pos(topmost.call_site.lo);
base::MRExpr(cx.mk_uint(topmost.call_site, loc.col.to_uint())) base::MRExpr(cx.expr_uint(topmost.call_site, loc.col.to_uint()))
} }
/* file!(): expands to the current filename */ /* file!(): expands to the current filename */
@ -53,19 +53,19 @@ pub fn expand_file(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree])
let topmost = topmost_expn_info(cx.backtrace().get()); let topmost = topmost_expn_info(cx.backtrace().get());
let Loc { file: @FileMap { name: filename, _ }, _ } = let Loc { file: @FileMap { name: filename, _ }, _ } =
cx.codemap().lookup_char_pos(topmost.call_site.lo); cx.codemap().lookup_char_pos(topmost.call_site.lo);
base::MRExpr(cx.mk_base_str(topmost.call_site, filename)) base::MRExpr(cx.expr_str(topmost.call_site, filename))
} }
pub fn expand_stringify(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree]) pub fn expand_stringify(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree])
-> base::MacResult { -> base::MacResult {
let s = pprust::tts_to_str(tts, cx.parse_sess().interner); let s = pprust::tts_to_str(tts, cx.parse_sess().interner);
base::MRExpr(cx.mk_base_str(sp, s)) base::MRExpr(cx.expr_str(sp, s))
} }
pub fn expand_mod(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree]) pub fn expand_mod(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree])
-> base::MacResult { -> base::MacResult {
base::check_zero_tts(cx, sp, tts, "module_path!"); base::check_zero_tts(cx, sp, tts, "module_path!");
base::MRExpr(cx.mk_base_str(sp, base::MRExpr(cx.expr_str(sp,
str::connect(cx.mod_path().map( str::connect(cx.mod_path().map(
|x| cx.str_of(*x)), "::"))) |x| cx.str_of(*x)), "::")))
} }
@ -94,7 +94,7 @@ pub fn expand_include_str(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree])
} }
} }
base::MRExpr(cx.mk_base_str(sp, result::unwrap(res))) base::MRExpr(cx.expr_str(sp, result::unwrap(res)))
} }
pub fn expand_include_bin(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree]) pub fn expand_include_bin(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree])
@ -103,9 +103,9 @@ pub fn expand_include_bin(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree])
match io::read_whole_file(&res_rel_file(cx, sp, &Path(file))) { match io::read_whole_file(&res_rel_file(cx, sp, &Path(file))) {
result::Ok(src) => { result::Ok(src) => {
let u8_exprs = vec::map(src, |char| { let u8_exprs = vec::map(src, |char| {
cx.mk_u8(sp, *char) cx.expr_u8(sp, *char)
}); });
base::MRExpr(cx.mk_base_vec_e(sp, u8_exprs)) base::MRExpr(cx.expr_vec(sp, u8_exprs))
} }
result::Err(ref e) => { result::Err(ref e) => {
cx.parse_sess().span_diagnostic.handler().fatal((*e)) cx.parse_sess().span_diagnostic.handler().fatal((*e))