bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Remove purity from fn_decl and move it out to containing AST elements.

Browse source
This commit is contained in:
Michael Sullivan 2012-08-23 18:17:16 -07:00
parent 34886ed488
commit 0f996f70a6
27 changed files with 208 additions and 192 deletions
Download patch file Download diff file Expand all files Collapse all files

12
src/libsyntax/ast.rs
View file

@ -531,7 +531,7 @@ type ty_field_ = {ident: ident, mt: mt};
type ty_field = spanned<ty_field_>; type ty_field = spanned<ty_field_>;
#[auto_serialize] #[auto_serialize]
type ty_method = {ident: ident, attrs: ~[attribute], type ty_method = {ident: ident, attrs: ~[attribute], purity: purity,
decl: fn_decl, tps: ~[ty_param], self_ty: self_ty, decl: fn_decl, tps: ~[ty_param], self_ty: self_ty,
id: node_id, span: span}; id: node_id, span: span};
@ -582,7 +582,7 @@ enum ty_ {
ty_ptr(mt), ty_ptr(mt),
ty_rptr(@region, mt), ty_rptr(@region, mt),
ty_rec(~[ty_field]), ty_rec(~[ty_field]),
ty_fn(proto, @~[ty_param_bound], fn_decl), ty_fn(proto, purity, @~[ty_param_bound], fn_decl),
ty_tup(~[@ty]), ty_tup(~[@ty]),
ty_path(@path, node_id), ty_path(@path, node_id),
ty_fixed_length(@ty, option<uint>), ty_fixed_length(@ty, option<uint>),
@ -600,7 +600,6 @@ type arg = {mode: mode, ty: @ty, ident: ident, id: node_id};
type fn_decl = type fn_decl =
{inputs: ~[arg], {inputs: ~[arg],
output: @ty, output: @ty,
purity: purity,
cf: ret_style}; cf: ret_style};
#[auto_serialize] #[auto_serialize]
@ -633,7 +632,8 @@ type self_ty = spanned<self_ty_>;
#[auto_serialize] #[auto_serialize]
type method = {ident: ident, attrs: ~[attribute], type method = {ident: ident, attrs: ~[attribute],
tps: ~[ty_param], self_ty: self_ty, decl: fn_decl, body: blk, tps: ~[ty_param], self_ty: self_ty,
purity: purity, decl: fn_decl, body: blk,
id: node_id, span: span, self_id: node_id, id: node_id, span: span, self_id: node_id,
vis: visibility}; // always public, unless it's a vis: visibility}; // always public, unless it's a
// class method // class method
@ -775,7 +775,7 @@ type item = {ident: ident, attrs: ~[attribute],
#[auto_serialize] #[auto_serialize]
enum item_ { enum item_ {
item_const(@ty, @expr), item_const(@ty, @expr),
item_fn(fn_decl, ~[ty_param], blk), item_fn(fn_decl, purity, ~[ty_param], blk),
item_mod(_mod), item_mod(_mod),
item_foreign_mod(foreign_mod), item_foreign_mod(foreign_mod),
item_ty(@ty, ~[ty_param]), item_ty(@ty, ~[ty_param]),
@ -821,7 +821,7 @@ type foreign_item =
#[auto_serialize] #[auto_serialize]
enum foreign_item_ { enum foreign_item_ {
foreign_item_fn(fn_decl, ~[ty_param]), foreign_item_fn(fn_decl, purity, ~[ty_param]),
} }
// The data we save and restore about an inlined item or method. This is not // The data we save and restore about an inlined item or method. This is not

7
src/libsyntax/ast_util.rs
View file

@ -311,7 +311,8 @@ fn trait_method_to_ty_method(method: trait_method) -> ty_method {
required(m) => m, required(m) => m,
provided(m) => { provided(m) => {
{ident: m.ident, attrs: m.attrs, {ident: m.ident, attrs: m.attrs,
decl: m.decl, tps: m.tps, self_ty: m.self_ty, purity: m.purity, decl: m.decl,
tps: m.tps, self_ty: m.self_ty,
id: m.id, span: m.span} id: m.id, span: m.span}
} }
} }
@ -411,7 +412,7 @@ fn dtor_dec() -> fn_decl {
{inputs: ~[{mode: ast::expl(ast::by_ref), {inputs: ~[{mode: ast::expl(ast::by_ref),
ty: nil_t, ident: parse::token::special_idents::underscore, ty: nil_t, ident: parse::token::special_idents::underscore,
id: 0}], id: 0}],
output: nil_t, purity: impure_fn, cf: return_val} output: nil_t, cf: return_val}
} }
// ______________________________________________________________________ // ______________________________________________________________________
@ -515,7 +516,7 @@ fn id_visitor(vfn: fn@(node_id)) -> visit::vt<()> {
vfn(self_id); vfn(self_id);
vfn(parent_id.node); vfn(parent_id.node);
} }
visit::fk_item_fn(_, tps) => { visit::fk_item_fn(_, tps, _) => {
vec::iter(tps, |tp| vfn(tp.id)); vec::iter(tps, |tp| vfn(tp.id));
} }
visit::fk_method(_, tps, m) => { visit::fk_method(_, tps, m) => {

6
src/libsyntax/ext/auto_serialize.rs
View file

@ -191,10 +191,10 @@ impl ext_ctxt: ext_ctxt_helpers {
@{id: self.next_id(), @{id: self.next_id(),
node: ast::ty_fn(ast::proto_block, node: ast::ty_fn(ast::proto_block,
ast::impure_fn,
@~[], @~[],
{inputs: args, {inputs: args,
output: output, output: output,
purity: ast::impure_fn,
cf: ast::return_val}), cf: ast::return_val}),
span: span} span: span}
} }
@ -604,8 +604,8 @@ fn mk_ser_fn(cx: ext_ctxt, span: span, name: ast::ident,
id: cx.next_id(), id: cx.next_id(),
node: ast::item_fn({inputs: ser_inputs, node: ast::item_fn({inputs: ser_inputs,
output: ser_output, output: ser_output,
purity: ast::impure_fn,
cf: ast::return_val}, cf: ast::return_val},
ast::impure_fn,
ser_tps, ser_tps,
ser_blk), ser_blk),
vis: ast::public, vis: ast::public,
@ -810,8 +810,8 @@ fn mk_deser_fn(cx: ext_ctxt, span: span,
id: cx.next_id(), id: cx.next_id(),
node: ast::item_fn({inputs: deser_inputs, node: ast::item_fn({inputs: deser_inputs,
output: v_ty, output: v_ty,
purity: ast::impure_fn,
cf: ast::return_val}, cf: ast::return_val},
ast::impure_fn,
deser_tps, deser_tps,
deser_blk), deser_blk),
vis: ast::public, vis: ast::public,

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

@ -203,7 +203,6 @@ impl ext_ctxt: ext_ctxt_ast_builder {
output: @ast::ty) -> ast::fn_decl { output: @ast::ty) -> ast::fn_decl {
{inputs: inputs, {inputs: inputs,
output: output, output: output,
purity: ast::impure_fn,
cf: ast::return_val} cf: ast::return_val}
} }
@ -226,6 +225,7 @@ impl ext_ctxt: ext_ctxt_ast_builder {
self.item(name, self.item(name,
self.empty_span(), self.empty_span(),
ast::item_fn(self.fn_decl(inputs, output), ast::item_fn(self.fn_decl(inputs, output),
ast::impure_fn,
ty_params, ty_params,
body)) body))
} }

24
src/libsyntax/fold.rs
View file

@ -127,7 +127,6 @@ fn fold_mac_(m: mac, fld: ast_fold) -> mac {
fn fold_fn_decl(decl: ast::fn_decl, fld: ast_fold) -> ast::fn_decl { fn fold_fn_decl(decl: ast::fn_decl, fld: ast_fold) -> ast::fn_decl {
return {inputs: vec::map(decl.inputs, |x| fold_arg_(x, fld) ), return {inputs: vec::map(decl.inputs, |x| fold_arg_(x, fld) ),
output: fld.fold_ty(decl.output), output: fld.fold_ty(decl.output),
purity: decl.purity,
cf: decl.cf} cf: decl.cf}
} }
@ -190,12 +189,12 @@ fn noop_fold_foreign_item(&&ni: @foreign_item, fld: ast_fold)
attrs: vec::map(ni.attrs, fold_attribute), attrs: vec::map(ni.attrs, fold_attribute),
node: node:
match ni.node { match ni.node {
foreign_item_fn(fdec, typms) => { foreign_item_fn(fdec, purity, typms) => {
foreign_item_fn({inputs: vec::map(fdec.inputs, fold_arg), foreign_item_fn({inputs: vec::map(fdec.inputs, fold_arg),
output: fld.fold_ty(fdec.output), output: fld.fold_ty(fdec.output),
purity: fdec.purity, cf: fdec.cf},
cf: fdec.cf}, purity,
fold_ty_params(typms, fld)) fold_ty_params(typms, fld))
} }
}, },
id: fld.new_id(ni.id), id: fld.new_id(ni.id),
@ -224,8 +223,9 @@ fn noop_fold_struct_field(&&sf: @struct_field, fld: ast_fold)
fn noop_fold_item_underscore(i: item_, fld: ast_fold) -> item_ { fn noop_fold_item_underscore(i: item_, fld: ast_fold) -> item_ {
return match i { return match i {
item_const(t, e) => item_const(fld.fold_ty(t), fld.fold_expr(e)), item_const(t, e) => item_const(fld.fold_ty(t), fld.fold_expr(e)),
item_fn(decl, typms, body) => { item_fn(decl, purity, typms, body) => {
item_fn(fold_fn_decl(decl, fld), item_fn(fold_fn_decl(decl, fld),
purity,
fold_ty_params(typms, fld), fold_ty_params(typms, fld),
fld.fold_block(body)) fld.fold_block(body))
} }
@ -314,6 +314,7 @@ fn noop_fold_method(&&m: @method, fld: ast_fold) -> @method {
attrs: /* FIXME (#2543) */ copy m.attrs, attrs: /* FIXME (#2543) */ copy m.attrs,
tps: fold_ty_params(m.tps, fld), tps: fold_ty_params(m.tps, fld),
self_ty: m.self_ty, self_ty: m.self_ty,
purity: m.purity,
decl: fold_fn_decl(m.decl, fld), decl: fold_fn_decl(m.decl, fld),
body: fld.fold_block(m.body), body: fld.fold_block(m.body),
id: fld.new_id(m.id), id: fld.new_id(m.id),
@ -531,10 +532,11 @@ fn noop_fold_ty(t: ty_, fld: ast_fold) -> ty_ {
ty_ptr(mt) => ty_ptr(fold_mt(mt, fld)), ty_ptr(mt) => ty_ptr(fold_mt(mt, fld)),
ty_rptr(region, mt) => ty_rptr(region, fold_mt(mt, fld)), ty_rptr(region, mt) => ty_rptr(region, fold_mt(mt, fld)),
ty_rec(fields) => ty_rec(vec::map(fields, |f| fold_field(f, fld))), ty_rec(fields) => ty_rec(vec::map(fields, |f| fold_field(f, fld))),
ty_fn(proto, bounds, decl) => ty_fn(proto, purity, bounds, decl) =>
ty_fn(proto, @vec::map(*bounds, ty_fn(proto, purity,
|x| fold_ty_param_bound(x, fld)), @vec::map(*bounds,
fold_fn_decl(decl, fld)), |x| fold_ty_param_bound(x, fld)),
fold_fn_decl(decl, fld)),
ty_tup(tys) => ty_tup(vec::map(tys, |ty| fld.fold_ty(ty))), ty_tup(tys) => ty_tup(vec::map(tys, |ty| fld.fold_ty(ty))),
ty_path(path, id) => ty_path(fld.fold_path(path), fld.new_id(id)), ty_path(path, id) => ty_path(fld.fold_path(path), fld.new_id(id)),
ty_fixed_length(t, vs) => ty_fixed_length(fld.fold_ty(t), vs), ty_fixed_length(t, vs) => ty_fixed_length(fld.fold_ty(t), vs),

64
src/libsyntax/parse/parser.rs
View file

@ -285,10 +285,10 @@ struct parser {
proto = self.parse_fn_ty_proto(); proto = self.parse_fn_ty_proto();
bounds = self.parse_optional_ty_param_bounds(); bounds = self.parse_optional_ty_param_bounds();
}; };
ty_fn(proto, bounds, self.parse_ty_fn_decl(purity)) ty_fn(proto, purity, bounds, self.parse_ty_fn_decl())
} }
fn parse_ty_fn_decl(purity: ast::purity) -> fn_decl { fn parse_ty_fn_decl() -> fn_decl {
let inputs = do self.parse_unspanned_seq( let inputs = do self.parse_unspanned_seq(
token::LPAREN, token::RPAREN, token::LPAREN, token::RPAREN,
seq_sep_trailing_disallowed(token::COMMA)) |p| { seq_sep_trailing_disallowed(token::COMMA)) |p| {
@ -297,7 +297,7 @@ struct parser {
}; };
let (ret_style, ret_ty) = self.parse_ret_ty(); let (ret_style, ret_ty) = self.parse_ret_ty();
return {inputs: inputs, output: ret_ty, return {inputs: inputs, output: ret_ty,
purity: purity, cf: ret_style}; cf: ret_style};
} }
fn parse_trait_methods() -> ~[trait_method] { fn parse_trait_methods() -> ~[trait_method] {
@ -316,7 +316,7 @@ struct parser {
let tps = p.parse_ty_params(); let tps = p.parse_ty_params();
let (self_ty, d, _) = do self.parse_fn_decl_with_self(pur) |p| { let (self_ty, d, _) = do self.parse_fn_decl_with_self() |p| {
// This is somewhat dubious; We don't want to allow argument // This is somewhat dubious; We don't want to allow argument
// names to be left off if there is a definition... // names to be left off if there is a definition...
either::Left(p.parse_arg_general(false)) either::Left(p.parse_arg_general(false))
@ -335,7 +335,7 @@ struct parser {
// NB: at the moment, visibility annotations on required // NB: at the moment, visibility annotations on required
// methods are ignored; this could change. // methods are ignored; this could change.
required({ident: ident, attrs: attrs, required({ident: ident, attrs: attrs,
decl: {purity: pur with d}, tps: tps, purity: pur, decl: d, tps: tps,
self_ty: self_ty, self_ty: self_ty,
id: p.get_id(), span: mk_sp(lo, hi)}) id: p.get_id(), span: mk_sp(lo, hi)})
} }
@ -348,6 +348,7 @@ struct parser {
attrs: attrs, attrs: attrs,
tps: tps, tps: tps,
self_ty: self_ty, self_ty: self_ty,
purity: pur,
decl: d, decl: d,
body: body, body: body,
id: p.get_id(), id: p.get_id(),
@ -518,7 +519,7 @@ struct parser {
self.parse_ty_fn(ast::impure_fn) self.parse_ty_fn(ast::impure_fn)
} else if self.eat_keyword(~"extern") { } else if self.eat_keyword(~"extern") {
self.expect_keyword(~"fn"); self.expect_keyword(~"fn");
ty_fn(proto_bare, @~[], self.parse_ty_fn_decl(ast::impure_fn)) ty_fn(proto_bare, ast::impure_fn, @~[], self.parse_ty_fn_decl())
} else if self.token == token::MOD_SEP || is_ident(self.token) { } else if self.token == token::MOD_SEP || is_ident(self.token) {
let path = self.parse_path_with_tps(colons_before_params); let path = self.parse_path_with_tps(colons_before_params);
ty_path(path, self.get_id()) ty_path(path, self.get_id())
@ -1492,8 +1493,7 @@ struct parser {
// if we want to allow fn expression argument types to be inferred in // if we want to allow fn expression argument types to be inferred in
// the future, just have to change parse_arg to parse_fn_block_arg. // the future, just have to change parse_arg to parse_fn_block_arg.
let (decl, capture_clause) = let (decl, capture_clause) =
self.parse_fn_decl(impure_fn, self.parse_fn_decl(|p| p.parse_arg_or_capture_item());
|p| p.parse_arg_or_capture_item());
let body = self.parse_block(); let body = self.parse_block();
return self.mk_expr(lo, body.span.hi, return self.mk_expr(lo, body.span.hi,
@ -1518,7 +1518,6 @@ struct parser {
node: ty_infer, node: ty_infer,
span: self.span span: self.span
}, },
purity: impure_fn,
cf: return_val cf: return_val
} }
}, },
@ -2281,8 +2280,7 @@ struct parser {
} else { ~[] } } else { ~[] }
} }
fn parse_fn_decl(purity: purity, fn parse_fn_decl(parse_arg_fn: fn(parser) -> arg_or_capture_item)
parse_arg_fn: fn(parser) -> arg_or_capture_item)
-> (fn_decl, capture_clause) { -> (fn_decl, capture_clause) {
let args_or_capture_items: ~[arg_or_capture_item] = let args_or_capture_items: ~[arg_or_capture_item] =
@ -2295,9 +2293,8 @@ struct parser {
let (ret_style, ret_ty) = self.parse_ret_ty(); let (ret_style, ret_ty) = self.parse_ret_ty();
return ({inputs: inputs, return ({inputs: inputs,
output: ret_ty, output: ret_ty,
purity: purity, cf: ret_style}, capture_clause);
cf: ret_style}, capture_clause);
} }
fn is_self_ident() -> bool { fn is_self_ident() -> bool {
@ -2316,8 +2313,7 @@ struct parser {
self.bump(); self.bump();
} }
fn parse_fn_decl_with_self(purity: purity, fn parse_fn_decl_with_self(parse_arg_fn:
parse_arg_fn:
fn(parser) -> arg_or_capture_item) fn(parser) -> arg_or_capture_item)
-> (self_ty, fn_decl, capture_clause) { -> (self_ty, fn_decl, capture_clause) {
@ -2401,7 +2397,6 @@ struct parser {
let fn_decl = { let fn_decl = {
inputs: inputs, inputs: inputs,
output: ret_ty, output: ret_ty,
purity: purity,
cf: ret_style cf: ret_style
}; };
@ -2425,10 +2420,9 @@ struct parser {
@{id: self.get_id(), node: ty_infer, span: self.span} @{id: self.get_id(), node: ty_infer, span: self.span}
}; };
return ({inputs: either::lefts(inputs_captures), return ({inputs: either::lefts(inputs_captures),
output: output, output: output,
purity: impure_fn, cf: return_val},
cf: return_val}, @either::rights(inputs_captures));
@either::rights(inputs_captures));
} }
fn parse_fn_header() -> {ident: ident, tps: ~[ty_param]} { fn parse_fn_header() -> {ident: ident, tps: ~[ty_param]} {
@ -2450,9 +2444,9 @@ struct parser {
fn parse_item_fn(purity: purity) -> item_info { fn parse_item_fn(purity: purity) -> item_info {
let t = self.parse_fn_header(); let t = self.parse_fn_header();
let (decl, _) = self.parse_fn_decl(purity, |p| p.parse_arg()); let (decl, _) = self.parse_fn_decl(|p| p.parse_arg());
let (inner_attrs, body) = self.parse_inner_attrs_and_block(true); let (inner_attrs, body) = self.parse_inner_attrs_and_block(true);
(t.ident, item_fn(decl, t.tps, body), some(inner_attrs)) (t.ident, item_fn(decl, purity, t.tps, body), some(inner_attrs))
} }
fn parse_method_name() -> ident { fn parse_method_name() -> ident {
@ -2469,7 +2463,7 @@ struct parser {
let pur = self.parse_fn_purity(); let pur = self.parse_fn_purity();
let ident = self.parse_method_name(); let ident = self.parse_method_name();
let tps = self.parse_ty_params(); let tps = self.parse_ty_params();
let (self_ty, decl, _) = do self.parse_fn_decl_with_self(pur) |p| { let (self_ty, decl, _) = do self.parse_fn_decl_with_self() |p| {
p.parse_arg() p.parse_arg()
}; };
// XXX: interaction between staticness, self_ty is broken now // XXX: interaction between staticness, self_ty is broken now
@ -2478,7 +2472,7 @@ struct parser {
let (inner_attrs, body) = self.parse_inner_attrs_and_block(true); let (inner_attrs, body) = self.parse_inner_attrs_and_block(true);
let attrs = vec::append(attrs, inner_attrs); let attrs = vec::append(attrs, inner_attrs);
@{ident: ident, attrs: attrs, @{ident: ident, attrs: attrs,
tps: tps, self_ty: self_ty, decl: decl, tps: tps, self_ty: self_ty, purity: pur, decl: decl,
body: body, id: self.get_id(), span: mk_sp(lo, body.span.hi), body: body, id: self.get_id(), span: mk_sp(lo, body.span.hi),
self_id: self.get_id(), vis: pr} self_id: self.get_id(), vis: pr}
} }
@ -2717,7 +2711,7 @@ struct parser {
fn parse_ctor(attrs: ~[attribute], fn parse_ctor(attrs: ~[attribute],
result_ty: ast::ty_) -> class_contents { result_ty: ast::ty_) -> class_contents {
let lo = self.last_span.lo; let lo = self.last_span.lo;
let (decl_, _) = self.parse_fn_decl(impure_fn, |p| p.parse_arg()); let (decl_, _) = self.parse_fn_decl(|p| p.parse_arg());
let decl = {output: @{id: self.get_id(), let decl = {output: @{id: self.get_id(),
node: result_ty, span: decl_.output.span} node: result_ty, span: decl_.output.span}
with decl_}; with decl_};
@ -2837,18 +2831,18 @@ struct parser {
(id, item_mod(m), some(inner_attrs.inner)) (id, item_mod(m), some(inner_attrs.inner))
} }
fn parse_item_foreign_fn(+attrs: ~[attribute], fn parse_item_foreign_fn(+attrs: ~[attribute]) -> @foreign_item {
purity: purity) -> @foreign_item { let lo = self.span.lo;
let lo = self.last_span.lo; let purity = self.parse_fn_purity();
let t = self.parse_fn_header(); let t = self.parse_fn_header();
let (decl, _) = self.parse_fn_decl(purity, |p| p.parse_arg()); let (decl, _) = self.parse_fn_decl(|p| p.parse_arg());
let mut hi = self.span.hi; let mut hi = self.span.hi;
self.expect(token::SEMI); self.expect(token::SEMI);
return @{ident: t.ident, return @{ident: t.ident,
attrs: attrs, attrs: attrs,
node: foreign_item_fn(decl, t.tps), node: foreign_item_fn(decl, purity, t.tps),
id: self.get_id(), id: self.get_id(),
span: mk_sp(lo, hi)}; span: mk_sp(lo, hi)};
} }
fn parse_fn_purity() -> purity { fn parse_fn_purity() -> purity {
@ -2865,7 +2859,7 @@ struct parser {
fn parse_foreign_item(+attrs: ~[attribute]) -> fn parse_foreign_item(+attrs: ~[attribute]) ->
@foreign_item { @foreign_item {
self.parse_item_foreign_fn(attrs, self.parse_fn_purity()) self.parse_item_foreign_fn(attrs)
} }
fn parse_foreign_mod_items(+first_item_attrs: ~[attribute]) -> fn parse_foreign_mod_items(+first_item_attrs: ~[attribute]) ->

40
src/libsyntax/print/pprust.rs
View file

@ -129,7 +129,7 @@ fn fun_to_str(decl: ast::fn_decl, name: ast::ident,
params: ~[ast::ty_param], intr: ident_interner) -> ~str { params: ~[ast::ty_param], intr: ident_interner) -> ~str {
let buffer = io::mem_buffer(); let buffer = io::mem_buffer();
let s = rust_printer(io::mem_buffer_writer(buffer), intr); let s = rust_printer(io::mem_buffer_writer(buffer), intr);
print_fn(s, decl, name, params, none); print_fn(s, decl, none, name, params, none);
end(s); // Close the head box end(s); // Close the head box
end(s); // Close the outer box end(s); // Close the outer box
eof(s.s); eof(s.s);
@ -390,8 +390,8 @@ fn print_type_ex(s: ps, &&ty: @ast::ty, print_colons: bool) {
commasep(s, inconsistent, elts, print_type); commasep(s, inconsistent, elts, print_type);
pclose(s); pclose(s);
} }
ast::ty_fn(proto, bounds, d) => { ast::ty_fn(proto, purity, bounds, d) => {
print_ty_fn(s, some(proto), bounds, d, none, none, none); print_ty_fn(s, some(proto), purity, bounds, d, none, none, none);
} }
ast::ty_path(path, _) => print_path(s, path, print_colons), ast::ty_path(path, _) => print_path(s, path, print_colons),
ast::ty_fixed_length(t, v) => { ast::ty_fixed_length(t, v) => {
@ -415,8 +415,8 @@ fn print_foreign_item(s: ps, item: @ast::foreign_item) {
maybe_print_comment(s, item.span.lo); maybe_print_comment(s, item.span.lo);
print_outer_attributes(s, item.attrs); print_outer_attributes(s, item.attrs);
match item.node { match item.node {
ast::foreign_item_fn(decl, typarams) => { ast::foreign_item_fn(decl, purity, typarams) => {
print_fn(s, decl, item.ident, typarams, none); print_fn(s, decl, some(purity), item.ident, typarams, none);
end(s); // end head-ibox end(s); // end head-ibox
word(s.s, ~";"); word(s.s, ~";");
end(s); // end the outer fn box end(s); // end the outer fn box
@ -445,8 +445,8 @@ fn print_item(s: ps, &&item: @ast::item) {
end(s); // end the outer cbox end(s); // end the outer cbox
} }
ast::item_fn(decl, typarams, body) => { ast::item_fn(decl, purity, typarams, body) => {
print_fn(s, decl, item.ident, typarams, none); print_fn(s, decl, some(purity), item.ident, typarams, none);
word(s.s, ~" "); word(s.s, ~" ");
print_block_with_attrs(s, body, item.attrs); print_block_with_attrs(s, body, item.attrs);
} }
@ -722,7 +722,8 @@ fn print_ty_method(s: ps, m: ast::ty_method) {
hardbreak_if_not_bol(s); hardbreak_if_not_bol(s);
maybe_print_comment(s, m.span.lo); maybe_print_comment(s, m.span.lo);
print_outer_attributes(s, m.attrs); print_outer_attributes(s, m.attrs);
print_ty_fn(s, none, @~[], m.decl, some(m.ident), some(m.tps), print_ty_fn(s, none, m.purity,
@~[], m.decl, some(m.ident), some(m.tps),
some(m.self_ty.node)); some(m.self_ty.node));
word(s.s, ~";"); word(s.s, ~";");
} }
@ -738,7 +739,8 @@ fn print_method(s: ps, meth: @ast::method) {
hardbreak_if_not_bol(s); hardbreak_if_not_bol(s);
maybe_print_comment(s, meth.span.lo); maybe_print_comment(s, meth.span.lo);
print_outer_attributes(s, meth.attrs); print_outer_attributes(s, meth.attrs);
print_fn(s, meth.decl, meth.ident, meth.tps, some(meth.self_ty.node)); print_fn(s, meth.decl, some(meth.purity),
meth.ident, meth.tps, some(meth.self_ty.node));
word(s.s, ~" "); word(s.s, ~" ");
print_block_with_attrs(s, meth.body, meth.attrs); print_block_with_attrs(s, meth.body, meth.attrs);
} }
@ -1188,7 +1190,7 @@ fn print_expr(s: ps, &&expr: @ast::expr) {
cbox(s, indent_unit); cbox(s, indent_unit);
// head-box, will be closed by print-block at start // head-box, will be closed by print-block at start
ibox(s, 0u); ibox(s, 0u);
word(s.s, fn_header_info_to_str(none, decl.purity, some(proto))); word(s.s, fn_header_info_to_str(none, none, some(proto)));
print_fn_args_and_ret(s, decl, *cap_clause, none); print_fn_args_and_ret(s, decl, *cap_clause, none);
space(s.s); space(s.s);
print_block(s, body); print_block(s, body);
@ -1542,10 +1544,11 @@ fn print_self_ty(s: ps, self_ty: ast::self_ty_) -> bool {
return true; return true;
} }
fn print_fn(s: ps, decl: ast::fn_decl, name: ast::ident, fn print_fn(s: ps, decl: ast::fn_decl, purity: option<ast::purity>,
name: ast::ident,
typarams: ~[ast::ty_param], typarams: ~[ast::ty_param],
opt_self_ty: option<ast::self_ty_>) { opt_self_ty: option<ast::self_ty_>) {
head(s, fn_header_info_to_str(opt_self_ty, decl.purity, none)); head(s, fn_header_info_to_str(opt_self_ty, purity, none));
print_ident(s, name); print_ident(s, name);
print_type_params(s, typarams); print_type_params(s, typarams);
print_fn_args_and_ret(s, decl, ~[], opt_self_ty); print_fn_args_and_ret(s, decl, ~[], opt_self_ty);
@ -1767,13 +1770,13 @@ fn print_arg(s: ps, input: ast::arg) {
end(s); end(s);
} }
fn print_ty_fn(s: ps, opt_proto: option<ast::proto>, fn print_ty_fn(s: ps, opt_proto: option<ast::proto>, purity: ast::purity,
bounds: @~[ast::ty_param_bound], bounds: @~[ast::ty_param_bound],
decl: ast::fn_decl, id: option<ast::ident>, decl: ast::fn_decl, id: option<ast::ident>,
tps: option<~[ast::ty_param]>, tps: option<~[ast::ty_param]>,
opt_self_ty: option<ast::self_ty_>) { opt_self_ty: option<ast::self_ty_>) {
ibox(s, indent_unit); ibox(s, indent_unit);
word(s.s, fn_header_info_to_str(opt_self_ty, decl.purity, opt_proto)); word(s.s, fn_header_info_to_str(opt_self_ty, some(purity), opt_proto));
print_bounds(s, bounds); print_bounds(s, bounds);
match id { some(id) => { word(s.s, ~" "); print_ident(s, id); } _ => () } match id { some(id) => { word(s.s, ~" "); print_ident(s, id); } _ => () }
match tps { some(tps) => print_type_params(s, tps), _ => () } match tps { some(tps) => print_type_params(s, tps), _ => () }
@ -1990,19 +1993,20 @@ fn next_comment(s: ps) -> option<comments::cmnt> {
} }
fn fn_header_info_to_str(opt_sty: option<ast::self_ty_>, fn fn_header_info_to_str(opt_sty: option<ast::self_ty_>,
purity: ast::purity, opt_purity: option<ast::purity>,
opt_p: option<ast::proto>) -> ~str { opt_p: option<ast::proto>) -> ~str {
let mut s = match opt_sty { let mut s = match opt_sty {
some(ast::sty_static) => ~"static ", some(ast::sty_static) => ~"static ",
_ => ~ "" _ => ~ ""
}; };
match purity { match opt_purity {
ast::impure_fn => { } some(ast::impure_fn) => { }
_ => { some(purity) => {
str::push_str(s, purity_to_str(purity)); str::push_str(s, purity_to_str(purity));
str::push_char(s, ' '); str::push_char(s, ' ');
} }
none => {}
} }
str::push_str(s, opt_proto_to_str(opt_p)); str::push_str(s, opt_proto_to_str(opt_p));

15
src/libsyntax/visit.rs
View file

@ -13,7 +13,7 @@ import codemap::span;
enum vt<E> { mk_vt(visitor<E>), } enum vt<E> { mk_vt(visitor<E>), }
enum fn_kind { enum fn_kind {
fk_item_fn(ident, ~[ty_param]), //< an item declared with fn() fk_item_fn(ident, ~[ty_param], purity), //< an item declared with fn()
fk_method(ident, ~[ty_param], @method), fk_method(ident, ~[ty_param], @method),
fk_anon(proto, capture_clause), //< an anonymous function like fn@(...) fk_anon(proto, capture_clause), //< an anonymous function like fn@(...)
fk_fn_block(capture_clause), //< a block {||...} fk_fn_block(capture_clause), //< a block {||...}
@ -26,7 +26,7 @@ enum fn_kind {
fn name_of_fn(fk: fn_kind) -> ident { fn name_of_fn(fk: fn_kind) -> ident {
match fk { match fk {
fk_item_fn(name, _) | fk_method(name, _, _) fk_item_fn(name, _, _) | fk_method(name, _, _)
| fk_ctor(name, _, _, _, _) => /* FIXME (#2543) */ copy name, | fk_ctor(name, _, _, _, _) => /* FIXME (#2543) */ copy name,
fk_anon(*) | fk_fn_block(*) => parse::token::special_idents::anon, fk_anon(*) | fk_fn_block(*) => parse::token::special_idents::anon,
fk_dtor(*) => parse::token::special_idents::dtor fk_dtor(*) => parse::token::special_idents::dtor
@ -35,7 +35,7 @@ fn name_of_fn(fk: fn_kind) -> ident {
fn tps_of_fn(fk: fn_kind) -> ~[ty_param] { fn tps_of_fn(fk: fn_kind) -> ~[ty_param] {
match fk { match fk {
fk_item_fn(_, tps) | fk_method(_, tps, _) fk_item_fn(_, tps, _) | fk_method(_, tps, _)
| fk_ctor(_, _, tps, _, _) | fk_dtor(tps, _, _, _) => { | fk_ctor(_, _, tps, _, _) | fk_dtor(tps, _, _, _) => {
/* FIXME (#2543) */ copy tps /* FIXME (#2543) */ copy tps
} }
@ -124,9 +124,10 @@ fn visit_local<E>(loc: @local, e: E, v: vt<E>) {
fn visit_item<E>(i: @item, e: E, v: vt<E>) { fn visit_item<E>(i: @item, e: E, v: vt<E>) {
match i.node { match i.node {
item_const(t, ex) => { v.visit_ty(t, e, v); v.visit_expr(ex, e, v); } item_const(t, ex) => { v.visit_ty(t, e, v); v.visit_expr(ex, e, v); }
item_fn(decl, tp, body) => { item_fn(decl, purity, tp, body) => {
v.visit_fn(fk_item_fn(/* FIXME (#2543) */ copy i.ident, v.visit_fn(fk_item_fn(/* FIXME (#2543) */ copy i.ident,
/* FIXME (#2543) */ copy tp), decl, body, /* FIXME (#2543) */ copy tp,
purity), decl, body,
i.span, i.id, e, v); i.span, i.id, e, v);
} }
item_mod(m) => v.visit_mod(m, i.span, i.id, e, v), item_mod(m) => v.visit_mod(m, i.span, i.id, e, v),
@ -199,7 +200,7 @@ fn visit_ty<E>(t: @ty, e: E, v: vt<E>) {
ty_tup(ts) => for ts.each |tt| { ty_tup(ts) => for ts.each |tt| {
v.visit_ty(tt, e, v); v.visit_ty(tt, e, v);
}, },
ty_fn(_, bounds, decl) => { ty_fn(_, _, bounds, decl) => {
for decl.inputs.each |a| { v.visit_ty(a.ty, e, v); } for decl.inputs.each |a| { v.visit_ty(a.ty, e, v); }
visit_ty_param_bounds(bounds, e, v); visit_ty_param_bounds(bounds, e, v);
v.visit_ty(decl.output, e, v); v.visit_ty(decl.output, e, v);
@ -249,7 +250,7 @@ fn visit_pat<E>(p: @pat, e: E, v: vt<E>) {
fn visit_foreign_item<E>(ni: @foreign_item, e: E, v: vt<E>) { fn visit_foreign_item<E>(ni: @foreign_item, e: E, v: vt<E>) {
match ni.node { match ni.node {
foreign_item_fn(fd, tps) => { foreign_item_fn(fd, purity, tps) => {
v.visit_ty_params(tps, e, v); v.visit_ty_params(tps, e, v);
visit_fn_decl(fd, e, v); visit_fn_decl(fd, e, v);
} }

13
src/rustc/front/test.rs
View file

@ -71,7 +71,7 @@ fn fold_mod(cx: test_ctxt, m: ast::_mod, fld: fold::ast_fold) -> ast::_mod {
// indicate to the translation pass which function we want to be main. // indicate to the translation pass which function we want to be main.
fn nomain(cx: test_ctxt, item: @ast::item) -> option<@ast::item> { fn nomain(cx: test_ctxt, item: @ast::item) -> option<@ast::item> {
match item.node { match item.node {
ast::item_fn(_, _, _) => { ast::item_fn(*) => {
if item.ident == cx.sess.ident_of(~"main") { if item.ident == cx.sess.ident_of(~"main") {
option::none option::none
} else { option::some(item) } } else { option::some(item) }
@ -105,7 +105,7 @@ fn fold_item(cx: test_ctxt, &&i: @ast::item, fld: fold::ast_fold) ->
if is_test_fn(i) { if is_test_fn(i) {
match i.node { match i.node {
ast::item_fn(decl, _, _) if decl.purity == ast::unsafe_fn => { ast::item_fn(decl, purity, _, _) if purity == ast::unsafe_fn => {
cx.sess.span_fatal( cx.sess.span_fatal(
i.span, i.span,
~"unsafe functions cannot be used for tests"); ~"unsafe functions cannot be used for tests");
@ -132,7 +132,7 @@ fn is_test_fn(i: @ast::item) -> bool {
fn has_test_signature(i: @ast::item) -> bool { fn has_test_signature(i: @ast::item) -> bool {
match i.node { match i.node {
ast::item_fn(decl, tps, _) => { ast::item_fn(decl, _, tps, _) => {
let input_cnt = vec::len(decl.inputs); let input_cnt = vec::len(decl.inputs);
let no_output = decl.output.node == ast::ty_nil; let no_output = decl.output.node == ast::ty_nil;
let tparm_cnt = vec::len(tps); let tparm_cnt = vec::len(tps);
@ -223,7 +223,6 @@ fn mk_tests(cx: test_ctxt) -> @ast::item {
let decl: ast::fn_decl = let decl: ast::fn_decl =
{inputs: ~[], {inputs: ~[],
output: ret_ty, output: ret_ty,
purity: ast::impure_fn,
cf: ast::return_val}; cf: ast::return_val};
// The vector of test_descs for this crate // The vector of test_descs for this crate
@ -233,7 +232,7 @@ fn mk_tests(cx: test_ctxt) -> @ast::item {
default_block(~[], option::some(test_descs), cx.sess.next_node_id()); default_block(~[], option::some(test_descs), cx.sess.next_node_id());
let body = nospan(body_); let body = nospan(body_);
let item_ = ast::item_fn(decl, ~[], body); let item_ = ast::item_fn(decl, ast::impure_fn, ~[], body);
let item: ast::item = let item: ast::item =
{ident: cx.sess.ident_of(~"tests"), {ident: cx.sess.ident_of(~"tests"),
attrs: ~[], attrs: ~[],
@ -389,7 +388,6 @@ fn mk_test_wrapper(cx: test_ctxt,
let wrapper_decl: ast::fn_decl = { let wrapper_decl: ast::fn_decl = {
inputs: ~[], inputs: ~[],
output: @{id: cx.sess.next_node_id(), node: ast::ty_nil, span: span}, output: @{id: cx.sess.next_node_id(), node: ast::ty_nil, span: span},
purity: ast::impure_fn,
cf: ast::return_val cf: ast::return_val
}; };
@ -442,7 +440,6 @@ fn mk_main(cx: test_ctxt) -> @ast::item {
let decl: ast::fn_decl = let decl: ast::fn_decl =
{inputs: ~[args_arg], {inputs: ~[args_arg],
output: @ret_ty, output: @ret_ty,
purity: ast::impure_fn,
cf: ast::return_val}; cf: ast::return_val};
let test_main_call_expr = mk_test_main_call(cx); let test_main_call_expr = mk_test_main_call(cx);
@ -452,7 +449,7 @@ fn mk_main(cx: test_ctxt) -> @ast::item {
cx.sess.next_node_id()); cx.sess.next_node_id());
let body = {node: body_, span: dummy_sp()}; let body = {node: body_, span: dummy_sp()};
let item_ = ast::item_fn(decl, ~[], body); let item_ = ast::item_fn(decl, ast::impure_fn, ~[], body);
let item: ast::item = let item: ast::item =
{ident: cx.sess.ident_of(~"main"), {ident: cx.sess.ident_of(~"main"),
attrs: ~[], attrs: ~[],

9
src/rustc/metadata/decoder.rs
View file

@ -695,13 +695,8 @@ fn get_trait_methods(intr: ident_interner, cdata: cmd, id: ast::node_id,
} }; } };
let self_ty = get_self_ty(mth); let self_ty = get_self_ty(mth);
vec::push(result, {ident: name, tps: bounds, fty: fty, vec::push(result, {ident: name, tps: bounds, fty: fty,
self_ty: self_ty, self_ty: self_ty,
purity: match item_family(mth) { vis: ast::public});
UnsafeFn => ast::unsafe_fn,
Fn => ast::impure_fn,
PureFn => ast::pure_fn,
_ => fail ~"bad purity"
}, vis: ast::public});
} }
#debug("get_trait_methods: }"); #debug("get_trait_methods: }");
@result @result

51
src/rustc/metadata/encoder.rs
View file

@ -414,14 +414,14 @@ fn encode_info_for_class(ecx: @encode_ctxt, ebml_w: ebml::writer,
*index *index
} }
fn encode_info_for_fn(ecx: @encode_ctxt, ebml_w: ebml::writer, // This is for encoding info for ctors and dtors
id: node_id, ident: ident, path: ast_map::path, fn encode_info_for_ctor(ecx: @encode_ctxt, ebml_w: ebml::writer,
item: option<inlined_item>, tps: ~[ty_param], id: node_id, ident: ident, path: ast_map::path,
decl: fn_decl) { item: option<inlined_item>, tps: ~[ty_param]) {
ebml_w.start_tag(tag_items_data_item); ebml_w.start_tag(tag_items_data_item);
encode_name(ecx, ebml_w, ident); encode_name(ecx, ebml_w, ident);
encode_def_id(ebml_w, local_def(id)); encode_def_id(ebml_w, local_def(id));
encode_family(ebml_w, purity_fn_family(decl.purity)); encode_family(ebml_w, purity_fn_family(ast::impure_fn));
encode_type_param_bounds(ebml_w, ecx, tps); encode_type_param_bounds(ebml_w, ecx, tps);
let its_ty = node_id_to_type(ecx.tcx, id); let its_ty = node_id_to_type(ecx.tcx, id);
debug!("fn name = %s ty = %s its node id = %d", debug!("fn name = %s ty = %s its node id = %d",
@ -448,7 +448,7 @@ fn encode_info_for_method(ecx: @encode_ctxt, ebml_w: ebml::writer,
ecx.tcx.sess.str_of(m.ident), all_tps.len()); ecx.tcx.sess.str_of(m.ident), all_tps.len());
ebml_w.start_tag(tag_items_data_item); ebml_w.start_tag(tag_items_data_item);
encode_def_id(ebml_w, local_def(m.id)); encode_def_id(ebml_w, local_def(m.id));
encode_family(ebml_w, purity_fn_family(m.decl.purity)); encode_family(ebml_w, purity_fn_family(m.purity));
encode_type_param_bounds(ebml_w, ecx, all_tps); encode_type_param_bounds(ebml_w, ecx, all_tps);
encode_type(ecx, ebml_w, node_id_to_type(ecx.tcx, m.id)); encode_type(ecx, ebml_w, node_id_to_type(ecx.tcx, m.id));
encode_name(ecx, ebml_w, m.ident); encode_name(ecx, ebml_w, m.ident);
@ -519,11 +519,11 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
encode_path(ecx, ebml_w, path, ast_map::path_name(item.ident)); encode_path(ecx, ebml_w, path, ast_map::path_name(item.ident));
ebml_w.end_tag(); ebml_w.end_tag();
} }
item_fn(decl, tps, _) => { item_fn(decl, purity, tps, _) => {
add_to_index(); add_to_index();
ebml_w.start_tag(tag_items_data_item); ebml_w.start_tag(tag_items_data_item);
encode_def_id(ebml_w, local_def(item.id)); encode_def_id(ebml_w, local_def(item.id));
encode_family(ebml_w, purity_fn_family(decl.purity)); encode_family(ebml_w, purity_fn_family(purity));
encode_type_param_bounds(ebml_w, ecx, tps); encode_type_param_bounds(ebml_w, ecx, tps);
encode_type(ecx, ebml_w, node_id_to_type(tcx, item.id)); encode_type(ecx, ebml_w, node_id_to_type(tcx, item.id));
encode_path(ecx, ebml_w, path, ast_map::path_name(item.ident)); encode_path(ecx, ebml_w, path, ast_map::path_name(item.ident));
@ -588,13 +588,14 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
/* Encode the dtor */ /* Encode the dtor */
do option::iter(struct_def.dtor) |dtor| { do option::iter(struct_def.dtor) |dtor| {
vec::push(*index, {val: dtor.node.id, pos: ebml_w.writer.tell()}); vec::push(*index, {val: dtor.node.id, pos: ebml_w.writer.tell()});
encode_info_for_fn(ecx, ebml_w, dtor.node.id, encode_info_for_ctor(ecx, ebml_w, dtor.node.id,
ecx.tcx.sess.ident_of( ecx.tcx.sess.ident_of(
ecx.tcx.sess.str_of(item.ident) + ~"_dtor"), ecx.tcx.sess.str_of(item.ident) +
path, if tps.len() > 0u { ~"_dtor"),
some(ii_dtor(dtor, item.ident, tps, path, if tps.len() > 0u {
local_def(item.id))) } some(ii_dtor(dtor, item.ident, tps,
else { none }, tps, ast_util::dtor_dec()); local_def(item.id))) }
else { none }, tps);
} }
/* Index the class*/ /* Index the class*/
@ -647,7 +648,7 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
/* Write the info that's needed when viewing this class /* Write the info that's needed when viewing this class
as a trait */ as a trait */
ebml_w.start_tag(tag_item_trait_method); ebml_w.start_tag(tag_item_trait_method);
encode_family(ebml_w, purity_fn_family(m.decl.purity)); encode_family(ebml_w, purity_fn_family(m.purity));
encode_name(ecx, ebml_w, m.ident); encode_name(ecx, ebml_w, m.ident);
encode_type_param_bounds(ebml_w, ecx, m.tps); encode_type_param_bounds(ebml_w, ecx, m.tps);
encode_type(ecx, ebml_w, node_id_to_type(tcx, m.id)); encode_type(ecx, ebml_w, node_id_to_type(tcx, m.id));
@ -675,11 +676,11 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
val: ctor.node.id, val: ctor.node.id,
pos: ebml_w.writer.tell() pos: ebml_w.writer.tell()
}); });
encode_info_for_fn(ecx, ebml_w, ctor.node.id, item.ident, encode_info_for_ctor(ecx, ebml_w, ctor.node.id, item.ident,
path, if tps.len() > 0u { path, if tps.len() > 0u {
some(ii_ctor(ctor, item.ident, tps, some(ii_ctor(ctor, item.ident, tps,
local_def(item.id))) } local_def(item.id))) }
else { none }, tps, ctor.node.dec); else { none }, tps);
} }
} }
item_impl(tps, traits, _, methods) => { item_impl(tps, traits, _, methods) => {
@ -734,7 +735,7 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
encode_name(ecx, ebml_w, mty.ident); encode_name(ecx, ebml_w, mty.ident);
encode_type_param_bounds(ebml_w, ecx, ty_m.tps); encode_type_param_bounds(ebml_w, ecx, ty_m.tps);
encode_type(ecx, ebml_w, ty::mk_fn(tcx, mty.fty)); encode_type(ecx, ebml_w, ty::mk_fn(tcx, mty.fty));
encode_family(ebml_w, purity_fn_family(mty.purity)); encode_family(ebml_w, purity_fn_family(mty.fty.purity));
encode_self_type(ebml_w, mty.self_ty); encode_self_type(ebml_w, mty.self_ty);
ebml_w.end_tag(); ebml_w.end_tag();
} }
@ -766,7 +767,7 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
encode_def_id(ebml_w, local_def(ty_m.id)); encode_def_id(ebml_w, local_def(ty_m.id));
encode_name(ecx, ebml_w, ty_m.ident); encode_name(ecx, ebml_w, ty_m.ident);
encode_family(ebml_w, encode_family(ebml_w,
purity_static_method_family(ty_m.decl.purity)); purity_static_method_family(ty_m.purity));
let polyty = ecx.tcx.tcache.get(local_def(ty_m.id)); let polyty = ecx.tcx.tcache.get(local_def(ty_m.id));
encode_ty_type_param_bounds(ebml_w, ecx, polyty.bounds); encode_ty_type_param_bounds(ebml_w, ecx, polyty.bounds);
encode_type(ecx, ebml_w, polyty.ty); encode_type(ecx, ebml_w, polyty.ty);
@ -789,9 +790,9 @@ fn encode_info_for_foreign_item(ecx: @encode_ctxt, ebml_w: ebml::writer,
ebml_w.start_tag(tag_items_data_item); ebml_w.start_tag(tag_items_data_item);
match nitem.node { match nitem.node {
foreign_item_fn(fn_decl, tps) => { foreign_item_fn(fn_decl, purity, tps) => {
encode_def_id(ebml_w, local_def(nitem.id)); encode_def_id(ebml_w, local_def(nitem.id));
encode_family(ebml_w, purity_fn_family(fn_decl.purity)); encode_family(ebml_w, purity_fn_family(purity));
encode_type_param_bounds(ebml_w, ecx, tps); encode_type_param_bounds(ebml_w, ecx, tps);
encode_type(ecx, ebml_w, node_id_to_type(ecx.tcx, nitem.id)); encode_type(ecx, ebml_w, node_id_to_type(ecx.tcx, nitem.id));
if abi == foreign_abi_rust_intrinsic { if abi == foreign_abi_rust_intrinsic {

6
src/rustc/middle/borrowck/check_loans.rs
View file

@ -521,6 +521,8 @@ fn check_loans_in_fn(fk: visit::fn_kind, decl: ast::fn_decl, body: ast::blk,
do save_and_restore(self.declared_purity) { do save_and_restore(self.declared_purity) {
do save_and_restore(self.fn_args) { do save_and_restore(self.fn_args) {
let is_stack_closure = self.is_stack_closure(id); let is_stack_closure = self.is_stack_closure(id);
let purity =
ty::ty_fn_purity(ty::node_id_to_type(self.tcx(), id));
// In principle, we could consider fk_anon(*) or // In principle, we could consider fk_anon(*) or
// fk_fn_block(*) to be in a ctor, I suppose, but the // fk_fn_block(*) to be in a ctor, I suppose, but the
@ -531,7 +533,7 @@ fn check_loans_in_fn(fk: visit::fn_kind, decl: ast::fn_decl, body: ast::blk,
match fk { match fk {
visit::fk_ctor(*) => { visit::fk_ctor(*) => {
self.in_ctor = true; self.in_ctor = true;
self.declared_purity = decl.purity; self.declared_purity = purity;
self.fn_args = @decl.inputs.map(|i| i.id ); self.fn_args = @decl.inputs.map(|i| i.id );
} }
visit::fk_anon(*) | visit::fk_anon(*) |
@ -543,7 +545,7 @@ fn check_loans_in_fn(fk: visit::fn_kind, decl: ast::fn_decl, body: ast::blk,
visit::fk_method(*) | visit::fk_item_fn(*) | visit::fk_method(*) | visit::fk_item_fn(*) |
visit::fk_dtor(*) => { visit::fk_dtor(*) => {
self.in_ctor = false; self.in_ctor = false;
self.declared_purity = decl.purity; self.declared_purity = purity;
self.fn_args = @decl.inputs.map(|i| i.id ); self.fn_args = @decl.inputs.map(|i| i.id );
} }
} }

2
src/rustc/middle/lint.rs
View file

@ -401,7 +401,7 @@ fn check_item_ctypes(cx: ty::ctxt, it: @ast::item) {
either::Right(ast::foreign_abi_rust_intrinsic) => { either::Right(ast::foreign_abi_rust_intrinsic) => {
for nmod.items.each |ni| { for nmod.items.each |ni| {
match ni.node { match ni.node {
ast::foreign_item_fn(decl, tps) => { ast::foreign_item_fn(decl, _, tps) => {
check_foreign_fn(cx, it.id, decl); check_foreign_fn(cx, it.id, decl);
} }
} }

10
src/rustc/middle/region.rs
View file

@ -613,8 +613,8 @@ fn determine_rp_in_ty(ty: @ast::ty,
} }
} }
ast::ty_fn(ast::proto_bare, _, _) | ast::ty_fn(ast::proto_bare, _, _, _) |
ast::ty_fn(ast::proto_block, _, _) if cx.anon_implies_rp => { ast::ty_fn(ast::proto_block, _, _, _) if cx.anon_implies_rp => {
debug!("referenced bare fn type with regions %s", debug!("referenced bare fn type with regions %s",
pprust::ty_to_str(ty, cx.sess.intr())); pprust::ty_to_str(ty, cx.sess.intr()));
cx.add_rp(cx.item_id, cx.add_variance(rv_contravariant)); cx.add_rp(cx.item_id, cx.add_variance(rv_contravariant));
@ -661,8 +661,8 @@ fn determine_rp_in_ty(ty: @ast::ty,
match ty.node { match ty.node {
ast::ty_box(mt) | ast::ty_uniq(mt) => { ast::ty_box(mt) | ast::ty_uniq(mt) => {
match mt.ty.node { match mt.ty.node {
ast::ty_fn(ast::proto_bare, _, _) | ast::ty_fn(ast::proto_bare, _, _, _) |
ast::ty_fn(ast::proto_block, _, _) => { ast::ty_fn(ast::proto_block, _, _, _) => {
do cx.with(cx.item_id, false) { do cx.with(cx.item_id, false) {
visit_mt(mt, cx, visitor); visit_mt(mt, cx, visitor);
} }
@ -695,7 +695,7 @@ fn determine_rp_in_ty(ty: @ast::ty,
} }
} }
ast::ty_fn(_, bounds, decl) => { ast::ty_fn(_, _, bounds, decl) => {
// fn() binds the & region, so do not consider &T types that // fn() binds the & region, so do not consider &T types that
// appear *inside* a fn() type to affect the enclosing item: // appear *inside* a fn() type to affect the enclosing item:
do cx.with(cx.item_id, false) { do cx.with(cx.item_id, false) {

16
src/rustc/middle/resolve3.rs
View file

@ -891,11 +891,11 @@ struct Resolver {
def_const(local_def(item.id)), def_const(local_def(item.id)),
sp); sp);
} }
item_fn(decl, _, _) => { item_fn(decl, purity, _, _) => {
let (name_bindings, new_parent) = self.add_child(atom, parent, let (name_bindings, new_parent) = self.add_child(atom, parent,
~[ValueNS], sp); ~[ValueNS], sp);
let def = def_fn(local_def(item.id), decl.purity); let def = def_fn(local_def(item.id), purity);
(*name_bindings).define_value (*name_bindings).define_value
(self.visibility_to_privacy(item.vis), def, sp); (self.visibility_to_privacy(item.vis), def, sp);
visit_item(item, new_parent, visitor); visit_item(item, new_parent, visitor);
@ -954,7 +954,7 @@ struct Resolver {
(*name_bindings).define_type (*name_bindings).define_type
(privacy, def_ty(local_def(item.id)), sp); (privacy, def_ty(local_def(item.id)), sp);
let purity = ctor.node.dec.purity; let purity = impure_fn;
let ctor_def = def_fn(local_def(ctor.node.id), let ctor_def = def_fn(local_def(ctor.node.id),
purity); purity);
(*name_bindings).define_value(privacy, ctor_def, sp); (*name_bindings).define_value(privacy, ctor_def, sp);
@ -992,7 +992,7 @@ struct Resolver {
self.add_child(atom, new_parent, ~[ValueNS], self.add_child(atom, new_parent, ~[ValueNS],
ty_m.span); ty_m.span);
let def = def_static_method(local_def(ty_m.id), let def = def_static_method(local_def(ty_m.id),
ty_m.decl.purity); ty_m.purity);
(*method_name_bindings).define_value (*method_name_bindings).define_value
(Public, def, ty_m.span); (Public, def, ty_m.span);
} }
@ -1215,11 +1215,11 @@ struct Resolver {
let name = foreign_item.ident; let name = foreign_item.ident;
match foreign_item.node { match foreign_item.node {
foreign_item_fn(fn_decl, type_parameters) => { foreign_item_fn(fn_decl, purity, type_parameters) => {
let (name_bindings, new_parent) = self.add_child(name, parent, let (name_bindings, new_parent) = self.add_child(name, parent,
~[ValueNS], foreign_item.span); ~[ValueNS], foreign_item.span);
let def = def_fn(local_def(foreign_item.id), fn_decl.purity); let def = def_fn(local_def(foreign_item.id), purity);
(*name_bindings).define_value(Public, def, foreign_item.span); (*name_bindings).define_value(Public, def, foreign_item.span);
do self.with_type_parameter_rib do self.with_type_parameter_rib
@ -2944,7 +2944,7 @@ struct Resolver {
do self.with_scope(some(item.ident)) { do self.with_scope(some(item.ident)) {
for foreign_module.items.each |foreign_item| { for foreign_module.items.each |foreign_item| {
match foreign_item.node { match foreign_item.node {
foreign_item_fn(_, type_parameters) => { foreign_item_fn(_, _, type_parameters) => {
do self.with_type_parameter_rib do self.with_type_parameter_rib
(HasTypeParameters(&type_parameters, (HasTypeParameters(&type_parameters,
foreign_item.id, foreign_item.id,
@ -2961,7 +2961,7 @@ struct Resolver {
} }
} }
item_fn(fn_decl, ty_params, block) => { item_fn(fn_decl, _, ty_params, block) => {
// If this is the main function, we must record it in the // If this is the main function, we must record it in the
// session. // session.
// //

12
src/rustc/middle/trans/base.rs
View file

@ -2214,7 +2214,7 @@ fn monomorphic_fn(ccx: @crate_ctxt, fn_id: ast::def_id,
let psubsts = some({tys: substs, vtables: vtables, bounds: tpt.bounds}); let psubsts = some({tys: substs, vtables: vtables, bounds: tpt.bounds});
let lldecl = match map_node { let lldecl = match map_node {
ast_map::node_item(i@@{node: ast::item_fn(decl, _, body), _}, _) => { ast_map::node_item(i@@{node: ast::item_fn(decl, _, _, body), _}, _) => {
let d = mk_lldecl(); let d = mk_lldecl();
set_inline_hint_if_appr(i.attrs, d); set_inline_hint_if_appr(i.attrs, d);
trans_fn(ccx, pt, decl, body, d, no_self, psubsts, fn_id.node); trans_fn(ccx, pt, decl, body, d, no_self, psubsts, fn_id.node);
@ -5010,8 +5010,8 @@ fn trans_item(ccx: @crate_ctxt, item: ast::item) {
ast_map::node_item(_, p) => p ast_map::node_item(_, p) => p
}; };
match item.node { match item.node {
ast::item_fn(decl, tps, body) => { ast::item_fn(decl, purity, tps, body) => {
if decl.purity == ast::extern_fn { if purity == ast::extern_fn {
let llfndecl = get_item_val(ccx, item.id); let llfndecl = get_item_val(ccx, item.id);
foreign::trans_foreign_fn(ccx, foreign::trans_foreign_fn(ccx,
vec::append( vec::append(
@ -5304,8 +5304,8 @@ fn get_item_val(ccx: @crate_ctxt, id: ast::node_id) -> ValueRef {
ccx.item_symbols.insert(i.id, s); ccx.item_symbols.insert(i.id, s);
g g
} }
ast::item_fn(decl, _, _) => { ast::item_fn(decl, purity, _, _) => {
let llfn = if decl.purity != ast::extern_fn { let llfn = if purity != ast::extern_fn {
register_fn(ccx, i.span, my_path, i.id) register_fn(ccx, i.span, my_path, i.id)
} else { } else {
foreign::register_foreign_fn(ccx, i.span, my_path, i.id) foreign::register_foreign_fn(ccx, i.span, my_path, i.id)
@ -5535,7 +5535,7 @@ fn push_rtcall(ccx: @crate_ctxt, name: ~str, did: ast::def_id) {
fn gather_local_rtcalls(ccx: @crate_ctxt, crate: @ast::crate) { fn gather_local_rtcalls(ccx: @crate_ctxt, crate: @ast::crate) {
visit::visit_crate(*crate, (), visit::mk_simple_visitor(@{ visit::visit_crate(*crate, (), visit::mk_simple_visitor(@{
visit_item: |item| match item.node { visit_item: |item| match item.node {
ast::item_fn(decl, _, _) => { ast::item_fn(decl, _, _, _) => {
let attr_metas = attr::attr_metas( let attr_metas = attr::attr_metas(
attr::find_attrs_by_name(item.attrs, ~"rt")); attr::find_attrs_by_name(item.attrs, ~"rt"));
do vec::iter(attr_metas) |attr_meta| { do vec::iter(attr_metas) |attr_meta| {

2
src/rustc/middle/trans/debuginfo.rs
View file

@ -721,7 +721,7 @@ fn create_function(fcx: fn_ctxt) -> @metadata<subprogram_md> {
let (ident, ret_ty, id) = match cx.tcx.items.get(fcx.id) { let (ident, ret_ty, id) = match cx.tcx.items.get(fcx.id) {
ast_map::node_item(item, _) => { ast_map::node_item(item, _) => {
match item.node { match item.node {
ast::item_fn(decl, _, _) => { ast::item_fn(decl, _, _, _) => {
(item.ident, decl.output, item.id) (item.ident, decl.output, item.id)
} }
_ => fcx.ccx.sess.span_bug(item.span, ~"create_function: item \ _ => fcx.ccx.sess.span_bug(item.span, ~"create_function: item \

2
src/rustc/middle/trans/foreign.rs
View file

@ -755,7 +755,7 @@ fn trans_foreign_mod(ccx: @crate_ctxt,
for vec::each(foreign_mod.items) |foreign_item| { for vec::each(foreign_mod.items) |foreign_item| {
match foreign_item.node { match foreign_item.node {
ast::foreign_item_fn(fn_decl, typarams) => { ast::foreign_item_fn(fn_decl, purity, typarams) => {
let id = foreign_item.id; let id = foreign_item.id;
if abi != ast::foreign_abi_rust_intrinsic { if abi != ast::foreign_abi_rust_intrinsic {
let llwrapfn = get_item_val(ccx, id); let llwrapfn = get_item_val(ccx, id);

2
src/rustc/middle/trans/reachable.rs
View file

@ -96,7 +96,7 @@ fn traverse_public_item(cx: ctx, item: @item) {
for vec::each(nm.items) |item| { cx.rmap.insert(item.id, ()); } for vec::each(nm.items) |item| { cx.rmap.insert(item.id, ()); }
} }
} }
item_fn(_, tps, blk) => { item_fn(_, _, tps, blk) => {
if tps.len() > 0u || if tps.len() > 0u ||
attr::find_inline_attr(item.attrs) != attr::ia_none { attr::find_inline_attr(item.attrs) != attr::ia_none {
traverse_inline_body(cx, blk); traverse_inline_body(cx, blk);

4
src/rustc/middle/trans/type_use.rs
View file

@ -65,7 +65,7 @@ fn type_uses_for(ccx: @crate_ctxt, fn_id: def_id, n_tps: uint)
fn_id_loc)) fn_id_loc))
}; };
match map_node { match map_node {
ast_map::node_item(@{node: item_fn(_, _, body), _}, _) | ast_map::node_item(@{node: item_fn(_, _, _, body), _}, _) |
ast_map::node_method(@{body, _}, _, _) => { ast_map::node_method(@{body, _}, _, _) => {
handle_body(cx, body); handle_body(cx, body);
} }
@ -78,7 +78,7 @@ fn type_uses_for(ccx: @crate_ctxt, fn_id: def_id, n_tps: uint)
ast_map::node_variant(_, _, _) => { ast_map::node_variant(_, _, _) => {
for uint::range(0u, n_tps) |n| { cx.uses[n] |= use_repr;} for uint::range(0u, n_tps) |n| { cx.uses[n] |= use_repr;}
} }
ast_map::node_foreign_item(i@@{node: foreign_item_fn(_, _), _}, ast_map::node_foreign_item(i@@{node: foreign_item_fn(*), _},
abi, _) => { abi, _) => {
if abi == foreign_abi_rust_intrinsic { if abi == foreign_abi_rust_intrinsic {
let flags = match cx.ccx.sess.str_of(i.ident) { let flags = match cx.ccx.sess.str_of(i.ident) {

10
src/rustc/middle/ty.rs
View file

@ -79,7 +79,7 @@ export ty_opaque_closure_ptr, mk_opaque_closure_ptr;
export ty_opaque_box, mk_opaque_box; export ty_opaque_box, mk_opaque_box;
export ty_float, mk_float, mk_mach_float, type_is_fp; export ty_float, mk_float, mk_mach_float, type_is_fp;
export ty_fn, fn_ty, mk_fn; export ty_fn, fn_ty, mk_fn;
export ty_fn_proto, ty_fn_ret, ty_fn_ret_style, tys_in_fn_ty; export ty_fn_proto, ty_fn_purity, ty_fn_ret, ty_fn_ret_style, tys_in_fn_ty;
export ty_int, mk_int, mk_mach_int, mk_char; export ty_int, mk_int, mk_mach_int, mk_char;
export mk_i8, mk_u8, mk_i16, mk_u16, mk_i32, mk_u32, mk_i64, mk_u64; export mk_i8, mk_u8, mk_i16, mk_u16, mk_i32, mk_u32, mk_i64, mk_u64;
export ty_estr, mk_estr, type_is_str; export ty_estr, mk_estr, type_is_str;
@ -202,7 +202,6 @@ type method = {ident: ast::ident,
tps: @~[param_bounds], tps: @~[param_bounds],
fty: fn_ty, fty: fn_ty,
self_ty: ast::self_ty_, self_ty: ast::self_ty_,
purity: ast::purity,
vis: ast::visibility}; vis: ast::visibility};
type mt = {ty: t, mutbl: ast::mutability}; type mt = {ty: t, mutbl: ast::mutability};
@ -2358,6 +2357,13 @@ fn ty_fn_proto(fty: t) -> fn_proto {
} }
} }
fn ty_fn_purity(fty: t) -> ast::purity {
match get(fty).struct {
ty_fn(ref f) => f.purity,
_ => fail ~"ty_fn_purity() called on non-fn type"
}
}
pure fn ty_fn_ret(fty: t) -> t { pure fn ty_fn_ret(fty: t) -> t {
match get(fty).struct { match get(fty).struct {
ty_fn(ref f) => f.output, ty_fn(ref f) => f.output,

2
src/rustc/middle/typeck.rs
View file

@ -259,7 +259,7 @@ fn check_main_fn_ty(ccx: @crate_ctxt,
match tcx.items.find(main_id) { match tcx.items.find(main_id) {
some(ast_map::node_item(it,_)) => { some(ast_map::node_item(it,_)) => {
match it.node { match it.node {
ast::item_fn(_,ps,_) if vec::is_not_empty(ps) => { ast::item_fn(_,_,ps,_) if vec::is_not_empty(ps) => {
tcx.sess.span_err(main_span, tcx.sess.span_err(main_span,
~"main function is not allowed to have type parameters"); ~"main function is not allowed to have type parameters");
return; return;

13
src/rustc/middle/typeck/astconv.rs
View file

@ -201,7 +201,7 @@ fn ast_ty_to_ty<AC: ast_conv, RS: region_scope copy owned>(
_ => () _ => ()
} }
} }
ast::ty_fn(ast::proto_block, ast_bounds, ast_fn_decl) => { ast::ty_fn(ast::proto_block, purity, ast_bounds, ast_fn_decl) => {
let new_proto; let new_proto;
match vst { match vst {
ty::vstore_fixed(_) => { ty::vstore_fixed(_) => {
@ -216,7 +216,8 @@ fn ast_ty_to_ty<AC: ast_conv, RS: region_scope copy owned>(
// Run through the normal function type conversion process. // Run through the normal function type conversion process.
let bounds = collect::compute_bounds(self.ccx(), ast_bounds); let bounds = collect::compute_bounds(self.ccx(), ast_bounds);
let fn_decl = ty_of_fn_decl(self, rscope, new_proto, bounds, let fn_decl = ty_of_fn_decl(self, rscope, new_proto, purity,
bounds,
ast_fn_decl, none, span); ast_fn_decl, none, span);
return ty::mk_fn(tcx, fn_decl); return ty::mk_fn(tcx, fn_decl);
} }
@ -301,9 +302,10 @@ fn ast_ty_to_ty<AC: ast_conv, RS: region_scope copy owned>(
}; };
ty::mk_rec(tcx, flds) ty::mk_rec(tcx, flds)
} }
ast::ty_fn(proto, ast_bounds, decl) => { ast::ty_fn(proto, purity, ast_bounds, decl) => {
let bounds = collect::compute_bounds(self.ccx(), ast_bounds); let bounds = collect::compute_bounds(self.ccx(), ast_bounds);
let fn_decl = ty_of_fn_decl(self, rscope, proto, bounds, decl, none, let fn_decl = ty_of_fn_decl(self, rscope, proto, purity,
bounds, decl, none,
ast_ty.span); ast_ty.span);
ty::mk_fn(tcx, fn_decl) ty::mk_fn(tcx, fn_decl)
} }
@ -465,6 +467,7 @@ type expected_tys = option<{inputs: ~[ty::arg],
fn ty_of_fn_decl<AC: ast_conv, RS: region_scope copy owned>( fn ty_of_fn_decl<AC: ast_conv, RS: region_scope copy owned>(
self: AC, rscope: RS, self: AC, rscope: RS,
ast_proto: ast::proto, ast_proto: ast::proto,
purity: ast::purity,
bounds: @~[ty::param_bound], bounds: @~[ty::param_bound],
decl: ast::fn_decl, decl: ast::fn_decl,
expected_tys: expected_tys, expected_tys: expected_tys,
@ -494,7 +497,7 @@ fn ty_of_fn_decl<AC: ast_conv, RS: region_scope copy owned>(
let proto = ast_proto_to_proto(self, rscope, span, ast_proto); let proto = ast_proto_to_proto(self, rscope, span, ast_proto);
{purity: decl.purity, proto: proto, bounds: bounds, inputs: input_tys, {purity: purity, proto: proto, bounds: bounds, inputs: input_tys,
output: output_ty, ret_style: decl.cf} output: output_ty, ret_style: decl.cf}
} }
} }

31
src/rustc/middle/typeck/check.rs
View file

@ -223,12 +223,12 @@ fn check_fn(ccx: @crate_ctxt,
none => { none => {
{infcx: infer::new_infer_ctxt(tcx), {infcx: infer::new_infer_ctxt(tcx),
locals: int_hash(), locals: int_hash(),
purity: decl.purity, purity: fn_ty.purity,
node_types: map::int_hash(), node_types: map::int_hash(),
node_type_substs: map::int_hash()} node_type_substs: map::int_hash()}
} }
some(fcx) => { some(fcx) => {
assert decl.purity == ast::impure_fn; assert fn_ty.purity == ast::impure_fn;
{infcx: fcx.infcx, {infcx: fcx.infcx,
locals: fcx.locals, locals: fcx.locals,
purity: fcx.purity, purity: fcx.purity,
@ -476,7 +476,7 @@ fn check_item(ccx: @crate_ctxt, it: @ast::item) {
ast::item_enum(enum_definition, _) => { ast::item_enum(enum_definition, _) => {
check_enum_variants(ccx, it.span, enum_definition.variants, it.id); check_enum_variants(ccx, it.span, enum_definition.variants, it.id);
} }
ast::item_fn(decl, tps, body) => { ast::item_fn(decl, _, tps, body) => {
check_bare_fn(ccx, decl, body, it.id, none); check_bare_fn(ccx, decl, body, it.id, none);
} }
ast::item_impl(tps, _, ty, ms) => { ast::item_impl(tps, _, ty, ms) => {
@ -1232,8 +1232,11 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
} }
} }
let purity = ast::impure_fn;
// construct the function type // construct the function type
let mut fn_ty = astconv::ty_of_fn_decl(fcx, fcx, ast_proto, @~[], let mut fn_ty = astconv::ty_of_fn_decl(fcx, fcx, ast_proto, purity,
@~[],
decl, expected_tys, expr.span); decl, expected_tys, expr.span);
// Patch up the function declaration, if necessary. // Patch up the function declaration, if necessary.
@ -1599,16 +1602,18 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
bot = alt::check_alt(fcx, expr, discrim, arms); bot = alt::check_alt(fcx, expr, discrim, arms);
} }
ast::expr_fn(proto, decl, body, cap_clause) => { ast::expr_fn(proto, decl, body, cap_clause) => {
check_expr_fn(fcx, expr, foap_ast_proto(proto), decl, body, false, check_expr_fn(fcx, expr, foap_ast_proto(proto),
decl, body, false,
expected); expected);
capture::check_capture_clause(tcx, expr.id, cap_clause); capture::check_capture_clause(tcx, expr.id, cap_clause);
} }
ast::expr_fn_block(decl, body, cap_clause) => { ast::expr_fn_block(decl, body, cap_clause) => {
// Take the prototype from the expected type, but default to block: // Take the prototype from the expected type, but default to block:
let proto = unpack_expected(fcx, expected, |sty| let proto = do unpack_expected(fcx, expected) |sty| {
match sty { ty::ty_fn({proto, _}) => some(proto), _ => none } match sty { ty::ty_fn({proto, _}) => some(proto), _ => none }
).get_default(ty::proto_vstore(ty::vstore_box)); }.get_default(ty::proto_vstore(ty::vstore_box));
check_expr_fn(fcx, expr, foap_fn_proto(proto), decl, body, false, check_expr_fn(fcx, expr, foap_fn_proto(proto),
decl, body, false,
expected); expected);
capture::check_capture_clause(tcx, expr.id, cap_clause); capture::check_capture_clause(tcx, expr.id, cap_clause);
} }
@ -1642,7 +1647,8 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
}; };
match check b.node { match check b.node {
ast::expr_fn_block(decl, body, cap_clause) => { ast::expr_fn_block(decl, body, cap_clause) => {
check_expr_fn(fcx, b, foap_fn_proto(proto), decl, body, true, check_expr_fn(fcx, b, foap_fn_proto(proto),
decl, body, true,
some(inner_ty)); some(inner_ty));
demand::suptype(fcx, b.span, inner_ty, fcx.expr_ty(b)); demand::suptype(fcx, b.span, inner_ty, fcx.expr_ty(b));
capture::check_capture_clause(tcx, b.id, cap_clause); capture::check_capture_clause(tcx, b.id, cap_clause);
@ -1671,7 +1677,8 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
}; };
match check b.node { match check b.node {
ast::expr_fn_block(decl, body, cap_clause) => { ast::expr_fn_block(decl, body, cap_clause) => {
check_expr_fn(fcx, b, foap_fn_proto(proto), decl, body, true, check_expr_fn(fcx, b, foap_fn_proto(proto),
decl, body, true,
some(inner_ty)); some(inner_ty));
demand::suptype(fcx, b.span, inner_ty, fcx.expr_ty(b)); demand::suptype(fcx, b.span, inner_ty, fcx.expr_ty(b));
capture::check_capture_clause(tcx, b.id, cap_clause); capture::check_capture_clause(tcx, b.id, cap_clause);

37
src/rustc/middle/typeck/collect.rs
View file

@ -247,7 +247,7 @@ fn compare_impl_method(tcx: ty::ctxt, sp: span,
trait_m: ty::method, trait_substs: ty::substs, trait_m: ty::method, trait_substs: ty::substs,
self_ty: ty::t) { self_ty: ty::t) {
if impl_m.purity != trait_m.purity { if impl_m.fty.purity != trait_m.fty.purity {
tcx.sess.span_err( tcx.sess.span_err(
sp, fmt!("method `%s`'s purity does \ sp, fmt!("method `%s`'s purity does \
not match the trait method's \ not match the trait method's \
@ -506,7 +506,8 @@ fn convert_struct(ccx: @crate_ctxt,
// Write the dtor type // Write the dtor type
let t_dtor = ty::mk_fn( let t_dtor = ty::mk_fn(
tcx, tcx,
ty_of_fn_decl(ccx, type_rscope(rp), ast::proto_bare, @~[], ty_of_fn_decl(ccx, type_rscope(rp), ast::proto_bare,
ast::impure_fn, @~[],
ast_util::dtor_dec(), none, dtor.span)); ast_util::dtor_dec(), none, dtor.span));
write_ty_to_tcx(tcx, dtor.node.id, t_dtor); write_ty_to_tcx(tcx, dtor.node.id, t_dtor);
tcx.tcache.insert(local_def(dtor.node.id), tcx.tcache.insert(local_def(dtor.node.id),
@ -537,7 +538,7 @@ fn convert_foreign(ccx: @crate_ctxt, i: @ast::foreign_item) {
// table. // table.
let tpt = ty_of_foreign_item(ccx, i); let tpt = ty_of_foreign_item(ccx, i);
match i.node { match i.node {
ast::foreign_item_fn(_, _) => { ast::foreign_item_fn(*) => {
write_ty_to_tcx(ccx.tcx, i.id, tpt.ty); write_ty_to_tcx(ccx.tcx, i.id, tpt.ty);
ccx.tcx.tcache.insert(local_def(i.id), tpt); ccx.tcx.tcache.insert(local_def(i.id), tpt);
} }
@ -549,10 +550,10 @@ fn ty_of_method(ccx: @crate_ctxt,
rp: option<ty::region_variance>) -> ty::method { rp: option<ty::region_variance>) -> ty::method {
{ident: m.ident, {ident: m.ident,
tps: ty_param_bounds(ccx, m.tps), tps: ty_param_bounds(ccx, m.tps),
fty: ty_of_fn_decl(ccx, type_rscope(rp), ast::proto_bare, @~[], fty: ty_of_fn_decl(ccx, type_rscope(rp), ast::proto_bare,
m.purity, @~[],
m.decl, none, m.span), m.decl, none, m.span),
self_ty: m.self_ty.node, self_ty: m.self_ty.node,
purity: m.decl.purity,
vis: m.vis} vis: m.vis}
} }
@ -561,11 +562,11 @@ fn ty_of_ty_method(self: @crate_ctxt,
rp: option<ty::region_variance>) -> ty::method { rp: option<ty::region_variance>) -> ty::method {
{ident: m.ident, {ident: m.ident,
tps: ty_param_bounds(self, m.tps), tps: ty_param_bounds(self, m.tps),
fty: ty_of_fn_decl(self, type_rscope(rp), ast::proto_bare, @~[], m.decl, fty: ty_of_fn_decl(self, type_rscope(rp), ast::proto_bare, m.purity,
none, m.span), @~[], m.decl, none, m.span),
// assume public, because this is only invoked on trait methods // assume public, because this is only invoked on trait methods
self_ty: m.self_ty.node, self_ty: m.self_ty.node,
purity: m.decl.purity, vis: ast::public} vis: ast::public}
} }
/* /*
@ -614,9 +615,10 @@ fn ty_of_item(ccx: @crate_ctxt, it: @ast::item)
tcx.tcache.insert(local_def(it.id), tpt); tcx.tcache.insert(local_def(it.id), tpt);
return tpt; return tpt;
} }
ast::item_fn(decl, tps, _) => { ast::item_fn(decl, purity, tps, _) => {
let bounds = ty_param_bounds(ccx, tps); let bounds = ty_param_bounds(ccx, tps);
let tofd = ty_of_fn_decl(ccx, empty_rscope, ast::proto_bare, @~[], let tofd = ty_of_fn_decl(ccx, empty_rscope,
ast::proto_bare, purity, @~[],
decl, none, it.span); decl, none, it.span);
let tpt = {bounds: bounds, let tpt = {bounds: bounds,
region_param: none, region_param: none,
@ -689,9 +691,9 @@ fn ty_of_item(ccx: @crate_ctxt, it: @ast::item)
fn ty_of_foreign_item(ccx: @crate_ctxt, it: @ast::foreign_item) fn ty_of_foreign_item(ccx: @crate_ctxt, it: @ast::foreign_item)
-> ty::ty_param_bounds_and_ty { -> ty::ty_param_bounds_and_ty {
match it.node { match it.node {
ast::foreign_item_fn(fn_decl, params) => { ast::foreign_item_fn(fn_decl, purity, params) => {
return ty_of_foreign_fn_decl(ccx, fn_decl, params, return ty_of_foreign_fn_decl(ccx, fn_decl, purity, params,
local_def(it.id)); local_def(it.id));
} }
} }
} }
@ -739,16 +741,17 @@ fn ty_param_bounds(ccx: @crate_ctxt,
} }
fn ty_of_foreign_fn_decl(ccx: @crate_ctxt, fn ty_of_foreign_fn_decl(ccx: @crate_ctxt,
decl: ast::fn_decl, decl: ast::fn_decl,
ty_params: ~[ast::ty_param], purity: ast::purity,
def_id: ast::def_id) -> ty::ty_param_bounds_and_ty { ty_params: ~[ast::ty_param],
def_id: ast::def_id) -> ty::ty_param_bounds_and_ty {
let bounds = ty_param_bounds(ccx, ty_params); let bounds = ty_param_bounds(ccx, ty_params);
let rb = in_binding_rscope(empty_rscope); let rb = in_binding_rscope(empty_rscope);
let input_tys = decl.inputs.map(|a| ty_of_arg(ccx, rb, a, none) ); let input_tys = decl.inputs.map(|a| ty_of_arg(ccx, rb, a, none) );
let output_ty = ast_ty_to_ty(ccx, rb, decl.output); let output_ty = ast_ty_to_ty(ccx, rb, decl.output);
let t_fn = ty::mk_fn(ccx.tcx, {purity: decl.purity, let t_fn = ty::mk_fn(ccx.tcx, {purity: purity,
proto: ty::proto_bare, proto: ty::proto_bare,
bounds: @~[], bounds: @~[],
inputs: input_tys, inputs: input_tys,

4
src/rustdoc/extract.rs
View file

@ -83,7 +83,7 @@ fn moddoc_from_mod(
nmoddoc_from_mod(itemdoc, nm) nmoddoc_from_mod(itemdoc, nm)
)) ))
} }
ast::item_fn(_, _, _) => { ast::item_fn(*) => {
some(doc::fntag( some(doc::fntag(
fndoc_from_fn(itemdoc) fndoc_from_fn(itemdoc)
)) ))
@ -129,7 +129,7 @@ fn nmoddoc_from_mod(
fns: do vec::map(module_.items) |item| { fns: do vec::map(module_.items) |item| {
let itemdoc = mk_itemdoc(item.id, to_str(item.ident)); let itemdoc = mk_itemdoc(item.id, to_str(item.ident));
match item.node { match item.node {
ast::foreign_item_fn(_, _) => { ast::foreign_item_fn(*) => {
fndoc_from_fn(itemdoc) fndoc_from_fn(itemdoc)
} }
} }

4
src/rustdoc/tystr_pass.rs
View file

@ -50,11 +50,11 @@ fn get_fn_sig(srv: astsrv::srv, fn_id: doc::ast_id) -> option<~str> {
match ctxt.ast_map.get(fn_id) { match ctxt.ast_map.get(fn_id) {
ast_map::node_item(@{ ast_map::node_item(@{
ident: ident, ident: ident,
node: ast::item_fn(decl, tys, _), _ node: ast::item_fn(decl, _, tys, _), _
}, _) | }, _) |
ast_map::node_foreign_item(@{ ast_map::node_foreign_item(@{
ident: ident, ident: ident,
node: ast::foreign_item_fn(decl, tys), _ node: ast::foreign_item_fn(decl, _, tys), _
}, _, _) => { }, _, _) => {
some(pprust::fun_to_str(decl, ident, tys, extract::interner())) some(pprust::fun_to_str(decl, ident, tys, extract::interner()))
} }