mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Disowned the Visitor.

Browse Source
This commit is contained in:
Eduard Burtescu 2014-01-06 14:00:46 +02:00
parent 4e622becdc
commit 3119d18e55
57 changed files with 1039 additions and 1142 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
src/librustc/driver/driver.rs
View File

@ -163,7 +163,8 @@ pub fn phase_1_parse_input(sess: Session, cfg: ast::CrateConfig, input: &input)
/// standard library and prelude.
pub fn phase_2_configure_and_expand(sess: Session,
cfg: ast::CrateConfig,
mut crate: ast::Crate) -> ast::Crate {
mut crate: ast::Crate)
-> (ast::Crate, syntax::ast_map::map) {
let time_passes = sess.time_passes();
sess.building_library.set(session::building_library(sess.opts, &crate));
@ -201,10 +202,8 @@ pub fn phase_2_configure_and_expand(sess: Session,
crate = time(time_passes, "std injection", crate, |crate|
front::std_inject::maybe_inject_libstd_ref(sess, crate));
crate = time(time_passes, "assigning node ids", crate, |crate|
front::assign_node_ids::assign_node_ids(sess, crate));
return crate;
time(time_passes, "assinging node ids and indexing ast", crate, |crate|
front::assign_node_ids_and_map::assign_node_ids_and_map(sess, crate))
}
pub struct CrateAnalysis {
@ -219,13 +218,11 @@ pub struct CrateAnalysis {
/// miscellaneous analysis passes on the crate. Return various
/// structures carrying the results of the analysis.
pub fn phase_3_run_analysis_passes(sess: Session,
crate: &ast::Crate) -> CrateAnalysis {
crate: &ast::Crate,
ast_map: syntax::ast_map::map) -> CrateAnalysis {
let time_passes = sess.time_passes();
let ast_map = time(time_passes, "ast indexing", (), |_|
syntax::ast_map::map_crate(sess.diagnostic(), crate));
time(time_passes, "external crate/lib resolution", (), |_|
creader::read_crates(sess, crate,
session::sess_os_to_meta_os(sess.targ_cfg.os),
@ -260,8 +257,7 @@ pub fn phase_3_run_analysis_passes(sess: Session,
region_map, lang_items);
// passes are timed inside typeck
let (method_map, vtable_map) = typeck::check_crate(
ty_cx, trait_map, crate);
let (method_map, vtable_map) = typeck::check_crate(ty_cx, trait_map, crate);
// These next two const passes can probably be merged
time(time_passes, "const marking", (), |_|
@ -489,7 +485,7 @@ pub fn compile_input(sess: Session, cfg: ast::CrateConfig, input: &input,
// large chunks of memory alive and we want to free them as soon as
// possible to keep the peak memory usage low
let (outputs, trans) = {
let expanded_crate = {
let (expanded_crate, ast_map) = {
let crate = phase_1_parse_input(sess, cfg.clone(), input);
if stop_after_phase_1(sess) { return; }
phase_2_configure_and_expand(sess, cfg, crate)
@ -501,7 +497,7 @@ pub fn compile_input(sess: Session, cfg: ast::CrateConfig, input: &input,
if stop_after_phase_2(sess) { return; }
let analysis = phase_3_run_analysis_passes(sess, &expanded_crate);
let analysis = phase_3_run_analysis_passes(sess, &expanded_crate, ast_map);
if stop_after_phase_3(sess) { return; }
let trans = phase_4_translate_to_llvm(sess, expanded_crate,
&analysis, outputs);
@ -578,11 +574,12 @@ pub fn pretty_print_input(sess: Session,
ppm: PpMode) {
let crate = phase_1_parse_input(sess, cfg.clone(), input);
let (crate, is_expanded) = match ppm {
let (crate, ast_map, is_expanded) = match ppm {
PpmExpanded | PpmExpandedIdentified | PpmTyped => {
(phase_2_configure_and_expand(sess, cfg, crate), true)
let (crate, ast_map) = phase_2_configure_and_expand(sess, cfg, crate);
(crate, Some(ast_map), true)
}
_ => (crate, false)
_ => (crate, None, false)
};
let annotation = match ppm {
@ -592,7 +589,8 @@ pub fn pretty_print_input(sess: Session,
} as @pprust::pp_ann
}
PpmTyped => {
let analysis = phase_3_run_analysis_passes(sess, &crate);
let ast_map = ast_map.expect("--pretty=typed missing ast_map");
let analysis = phase_3_run_analysis_passes(sess, &crate, ast_map);
@TypedAnnotation {
analysis: analysis
} as @pprust::pp_ann

17
src/librustc/front/assign_node_ids.rs → src/librustc/front/assign_node_ids_and_map.rs
View File

@ -1,4 +1,4 @@
// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
@ -11,22 +11,19 @@
use driver::session::Session;
use syntax::ast;
use syntax::fold::ast_fold;
use syntax::ast_map;
struct NodeIdAssigner {
sess: Session,
sess: Session
}
impl ast_fold for NodeIdAssigner {
fn new_id(&mut self, old_id: ast::NodeId) -> ast::NodeId {
impl ast_map::FoldOps for NodeIdAssigner {
fn new_id(&self, old_id: ast::NodeId) -> ast::NodeId {
assert_eq!(old_id, ast::DUMMY_NODE_ID);
self.sess.next_node_id()
}
}
pub fn assign_node_ids(sess: Session, crate: ast::Crate) -> ast::Crate {
let mut fold = NodeIdAssigner {
sess: sess,
};
fold.fold_crate(crate)
pub fn assign_node_ids_and_map(sess: Session, crate: ast::Crate) -> (ast::Crate, ast_map::map) {
ast_map::map_crate(sess.diagnostic(), crate, NodeIdAssigner { sess: sess })
}

4
src/librustc/front/feature_gate.rs
View File

@ -119,7 +119,7 @@ impl Visitor<()> for Context {
visit::walk_view_item(self, i, ())
}
fn visit_item(&mut self, i: @ast::item, _:()) {
fn visit_item(&mut self, i: &ast::item, _:()) {
for attr in i.attrs.iter() {
if "thread_local" == attr.name() {
self.gate_feature("thread_local", i.span,
@ -187,7 +187,7 @@ impl Visitor<()> for Context {
visit::walk_ty(self, t, ());
}
fn visit_expr(&mut self, e: @ast::Expr, _: ()) {
fn visit_expr(&mut self, e: &ast::Expr, _: ()) {
match e.node {
ast::ExprUnary(_, ast::UnBox, _) |
ast::ExprVstore(_, ast::ExprVstoreBox) => {

2
src/librustc/lib.rs
View File

@ -81,7 +81,7 @@ pub mod front {
pub mod config;
pub mod test;
pub mod std_inject;
pub mod assign_node_ids;
pub mod assign_node_ids_and_map;
pub mod feature_gate;
}

6
src/librustc/metadata/creader.rs
View File

@ -58,11 +58,11 @@ struct ReadCrateVisitor<'a> {
}
impl<'a> visit::Visitor<()> for ReadCrateVisitor<'a> {
fn visit_view_item(&mut self, a:&ast::view_item, _:()) {
fn visit_view_item(&mut self, a: &ast::view_item, _: ()) {
visit_view_item(self.e, a);
visit::walk_view_item(self, a, ());
}
fn visit_item(&mut self, a:@ast::item, _:()) {
fn visit_item(&mut self, a: &ast::item, _: ()) {
visit_item(self.e, a);
visit::walk_item(self, a, ());
}
@ -164,7 +164,7 @@ fn visit_view_item(e: &mut Env, i: &ast::view_item) {
}
}
fn visit_item(e: &Env, i: @ast::item) {
fn visit_item(e: &Env, i: &ast::item) {
match i.node {
ast::item_foreign_mod(ref fm) => {
if fm.abis.is_rust() || fm.abis.is_intrinsic() {

49
src/librustc/metadata/encoder.rs
View File

@ -50,10 +50,17 @@ use writer = extra::ebml::writer;
// used by astencode:
type abbrev_map = @RefCell<HashMap<ty::t, tyencode::ty_abbrev>>;
/// A borrowed version of ast::inlined_item.
pub enum InlinedItemRef<'a> {
ii_item_ref(&'a ast::item),
ii_method_ref(ast::DefId, bool, &'a ast::method),
ii_foreign_ref(&'a ast::foreign_item)
}
pub type encode_inlined_item<'a> = 'a |ecx: &EncodeContext,
ebml_w: &mut writer::Encoder,
path: &[ast_map::path_elt],
ii: ast::inlined_item|;
ebml_w: &mut writer::Encoder,
path: &[ast_map::path_elt],
ii: InlinedItemRef|;
pub struct EncodeParams<'a> {
diag: @SpanHandler,
@ -837,13 +844,13 @@ fn encode_info_for_method(ecx: &EncodeContext,
None => ()
}
for ast_method in ast_method_opt.iter() {
for &ast_method in ast_method_opt.iter() {
let num_params = tpt.generics.type_param_defs.len();
if num_params > 0u || is_default_impl
|| should_inline(ast_method.attrs) {
(ecx.encode_inlined_item)(
ecx, ebml_w, impl_path,
ii_method(local_def(parent_id), false, *ast_method));
ii_method_ref(local_def(parent_id), false, ast_method));
} else {
encode_symbol(ecx, ebml_w, m.def_id.node);
}
@ -915,13 +922,13 @@ fn encode_extension_implementations(ecx: &EncodeContext,
fn encode_info_for_item(ecx: &EncodeContext,
ebml_w: &mut writer::Encoder,
item: @item,
item: &item,
index: @RefCell<~[entry<i64>]>,
path: &[ast_map::path_elt],
vis: ast::visibility) {
let tcx = ecx.tcx;
fn add_to_index(item: @item, ebml_w: &writer::Encoder,
fn add_to_index(item: &item, ebml_w: &writer::Encoder,
index: @RefCell<~[entry<i64>]>) {
let mut index = index.borrow_mut();
index.get().push(entry {
@ -958,7 +965,7 @@ fn encode_info_for_item(ecx: &EncodeContext,
}
if !non_inlineable {
(ecx.encode_inlined_item)(ecx, ebml_w, path, ii_item(item));
(ecx.encode_inlined_item)(ecx, ebml_w, path, ii_item_ref(item));
}
encode_visibility(ebml_w, vis);
ebml_w.end_tag();
@ -974,7 +981,7 @@ fn encode_info_for_item(ecx: &EncodeContext,
encode_path(ecx, ebml_w, path, ast_map::path_name(item.ident));
encode_attributes(ebml_w, item.attrs);
if tps_len > 0u || should_inline(item.attrs) {
(ecx.encode_inlined_item)(ecx, ebml_w, path, ii_item(item));
(ecx.encode_inlined_item)(ecx, ebml_w, path, ii_item_ref(item));
} else {
encode_symbol(ecx, ebml_w, item.id);
}
@ -1032,7 +1039,7 @@ fn encode_info_for_item(ecx: &EncodeContext,
for v in (*enum_definition).variants.iter() {
encode_variant_id(ebml_w, local_def(v.node.id));
}
(ecx.encode_inlined_item)(ecx, ebml_w, path, ii_item(item));
(ecx.encode_inlined_item)(ecx, ebml_w, path, ii_item_ref(item));
encode_path(ecx, ebml_w, path, ast_map::path_name(item.ident));
// Encode inherent implementations for this enumeration.
@ -1077,7 +1084,7 @@ fn encode_info_for_item(ecx: &EncodeContext,
needs to know*/
encode_struct_fields(ecx, ebml_w, struct_def);
(ecx.encode_inlined_item)(ecx, ebml_w, path, ii_item(item));
(ecx.encode_inlined_item)(ecx, ebml_w, path, ii_item_ref(item));
// Encode inherent implementations for this structure.
encode_inherent_implementations(ecx, ebml_w, def_id);
@ -1272,7 +1279,7 @@ fn encode_info_for_item(ecx: &EncodeContext,
encode_method_sort(ebml_w, 'p');
(ecx.encode_inlined_item)(
ecx, ebml_w, path,
ii_method(def_id, true, m));
ii_method_ref(def_id, true, m));
}
}
@ -1288,7 +1295,7 @@ fn encode_info_for_item(ecx: &EncodeContext,
fn encode_info_for_foreign_item(ecx: &EncodeContext,
ebml_w: &mut writer::Encoder,
nitem: @foreign_item,
nitem: &foreign_item,
index: @RefCell<~[entry<i64>]>,
path: &ast_map::path,
abi: AbiSet) {
@ -1309,7 +1316,7 @@ fn encode_info_for_foreign_item(ecx: &EncodeContext,
&lookup_item_type(ecx.tcx,local_def(nitem.id)));
encode_name(ecx, ebml_w, nitem.ident);
if abi.is_intrinsic() {
(ecx.encode_inlined_item)(ecx, ebml_w, *path, ii_foreign(nitem));
(ecx.encode_inlined_item)(ecx, ebml_w, *path, ii_foreign_ref(nitem));
} else {
encode_symbol(ecx, ebml_w, nitem.id);
}
@ -1331,9 +1338,9 @@ fn encode_info_for_foreign_item(ecx: &EncodeContext,
ebml_w.end_tag();
}
fn my_visit_expr(_e:@Expr) { }
fn my_visit_expr(_e: &Expr) { }
fn my_visit_item(i: @item,
fn my_visit_item(i: &item,
items: ast_map::map,
ebml_w: &mut writer::Encoder,
ecx_ptr: *int,
@ -1352,7 +1359,7 @@ fn my_visit_item(i: @item,
}
}
fn my_visit_foreign_item(ni: @foreign_item,
fn my_visit_foreign_item(ni: &foreign_item,
items: ast_map::map,
ebml_w: &mut writer::Encoder,
ecx_ptr:*int,
@ -1391,11 +1398,11 @@ struct EncodeVisitor<'a,'b> {
}
impl<'a,'b> visit::Visitor<()> for EncodeVisitor<'a,'b> {
fn visit_expr(&mut self, ex:@Expr, _:()) {
fn visit_expr(&mut self, ex: &Expr, _: ()) {
visit::walk_expr(self, ex, ());
my_visit_expr(ex);
}
fn visit_item(&mut self, i:@item, _:()) {
fn visit_item(&mut self, i: &item, _: ()) {
visit::walk_item(self, i, ());
my_visit_item(i,
self.items,
@ -1403,7 +1410,7 @@ impl<'a,'b> visit::Visitor<()> for EncodeVisitor<'a,'b> {
self.ecx_ptr,
self.index);
}
fn visit_foreign_item(&mut self, ni:@foreign_item, _:()) {
fn visit_foreign_item(&mut self, ni: &foreign_item, _: ()) {
visit::walk_foreign_item(self, ni, ());
my_visit_foreign_item(ni,
self.items,
@ -1692,7 +1699,7 @@ struct ImplVisitor<'a,'b> {
}
impl<'a,'b> Visitor<()> for ImplVisitor<'a,'b> {
fn visit_item(&mut self, item: @item, _: ()) {
fn visit_item(&mut self, item: &item, _: ()) {
match item.node {
item_impl(_, Some(ref trait_ref), _, _) => {
let def_map = self.ecx.tcx.def_map;

109
src/librustc/middle/astencode.rs
View File

@ -24,14 +24,10 @@ use middle::{ty, typeck, moves};
use middle;
use util::ppaux::ty_to_str;
use syntax::ast;
use syntax::ast_map;
use syntax::ast_util::inlined_item_utils;
use syntax::ast_util;
use syntax::{ast, ast_map, ast_util, codemap, fold};
use syntax::codemap::Span;
use syntax::codemap;
use syntax::fold::*;
use syntax::fold;
use syntax::diagnostic::SpanHandler;
use syntax::fold::ast_fold;
use syntax::parse::token;
use syntax;
@ -84,24 +80,30 @@ trait tr_intern {
pub fn encode_inlined_item(ecx: &e::EncodeContext,
ebml_w: &mut writer::Encoder,
path: &[ast_map::path_elt],
ii: ast::inlined_item,
ii: e::InlinedItemRef,
maps: Maps) {
let ident = match ii {
e::ii_item_ref(i) => i.ident,
e::ii_foreign_ref(i) => i.ident,
e::ii_method_ref(_, _, m) => m.ident,
};
debug!("> Encoding inlined item: {}::{} ({})",
ast_map::path_to_str(path, token::get_ident_interner()),
ecx.tcx.sess.str_of(ii.ident()),
ecx.tcx.sess.str_of(ident),
ebml_w.writer.tell());
let ii = simplify_ast(ii);
let id_range = ast_util::compute_id_range_for_inlined_item(&ii);
ebml_w.start_tag(c::tag_ast as uint);
id_range.encode(ebml_w);
encode_ast(ebml_w, simplify_ast(&ii));
encode_ast(ebml_w, ii);
encode_side_tables_for_ii(ecx, maps, ebml_w, &ii);
ebml_w.end_tag();
debug!("< Encoded inlined fn: {}::{} ({})",
ast_map::path_to_str(path, token::get_ident_interner()),
ecx.tcx.sess.str_of(ii.ident()),
ecx.tcx.sess.str_of(ident),
ebml_w.writer.tell());
}
@ -130,15 +132,20 @@ pub fn decode_inlined_item(cdata: @cstore::crate_metadata,
to_id_range: to_id_range
};
let raw_ii = decode_ast(ast_doc);
let ii = renumber_ast(xcx, raw_ii);
debug!("Fn named: {}", tcx.sess.str_of(ii.ident()));
let ii = renumber_and_map_ast(xcx,
tcx.sess.diagnostic(),
dcx.tcx.items,
path.to_owned(),
raw_ii);
let ident = match ii {
ast::ii_item(i) => i.ident,
ast::ii_foreign(i) => i.ident,
ast::ii_method(_, _, m) => m.ident,
};
debug!("Fn named: {}", tcx.sess.str_of(ident));
debug!("< Decoded inlined fn: {}::{}",
ast_map::path_to_str(path, token::get_ident_interner()),
tcx.sess.str_of(ii.ident()));
ast_map::map_decoded_item(tcx.sess.diagnostic(),
dcx.tcx.items,
path.to_owned(),
&ii);
tcx.sess.str_of(ident));
decode_side_tables(xcx, ast_doc);
match ii {
ast::ii_item(i) => {
@ -295,11 +302,9 @@ fn encode_ast(ebml_w: &mut writer::Encoder, item: ast::inlined_item) {
ebml_w.end_tag();
}
struct NestedItemsDropper {
contents: (),
}
struct NestedItemsDropper;
impl fold::ast_fold for NestedItemsDropper {
impl ast_fold for NestedItemsDropper {
fn fold_block(&mut self, blk: ast::P<ast::Block>) -> ast::P<ast::Block> {
let stmts_sans_items = blk.stmts.iter().filter_map(|stmt| {
match stmt.node {
@ -338,18 +343,15 @@ impl fold::ast_fold for NestedItemsDropper {
// As it happens, trans relies on the fact that we do not export
// nested items, as otherwise it would get confused when translating
// inlined items.
fn simplify_ast(ii: &ast::inlined_item) -> ast::inlined_item {
let mut fld = NestedItemsDropper {
contents: (),
};
fn simplify_ast(ii: e::InlinedItemRef) -> ast::inlined_item {
let mut fld = NestedItemsDropper;
match *ii {
//hack: we're not dropping items
ast::ii_item(i) => ast::ii_item(fld.fold_item(i)
.expect_one("expected one item")),
ast::ii_method(d, is_provided, m) =>
ast::ii_method(d, is_provided, fld.fold_method(m)),
ast::ii_foreign(i) => ast::ii_foreign(fld.fold_foreign_item(i))
match ii {
// HACK we're not dropping items.
e::ii_item_ref(i) => ast::ii_item(fold::noop_fold_item(i, &mut fld)
.expect_one("expected one item")),
e::ii_method_ref(d, p, m) => ast::ii_method(d, p, fold::noop_fold_method(m, &mut fld)),
e::ii_foreign_ref(i) => ast::ii_foreign(fold::noop_fold_foreign_item(i, &mut fld))
}
}
@ -363,27 +365,31 @@ struct AstRenumberer {
xcx: @ExtendedDecodeContext,
}
impl fold::ast_fold for AstRenumberer {
fn new_id(&mut self, id: ast::NodeId) -> ast::NodeId {
impl ast_map::FoldOps for AstRenumberer {
fn new_id(&self, id: ast::NodeId) -> ast::NodeId {
self.xcx.tr_id(id)
}
fn new_span(&mut self, span: Span) -> Span {
fn new_span(&self, span: Span) -> Span {
self.xcx.tr_span(span)
}
}
fn renumber_ast(xcx: @ExtendedDecodeContext, ii: ast::inlined_item)
-> ast::inlined_item {
let mut fld = AstRenumberer {
xcx: xcx,
};
match ii {
ast::ii_item(i) => ast::ii_item(fld.fold_item(i)
.expect_one("expected one item")),
ast::ii_method(d, is_provided, m) =>
ast::ii_method(xcx.tr_def_id(d), is_provided, fld.fold_method(m)),
ast::ii_foreign(i) => ast::ii_foreign(fld.fold_foreign_item(i)),
}
fn renumber_and_map_ast(xcx: @ExtendedDecodeContext,
diag: @SpanHandler,
map: ast_map::map,
path: ast_map::path,
ii: ast::inlined_item) -> ast::inlined_item {
ast_map::map_decoded_item(diag, map, path, AstRenumberer { xcx: xcx }, |fld| {
match ii {
ast::ii_item(i) => {
ast::ii_item(fld.fold_item(i).expect_one("expected one item"))
}
ast::ii_method(d, is_provided, m) => {
ast::ii_method(xcx.tr_def_id(d), is_provided, fld.fold_method(m))
}
ast::ii_foreign(i) => ast::ii_foreign(fld.fold_foreign_item(i))
}
})
}
// ______________________________________________________________________
@ -1504,13 +1510,14 @@ fn test_more() {
#[test]
fn test_simplification() {
let cx = mk_ctxt();
let item_in = ast::ii_item(quote_item!(cx,
let item = quote_item!(cx,
fn new_int_alist<B>() -> alist<int, B> {
fn eq_int(a: int, b: int) -> bool { a == b }
return alist {eq_fn: eq_int, data: ~[]};
}
).unwrap());
let item_out = simplify_ast(&item_in);
).unwrap();
let item_in = e::ii_item_ref(item);
let item_out = simplify_ast(item_in);
let item_exp = ast::ii_item(quote_item!(cx,
fn new_int_alist<B>() -> alist<int, B> {
return alist {eq_fn: eq_int, data: ~[]};

50
src/librustc/middle/borrowck/check_loans.rs
View File

@ -30,30 +30,29 @@ use syntax::visit::Visitor;
use syntax::visit;
use util::ppaux::Repr;
#[deriving(Clone)]
struct CheckLoanCtxt<'a> {
bccx: &'a BorrowckCtxt,
dfcx_loans: &'a LoanDataFlow,
move_data: @move_data::FlowedMoveData,
move_data: move_data::FlowedMoveData,
all_loans: &'a [Loan],
}
impl<'a> Visitor<()> for CheckLoanCtxt<'a> {
fn visit_expr(&mut self, ex:@ast::Expr, _:()) {
fn visit_expr(&mut self, ex: &ast::Expr, _: ()) {
check_loans_in_expr(self, ex);
}
fn visit_local(&mut self, l:@ast::Local, _:()) {
fn visit_local(&mut self, l: &ast::Local, _: ()) {
check_loans_in_local(self, l);
}
fn visit_block(&mut self, b:ast::P<ast::Block>, _:()) {
fn visit_block(&mut self, b: &ast::Block, _: ()) {
check_loans_in_block(self, b);
}
fn visit_pat(&mut self, p:&ast::Pat, _:()) {
fn visit_pat(&mut self, p: &ast::Pat, _: ()) {
check_loans_in_pat(self, p);
}
fn visit_fn(&mut self, fk:&visit::fn_kind, fd:&ast::fn_decl,
b:ast::P<ast::Block>, s:Span, n:ast::NodeId, _:()) {
fn visit_fn(&mut self, fk: &visit::fn_kind, fd: &ast::fn_decl,
b: &ast::Block, s: Span, n: ast::NodeId, _: ()) {
check_loans_in_fn(self, fk, fd, b, s, n);
}
@ -65,13 +64,13 @@ pub fn check_loans(bccx: &BorrowckCtxt,
dfcx_loans: &LoanDataFlow,
move_data: move_data::FlowedMoveData,
all_loans: &[Loan],
body: ast::P<ast::Block>) {
body: &ast::Block) {
debug!("check_loans(body id={:?})", body.id);
let mut clcx = CheckLoanCtxt {
bccx: bccx,
dfcx_loans: dfcx_loans,
move_data: @move_data,
move_data: move_data,
all_loans: all_loans,
};
@ -107,9 +106,9 @@ impl<'a> CheckLoanCtxt<'a> {
//! Like `each_issued_loan()`, but only considers loans that are
//! currently in scope.
let region_maps = self.tcx().region_maps;
let tcx = self.tcx();
self.each_issued_loan(scope_id, |loan| {
if region_maps.is_subscope_of(scope_id, loan.kill_scope) {
if tcx.region_maps.is_subscope_of(scope_id, loan.kill_scope) {
op(loan)
} else {
true
@ -190,9 +189,8 @@ impl<'a> CheckLoanCtxt<'a> {
new_loan.repr(self.tcx()));
// Should only be called for loans that are in scope at the same time.
let region_maps = self.tcx().region_maps;
assert!(region_maps.scopes_intersect(old_loan.kill_scope,
new_loan.kill_scope));
assert!(self.tcx().region_maps.scopes_intersect(old_loan.kill_scope,
new_loan.kill_scope));
self.report_error_if_loan_conflicts_with_restriction(
old_loan, new_loan, old_loan, new_loan) &&
@ -290,7 +288,7 @@ impl<'a> CheckLoanCtxt<'a> {
});
}
pub fn check_assignment(&self, expr: @ast::Expr) {
pub fn check_assignment(&self, expr: &ast::Expr) {
// We don't use cat_expr() here because we don't want to treat
// auto-ref'd parameters in overloaded operators as rvalues.
let adj = {
@ -401,7 +399,7 @@ impl<'a> CheckLoanCtxt<'a> {
}
fn check_for_aliasable_mutable_writes(this: &CheckLoanCtxt,
expr: @ast::Expr,
expr: &ast::Expr,
cmt: mc::cmt) -> bool {
//! Safety checks related to writes to aliasable, mutable locations
@ -422,7 +420,7 @@ impl<'a> CheckLoanCtxt<'a> {
}
fn check_for_aliasability_violation(this: &CheckLoanCtxt,
expr: @ast::Expr,
expr: &ast::Expr,
cmt: mc::cmt) -> bool {
let mut cmt = cmt;
@ -467,7 +465,7 @@ impl<'a> CheckLoanCtxt<'a> {
fn check_for_assignment_to_restricted_or_frozen_location(
this: &CheckLoanCtxt,
expr: @ast::Expr,
expr: &ast::Expr,
cmt: mc::cmt) -> bool
{
//! Check for assignments that violate the terms of an
@ -601,7 +599,7 @@ impl<'a> CheckLoanCtxt<'a> {
}
pub fn report_illegal_mutation(&self,
expr: @ast::Expr,
expr: &ast::Expr,
loan_path: &LoanPath,
loan: &Loan) {
self.bccx.span_err(
@ -614,7 +612,7 @@ impl<'a> CheckLoanCtxt<'a> {
self.bccx.loan_path_to_str(loan_path)));
}
fn check_move_out_from_expr(&self, expr: @ast::Expr) {
fn check_move_out_from_expr(&self, expr: &ast::Expr) {
match expr.node {
ast::ExprFnBlock(..) | ast::ExprProc(..) => {
// moves due to capture clauses are checked
@ -668,7 +666,7 @@ impl<'a> CheckLoanCtxt<'a> {
}
pub fn check_call(&self,
_expr: @ast::Expr,
_expr: &ast::Expr,
_callee: Option<@ast::Expr>,
_callee_id: ast::NodeId,
_callee_span: Span,
@ -686,7 +684,7 @@ impl<'a> CheckLoanCtxt<'a> {
fn check_loans_in_fn<'a>(this: &mut CheckLoanCtxt<'a>,
fk: &visit::fn_kind,
decl: &ast::fn_decl,
body: ast::P<ast::Block>,
body: &ast::Block,
sp: Span,
id: ast::NodeId) {
match *fk {
@ -746,12 +744,12 @@ fn check_loans_in_fn<'a>(this: &mut CheckLoanCtxt<'a>,
}
fn check_loans_in_local<'a>(this: &mut CheckLoanCtxt<'a>,
local: @ast::Local) {
local: &ast::Local) {
visit::walk_local(this, local, ());
}
fn check_loans_in_expr<'a>(this: &mut CheckLoanCtxt<'a>,
expr: @ast::Expr) {
expr: &ast::Expr) {
visit::walk_expr(this, expr, ());
debug!("check_loans_in_expr(expr={})",
@ -818,7 +816,7 @@ fn check_loans_in_pat<'a>(this: &mut CheckLoanCtxt<'a>,
}
fn check_loans_in_block<'a>(this: &mut CheckLoanCtxt<'a>,
blk: ast::P<ast::Block>)
blk: &ast::Block)
{
visit::walk_block(this, blk, ());
this.check_for_conflicting_loans(blk.id);

14
src/librustc/middle/borrowck/gather_loans/gather_moves.rs
View File

@ -33,18 +33,16 @@ pub fn gather_decl(bccx: &BorrowckCtxt,
pub fn gather_move_from_expr(bccx: &BorrowckCtxt,
move_data: &MoveData,
move_expr: @ast::Expr,
move_expr: &ast::Expr,
cmt: mc::cmt) {
gather_move_from_expr_or_pat(bccx, move_data, move_expr.id,
MoveExpr(move_expr), cmt);
gather_move_from_expr_or_pat(bccx, move_data, move_expr.id, MoveExpr, cmt);
}
pub fn gather_move_from_pat(bccx: &BorrowckCtxt,
move_data: &MoveData,
move_pat: @ast::Pat,
move_pat: &ast::Pat,
cmt: mc::cmt) {
gather_move_from_expr_or_pat(bccx, move_data, move_pat.id,
MovePat(move_pat), cmt);
gather_move_from_expr_or_pat(bccx, move_data, move_pat.id, MovePat, cmt);
}
fn gather_move_from_expr_or_pat(bccx: &BorrowckCtxt,
@ -68,7 +66,7 @@ fn gather_move_from_expr_or_pat(bccx: &BorrowckCtxt,
pub fn gather_captures(bccx: &BorrowckCtxt,
move_data: &MoveData,
closure_expr: @ast::Expr) {
closure_expr: &ast::Expr) {
let capture_map = bccx.capture_map.borrow();
let captured_vars = capture_map.get().get(&closure_expr.id);
for captured_var in captured_vars.iter() {
@ -77,7 +75,7 @@ pub fn gather_captures(bccx: &BorrowckCtxt,
let fvar_id = ast_util::def_id_of_def(captured_var.def).node;
let loan_path = @LpVar(fvar_id);
move_data.add_move(bccx.tcx, loan_path, closure_expr.id,
Captured(closure_expr));
Captured);
}
moves::CapCopy | moves::CapRef => {}
}

67
src/librustc/middle/borrowck/gather_loans/mod.rs
View File

@ -33,7 +33,7 @@ use syntax::codemap::Span;
use syntax::print::pprust;
use syntax::visit;
use syntax::visit::{Visitor, fn_kind};
use syntax::ast::{P, Expr, fn_decl, Block, NodeId, Stmt, Pat, Local};
use syntax::ast::{Expr, fn_decl, Block, NodeId, Stmt, Pat, Local};
mod lifetime;
mod restrictions;
@ -68,50 +68,50 @@ mod gather_moves;
struct GatherLoanCtxt<'a> {
bccx: &'a BorrowckCtxt,
id_range: id_range,
move_data: @move_data::MoveData,
move_data: move_data::MoveData,
all_loans: @RefCell<~[Loan]>,
item_ub: ast::NodeId,
repeating_ids: ~[ast::NodeId]
}
impl<'a> visit::Visitor<()> for GatherLoanCtxt<'a> {
fn visit_expr(&mut self, ex:@Expr, _:()) {
fn visit_expr(&mut self, ex: &Expr, _: ()) {
gather_loans_in_expr(self, ex);
}
fn visit_block(&mut self, b:P<Block>, _:()) {
fn visit_block(&mut self, b: &Block, _: ()) {
gather_loans_in_block(self, b);
}
fn visit_fn(&mut self, fk:&fn_kind, fd:&fn_decl, b:P<Block>,
s:Span, n:NodeId, _:()) {
fn visit_fn(&mut self, fk: &fn_kind, fd: &fn_decl, b: &Block,
s: Span, n: NodeId, _: ()) {
gather_loans_in_fn(self, fk, fd, b, s, n);
}
fn visit_stmt(&mut self, s:@Stmt, _:()) {
fn visit_stmt(&mut self, s: &Stmt, _: ()) {
visit::walk_stmt(self, s, ());
}
fn visit_pat(&mut self, p:&Pat, _:()) {
fn visit_pat(&mut self, p: &Pat, _: ()) {
add_pat_to_id_range(self, p);
}
fn visit_local(&mut self, l:@Local, _:()) {
fn visit_local(&mut self, l: &Local, _: ()) {
gather_loans_in_local(self, l);
}
// #7740: Do not visit items here, not even fn items nor methods
// of impl items; the outer loop in borrowck/mod will visit them
// for us in turn. Thus override visit_item's walk with a no-op.
fn visit_item(&mut self, _:@ast::item, _:()) { }
fn visit_item(&mut self, _: &ast::item, _: ()) { }
}
pub fn gather_loans(bccx: &BorrowckCtxt,
decl: &ast::fn_decl,
body: ast::P<ast::Block>)
-> (id_range, @RefCell<~[Loan]>, @move_data::MoveData) {
body: &ast::Block)
-> (id_range, @RefCell<~[Loan]>, move_data::MoveData) {
let mut glcx = GatherLoanCtxt {
bccx: bccx,
id_range: id_range::max(),
all_loans: @RefCell::new(~[]),
item_ub: body.id,
repeating_ids: ~[body.id],
move_data: @MoveData::new()
move_data: MoveData::new()
};
glcx.gather_fn_arg_patterns(decl, body);
@ -132,7 +132,7 @@ fn add_pat_to_id_range(this: &mut GatherLoanCtxt,
fn gather_loans_in_fn(this: &mut GatherLoanCtxt,
fk: &fn_kind,
decl: &ast::fn_decl,
body: ast::P<ast::Block>,
body: &ast::Block,
sp: Span,
id: ast::NodeId) {
match fk {
@ -151,20 +151,20 @@ fn gather_loans_in_fn(this: &mut GatherLoanCtxt,
}
fn gather_loans_in_block(this: &mut GatherLoanCtxt,
blk: ast::P<ast::Block>) {
blk: &ast::Block) {
this.id_range.add(blk.id);
visit::walk_block(this, blk, ());
}
fn gather_loans_in_local(this: &mut GatherLoanCtxt,
local: @ast::Local) {
local: &ast::Local) {
match local.init {
None => {
// Variable declarations without initializers are considered "moves":
let tcx = this.bccx.tcx;
pat_util::pat_bindings(tcx.def_map, local.pat, |_, id, span, _| {
gather_moves::gather_decl(this.bccx,
this.move_data,
&this.move_data,
id,
span,
id);
@ -175,7 +175,7 @@ fn gather_loans_in_local(this: &mut GatherLoanCtxt,
let tcx = this.bccx.tcx;
pat_util::pat_bindings(tcx.def_map, local.pat, |_, id, span, _| {
gather_moves::gather_assignment(this.bccx,
this.move_data,
&this.move_data,
id,
span,
@LpVar(id),
@ -191,7 +191,7 @@ fn gather_loans_in_local(this: &mut GatherLoanCtxt,
fn gather_loans_in_expr(this: &mut GatherLoanCtxt,
ex: @ast::Expr) {
ex: &ast::Expr) {
let bccx = this.bccx;
let tcx = bccx.tcx;
@ -220,7 +220,7 @@ fn gather_loans_in_expr(this: &mut GatherLoanCtxt,
if this.bccx.is_move(ex.id) {
let cmt = this.bccx.cat_expr(ex);
gather_moves::gather_move_from_expr(
this.bccx, this.move_data, ex, cmt);
this.bccx, &this.move_data, ex, cmt);
}
// Special checks for various kinds of expressions:
@ -247,7 +247,7 @@ fn gather_loans_in_expr(this: &mut GatherLoanCtxt,
let l_cmt = this.bccx.cat_expr(l);
match opt_loan_path(l_cmt) {
Some(l_lp) => {
gather_moves::gather_assignment(this.bccx, this.move_data,
gather_moves::gather_assignment(this.bccx, &this.move_data,
ex.id, ex.span,
l_lp, l.id);
}
@ -309,7 +309,7 @@ fn gather_loans_in_expr(this: &mut GatherLoanCtxt,
}
ast::ExprFnBlock(..) | ast::ExprProc(..) => {
gather_moves::gather_captures(this.bccx, this.move_data, ex);
gather_moves::gather_captures(this.bccx, &this.move_data, ex);
visit::walk_expr(this, ex, ());
}
@ -318,7 +318,7 @@ fn gather_loans_in_expr(this: &mut GatherLoanCtxt,
let out_cmt = this.bccx.cat_expr(out);
match opt_loan_path(out_cmt) {
Some(out_lp) => {
gather_moves::gather_assignment(this.bccx, this.move_data,
gather_moves::gather_assignment(this.bccx, &this.move_data,
ex.id, ex.span,
out_lp, out.id);
}
@ -349,7 +349,7 @@ impl<'a> GatherLoanCtxt<'a> {
}
pub fn guarantee_adjustments(&mut self,
expr: @ast::Expr,
expr: &ast::Expr,
adjustment: &ty::AutoAdjustment) {
debug!("guarantee_adjustments(expr={}, adjustment={:?})",
expr.repr(self.tcx()), adjustment);
@ -639,8 +639,7 @@ impl<'a> GatherLoanCtxt<'a> {
//! notably method arguments, the loan may be introduced only
//! later, once it comes into scope.
let rm = self.bccx.tcx.region_maps;
if rm.is_subscope_of(borrow_id, loan_scope) {
if self.bccx.tcx.region_maps.is_subscope_of(borrow_id, loan_scope) {
borrow_id
} else {
loan_scope
@ -668,12 +667,11 @@ impl<'a> GatherLoanCtxt<'a> {
//! with immutable `&` pointers, because borrows of such pointers
//! do not require restrictions and hence do not cause a loan.
let rm = self.bccx.tcx.region_maps;
let lexical_scope = rm.encl_scope(lp.node_id());
if rm.is_subscope_of(lexical_scope, loan_scope) {
let lexical_scope = self.bccx.tcx.region_maps.encl_scope(lp.node_id());
if self.bccx.tcx.region_maps.is_subscope_of(lexical_scope, loan_scope) {
lexical_scope
} else {
assert!(rm.is_subscope_of(loan_scope, lexical_scope));
assert!(self.bccx.tcx.region_maps.is_subscope_of(loan_scope, lexical_scope));
loan_scope
}
}
@ -704,7 +702,7 @@ impl<'a> GatherLoanCtxt<'a> {
fn gather_pat(&mut self,
discr_cmt: mc::cmt,
root_pat: @ast::Pat,
root_pat: &ast::Pat,
arm_match_ids: Option<(ast::NodeId, ast::NodeId)>) {
/*!
* Walks patterns, examining the bindings to determine if they
@ -755,7 +753,7 @@ impl<'a> GatherLoanCtxt<'a> {
// No borrows here, but there may be moves
if self.bccx.is_move(pat.id) {
gather_moves::gather_move_from_pat(
self.bccx, self.move_data, pat, cmt);
self.bccx, &self.move_data, pat, cmt);
}
}
}
@ -804,7 +802,7 @@ impl<'a> GatherLoanCtxt<'a> {
})
}
pub fn vec_slice_info(&self, pat: @ast::Pat, slice_ty: ty::t)
pub fn vec_slice_info(&self, pat: &ast::Pat, slice_ty: ty::t)
-> (ast::Mutability, ty::Region) {
/*!
*
@ -831,8 +829,7 @@ impl<'a> GatherLoanCtxt<'a> {
}
}
pub fn pat_is_binding(&self, pat: @ast::Pat) -> bool {
pub fn pat_is_binding(&self, pat: &ast::Pat) -> bool {
pat_util::pat_is_binding(self.bccx.tcx.def_map, pat)
}
}

54
src/librustc/middle/borrowck/mod.rs
View File

@ -29,7 +29,7 @@ use syntax::codemap::Span;
use syntax::parse::token;
use syntax::visit;
use syntax::visit::{Visitor,fn_kind};
use syntax::ast::{P,fn_decl,Block,NodeId};
use syntax::ast::{fn_decl,Block,NodeId};
macro_rules! if_ok(
($inp: expr) => (
@ -61,8 +61,8 @@ impl Clone for LoanDataFlowOperator {
pub type LoanDataFlow = DataFlowContext<LoanDataFlowOperator>;
impl Visitor<()> for BorrowckCtxt {
fn visit_fn(&mut self, fk:&fn_kind, fd:&fn_decl,
b:P<Block>, s:Span, n:NodeId, _:()) {
fn visit_fn(&mut self, fk: &fn_kind, fd: &fn_decl,
b: &Block, s: Span, n: NodeId, _: ()) {
borrowck_fn(self, fk, fd, b, s, n);
}
}
@ -116,7 +116,7 @@ pub fn check_crate(tcx: ty::ctxt,
fn borrowck_fn(this: &mut BorrowckCtxt,
fk: &visit::fn_kind,
decl: &ast::fn_decl,
body: ast::P<ast::Block>,
body: &ast::Block,
sp: Span,
id: ast::NodeId) {
match fk {
@ -455,17 +455,17 @@ impl BorrowckCtxt {
moves_map.get().contains(&id)
}
pub fn cat_expr(&self, expr: @ast::Expr) -> mc::cmt {
pub fn cat_expr(&self, expr: &ast::Expr) -> mc::cmt {
mc::cat_expr(self.tcx, self.method_map, expr)
}
pub fn cat_expr_unadjusted(&self, expr: @ast::Expr) -> mc::cmt {
pub fn cat_expr_unadjusted(&self, expr: &ast::Expr) -> mc::cmt {
mc::cat_expr_unadjusted(self.tcx, self.method_map, expr)
}
pub fn cat_expr_autoderefd(&self,
expr: @ast::Expr,
adj: @ty::AutoAdjustment)
expr: &ast::Expr,
adj: &ty::AutoAdjustment)
-> mc::cmt {
match *adj {
ty::AutoAddEnv(..) | ty::AutoObject(..) => {
@ -504,8 +504,8 @@ impl BorrowckCtxt {
pub fn cat_pattern(&self,
cmt: mc::cmt,
pat: @ast::Pat,
op: |mc::cmt, @ast::Pat|) {
pat: &ast::Pat,
op: |mc::cmt, &ast::Pat|) {
let mc = self.mc_ctxt();
mc.cat_pattern(cmt, pat, op);
}
@ -550,34 +550,48 @@ impl BorrowckCtxt {
match move.kind {
move_data::Declared => {}
move_data::MoveExpr(expr) => {
let expr_ty = ty::expr_ty_adjusted(self.tcx, expr);
move_data::MoveExpr => {
let items = self.tcx.items.borrow();
let (expr_ty, expr_span) = match items.get().find(&move.id) {
Some(&ast_map::node_expr(expr)) => {
(ty::expr_ty_adjusted(self.tcx, expr), expr.span)
}
r => self.tcx.sess.bug(format!("MoveExpr({:?}) maps to {:?}, not Expr",
move.id, r))
};
let suggestion = move_suggestion(self.tcx, expr_ty,
"moved by default (use `copy` to override)");
self.tcx.sess.span_note(
expr.span,
expr_span,
format!("`{}` moved here because it has type `{}`, which is {}",
self.loan_path_to_str(moved_lp),
expr_ty.user_string(self.tcx), suggestion));
}
move_data::MovePat(pat) => {
let pat_ty = ty::node_id_to_type(self.tcx, pat.id);
move_data::MovePat => {
let pat_ty = ty::node_id_to_type(self.tcx, move.id);
self.tcx.sess.span_note(
pat.span,
ast_map::node_span(self.tcx.items, move.id),
format!("`{}` moved here because it has type `{}`, \
which is moved by default (use `ref` to override)",
self.loan_path_to_str(moved_lp),
pat_ty.user_string(self.tcx)));
}
move_data::Captured(expr) => {
let expr_ty = ty::expr_ty_adjusted(self.tcx, expr);
move_data::Captured => {
let items = self.tcx.items.borrow();
let (expr_ty, expr_span) = match items.get().find(&move.id) {
Some(&ast_map::node_expr(expr)) => {
(ty::expr_ty_adjusted(self.tcx, expr), expr.span)
}
r => self.tcx.sess.bug(format!("Captured({:?}) maps to {:?}, not Expr",
move.id, r))
};
let suggestion = move_suggestion(self.tcx, expr_ty,
"moved by default (make a copy and \
capture that instead to override)");
self.tcx.sess.span_note(
expr.span,
expr_span,
format!("`{}` moved into closure environment here because it \
has type `{}`, which is {}",
self.loan_path_to_str(moved_lp),
@ -757,7 +771,7 @@ impl BorrowckCtxt {
LpVar(id) => {
let items = self.tcx.items.borrow();
match items.get().find(&id) {
Some(&ast_map::node_local(ref ident)) => {
Some(&ast_map::node_local(ref ident, _)) => {
out.push_str(token::ident_to_str(ident));
}
r => {

19
src/librustc/middle/borrowck/move_data.rs
View File

@ -53,12 +53,7 @@ pub struct MoveData {
}
pub struct FlowedMoveData {
move_data: @MoveData,
// ^~~~~~~~~
// It makes me sad to use @ here, except that due to
// the old visitor design, this is what gather_loans
// used to have to produce, and this code hasn't been
// updated.
move_data: MoveData,
dfcx_moves: MoveDataFlow,
@ -120,10 +115,10 @@ pub struct MovePath {
}
pub enum MoveKind {
Declared, // When declared, variables start out "moved".
MoveExpr(@ast::Expr), // Expression or binding that moves a variable
MovePat(@ast::Pat), // By-move binding
Captured(@ast::Expr), // Closure creation that moves a value
Declared, // When declared, variables start out "moved".
MoveExpr, // Expression or binding that moves a variable
MovePat, // By-move binding
Captured // Closure creation that moves a value
}
pub struct Move {
@ -137,7 +132,7 @@ pub struct Move {
kind: MoveKind,
/// Next node in linked list of moves from `path`, or `InvalidMoveIndex`
next_move: MoveIndex,
next_move: MoveIndex
}
pub struct Assignment {
@ -568,7 +563,7 @@ impl MoveData {
}
impl FlowedMoveData {
pub fn new(move_data: @MoveData,
pub fn new(move_data: MoveData,
tcx: ty::ctxt,
method_map: typeck::method_map,
id_range: ast_util::id_range,

56
src/librustc/middle/check_const.rs
View File

@ -15,7 +15,6 @@ use middle::ty;
use middle::typeck;
use util::ppaux;
use std::cell::RefCell;
use syntax::ast::*;
use syntax::codemap;
use syntax::{ast_util, ast_map};
@ -31,13 +30,13 @@ struct CheckCrateVisitor {
}
impl Visitor<bool> for CheckCrateVisitor {
fn visit_item(&mut self, i:@item, env:bool) {
fn visit_item(&mut self, i: &item, env: bool) {
check_item(self, self.sess, self.ast_map, self.def_map, i, env);
}
fn visit_pat(&mut self, p:&Pat, env:bool) {
fn visit_pat(&mut self, p: &Pat, env: bool) {
check_pat(self, p, env);
}
fn visit_expr(&mut self, ex:@Expr, env:bool) {
fn visit_expr(&mut self, ex: &Expr, env: bool) {
check_expr(self, self.sess, self.def_map, self.method_map,
self.tcx, ex, env);
}
@ -64,7 +63,7 @@ pub fn check_item(v: &mut CheckCrateVisitor,
sess: Session,
ast_map: ast_map::map,
def_map: resolve::DefMap,
it: @item,
it: &item,
_is_const: bool) {
match it.node {
item_static(_, _, ex) => {
@ -111,7 +110,7 @@ pub fn check_expr(v: &mut CheckCrateVisitor,
def_map: resolve::DefMap,
method_map: typeck::method_map,
tcx: ty::ctxt,
e: @Expr,
e: &Expr,
is_const: bool) {
if is_const {
match e.node {
@ -211,17 +210,12 @@ pub fn check_expr(v: &mut CheckCrateVisitor,
visit::walk_expr(v, e, is_const);
}
#[deriving(Clone)]
struct env {
root_it: @item,
struct CheckItemRecursionVisitor<'a> {
root_it: &'a item,
sess: Session,
ast_map: ast_map::map,
def_map: resolve::DefMap,
idstack: @RefCell<~[NodeId]>,
}
struct CheckItemRecursionVisitor {
env: env,
idstack: ~[NodeId]
}
// Make sure a const item doesn't recursively refer to itself
@ -229,44 +223,36 @@ struct CheckItemRecursionVisitor {
pub fn check_item_recursion(sess: Session,
ast_map: ast_map::map,
def_map: resolve::DefMap,
it: @item) {
let env = env {
it: &item) {
let mut visitor = CheckItemRecursionVisitor {
root_it: it,
sess: sess,
ast_map: ast_map,
def_map: def_map,
idstack: @RefCell::new(~[]),
idstack: ~[]
};
let mut visitor = CheckItemRecursionVisitor { env: env };
visitor.visit_item(it, ());
}
impl Visitor<()> for CheckItemRecursionVisitor {
fn visit_item(&mut self, it: @item, _: ()) {
{
let mut idstack = self.env.idstack.borrow_mut();
if idstack.get().iter().any(|x| x == &(it.id)) {
self.env.sess.span_fatal(self.env.root_it.span,
"recursive constant");
}
idstack.get().push(it.id);
impl<'a> Visitor<()> for CheckItemRecursionVisitor<'a> {
fn visit_item(&mut self, it: &item, _: ()) {
if self.idstack.iter().any(|x| x == &(it.id)) {
self.sess.span_fatal(self.root_it.span, "recursive constant");
}
self.idstack.push(it.id);
visit::walk_item(self, it, ());
{
let mut idstack = self.env.idstack.borrow_mut();
idstack.get().pop();
}
self.idstack.pop();
}
fn visit_expr(&mut self, e: @Expr, _: ()) {
fn visit_expr(&mut self, e: &Expr, _: ()) {
match e.node {
ExprPath(..) => {
let def_map = self.env.def_map.borrow();
let def_map = self.def_map.borrow();
match def_map.get().find(&e.id) {
Some(&DefStatic(def_id, _)) if
ast_util::is_local(def_id) => {
let ast_map = self.env.ast_map.borrow();
let ast_map = self.ast_map.borrow();
match ast_map.get().get_copy(&def_id.node) {
ast_map::node_item(it, _) => {
self.visit_item(it, ());

4
src/librustc/middle/check_loop.rs
View File

@ -29,11 +29,11 @@ pub fn check_crate(tcx: ty::ctxt, crate: &ast::Crate) {
}
impl Visitor<Context> for CheckLoopVisitor {
fn visit_item(&mut self, i: @ast::item, _cx: Context) {
fn visit_item(&mut self, i: &ast::item, _cx: Context) {
visit::walk_item(self, i, Normal);
}
fn visit_expr(&mut self, e: @ast::Expr, cx:Context) {
fn visit_expr(&mut self, e: &ast::Expr, cx:Context) {
match e.node {
ast::ExprWhile(e, b) => {
self.visit_expr(e, cx);

18
src/librustc/middle/check_match.rs
View File

@ -38,14 +38,14 @@ struct CheckMatchVisitor {
}
impl Visitor<()> for CheckMatchVisitor {
fn visit_expr(&mut self, ex:@Expr, e:()) {
check_expr(self, self.cx, ex, e);
fn visit_expr(&mut self, ex: &Expr, _: ()) {
check_expr(self, self.cx, ex, ());
}
fn visit_local(&mut self, l:@Local, e:()) {
check_local(self, self.cx, l, e);
fn visit_local(&mut self, l: &Local, _: ()) {
check_local(self, self.cx, l, ());
}
fn visit_fn(&mut self, fk:&fn_kind, fd:&fn_decl, b:P<Block>, s:Span, n:NodeId, e:()) {
check_fn(self, self.cx, fk, fd, b, s, n, e);
fn visit_fn(&mut self, fk: &fn_kind, fd: &fn_decl, b: &Block, s: Span, n: NodeId, _: ()) {
check_fn(self, self.cx, fk, fd, b, s, n, ());
}
}
@ -65,7 +65,7 @@ pub fn check_crate(tcx: ty::ctxt,
fn check_expr(v: &mut CheckMatchVisitor,
cx: @MatchCheckCtxt,
ex: @Expr,
ex: &Expr,
s: ()) {
visit::walk_expr(v, ex, s);
match ex.node {
@ -830,7 +830,7 @@ fn default(cx: &MatchCheckCtxt, r: &[@Pat]) -> Option<~[@Pat]> {
fn check_local(v: &mut CheckMatchVisitor,
cx: &MatchCheckCtxt,
loc: @Local,
loc: &Local,
s: ()) {
visit::walk_local(v, loc, s);
if is_refutable(cx, loc.pat) {
@ -846,7 +846,7 @@ fn check_fn(v: &mut CheckMatchVisitor,
cx: &MatchCheckCtxt,
kind: &visit::fn_kind,
decl: &fn_decl,
body: P<Block>,
body: &Block,
sp: Span,
id: NodeId,
s: ()) {

2
src/librustc/middle/const_eval.rs
View File

@ -296,7 +296,7 @@ impl ConstEvalVisitor {
}
impl Visitor<()> for ConstEvalVisitor {
fn visit_expr_post(&mut self, e:@Expr, _:()) {
fn visit_expr_post(&mut self, e: &Expr, _: ()) {
self.classify(e);
}
}

3
src/librustc/middle/dataflow.rs
View File

@ -753,7 +753,6 @@ impl<'a, O:DataFlowOperator> PropagationContext<'a, O> {
//! concern items that are going out of scope).
let tcx = self.tcx();
let region_maps = tcx.region_maps;
debug!("pop_scopes(from_expr={}, to_scope={:?}, in_out={})",
from_expr.repr(tcx), to_scope.loop_id,
@ -763,7 +762,7 @@ impl<'a, O:DataFlowOperator> PropagationContext<'a, O> {
while id != to_scope.loop_id {
self.dfcx.apply_kill(id, in_out);
match region_maps.opt_encl_scope(id) {
match tcx.region_maps.opt_encl_scope(id) {
Some(i) => { id = i; }
None => {
tcx.sess.span_bug(

16
src/librustc/middle/dead.rs
View File

@ -174,7 +174,7 @@ impl MarkSymbolVisitor {
impl Visitor<()> for MarkSymbolVisitor {
fn visit_expr(&mut self, expr: @ast::Expr, _: ()) {
fn visit_expr(&mut self, expr: &ast::Expr, _: ()) {
match expr.node {
ast::ExprMethodCall(..) => {
self.lookup_and_handle_method(&expr.id, expr.span);
@ -190,7 +190,7 @@ impl Visitor<()> for MarkSymbolVisitor {
visit::walk_path(self, path, ());
}
fn visit_item(&mut self, _item: @ast::item, _: ()) {
fn visit_item(&mut self, _item: &ast::item, _: ()) {
// Do not recurse into items. These items will be added to the
// worklist and recursed into manually if necessary.
}
@ -204,7 +204,7 @@ struct TraitMethodSeeder {
}
impl Visitor<()> for TraitMethodSeeder {
fn visit_item(&mut self, item: @ast::item, _: ()) {
fn visit_item(&mut self, item: &ast::item, _: ()) {
match item.node {
ast::item_impl(_, Some(ref _trait_ref), _, ref methods) => {
for method in methods.iter() {
@ -265,7 +265,7 @@ fn find_live(tcx: ty::ctxt,
symbol_visitor.live_symbols
}
fn should_warn(item: @ast::item) -> bool {
fn should_warn(item: &ast::item) -> bool {
match item.node {
ast::item_static(..)
| ast::item_fn(..)
@ -335,7 +335,7 @@ impl DeadVisitor {
}
impl Visitor<()> for DeadVisitor {
fn visit_item(&mut self, item: @ast::item, _: ()) {
fn visit_item(&mut self, item: &ast::item, _: ()) {
let ctor_id = get_struct_ctor_id(item);
if !self.symbol_is_live(item.id, ctor_id) && should_warn(item) {
self.warn_dead_code(item.id, item.span, &item.ident);
@ -343,7 +343,7 @@ impl Visitor<()> for DeadVisitor {
visit::walk_item(self, item, ());
}
fn visit_foreign_item(&mut self, fi: @ast::foreign_item, _: ()) {
fn visit_foreign_item(&mut self, fi: &ast::foreign_item, _: ()) {
if !self.symbol_is_live(fi.id, None) {
self.warn_dead_code(fi.id, fi.span, &fi.ident);
}
@ -351,7 +351,7 @@ impl Visitor<()> for DeadVisitor {
}
fn visit_fn(&mut self, fk: &visit::fn_kind,
_: &ast::fn_decl, block: ast::P<ast::Block>,
_: &ast::fn_decl, block: &ast::Block,
span: codemap::Span, id: ast::NodeId, _: ()) {
// Have to warn method here because methods are not ast::item
match *fk {
@ -367,7 +367,7 @@ impl Visitor<()> for DeadVisitor {
}
// Overwrite so that we don't warn the trait method itself.
fn visit_trait_method(&mut self, trait_method :&ast::trait_method, _: ()) {
fn visit_trait_method(&mut self, trait_method: &ast::trait_method, _: ()) {
match *trait_method {
ast::provided(method) => visit::walk_block(self, method.body, ()),
ast::required(_) => ()

6
src/librustc/middle/effect.rs
View File

@ -82,7 +82,7 @@ impl EffectCheckVisitor {
impl Visitor<()> for EffectCheckVisitor {
fn visit_fn(&mut self, fn_kind: &visit::fn_kind, fn_decl: &ast::fn_decl,
block: ast::P<ast::Block>, span: Span, node_id: ast::NodeId, _:()) {
block: &ast::Block, span: Span, node_id: ast::NodeId, _:()) {
let (is_item_fn, is_unsafe_fn) = match *fn_kind {
visit::fk_item_fn(_, _, purity, _) =>
@ -104,7 +104,7 @@ impl Visitor<()> for EffectCheckVisitor {
self.unsafe_context = old_unsafe_context
}
fn visit_block(&mut self, block: ast::P<ast::Block>, _:()) {
fn visit_block(&mut self, block: &ast::Block, _:()) {
let old_unsafe_context = self.unsafe_context;
let is_unsafe = match block.rules {
ast::UnsafeBlock(..) => true, ast::DefaultBlock => false
@ -118,7 +118,7 @@ impl Visitor<()> for EffectCheckVisitor {
self.unsafe_context = old_unsafe_context
}
fn visit_expr(&mut self, expr: @ast::Expr, _:()) {
fn visit_expr(&mut self, expr: &ast::Expr, _:()) {
match expr.node {
ast::ExprMethodCall(callee_id, _, _, _, _, _) => {
let base_type = ty::node_id_to_type(self.tcx, callee_id);

4
src/librustc/middle/entry.rs
View File

@ -39,7 +39,7 @@ struct EntryContext {
}
impl Visitor<()> for EntryContext {
fn visit_item(&mut self, item:@item, _:()) {
fn visit_item(&mut self, item: &item, _:()) {
find_item(item, self);
}
}
@ -70,7 +70,7 @@ pub fn find_entry_point(session: Session, crate: &Crate, ast_map: ast_map::map)
configure_main(&mut ctxt);
}
fn find_item(item: @item, ctxt: &mut EntryContext) {
fn find_item(item: &item, ctxt: &mut EntryContext) {
match item.node {
item_fn(..) => {
if item.ident.name == special_idents::main.name {

64
src/librustc/middle/freevars.rs
View File

@ -40,45 +40,44 @@ struct CollectFreevarsVisitor {
impl Visitor<int> for CollectFreevarsVisitor {
fn visit_item(&mut self, _:@item, _:int) {
fn visit_item(&mut self, _: &item, _: int) {
// ignore_item
}
fn visit_expr(&mut self, expr:@ast::Expr, depth:int) {
match expr.node {
ast::ExprFnBlock(..) | ast::ExprProc(..) => {
fn visit_expr(&mut self, expr: &ast::Expr, depth: int) {
match expr.node {
ast::ExprFnBlock(..) | ast::ExprProc(..) => {
visit::walk_expr(self, expr, depth + 1)
}
ast::ExprPath(..) | ast::ExprSelf => {
let mut i = 0;
let def_map = self.def_map.borrow();
match def_map.get().find(&expr.id) {
}
ast::ExprPath(..) | ast::ExprSelf => {
let mut i = 0;
let def_map = self.def_map.borrow();
match def_map.get().find(&expr.id) {
None => fail!("path not found"),
Some(&df) => {
let mut def = df;
while i < depth {
match def {
ast::DefUpvar(_, inner, _, _) => { def = *inner; }
_ => break
let mut def = df;
while i < depth {
match def {
ast::DefUpvar(_, inner, _, _) => { def = *inner; }
_ => break
}
i += 1;
}
i += 1;
}
if i == depth { // Made it to end of loop
let dnum = ast_util::def_id_of_def(def).node;
if !self.seen.contains_key(&dnum) {
self.refs.push(@freevar_entry {
def: def,
span: expr.span,
});
self.seen.insert(dnum, ());
if i == depth { // Made it to end of loop
let dnum = ast_util::def_id_of_def(def).node;
if !self.seen.contains_key(&dnum) {
self.refs.push(@freevar_entry {
def: def,
span: expr.span,
});
self.seen.insert(dnum, ());
}
}
}
}
}
}
_ => visit::walk_expr(self, expr, depth)
}
}
_ => visit::walk_expr(self, expr, depth)
}
}
@ -89,8 +88,7 @@ impl Visitor<int> for CollectFreevarsVisitor {
// Since we want to be able to collect upvars in some arbitrary piece
// of the AST, we take a walker function that we invoke with a visitor
// in order to start the search.
fn collect_freevars(def_map: resolve::DefMap, blk: ast::P<ast::Block>)
-> freevar_info {
fn collect_freevars(def_map: resolve::DefMap, blk: &ast::Block) -> freevar_info {
let seen = HashMap::new();
let refs = ~[];
@ -114,8 +112,8 @@ struct AnnotateFreevarsVisitor {
}
impl Visitor<()> for AnnotateFreevarsVisitor {
fn visit_fn(&mut self, fk:&visit::fn_kind, fd:&ast::fn_decl,
blk:ast::P<ast::Block>, s:Span, nid:ast::NodeId, _:()) {
fn visit_fn(&mut self, fk: &visit::fn_kind, fd: &ast::fn_decl,
blk: &ast::Block, s: Span, nid: ast::NodeId, _: ()) {
let vars = collect_freevars(self.def_map, blk);
self.freevars.insert(nid, vars);
visit::walk_fn(self, fk, fd, blk, s, nid, ());

17
src/librustc/middle/kind.rs
View File

@ -58,18 +58,19 @@ pub struct Context {
impl Visitor<()> for Context {
fn visit_expr(&mut self, ex:@Expr, _:()) {
fn visit_expr(&mut self, ex: &Expr, _: ()) {
check_expr(self, ex);
}
fn visit_fn(&mut self, fk:&visit::fn_kind, fd:&fn_decl, b:P<Block>, s:Span, n:NodeId, _:()) {
fn visit_fn(&mut self, fk: &visit::fn_kind, fd: &fn_decl,
b: &Block, s: Span, n: NodeId, _: ()) {
check_fn(self, fk, fd, b, s, n);
}
fn visit_ty(&mut self, t:&Ty, _:()) {
fn visit_ty(&mut self, t: &Ty, _: ()) {
check_ty(self, t);
}
fn visit_item(&mut self, i:@item, _:()) {
fn visit_item(&mut self, i: &item, _: ()) {
check_item(self, i);
}
}
@ -115,7 +116,7 @@ fn check_struct_safe_for_destructor(cx: &mut Context,
}
}
fn check_impl_of_trait(cx: &mut Context, it: @item, trait_ref: &trait_ref, self_type: &Ty) {
fn check_impl_of_trait(cx: &mut Context, it: &item, trait_ref: &trait_ref, self_type: &Ty) {
let def_map = cx.tcx.def_map.borrow();
let ast_trait_def = def_map.get()
.find(&trait_ref.ref_id)
@ -158,7 +159,7 @@ fn check_impl_of_trait(cx: &mut Context, it: @item, trait_ref: &trait_ref, self_
}
}
fn check_item(cx: &mut Context, item: @item) {
fn check_item(cx: &mut Context, item: &item) {
if !attr::contains_name(item.attrs, "unsafe_destructor") {
match item.node {
item_impl(_, Some(ref trait_ref), self_type, _) => {
@ -247,7 +248,7 @@ fn check_fn(
cx: &mut Context,
fk: &visit::fn_kind,
decl: &fn_decl,
body: P<Block>,
body: &Block,
sp: Span,
fn_id: NodeId) {
@ -262,7 +263,7 @@ fn check_fn(
visit::walk_fn(cx, fk, decl, body, sp, fn_id, ());
}
pub fn check_expr(cx: &mut Context, e: @Expr) {
pub fn check_expr(cx: &mut Context, e: &Expr) {
debug!("kind::check_expr({})", expr_to_str(e, cx.tcx.sess.intr()));
// Handle any kind bounds on type parameters

2
src/librustc/middle/lang_items.rs
View File

@ -109,7 +109,7 @@ struct LanguageItemVisitor<'a> {
}
impl<'a> Visitor<()> for LanguageItemVisitor<'a> {
fn visit_item(&mut self, item: @ast::item, _: ()) {
fn visit_item(&mut self, item: &ast::item, _: ()) {
match extract(item.attrs) {
Some(value) => {
let item_index = self.this.item_refs.find_equiv(&value).map(|x| *x);

12
src/librustc/middle/lint.rs
View File

@ -1303,7 +1303,7 @@ fn check_stability(cx: &Context, e: &ast::Expr) {
}
impl<'a> Visitor<()> for Context<'a> {
fn visit_item(&mut self, it: @ast::item, _: ()) {
fn visit_item(&mut self, it: &ast::item, _: ()) {
self.with_lint_attrs(it.attrs, |cx| {
check_item_ctypes(cx, it);
check_item_non_camel_case_types(cx, it);
@ -1318,7 +1318,7 @@ impl<'a> Visitor<()> for Context<'a> {
})
}
fn visit_foreign_item(&mut self, it: @ast::foreign_item, _: ()) {
fn visit_foreign_item(&mut self, it: &ast::foreign_item, _: ()) {
self.with_lint_attrs(it.attrs, |cx| {
check_attrs_usage(cx, it.attrs);
visit::walk_foreign_item(cx, it, ());
@ -1339,7 +1339,7 @@ impl<'a> Visitor<()> for Context<'a> {
visit::walk_pat(self, p, ());
}
fn visit_expr(&mut self, e: @ast::Expr, _: ()) {
fn visit_expr(&mut self, e: &ast::Expr, _: ()) {
match e.node {
ast::ExprUnary(_, ast::UnNeg, expr) => {
// propagate negation, if the negation itself isn't negated
@ -1365,14 +1365,14 @@ impl<'a> Visitor<()> for Context<'a> {
visit::walk_expr(self, e, ());
}
fn visit_stmt(&mut self, s: @ast::Stmt, _: ()) {
fn visit_stmt(&mut self, s: &ast::Stmt, _: ()) {
check_path_statement(self, s);
visit::walk_stmt(self, s, ());
}
fn visit_fn(&mut self, fk: &visit::fn_kind, decl: &ast::fn_decl,
body: ast::P<ast::Block>, span: Span, id: ast::NodeId, _: ()) {
body: &ast::Block, span: Span, id: ast::NodeId, _: ()) {
let recurse = |this: &mut Context| {
visit::walk_fn(this, fk, decl, body, span, id, ());
};
@ -1404,7 +1404,7 @@ impl<'a> Visitor<()> for Context<'a> {
}
fn visit_struct_def(&mut self,
s: @ast::struct_def,
s: &ast::struct_def,
i: ast::Ident,
g: &ast::Generics,
id: ast::NodeId,

26
src/librustc/middle/liveness.rs
View File

@ -164,12 +164,12 @@ fn live_node_kind_to_str(lnk: LiveNodeKind, cx: ty::ctxt) -> ~str {
struct LivenessVisitor;
impl Visitor<@IrMaps> for LivenessVisitor {
fn visit_fn(&mut self, fk:&fn_kind, fd:&fn_decl, b:P<Block>, s:Span, n:NodeId, e:@IrMaps) {
fn visit_fn(&mut self, fk: &fn_kind, fd: &fn_decl, b: &Block, s: Span, n: NodeId, e: @IrMaps) {
visit_fn(self, fk, fd, b, s, n, e);
}
fn visit_local(&mut self, l:@Local, e:@IrMaps) { visit_local(self, l, e); }
fn visit_expr(&mut self, ex:@Expr, e:@IrMaps) { visit_expr(self, ex, e); }
fn visit_arm(&mut self, a:&Arm, e:@IrMaps) { visit_arm(self, a, e); }
fn visit_local(&mut self, l: &Local, e: @IrMaps) { visit_local(self, l, e); }
fn visit_expr(&mut self, ex: &Expr, e: @IrMaps) { visit_expr(self, ex, e); }
fn visit_arm(&mut self, a: &Arm, e: @IrMaps) { visit_arm(self, a, e); }
}
pub fn check_crate(tcx: ty::ctxt,
@ -364,16 +364,16 @@ impl IrMaps {
}
impl Visitor<()> for Liveness {
fn visit_fn(&mut self, fk:&fn_kind, fd:&fn_decl, b:P<Block>, s:Span, n:NodeId, _:()) {
fn visit_fn(&mut self, fk: &fn_kind, fd: &fn_decl, b: &Block, s: Span, n: NodeId, _: ()) {
check_fn(self, fk, fd, b, s, n);
}
fn visit_local(&mut self, l:@Local, _:()) {
fn visit_local(&mut self, l: &Local, _: ()) {
check_local(self, l);
}
fn visit_expr(&mut self, ex:@Expr, _:()) {
fn visit_expr(&mut self, ex: &Expr, _: ()) {
check_expr(self, ex);
}
fn visit_arm(&mut self, a:&Arm, _:()) {
fn visit_arm(&mut self, a: &Arm, _: ()) {
check_arm(self, a);
}
}
@ -381,7 +381,7 @@ impl Visitor<()> for Liveness {
fn visit_fn(v: &mut LivenessVisitor,
fk: &visit::fn_kind,
decl: &fn_decl,
body: P<Block>,
body: &Block,
sp: Span,
id: NodeId,
this: @IrMaps) {
@ -443,7 +443,7 @@ fn visit_fn(v: &mut LivenessVisitor,
lsets.warn_about_unused_args(decl, entry_ln);
}
fn visit_local(v: &mut LivenessVisitor, local: @Local, this: @IrMaps) {
fn visit_local(v: &mut LivenessVisitor, local: &Local, this: @IrMaps) {
let def_map = this.tcx.def_map;
pat_util::pat_bindings(def_map, local.pat, |bm, p_id, sp, path| {
debug!("adding local variable {}", p_id);
@ -490,7 +490,7 @@ fn visit_arm(v: &mut LivenessVisitor, arm: &Arm, this: @IrMaps) {
visit::walk_arm(v, arm, this);
}
fn visit_expr(v: &mut LivenessVisitor, expr: @Expr, this: @IrMaps) {
fn visit_expr(v: &mut LivenessVisitor, expr: &Expr, this: @IrMaps) {
match expr.node {
// live nodes required for uses or definitions of variables:
ExprPath(_) | ExprSelf => {
@ -1472,7 +1472,7 @@ impl Liveness {
// _______________________________________________________________________
// Checking for error conditions
fn check_local(this: &mut Liveness, local: @Local) {
fn check_local(this: &mut Liveness, local: &Local) {
match local.init {
Some(_) => {
this.warn_about_unused_or_dead_vars_in_pat(local.pat);
@ -1508,7 +1508,7 @@ fn check_arm(this: &mut Liveness, arm: &Arm) {
visit::walk_arm(this, arm, ());
}
fn check_expr(this: &mut Liveness, expr: @Expr) {
fn check_expr(this: &mut Liveness, expr: &Expr) {
match expr.node {
ExprAssign(l, r) => {
this.check_lvalue(l);

42
src/librustc/middle/mem_categorization.rs
View File

@ -216,7 +216,7 @@ pub fn deref_kind(tcx: ty::ctxt, t: ty::t) -> deref_kind {
pub fn cat_expr(tcx: ty::ctxt,
method_map: typeck::method_map,
expr: @ast::Expr)
expr: &ast::Expr)
-> cmt {
let mcx = &mem_categorization_ctxt {
tcx: tcx, method_map: method_map
@ -226,7 +226,7 @@ pub fn cat_expr(tcx: ty::ctxt,
pub fn cat_expr_unadjusted(tcx: ty::ctxt,
method_map: typeck::method_map,
expr: @ast::Expr)
expr: &ast::Expr)
-> cmt {
let mcx = &mem_categorization_ctxt {
tcx: tcx, method_map: method_map
@ -237,7 +237,7 @@ pub fn cat_expr_unadjusted(tcx: ty::ctxt,
pub fn cat_expr_autoderefd(
tcx: ty::ctxt,
method_map: typeck::method_map,
expr: @ast::Expr,
expr: &ast::Expr,
autoderefs: uint) -> cmt
{
let mcx = &mem_categorization_ctxt {
@ -265,12 +265,12 @@ pub trait ast_node {
fn span(&self) -> Span;
}
impl ast_node for @ast::Expr {
impl ast_node for ast::Expr {
fn id(&self) -> ast::NodeId { self.id }
fn span(&self) -> Span { self.span }
}
impl ast_node for @ast::Pat {
impl ast_node for ast::Pat {
fn id(&self) -> ast::NodeId { self.id }
fn span(&self) -> Span { self.span }
}
@ -325,15 +325,15 @@ impl MutabilityCategory {
}
impl mem_categorization_ctxt {
pub fn expr_ty(&self, expr: @ast::Expr) -> ty::t {
pub fn expr_ty(&self, expr: &ast::Expr) -> ty::t {
ty::expr_ty(self.tcx, expr)
}
pub fn pat_ty(&self, pat: @ast::Pat) -> ty::t {
pub fn pat_ty(&self, pat: &ast::Pat) -> ty::t {
ty::node_id_to_type(self.tcx, pat.id)
}
pub fn cat_expr(&self, expr: @ast::Expr) -> cmt {
pub fn cat_expr(&self, expr: &ast::Expr) -> cmt {
let adjustments = self.tcx.adjustments.borrow();
match adjustments.get().find(&expr.id) {
None => {
@ -375,7 +375,7 @@ impl mem_categorization_ctxt {
}
}
pub fn cat_expr_autoderefd(&self, expr: @ast::Expr, autoderefs: uint)
pub fn cat_expr_autoderefd(&self, expr: &ast::Expr, autoderefs: uint)
-> cmt {
let mut cmt = self.cat_expr_unadjusted(expr);
for deref in range(1u, autoderefs + 1) {
@ -384,7 +384,7 @@ impl mem_categorization_ctxt {
return cmt;
}
pub fn cat_expr_unadjusted(&self, expr: @ast::Expr) -> cmt {
pub fn cat_expr_unadjusted(&self, expr: &ast::Expr) -> cmt {
debug!("cat_expr: id={} expr={}",
expr.id, pprust::expr_to_str(expr, self.tcx.sess.intr()));
@ -577,7 +577,7 @@ impl mem_categorization_ctxt {
}
pub fn cat_rvalue_node<N:ast_node>(&self,
node: N,
node: &N,
expr_ty: ty::t) -> cmt {
self.cat_rvalue(node.id(),
node.span(),
@ -614,7 +614,7 @@ impl mem_categorization_ctxt {
}
pub fn cat_field<N:ast_node>(&self,
node: N,
node: &N,
base_cmt: cmt,
f_name: ast::Ident,
f_ty: ty::t)
@ -629,7 +629,7 @@ impl mem_categorization_ctxt {
}
pub fn cat_deref_fn_or_obj<N:ast_node>(&self,
node: N,
node: &N,
base_cmt: cmt,
deref_cnt: uint)
-> cmt {
@ -644,7 +644,7 @@ impl mem_categorization_ctxt {
}
pub fn cat_deref<N:ast_node>(&self,
node: N,
node: &N,
base_cmt: cmt,
deref_cnt: uint)
-> cmt {
@ -662,7 +662,7 @@ impl mem_categorization_ctxt {
}
pub fn cat_deref_common<N:ast_node>(&self,
node: N,
node: &N,
base_cmt: cmt,
deref_cnt: uint,
deref_ty: ty::t)
@ -706,7 +706,7 @@ impl mem_categorization_ctxt {
}
pub fn cat_index<N:ast_node>(&self,
elt: N,
elt: &N,
base_cmt: cmt,
derefs: uint)
-> cmt {
@ -786,7 +786,7 @@ impl mem_categorization_ctxt {
}
};
fn interior<N: ast_node>(elt: N,
fn interior<N: ast_node>(elt: &N,
of_cmt: cmt,
vec_ty: ty::t,
mutbl: MutabilityCategory,
@ -803,7 +803,7 @@ impl mem_categorization_ctxt {
}
pub fn cat_imm_interior<N:ast_node>(&self,
node: N,
node: &N,
base_cmt: cmt,
interior_ty: ty::t,
interior: InteriorKind)
@ -818,7 +818,7 @@ impl mem_categorization_ctxt {
}
pub fn cat_downcast<N:ast_node>(&self,
node: N,
node: &N,
base_cmt: cmt,
downcast_ty: ty::t)
-> cmt {
@ -833,8 +833,8 @@ impl mem_categorization_ctxt {
pub fn cat_pattern(&self,
cmt: cmt,
pat: @ast::Pat,
op: |cmt, @ast::Pat|) {
pat: &ast::Pat,
op: |cmt, &ast::Pat|) {
// Here, `cmt` is the categorization for the value being
// matched and pat is the pattern it is being matched against.
//

18
src/librustc/middle/moves.rs
View File

@ -193,14 +193,14 @@ enum UseMode {
}
impl visit::Visitor<()> for VisitContext {
fn visit_fn(&mut self, fk:&visit::fn_kind, fd:&fn_decl,
b:P<Block>, s:Span, n:NodeId, _:()) {
fn visit_fn(&mut self, fk: &visit::fn_kind, fd: &fn_decl,
b: &Block, s: Span, n: NodeId, _: ()) {
compute_modes_for_fn(self, fk, fd, b, s, n);
}
fn visit_expr(&mut self, ex:@Expr, _:()) {
fn visit_expr(&mut self, ex: &Expr, _: ()) {
compute_modes_for_expr(self, ex);
}
fn visit_local(&mut self, l:@Local, _:()) {
fn visit_local(&mut self, l: &Local, _: ()) {
compute_modes_for_local(self, l);
}
// FIXME(#10894) should continue recursing
@ -240,7 +240,7 @@ pub fn moved_variable_node_id_from_def(def: Def) -> Option<NodeId> {
// Expressions
fn compute_modes_for_local<'a>(cx: &mut VisitContext,
local: @Local) {
local: &Local) {
cx.use_pat(local.pat);
for &init in local.init.iter() {
cx.use_expr(init, Read);
@ -250,7 +250,7 @@ fn compute_modes_for_local<'a>(cx: &mut VisitContext,
fn compute_modes_for_fn(cx: &mut VisitContext,
fk: &visit::fn_kind,
decl: &fn_decl,
body: P<Block>,
body: &Block,
span: Span,
id: NodeId) {
for a in decl.inputs.iter() {
@ -260,7 +260,7 @@ fn compute_modes_for_fn(cx: &mut VisitContext,
}
fn compute_modes_for_expr(cx: &mut VisitContext,
expr: @Expr)
expr: &Expr)
{
cx.consume_expr(expr);
}
@ -272,7 +272,7 @@ impl VisitContext {
}
}
pub fn consume_expr(&mut self, expr: @Expr) {
pub fn consume_expr(&mut self, expr: &Expr) {
/*!
* Indicates that the value of `expr` will be consumed,
* meaning either copied or moved depending on its type.
@ -311,7 +311,7 @@ impl VisitContext {
}
pub fn use_expr(&mut self,
expr: @Expr,
expr: &Expr,
expr_mode: UseMode) {
/*!
* Indicates that `expr` is used with a given mode. This will

26
src/librustc/middle/privacy.rs
View File

@ -45,7 +45,7 @@ struct ParentVisitor {
}
impl Visitor<()> for ParentVisitor {
fn visit_item(&mut self, item: @ast::item, _: ()) {
fn visit_item(&mut self, item: &ast::item, _: ()) {
self.parents.insert(item.id, self.curparent);
let prev = self.curparent;
@ -90,13 +90,13 @@ impl Visitor<()> for ParentVisitor {
self.curparent = prev;
}
fn visit_foreign_item(&mut self, a: @ast::foreign_item, _: ()) {
fn visit_foreign_item(&mut self, a: &ast::foreign_item, _: ()) {
self.parents.insert(a.id, self.curparent);
visit::walk_foreign_item(self, a, ());
}
fn visit_fn(&mut self, a: &visit::fn_kind, b: &ast::fn_decl,
c: ast::P<ast::Block>, d: Span, id: ast::NodeId, _: ()) {
c: &ast::Block, d: Span, id: ast::NodeId, _: ()) {
// We already took care of some trait methods above, otherwise things
// like impl methods and pub trait methods are parented to the
// containing module, not the containing trait.
@ -106,7 +106,7 @@ impl Visitor<()> for ParentVisitor {
visit::walk_fn(self, a, b, c, d, id, ());
}
fn visit_struct_def(&mut self, s: @ast::struct_def, i: ast::Ident,
fn visit_struct_def(&mut self, s: &ast::struct_def, i: ast::Ident,
g: &ast::Generics, n: ast::NodeId, _: ()) {
// Struct constructors are parented to their struct definitions because
// they essentially are the struct definitions.
@ -185,7 +185,7 @@ impl<'a> EmbargoVisitor<'a> {
}
impl<'a> Visitor<()> for EmbargoVisitor<'a> {
fn visit_item(&mut self, item: @ast::item, _: ()) {
fn visit_item(&mut self, item: &ast::item, _: ()) {
let orig_all_pub = self.prev_exported;
match item.node {
// impls/extern blocks do not break the "public chain" because they
@ -307,7 +307,7 @@ impl<'a> Visitor<()> for EmbargoVisitor<'a> {
self.prev_exported = orig_all_pub;
}
fn visit_foreign_item(&mut self, a: @ast::foreign_item, _: ()) {
fn visit_foreign_item(&mut self, a: &ast::foreign_item, _: ()) {
if self.prev_exported && a.vis == ast::public {
self.exported_items.insert(a.id);
}
@ -620,7 +620,7 @@ impl<'a> PrivacyVisitor<'a> {
}
impl<'a> Visitor<()> for PrivacyVisitor<'a> {
fn visit_item(&mut self, item: @ast::item, _: ()) {
fn visit_item(&mut self, item: &ast::item, _: ()) {
// Do not check privacy inside items with the resolve_unexported
// attribute. This is used for the test runner.
if attr::contains_name(item.attrs, "!resolve_unexported") {
@ -632,7 +632,7 @@ impl<'a> Visitor<()> for PrivacyVisitor<'a> {
self.curitem = orig_curitem;
}
fn visit_expr(&mut self, expr: @ast::Expr, _: ()) {
fn visit_expr(&mut self, expr: &ast::Expr, _: ()) {
match expr.node {
ast::ExprField(base, ident, _) => {
// Method calls are now a special syntactic form,
@ -778,7 +778,7 @@ impl<'a> Visitor<()> for PrivacyVisitor<'a> {
visit::walk_pat(self, pattern, ());
}
fn visit_foreign_item(&mut self, fi: @ast::foreign_item, _: ()) {
fn visit_foreign_item(&mut self, fi: &ast::foreign_item, _: ()) {
self.in_foreign = true;
visit::walk_foreign_item(self, fi, ());
self.in_foreign = false;
@ -800,7 +800,7 @@ struct SanePrivacyVisitor {
}
impl Visitor<()> for SanePrivacyVisitor {
fn visit_item(&mut self, item: @ast::item, _: ()) {
fn visit_item(&mut self, item: &ast::item, _: ()) {
if self.in_fn {
self.check_all_inherited(item);
} else {
@ -816,7 +816,7 @@ impl Visitor<()> for SanePrivacyVisitor {
}
fn visit_fn(&mut self, fk: &visit::fn_kind, fd: &ast::fn_decl,
b: ast::P<ast::Block>, s: Span, n: ast::NodeId, _: ()) {
b: &ast::Block, s: Span, n: ast::NodeId, _: ()) {
// This catches both functions and methods
let orig_in_fn = util::replace(&mut self.in_fn, true);
visit::walk_fn(self, fk, fd, b, s, n, ());
@ -829,7 +829,7 @@ impl SanePrivacyVisitor {
/// ensures that there are no extraneous qualifiers that don't actually do
/// anything. In theory these qualifiers wouldn't parse, but that may happen
/// later on down the road...
fn check_sane_privacy(&self, item: @ast::item) {
fn check_sane_privacy(&self, item: &ast::item) {
let tcx = self.tcx;
let check_inherited = |sp: Span, vis: ast::visibility, note: &str| {
if vis != ast::inherited {
@ -941,7 +941,7 @@ impl SanePrivacyVisitor {
/// When inside of something like a function or a method, visibility has no
/// control over anything so this forbids any mention of any visibility
fn check_all_inherited(&self, item: @ast::item) {
fn check_all_inherited(&self, item: &ast::item) {
let tcx = self.tcx;
let check_inherited = |sp: Span, vis: ast::visibility| {
if vis != ast::inherited {

6
src/librustc/middle/reachable.rs
View File

@ -44,7 +44,7 @@ fn generics_require_inlining(generics: &ast::Generics) -> bool {
// Returns true if the given item must be inlined because it may be
// monomorphized or it was marked with `#[inline]`. This will only return
// true for functions.
fn item_might_be_inlined(item: @ast::item) -> bool {
fn item_might_be_inlined(item: &ast::item) -> bool {
if attributes_specify_inlining(item.attrs) {
return true
}
@ -105,7 +105,7 @@ struct MarkSymbolVisitor {
impl Visitor<()> for MarkSymbolVisitor {
fn visit_expr(&mut self, expr:@ast::Expr, _:()) {
fn visit_expr(&mut self, expr: &ast::Expr, _: ()) {
match expr.node {
ast::ExprPath(_) => {
@ -187,7 +187,7 @@ impl Visitor<()> for MarkSymbolVisitor {
visit::walk_expr(self, expr, ())
}
fn visit_item(&mut self, _item: @ast::item, _: ()) {
fn visit_item(&mut self, _item: &ast::item, _: ()) {
// Do not recurse into items. These items will be added to the worklist
// and recursed into manually if necessary.
}

51
src/librustc/middle/region.rs
View File

@ -30,7 +30,7 @@ use std::hashmap::{HashMap, HashSet};
use syntax::codemap::Span;
use syntax::{ast, visit};
use syntax::visit::{Visitor,fn_kind};
use syntax::ast::{P,Block,item,fn_decl,NodeId,Arm,Pat,Stmt,Expr,Local};
use syntax::ast::{Block,item,fn_decl,NodeId,Arm,Pat,Stmt,Expr,Local};
/**
The region maps encode information about region relationships.
@ -69,7 +69,7 @@ struct RegionResolutionVisitor {
sess: Session,
// Generated maps:
region_maps: @RegionMaps,
region_maps: RegionMaps,
}
@ -333,7 +333,7 @@ fn parent_to_expr(visitor: &mut RegionResolutionVisitor,
}
fn resolve_block(visitor: &mut RegionResolutionVisitor,
blk: ast::P<ast::Block>,
blk: &ast::Block,
cx: Context) {
// Record the parent of this block.
parent_to_expr(visitor, cx, blk.id, blk.span);
@ -359,7 +359,7 @@ fn resolve_pat(visitor: &mut RegionResolutionVisitor,
}
fn resolve_stmt(visitor: &mut RegionResolutionVisitor,
stmt: @ast::Stmt,
stmt: &ast::Stmt,
cx: Context) {
match stmt.node {
ast::StmtDecl(..) => {
@ -376,7 +376,7 @@ fn resolve_stmt(visitor: &mut RegionResolutionVisitor,
}
fn resolve_expr(visitor: &mut RegionResolutionVisitor,
expr: @ast::Expr,
expr: &ast::Expr,
cx: Context) {
parent_to_expr(visitor, cx, expr.id, expr.span);
@ -417,7 +417,7 @@ fn resolve_expr(visitor: &mut RegionResolutionVisitor,
}
fn resolve_local(visitor: &mut RegionResolutionVisitor,
local: @ast::Local,
local: &ast::Local,
cx: Context) {
assert_eq!(cx.var_parent, cx.parent);
parent_to_expr(visitor, cx, local.id, local.span);
@ -425,7 +425,7 @@ fn resolve_local(visitor: &mut RegionResolutionVisitor,
}
fn resolve_item(visitor: &mut RegionResolutionVisitor,
item: @ast::item,
item: &ast::item,
cx: Context) {
// Items create a new outer block scope as far as we're concerned.
let new_cx = Context {var_parent: None, parent: None, ..cx};
@ -435,7 +435,7 @@ fn resolve_item(visitor: &mut RegionResolutionVisitor,
fn resolve_fn(visitor: &mut RegionResolutionVisitor,
fk: &visit::fn_kind,
decl: &ast::fn_decl,
body: ast::P<ast::Block>,
body: &ast::Block,
sp: Span,
id: ast::NodeId,
cx: Context) {
@ -476,47 +476,46 @@ fn resolve_fn(visitor: &mut RegionResolutionVisitor,
impl Visitor<Context> for RegionResolutionVisitor {
fn visit_block(&mut self, b:P<Block>, cx:Context) {
fn visit_block(&mut self, b: &Block, cx: Context) {
resolve_block(self, b, cx);
}
fn visit_item(&mut self, i:@item, cx:Context) {
fn visit_item(&mut self, i: &item, cx: Context) {
resolve_item(self, i, cx);
}
fn visit_fn(&mut self, fk:&fn_kind, fd:&fn_decl, b:P<Block>, s:Span, n:NodeId, cx:Context) {
fn visit_fn(&mut self, fk: &fn_kind, fd: &fn_decl,
b: &Block, s: Span, n: NodeId, cx: Context) {
resolve_fn(self, fk, fd, b, s, n, cx);
}
fn visit_arm(&mut self, a:&Arm, cx:Context) {
fn visit_arm(&mut self, a: &Arm, cx: Context) {
resolve_arm(self, a, cx);
}
fn visit_pat(&mut self, p:&Pat, cx:Context) {
fn visit_pat(&mut self, p: &Pat, cx: Context) {
resolve_pat(self, p, cx);
}
fn visit_stmt(&mut self, s:@Stmt, cx:Context) {
fn visit_stmt(&mut self, s: &Stmt, cx: Context) {
resolve_stmt(self, s, cx);
}
fn visit_expr(&mut self, ex:@Expr, cx:Context) {
fn visit_expr(&mut self, ex: &Expr, cx: Context) {
resolve_expr(self, ex, cx);
}
fn visit_local(&mut self, l:@Local, cx:Context) {
fn visit_local(&mut self, l: &Local, cx: Context) {
resolve_local(self, l, cx);
}
}
pub fn resolve_crate(sess: Session, crate: &ast::Crate) -> @RegionMaps {
let region_maps = @RegionMaps {
scope_map: RefCell::new(HashMap::new()),
free_region_map: RefCell::new(HashMap::new()),
cleanup_scopes: RefCell::new(HashSet::new()),
};
let cx = Context {parent: None,
var_parent: None};
pub fn resolve_crate(sess: Session, crate: &ast::Crate) -> RegionMaps {
let mut visitor = RegionResolutionVisitor {
sess: sess,
region_maps: region_maps,
region_maps: RegionMaps {
scope_map: RefCell::new(HashMap::new()),
free_region_map: RefCell::new(HashMap::new()),
cleanup_scopes: RefCell::new(HashSet::new())
}
};
let cx = Context { parent: None, var_parent: None };
visit::walk_crate(&mut visitor, crate, cx);
return region_maps;
return visitor.region_maps;
}

39
src/librustc/middle/resolve.rs
View File

@ -137,22 +137,22 @@ enum SelfBinding {
}
impl Visitor<()> for Resolver {
fn visit_item(&mut self, item:@item, _:()) {
fn visit_item(&mut self, item: &item, _: ()) {
self.resolve_item(item);
}
fn visit_arm(&mut self, arm:&Arm, _:()) {
fn visit_arm(&mut self, arm: &Arm, _: ()) {
self.resolve_arm(arm);
}
fn visit_block(&mut self, block:P<Block>, _:()) {
fn visit_block(&mut self, block: &Block, _: ()) {
self.resolve_block(block);
}
fn visit_expr(&mut self, expr:@Expr, _:()) {
fn visit_expr(&mut self, expr: &Expr, _: ()) {
self.resolve_expr(expr);
}
fn visit_local(&mut self, local:@Local, _:()) {
fn visit_local(&mut self, local: &Local, _: ()) {
self.resolve_local(local);
}
fn visit_ty(&mut self, ty:&Ty, _:()) {
fn visit_ty(&mut self, ty: &Ty, _: ()) {
self.resolve_type(ty);
}
}
@ -898,13 +898,13 @@ struct BuildReducedGraphVisitor<'a> {
impl<'a> Visitor<ReducedGraphParent> for BuildReducedGraphVisitor<'a> {
fn visit_item(&mut self, item:@item, context:ReducedGraphParent) {
fn visit_item(&mut self, item: &item, context: ReducedGraphParent) {
let p = self.resolver.build_reduced_graph_for_item(item, context);
visit::walk_item(self, item, p);
}
fn visit_foreign_item(&mut self, foreign_item: @foreign_item,
context:ReducedGraphParent) {
fn visit_foreign_item(&mut self, foreign_item: &foreign_item,
context: ReducedGraphParent) {
self.resolver.build_reduced_graph_for_foreign_item(foreign_item,
context,
|r, c| {
@ -913,11 +913,11 @@ impl<'a> Visitor<ReducedGraphParent> for BuildReducedGraphVisitor<'a> {
})
}
fn visit_view_item(&mut self, view_item:&view_item, context:ReducedGraphParent) {
fn visit_view_item(&mut self, view_item: &view_item, context: ReducedGraphParent) {
self.resolver.build_reduced_graph_for_view_item(view_item, context);
}
fn visit_block(&mut self, block:P<Block>, context:ReducedGraphParent) {
fn visit_block(&mut self, block: &Block, context: ReducedGraphParent) {
let np = self.resolver.build_reduced_graph_for_block(block, context);
visit::walk_block(self, block, np);
}
@ -927,7 +927,7 @@ impl<'a> Visitor<ReducedGraphParent> for BuildReducedGraphVisitor<'a> {
struct UnusedImportCheckVisitor<'a> { resolver: &'a Resolver }
impl<'a> Visitor<()> for UnusedImportCheckVisitor<'a> {
fn visit_view_item(&mut self, vi:&view_item, _:()) {
fn visit_view_item(&mut self, vi: &view_item, _: ()) {
self.resolver.check_for_item_unused_imports(vi);
visit::walk_view_item(self, vi, ());
}
@ -1141,7 +1141,7 @@ impl Resolver {
/// Constructs the reduced graph for one item.
fn build_reduced_graph_for_item(&mut self,
item: @item,
item: &item,
parent: ReducedGraphParent)
-> ReducedGraphParent
{
@ -1550,7 +1550,7 @@ impl Resolver {
/// Constructs the reduced graph for one foreign item.
fn build_reduced_graph_for_foreign_item(&mut self,
foreign_item: @foreign_item,
foreign_item: &foreign_item,
parent: ReducedGraphParent,
f: |&mut Resolver,
ReducedGraphParent|) {
@ -3633,7 +3633,7 @@ impl Resolver {
visit::walk_crate(self, crate, ());
}
fn resolve_item(&mut self, item: @item) {
fn resolve_item(&mut self, item: &item) {
debug!("(resolving item) resolving {}",
self.session.str_of(item.ident));
@ -4170,7 +4170,7 @@ impl Resolver {
visit::walk_mod(self, module_, ());
}
fn resolve_local(&mut self, local: @Local) {
fn resolve_local(&mut self, local: &Local) {
// Resolve the type.
self.resolve_type(local.ty);
@ -4268,7 +4268,7 @@ impl Resolver {
value_ribs.get().pop();
}
fn resolve_block(&mut self, block: P<Block>) {
fn resolve_block(&mut self, block: &Block) {
debug!("(resolving block) entering block");
{
let mut value_ribs = self.value_ribs.borrow_mut();
@ -5152,7 +5152,7 @@ impl Resolver {
}
}
fn resolve_expr(&mut self, expr: @Expr) {
fn resolve_expr(&mut self, expr: &Expr) {
// First, record candidate traits for this expression if it could
// result in the invocation of a method call.
@ -5324,8 +5324,7 @@ impl Resolver {
}
}
fn record_candidate_traits_for_expr_if_necessary(&mut self,
expr: @Expr) {
fn record_candidate_traits_for_expr_if_necessary(&mut self, expr: &Expr) {
match expr.node {
ExprField(_, ident, _) => {
// FIXME(#6890): Even though you can't treat a method like a

6
src/librustc/middle/resolve_lifetime.rs
View File

@ -57,7 +57,7 @@ pub fn crate(sess: session::Session, crate: &ast::Crate)
impl<'a> Visitor<&'a ScopeChain<'a>> for LifetimeContext {
fn visit_item(&mut self,
item: @ast::item,
item: &ast::item,
_: &'a ScopeChain<'a>) {
let scope = match item.node {
ast::item_fn(..) | // fn lifetimes get added in visit_fn below
@ -84,7 +84,7 @@ impl<'a> Visitor<&'a ScopeChain<'a>> for LifetimeContext {
fn visit_fn(&mut self,
fk: &visit::fn_kind,
fd: &ast::fn_decl,
b: ast::P<ast::Block>,
b: &ast::Block,
s: Span,
n: ast::NodeId,
scope: &'a ScopeChain<'a>) {
@ -132,7 +132,7 @@ impl<'a> Visitor<&'a ScopeChain<'a>> for LifetimeContext {
}
fn visit_block(&mut self,
b: ast::P<ast::Block>,
b: &ast::Block,
scope: &'a ScopeChain<'a>) {
let scope1 = BlockScope(b.id, scope);
debug!("pushing block scope {}", b.id);

2
src/librustc/middle/trans/base.rs
View File

@ -2203,7 +2203,7 @@ pub struct TransItemVisitor {
}
impl Visitor<()> for TransItemVisitor {
fn visit_item(&mut self, i: @ast::item, _:()) {
fn visit_item(&mut self, i: &ast::item, _:()) {
trans_item(self.ccx, i);
}
}

2
src/librustc/middle/trans/debuginfo.rs
View File

@ -331,7 +331,7 @@ pub fn create_captured_var_metadata(bcx: @Block,
None => {
cx.sess.span_bug(span, "debuginfo::create_captured_var_metadata() - NodeId not found");
}
Some(ast_map::node_local(ident)) => ident,
Some(ast_map::node_local(ident, _)) => ident,
Some(ast_map::node_arg(@ast::Pat { node: ast::PatIdent(_, ref path, _), .. })) => {
ast_util::path_to_ident(path)
}

4
src/librustc/middle/ty.rs
View File

@ -276,7 +276,7 @@ struct ctxt_ {
named_region_map: @RefCell<resolve_lifetime::NamedRegionMap>,
region_maps: @middle::region::RegionMaps,
region_maps: middle::region::RegionMaps,
// Stores the types for various nodes in the AST. Note that this table
// is not guaranteed to be populated until after typeck. See
@ -966,7 +966,7 @@ pub fn mk_ctxt(s: session::Session,
named_region_map: @RefCell<resolve_lifetime::NamedRegionMap>,
amap: ast_map::map,
freevars: freevars::freevar_map,
region_maps: @middle::region::RegionMaps,
region_maps: middle::region::RegionMaps,
lang_items: middle::lang_items::LanguageItems)
-> ctxt {
@ctxt_ {

10
src/librustc/middle/typeck/check/_match.rs
View File

@ -26,8 +26,8 @@ use syntax::codemap::Span;
use syntax::print::pprust;
pub fn check_match(fcx: @FnCtxt,
expr: @ast::Expr,
discrim: @ast::Expr,
expr: &ast::Expr,
discrim: &ast::Expr,
arms: &[ast::Arm]) {
let tcx = fcx.ccx.tcx;
@ -106,7 +106,7 @@ pub struct pat_ctxt {
map: PatIdMap,
}
pub fn check_pat_variant(pcx: &pat_ctxt, pat: @ast::Pat, path: &ast::Path,
pub fn check_pat_variant(pcx: &pat_ctxt, pat: &ast::Pat, path: &ast::Path,
subpats: &Option<~[@ast::Pat]>, expected: ty::t) {
// Typecheck the path.
@ -418,7 +418,7 @@ pub fn check_struct_like_enum_variant_pat(pcx: &pat_ctxt,
// Pattern checking is top-down rather than bottom-up so that bindings get
// their types immediately.
pub fn check_pat(pcx: &pat_ctxt, pat: @ast::Pat, expected: ty::t) {
pub fn check_pat(pcx: &pat_ctxt, pat: &ast::Pat, expected: ty::t) {
let fcx = pcx.fcx;
let tcx = pcx.fcx.ccx.tcx;
@ -662,7 +662,7 @@ pub fn check_pat(pcx: &pat_ctxt, pat: @ast::Pat, expected: ty::t) {
// Helper function to check @, ~ and & patterns
pub fn check_pointer_pat(pcx: &pat_ctxt,
pointer_kind: PointerKind,
inner: @ast::Pat,
inner: &ast::Pat,
pat_id: ast::NodeId,
span: Span,
expected: ty::t) {

2
src/librustc/middle/typeck/check/demand.rs
View File

@ -56,7 +56,7 @@ pub fn eqtype(fcx: @FnCtxt, sp: Span, expected: ty::t, actual: ty::t) {
}
// Checks that the type `actual` can be coerced to `expected`.
pub fn coerce(fcx: @FnCtxt, sp: Span, expected: ty::t, expr: @ast::Expr) {
pub fn coerce(fcx: @FnCtxt, sp: Span, expected: ty::t, expr: &ast::Expr) {
let expr_ty = fcx.expr_ty(expr);
match fcx.mk_assignty(expr, expr_ty, expected) {
result::Ok(()) => { /* ok */ }

8
src/librustc/middle/typeck/check/method.rs
View File

@ -122,8 +122,8 @@ pub fn lookup(
fcx: @FnCtxt,
// In a call `a.b::<X, Y, ...>(...)`:
expr: @ast::Expr, // The expression `a.b(...)`.
self_expr: @ast::Expr, // The expression `a`.
expr: &ast::Expr, // The expression `a.b(...)`.
self_expr: &ast::Expr, // The expression `a`.
callee_id: NodeId, /* Where to store `a.b`'s type,
* also the scope of the call */
m_name: ast::Name, // The name `b`.
@ -170,8 +170,8 @@ pub fn lookup(
pub struct LookupContext<'a> {
fcx: @FnCtxt,
expr: @ast::Expr,
self_expr: @ast::Expr,
expr: &'a ast::Expr,
self_expr: &'a ast::Expr,
callee_id: NodeId,
m_name: ast::Name,
supplied_tps: &'a [ty::t],

114
src/librustc/middle/typeck/check/mod.rs
View File

@ -305,7 +305,7 @@ impl ExprTyProvider for FnCtxt {
struct CheckItemTypesVisitor { ccx: @CrateCtxt }
impl Visitor<()> for CheckItemTypesVisitor {
fn visit_item(&mut self, i:@ast::item, _:()) {
fn visit_item(&mut self, i: &ast::item, _: ()) {
check_item(self.ccx, i);
visit::walk_item(self, i, ());
}
@ -318,7 +318,7 @@ pub fn check_item_types(ccx: @CrateCtxt, crate: &ast::Crate) {
pub fn check_bare_fn(ccx: @CrateCtxt,
decl: &ast::fn_decl,
body: ast::P<ast::Block>,
body: &ast::Block,
id: ast::NodeId,
self_info: Option<SelfInfo>,
fty: ty::t,
@ -365,7 +365,7 @@ impl GatherLocalsVisitor {
impl Visitor<()> for GatherLocalsVisitor {
// Add explicitly-declared locals.
fn visit_local(&mut self, local:@ast::Local, _:()) {
fn visit_local(&mut self, local: &ast::Local, _: ()) {
let o_ty = match local.ty.node {
ast::ty_infer => None,
_ => Some(self.fcx.to_ty(local.ty))
@ -382,7 +382,7 @@ impl Visitor<()> for GatherLocalsVisitor {
}
// Add pattern bindings.
fn visit_pat(&mut self, p:&ast::Pat, _:()) {
fn visit_pat(&mut self, p: &ast::Pat, _: ()) {
match p.node {
ast::PatIdent(_, ref path, _)
if pat_util::pat_is_binding(self.fcx.ccx.tcx.def_map, p) => {
@ -401,17 +401,17 @@ impl Visitor<()> for GatherLocalsVisitor {
}
fn visit_block(&mut self, b:ast::P<ast::Block>, _:()) {
fn visit_block(&mut self, b: &ast::Block, _: ()) {
// non-obvious: the `blk` variable maps to region lb, so
// we have to keep this up-to-date. This
// is... unfortunate. It'd be nice to not need this.
self.fcx.with_region_lb(b.id, || visit::walk_block(self, b, ()));
}
// Don't descend into fns and items
fn visit_fn(&mut self, _:&visit::fn_kind, _:&ast::fn_decl,
_:ast::P<ast::Block>, _:Span, _:ast::NodeId, _:()) { }
fn visit_item(&mut self, _:@ast::item, _:()) { }
// Don't descend into fns and items
fn visit_fn(&mut self, _: &visit::fn_kind, _: &ast::fn_decl,
_: &ast::Block, _: Span, _: ast::NodeId, _: ()) { }
fn visit_item(&mut self, _: &ast::item, _: ()) { }
}
@ -421,7 +421,7 @@ pub fn check_fn(ccx: @CrateCtxt,
fn_sig: &ty::FnSig,
decl: &ast::fn_decl,
id: ast::NodeId,
body: ast::P<ast::Block>,
body: &ast::Block,
fn_kind: FnKind,
inherited: @Inherited) -> @FnCtxt
{
@ -507,7 +507,7 @@ pub fn check_fn(ccx: @CrateCtxt,
fn gather_locals(fcx: @FnCtxt,
decl: &ast::fn_decl,
body: ast::P<ast::Block>,
body: &ast::Block,
arg_tys: &[ty::t],
opt_self_info: Option<SelfInfo>) {
let tcx = fcx.ccx.tcx;
@ -576,7 +576,7 @@ pub fn check_struct(ccx: @CrateCtxt, id: ast::NodeId, span: Span) {
}
}
pub fn check_item(ccx: @CrateCtxt, it: @ast::item) {
pub fn check_item(ccx: @CrateCtxt, it: &ast::item) {
debug!("check_item(it.id={}, it.ident={})",
it.id,
ty::item_path_str(ccx.tcx, local_def(it.id)));
@ -682,7 +682,7 @@ pub fn check_item(ccx: @CrateCtxt, it: @ast::item) {
fn check_method_body(ccx: @CrateCtxt,
item_generics: &ty::Generics,
self_bound: Option<@ty::TraitRef>,
method: @ast::method) {
method: &ast::method) {
/*!
* Type checks a method body.
*
@ -1166,7 +1166,7 @@ impl FnCtxt {
ast_ty_to_ty(self, &self.infcx(), ast_t)
}
pub fn pat_to_str(&self, pat: @ast::Pat) -> ~str {
pub fn pat_to_str(&self, pat: &ast::Pat) -> ~str {
pat.repr(self.tcx())
}
@ -1236,13 +1236,13 @@ impl FnCtxt {
}
pub fn mk_assignty(&self,
expr: @ast::Expr,
expr: &ast::Expr,
sub: ty::t,
sup: ty::t)
-> Result<(), ty::type_err> {
match infer::mk_coercety(self.infcx(),
false,
infer::ExprAssignable(expr),
infer::ExprAssignable(expr.span),
sub,
sup) {
Ok(None) => result::Ok(()),
@ -1378,7 +1378,7 @@ pub fn do_autoderef(fcx: @FnCtxt, sp: Span, t: ty::t) -> (ty::t, uint) {
}
// AST fragment checking
pub fn check_lit(fcx: @FnCtxt, lit: @ast::lit) -> ty::t {
pub fn check_lit(fcx: @FnCtxt, lit: &ast::lit) -> ty::t {
let tcx = fcx.ccx.tcx;
match lit.node {
@ -1407,8 +1407,8 @@ pub fn check_lit(fcx: @FnCtxt, lit: @ast::lit) -> ty::t {
}
pub fn valid_range_bounds(ccx: @CrateCtxt,
from: @ast::Expr,
to: @ast::Expr)
from: &ast::Expr,
to: &ast::Expr)
-> Option<bool> {
match const_eval::compare_lit_exprs(ccx.tcx, from, to) {
Some(val) => Some(val <= 0),
@ -1417,7 +1417,7 @@ pub fn valid_range_bounds(ccx: @CrateCtxt,
}
pub fn check_expr_has_type(
fcx: @FnCtxt, expr: @ast::Expr,
fcx: @FnCtxt, expr: &ast::Expr,
expected: ty::t) {
check_expr_with_unifier(fcx, expr, Some(expected), || {
demand::suptype(fcx, expr.span, expected, fcx.expr_ty(expr));
@ -1425,7 +1425,7 @@ pub fn check_expr_has_type(
}
pub fn check_expr_coercable_to_type(
fcx: @FnCtxt, expr: @ast::Expr,
fcx: @FnCtxt, expr: &ast::Expr,
expected: ty::t) {
check_expr_with_unifier(fcx, expr, Some(expected), || {
demand::coerce(fcx, expr.span, expected, expr)
@ -1433,18 +1433,18 @@ pub fn check_expr_coercable_to_type(
}
pub fn check_expr_with_hint(
fcx: @FnCtxt, expr: @ast::Expr,
fcx: @FnCtxt, expr: &ast::Expr,
expected: ty::t) {
check_expr_with_unifier(fcx, expr, Some(expected), || ())
}
pub fn check_expr_with_opt_hint(
fcx: @FnCtxt, expr: @ast::Expr,
fcx: @FnCtxt, expr: &ast::Expr,
expected: Option<ty::t>) {
check_expr_with_unifier(fcx, expr, expected, || ())
}
pub fn check_expr(fcx: @FnCtxt, expr: @ast::Expr) {
pub fn check_expr(fcx: @FnCtxt, expr: &ast::Expr) {
check_expr_with_unifier(fcx, expr, None, || ())
}
@ -1651,7 +1651,7 @@ fn check_type_parameter_positions_in_path(function_context: @FnCtxt,
/// that there are actually multiple representations for both `ty_err` and
/// `ty_bot`, so avoid that when err and bot need to be handled differently.
pub fn check_expr_with_unifier(fcx: @FnCtxt,
expr: @ast::Expr,
expr: &ast::Expr,
expected: Option<ty::t>,
unifier: ||) {
debug!(">> typechecking");
@ -1660,7 +1660,7 @@ pub fn check_expr_with_unifier(fcx: @FnCtxt,
fcx: @FnCtxt,
sp: Span,
method_fn_ty: ty::t,
callee_expr: @ast::Expr,
callee_expr: &ast::Expr,
args: &[@ast::Expr],
sugar: ast::CallSugar,
deref_args: DerefArgs) -> ty::t
@ -1689,7 +1689,7 @@ pub fn check_expr_with_unifier(fcx: @FnCtxt,
fn check_argument_types(fcx: @FnCtxt,
sp: Span,
fn_inputs: &[ty::t],
callee_expr: @ast::Expr,
callee_expr: &ast::Expr,
args: &[@ast::Expr],
sugar: ast::CallSugar,
deref_args: DerefArgs,
@ -1842,8 +1842,8 @@ pub fn check_expr_with_unifier(fcx: @FnCtxt,
// A generic function for checking assignment expressions
fn check_assignment(fcx: @FnCtxt,
lhs: @ast::Expr,
rhs: @ast::Expr,
lhs: &ast::Expr,
rhs: &ast::Expr,
id: ast::NodeId) {
check_expr(fcx, lhs);
let lhs_type = fcx.expr_ty(lhs);
@ -1853,7 +1853,7 @@ pub fn check_expr_with_unifier(fcx: @FnCtxt,
}
fn write_call(fcx: @FnCtxt,
call_expr: @ast::Expr,
call_expr: &ast::Expr,
output: ty::t,
sugar: ast::CallSugar) {
let ret_ty = match sugar {
@ -1875,8 +1875,8 @@ pub fn check_expr_with_unifier(fcx: @FnCtxt,
// A generic function for doing all of the checking for call expressions
fn check_call(fcx: @FnCtxt,
callee_id: ast::NodeId,
call_expr: @ast::Expr,
f: @ast::Expr,
call_expr: &ast::Expr,
f: &ast::Expr,
args: &[@ast::Expr],
sugar: ast::CallSugar) {
// Index expressions need to be handled separately, to inform them
@ -1937,8 +1937,8 @@ pub fn check_expr_with_unifier(fcx: @FnCtxt,
// Checks a method call.
fn check_method_call(fcx: @FnCtxt,
callee_id: ast::NodeId,
expr: @ast::Expr,
rcvr: @ast::Expr,
expr: &ast::Expr,
rcvr: &ast::Expr,
method_name: ast::Ident,
args: &[@ast::Expr],
tps: &[ast::P<ast::Ty>],
@ -1997,7 +1997,7 @@ pub fn check_expr_with_unifier(fcx: @FnCtxt,
// A generic function for checking the then and else in an if
// or if-check
fn check_then_else(fcx: @FnCtxt,
cond_expr: @ast::Expr,
cond_expr: &ast::Expr,
then_blk: &ast::Block,
opt_else_expr: Option<@ast::Expr>,
id: ast::NodeId,
@ -2037,11 +2037,11 @@ pub fn check_expr_with_unifier(fcx: @FnCtxt,
fn lookup_op_method(fcx: @FnCtxt,
callee_id: ast::NodeId,
op_ex: @ast::Expr,
self_ex: @ast::Expr,
op_ex: &ast::Expr,
self_ex: &ast::Expr,
self_t: ty::t,
opname: ast::Name,
args: ~[@ast::Expr],
args: &[@ast::Expr],
deref_args: DerefArgs,
autoderef_receiver: AutoderefReceiverFlag,
unbound_method: ||,
@ -2078,9 +2078,9 @@ pub fn check_expr_with_unifier(fcx: @FnCtxt,
// could be either a expr_binop or an expr_assign_binop
fn check_binop(fcx: @FnCtxt,
callee_id: ast::NodeId,
expr: @ast::Expr,
expr: &ast::Expr,
op: ast::BinOp,
lhs: @ast::Expr,
lhs: &ast::Expr,
rhs: @ast::Expr,
// Used only in the error case
expected_result: Option<ty::t>,
@ -2166,8 +2166,8 @@ pub fn check_expr_with_unifier(fcx: @FnCtxt,
fn check_user_binop(fcx: @FnCtxt,
callee_id: ast::NodeId,
ex: @ast::Expr,
lhs_expr: @ast::Expr,
ex: &ast::Expr,
lhs_expr: &ast::Expr,
lhs_resolved_t: ty::t,
op: ast::BinOp,
rhs: @ast::Expr,
@ -2184,7 +2184,7 @@ pub fn check_expr_with_unifier(fcx: @FnCtxt,
};
return lookup_op_method(fcx, callee_id, ex, lhs_expr, lhs_resolved_t,
token::intern(*name),
~[rhs], DoDerefArgs, DontAutoderefReceiver, if_op_unbound,
&[rhs], DoDerefArgs, DontAutoderefReceiver, if_op_unbound,
expected_result);
}
None => ()
@ -2210,14 +2210,14 @@ pub fn check_expr_with_unifier(fcx: @FnCtxt,
callee_id: ast::NodeId,
op_str: &str,
mname: &str,
ex: @ast::Expr,
rhs_expr: @ast::Expr,
ex: &ast::Expr,
rhs_expr: &ast::Expr,
rhs_t: ty::t,
expected_t: Option<ty::t>)
-> ty::t {
lookup_op_method(
fcx, callee_id, ex, rhs_expr, rhs_t,
token::intern(mname), ~[],
token::intern(mname), &[],
DoDerefArgs, DontAutoderefReceiver,
|| {
fcx.type_error_message(ex.span, |actual| {
@ -2248,7 +2248,7 @@ pub fn check_expr_with_unifier(fcx: @FnCtxt,
}
fn check_expr_fn(fcx: @FnCtxt,
expr: @ast::Expr,
expr: &ast::Expr,
ast_sigil_opt: Option<ast::Sigil>,
decl: &ast::fn_decl,
body: ast::P<ast::Block>,
@ -2354,8 +2354,8 @@ pub fn check_expr_with_unifier(fcx: @FnCtxt,
// Check field access expressions
fn check_field(fcx: @FnCtxt,
expr: @ast::Expr,
base: @ast::Expr,
expr: &ast::Expr,
base: &ast::Expr,
field: ast::Name,
tys: &[ast::P<ast::Ty>]) {
let tcx = fcx.ccx.tcx;
@ -3263,7 +3263,7 @@ pub fn check_expr_with_unifier(fcx: @FnCtxt,
base,
resolved,
index_ident.name,
~[idx],
&[idx],
DoDerefArgs,
AutoderefReceiver,
error_message,
@ -3298,13 +3298,13 @@ pub fn require_integral(fcx: @FnCtxt, sp: Span, t: ty::t) {
pub fn check_decl_initializer(fcx: @FnCtxt,
nid: ast::NodeId,
init: @ast::Expr)
init: &ast::Expr)
{
let local_ty = fcx.local_ty(init.span, nid);
check_expr_coercable_to_type(fcx, init, local_ty)
}
pub fn check_decl_local(fcx: @FnCtxt, local: @ast::Local) {
pub fn check_decl_local(fcx: @FnCtxt, local: &ast::Local) {
let tcx = fcx.ccx.tcx;
let t = fcx.local_ty(local.span, local.id);
@ -3332,7 +3332,7 @@ pub fn check_decl_local(fcx: @FnCtxt, local: @ast::Local) {
}
}
pub fn check_stmt(fcx: @FnCtxt, stmt: @ast::Stmt) {
pub fn check_stmt(fcx: @FnCtxt, stmt: &ast::Stmt) {
let node_id;
let mut saw_bot = false;
let mut saw_err = false;
@ -3465,7 +3465,7 @@ pub fn check_block_with_expected(fcx: @FnCtxt,
pub fn check_const(ccx: @CrateCtxt,
sp: Span,
e: @ast::Expr,
e: &ast::Expr,
id: ast::NodeId) {
let rty = ty::node_id_to_type(ccx.tcx, id);
let fcx = blank_fn_ctxt(ccx, rty, e.id);
@ -3478,7 +3478,7 @@ pub fn check_const(ccx: @CrateCtxt,
pub fn check_const_with_ty(fcx: @FnCtxt,
_: Span,
e: @ast::Expr,
e: &ast::Expr,
declty: ty::t) {
check_expr(fcx, e);
let cty = fcx.expr_ty(e);
@ -3907,7 +3907,7 @@ pub fn type_is_c_like_enum(fcx: @FnCtxt, sp: Span, typ: ty::t) -> bool {
}
pub fn ast_expr_vstore_to_vstore(fcx: @FnCtxt,
e: @ast::Expr,
e: &ast::Expr,
v: ast::ExprVstore)
-> ty::vstore {
match v {
@ -3975,7 +3975,7 @@ pub fn check_bounds_are_used(ccx: @CrateCtxt,
}
}
pub fn check_intrinsic_type(ccx: @CrateCtxt, it: @ast::foreign_item) {
pub fn check_intrinsic_type(ccx: @CrateCtxt, it: &ast::foreign_item) {
fn param(ccx: @CrateCtxt, n: uint) -> ty::t {
ty::mk_param(ccx.tcx, n, local_def(0))
}

62
src/librustc/middle/typeck/check/regionck.rs
View File

@ -128,7 +128,7 @@ impl Rcx {
}
/// Try to resolve the type for the given node.
pub fn resolve_expr_type_adjusted(&mut self, expr: @ast::Expr) -> ty::t {
pub fn resolve_expr_type_adjusted(&mut self, expr: &ast::Expr) -> ty::t {
let ty_unadjusted = self.resolve_node_type(expr.id);
if ty::type_is_error(ty_unadjusted) || ty::type_is_bot(ty_unadjusted) {
ty_unadjusted
@ -143,7 +143,7 @@ impl Rcx {
}
}
pub fn regionck_expr(fcx: @FnCtxt, e: @ast::Expr) {
pub fn regionck_expr(fcx: @FnCtxt, e: &ast::Expr) {
let mut rcx = Rcx { fcx: fcx, errors_reported: 0,
repeating_scope: e.id };
let rcx = &mut rcx;
@ -154,7 +154,7 @@ pub fn regionck_expr(fcx: @FnCtxt, e: @ast::Expr) {
fcx.infcx().resolve_regions();
}
pub fn regionck_fn(fcx: @FnCtxt, blk: ast::P<ast::Block>) {
pub fn regionck_fn(fcx: @FnCtxt, blk: &ast::Block) {
let mut rcx = Rcx { fcx: fcx, errors_reported: 0,
repeating_scope: blk.id };
let rcx = &mut rcx;
@ -174,24 +174,24 @@ impl Visitor<()> for Rcx {
// hierarchy, and in particular the relationships between free
// regions, until regionck, as described in #3238.
fn visit_item(&mut self, i:@ast::item, _:()) { visit_item(self, i); }
fn visit_item(&mut self, i: &ast::item, _: ()) { visit_item(self, i); }
fn visit_expr(&mut self, ex:@ast::Expr, _:()) { visit_expr(self, ex); }
fn visit_expr(&mut self, ex: &ast::Expr, _: ()) { visit_expr(self, ex); }
//visit_pat: visit_pat, // (..) see above
//visit_pat: visit_pat, // (..) see above
fn visit_arm(&mut self, a:&ast::Arm, _:()) { visit_arm(self, a); }
fn visit_arm(&mut self, a: &ast::Arm, _: ()) { visit_arm(self, a); }
fn visit_local(&mut self, l:@ast::Local, _:()) { visit_local(self, l); }
fn visit_local(&mut self, l: &ast::Local, _: ()) { visit_local(self, l); }
fn visit_block(&mut self, b:ast::P<ast::Block>, _:()) { visit_block(self, b); }
fn visit_block(&mut self, b: &ast::Block, _: ()) { visit_block(self, b); }
}
fn visit_item(_rcx: &mut Rcx, _item: @ast::item) {
fn visit_item(_rcx: &mut Rcx, _item: &ast::item) {
// Ignore items
}
fn visit_block(rcx: &mut Rcx, b: ast::P<ast::Block>) {
fn visit_block(rcx: &mut Rcx, b: &ast::Block) {
rcx.fcx.tcx().region_maps.record_cleanup_scope(b.id);
visit::walk_block(rcx, b, ());
}
@ -205,13 +205,13 @@ fn visit_arm(rcx: &mut Rcx, arm: &ast::Arm) {
visit::walk_arm(rcx, arm, ());
}
fn visit_local(rcx: &mut Rcx, l: @ast::Local) {
fn visit_local(rcx: &mut Rcx, l: &ast::Local) {
// see above
constrain_bindings_in_pat(l.pat, rcx);
visit::walk_local(rcx, l, ());
}
fn constrain_bindings_in_pat(pat: @ast::Pat, rcx: &mut Rcx) {
fn constrain_bindings_in_pat(pat: &ast::Pat, rcx: &mut Rcx) {
let tcx = rcx.fcx.tcx();
debug!("regionck::visit_pat(pat={})", pat.repr(tcx));
pat_util::pat_bindings(tcx.def_map, pat, |_, id, span, _| {
@ -245,7 +245,7 @@ fn constrain_bindings_in_pat(pat: @ast::Pat, rcx: &mut Rcx) {
})
}
fn visit_expr(rcx: &mut Rcx, expr: @ast::Expr) {
fn visit_expr(rcx: &mut Rcx, expr: &ast::Expr) {
debug!("regionck::visit_expr(e={}, repeating_scope={:?})",
expr.repr(rcx.fcx.tcx()), rcx.repeating_scope);
@ -479,7 +479,7 @@ fn visit_expr(rcx: &mut Rcx, expr: @ast::Expr) {
}
fn check_expr_fn_block(rcx: &mut Rcx,
expr: @ast::Expr) {
expr: &ast::Expr) {
let tcx = rcx.fcx.tcx();
match expr.node {
ast::ExprFnBlock(_, ref body) | ast::ExprProc(_, ref body) => {
@ -522,8 +522,8 @@ fn check_expr_fn_block(rcx: &mut Rcx,
fn constrain_callee(rcx: &mut Rcx,
callee_id: ast::NodeId,
call_expr: @ast::Expr,
callee_expr: @ast::Expr)
call_expr: &ast::Expr,
callee_expr: &ast::Expr)
{
let call_region = ty::ReScope(call_expr.id);
@ -549,7 +549,7 @@ fn constrain_call(rcx: &mut Rcx,
// might be expr_call, expr_method_call, or an overloaded
// operator
callee_id: ast::NodeId,
call_expr: @ast::Expr,
call_expr: &ast::Expr,
receiver: Option<@ast::Expr>,
arg_exprs: &[@ast::Expr],
implicitly_ref_args: bool)
@ -618,7 +618,7 @@ fn constrain_call(rcx: &mut Rcx,
}
fn constrain_derefs(rcx: &mut Rcx,
deref_expr: @ast::Expr,
deref_expr: &ast::Expr,
derefs: uint,
mut derefd_ty: ty::t)
{
@ -662,7 +662,7 @@ pub fn mk_subregion_due_to_derefence(rcx: &mut Rcx,
fn constrain_index(rcx: &mut Rcx,
index_expr: @ast::Expr,
index_expr: &ast::Expr,
indexed_ty: ty::t)
{
/*!
@ -688,7 +688,7 @@ fn constrain_index(rcx: &mut Rcx,
fn constrain_free_variables(rcx: &mut Rcx,
region: ty::Region,
expr: @ast::Expr) {
expr: &ast::Expr) {
/*!
* Make sure that all free variables referenced inside the closure
* outlive the closure itself.
@ -842,7 +842,7 @@ pub mod guarantor {
use syntax::codemap::Span;
use util::ppaux::{ty_to_str};
pub fn for_addr_of(rcx: &mut Rcx, expr: @ast::Expr, base: @ast::Expr) {
pub fn for_addr_of(rcx: &mut Rcx, expr: &ast::Expr, base: &ast::Expr) {
/*!
* Computes the guarantor for an expression `&base` and then
* ensures that the lifetime of the resulting pointer is linked
@ -855,7 +855,7 @@ pub mod guarantor {
link(rcx, expr.span, expr.id, guarantor);
}
pub fn for_match(rcx: &mut Rcx, discr: @ast::Expr, arms: &[ast::Arm]) {
pub fn for_match(rcx: &mut Rcx, discr: &ast::Expr, arms: &[ast::Arm]) {
/*!
* Computes the guarantors for any ref bindings in a match and
* then ensures that the lifetime of the resulting pointer is
@ -873,7 +873,7 @@ pub mod guarantor {
}
pub fn for_autoref(rcx: &mut Rcx,
expr: @ast::Expr,
expr: &ast::Expr,
autoderefs: uint,
autoref: &ty::AutoRef) {
/*!
@ -913,7 +913,7 @@ pub mod guarantor {
fn maybe_make_subregion(
rcx: &mut Rcx,
expr: @ast::Expr,
expr: &ast::Expr,
sub_region: ty::Region,
sup_region: Option<ty::Region>)
{
@ -925,7 +925,7 @@ pub mod guarantor {
}
pub fn for_by_ref(rcx: &mut Rcx,
expr: @ast::Expr,
expr: &ast::Expr,
callee_scope: ast::NodeId) {
/*!
* Computes the guarantor for cases where the `expr` is
@ -1004,7 +1004,7 @@ pub mod guarantor {
ty: ty::t
}
fn guarantor(rcx: &mut Rcx, expr: @ast::Expr) -> Option<ty::Region> {
fn guarantor(rcx: &mut Rcx, expr: &ast::Expr) -> Option<ty::Region> {
/*!
*
* Computes the guarantor of `expr`, or None if `expr` is
@ -1076,7 +1076,7 @@ pub mod guarantor {
}
}
fn categorize(rcx: &mut Rcx, expr: @ast::Expr) -> ExprCategorization {
fn categorize(rcx: &mut Rcx, expr: &ast::Expr) -> ExprCategorization {
debug!("categorize()");
let mut expr_ct = categorize_unadjusted(rcx, expr);
@ -1152,7 +1152,7 @@ pub mod guarantor {
}
fn categorize_unadjusted(rcx: &mut Rcx,
expr: @ast::Expr)
expr: &ast::Expr)
-> ExprCategorizationType {
debug!("categorize_unadjusted()");
@ -1177,7 +1177,7 @@ pub mod guarantor {
fn apply_autoderefs(
rcx: &mut Rcx,
expr: @ast::Expr,
expr: &ast::Expr,
autoderefs: uint,
ct: ExprCategorizationType)
-> ExprCategorizationType {
@ -1255,7 +1255,7 @@ pub mod guarantor {
fn link_ref_bindings_in_pat(
rcx: &mut Rcx,
pat: @ast::Pat,
pat: &ast::Pat,
guarantor: Option<ty::Region>) {
/*!
*

22
src/librustc/middle/typeck/check/vtable.rs
View File

@ -544,28 +544,26 @@ fn insert_vtables(fcx: @FnCtxt,
vtable_map.get().insert(callee_id, vtables);
}
pub fn location_info_for_expr(expr: @ast::Expr) -> LocationInfo {
pub fn location_info_for_expr(expr: &ast::Expr) -> LocationInfo {
LocationInfo {
span: expr.span,
id: expr.id
}
}
pub fn location_info_for_item(item: @ast::item) -> LocationInfo {
pub fn location_info_for_item(item: &ast::item) -> LocationInfo {
LocationInfo {
span: item.span,
id: item.id
}
}
pub fn early_resolve_expr(ex: @ast::Expr,
fcx: @FnCtxt,
is_early: bool) {
pub fn early_resolve_expr(ex: &ast::Expr, fcx: @FnCtxt, is_early: bool) {
debug!("vtable: early_resolve_expr() ex with id {:?} (early: {}): {}",
ex.id, is_early, expr_to_str(ex, fcx.tcx().sess.intr()));
let _indent = indenter();
let cx = fcx.ccx;
let resolve_object_cast = |src: @ast::Expr, target_ty: ty::t| {
let resolve_object_cast = |src: &ast::Expr, target_ty: ty::t| {
match ty::get(target_ty).sty {
// Bounds of type's contents are not checked here, but in kind.rs.
ty::ty_trait(target_def_id, ref target_substs, store,
@ -753,15 +751,14 @@ pub fn early_resolve_expr(ex: @ast::Expr,
}
}
fn resolve_expr(fcx: @FnCtxt,
ex: @ast::Expr) {
fn resolve_expr(fcx: @FnCtxt, ex: &ast::Expr) {
let mut fcx = fcx;
early_resolve_expr(ex, fcx, false);
visit::walk_expr(&mut fcx, ex, ());
}
pub fn resolve_impl(ccx: @CrateCtxt,
impl_item: @ast::item,
impl_item: &ast::item,
impl_generics: &ty::Generics,
impl_trait_ref: &ty::TraitRef) {
let param_env = ty::construct_parameter_environment(
@ -817,17 +814,16 @@ pub fn resolve_impl(ccx: @CrateCtxt,
}
impl visit::Visitor<()> for @FnCtxt {
fn visit_expr(&mut self, ex:@ast::Expr, _:()) {
fn visit_expr(&mut self, ex: &ast::Expr, _: ()) {
resolve_expr(*self, ex);
}
fn visit_item(&mut self, _:@ast::item, _:()) {
fn visit_item(&mut self, _: &ast::item, _: ()) {
// no-op
}
}
// Detect points where a trait-bounded type parameter is
// instantiated, resolve the impls for the parameters.
pub fn resolve_in_block(fcx: @FnCtxt, bl: ast::P<ast::Block>) {
let mut fcx = fcx;
pub fn resolve_in_block(mut fcx: @FnCtxt, bl: &ast::Block) {
visit::walk_block(&mut fcx, bl, ());
}

28
src/librustc/middle/typeck/check/writeback.rs
View File

@ -242,13 +242,13 @@ struct WbCtxt {
success: bool,
}
fn visit_stmt(s: @ast::Stmt, wbcx: &mut WbCtxt) {
fn visit_stmt(s: &ast::Stmt, wbcx: &mut WbCtxt) {
if !wbcx.success { return; }
resolve_type_vars_for_node(wbcx, s.span, ty::stmt_node_id(s));
visit::walk_stmt(wbcx, s, ());
}
fn visit_expr(e: @ast::Expr, wbcx: &mut WbCtxt) {
fn visit_expr(e: &ast::Expr, wbcx: &mut WbCtxt) {
if !wbcx.success {
return;
}
@ -296,7 +296,7 @@ fn visit_expr(e: @ast::Expr, wbcx: &mut WbCtxt) {
visit::walk_expr(wbcx, e, ());
}
fn visit_block(b: ast::P<ast::Block>, wbcx: &mut WbCtxt) {
fn visit_block(b: &ast::Block, wbcx: &mut WbCtxt) {
if !wbcx.success {
return;
}
@ -319,7 +319,7 @@ fn visit_pat(p: &ast::Pat, wbcx: &mut WbCtxt) {
visit::walk_pat(wbcx, p, ());
}
fn visit_local(l: @ast::Local, wbcx: &mut WbCtxt) {
fn visit_local(l: &ast::Local, wbcx: &mut WbCtxt) {
if !wbcx.success { return; }
let var_ty = wbcx.fcx.local_ty(l.span, l.id);
match resolve_type(wbcx.fcx.infcx(), var_ty, resolve_all | force_all) {
@ -341,22 +341,22 @@ fn visit_local(l: @ast::Local, wbcx: &mut WbCtxt) {
}
visit::walk_local(wbcx, l, ());
}
fn visit_item(_item: @ast::item, _wbcx: &mut WbCtxt) {
fn visit_item(_item: &ast::item, _wbcx: &mut WbCtxt) {
// Ignore items
}
impl Visitor<()> for WbCtxt {
fn visit_item(&mut self, i:@ast::item, _:()) { visit_item(i, self); }
fn visit_stmt(&mut self, s:@ast::Stmt, _:()) { visit_stmt(s, self); }
fn visit_expr(&mut self, ex:@ast::Expr, _:()) { visit_expr(ex, self); }
fn visit_block(&mut self, b:ast::P<ast::Block>, _:()) { visit_block(b, self); }
fn visit_pat(&mut self, p:&ast::Pat, _:()) { visit_pat(p, self); }
fn visit_local(&mut self, l:@ast::Local, _:()) { visit_local(l, self); }
fn visit_item(&mut self, i: &ast::item, _: ()) { visit_item(i, self); }
fn visit_stmt(&mut self, s: &ast::Stmt, _: ()) { visit_stmt(s, self); }
fn visit_expr(&mut self, ex:&ast::Expr, _: ()) { visit_expr(ex, self); }
fn visit_block(&mut self, b: &ast::Block, _: ()) { visit_block(b, self); }
fn visit_pat(&mut self, p: &ast::Pat, _: ()) { visit_pat(p, self); }
fn visit_local(&mut self, l: &ast::Local, _: ()) { visit_local(l, self); }
// FIXME(#10894) should continue recursing
fn visit_ty(&mut self, _t: &ast::Ty, _:()) {}
fn visit_ty(&mut self, _t: &ast::Ty, _: ()) {}
}
pub fn resolve_type_vars_in_expr(fcx: @FnCtxt, e: @ast::Expr) -> bool {
pub fn resolve_type_vars_in_expr(fcx: @FnCtxt, e: &ast::Expr) -> bool {
let mut wbcx = WbCtxt { fcx: fcx, success: true };
let wbcx = &mut wbcx;
wbcx.visit_expr(e, ());
@ -365,7 +365,7 @@ pub fn resolve_type_vars_in_expr(fcx: @FnCtxt, e: @ast::Expr) -> bool {
pub fn resolve_type_vars_in_fn(fcx: @FnCtxt,
decl: &ast::fn_decl,
blk: ast::P<ast::Block>,
blk: &ast::Block,
self_info: Option<SelfInfo>) -> bool {
let mut wbcx = WbCtxt { fcx: fcx, success: true };
let wbcx = &mut wbcx;

111
src/librustc/middle/typeck/coherence.rs
View File

@ -158,23 +158,24 @@ pub struct CoherenceChecker {
struct CoherenceCheckVisitor { cc: CoherenceChecker }
impl visit::Visitor<()> for CoherenceCheckVisitor {
fn visit_item(&mut self, item:@item, _:()) {
fn visit_item(&mut self, item: &item, _: ()) {
// debug!("(checking coherence) item '{}'",
// self.cc.crate_context.tcx.sess.str_of(item.ident));
// debug!("(checking coherence) item '{}'",
// self.cc.crate_context.tcx.sess.str_of(item.ident));
match item.node {
item_impl(_, ref opt_trait, _, _) => {
let opt_trait : ~[trait_ref] =
opt_trait.iter()
.map(|x| (*x).clone())
.collect();
self.cc.check_implementation(item, opt_trait);
match item.node {
item_impl(_, ref opt_trait, _, _) => {
match opt_trait.clone() {
Some(opt_trait) => {
self.cc.check_implementation(item, [opt_trait]);
}
_ => {
// Nothing to do.
}
};
None => self.cc.check_implementation(item, [])
}
}
_ => {
// Nothing to do.
}
};
visit::walk_item(self, item, ());
}
@ -183,50 +184,50 @@ impl visit::Visitor<()> for CoherenceCheckVisitor {
struct PrivilegedScopeVisitor { cc: CoherenceChecker }
impl visit::Visitor<()> for PrivilegedScopeVisitor {
fn visit_item(&mut self, item:@item, _:()) {
fn visit_item(&mut self, item: &item, _: ()) {
match item.node {
item_mod(ref module_) => {
// Then visit the module items.
visit::walk_mod(self, module_, ());
}
item_impl(_, None, ast_ty, _) => {
if !self.cc.ast_type_is_defined_in_local_crate(ast_ty) {
// This is an error.
let session = self.cc.crate_context.tcx.sess;
session.span_err(item.span,
"cannot associate methods with a type outside the \
crate the type is defined in; define and implement \
a trait or new type instead");
}
}
item_impl(_, Some(ref trait_ref), _, _) => {
// `for_ty` is `Type` in `impl Trait for Type`
let for_ty =
ty::node_id_to_type(self.cc.crate_context.tcx,
item.id);
if !type_is_defined_in_local_crate(for_ty) {
// This implementation is not in scope of its base
// type. This still might be OK if the trait is
// defined in the same crate.
match item.node {
item_mod(ref module_) => {
// Then visit the module items.
visit::walk_mod(self, module_, ());
}
item_impl(_, None, ast_ty, _) => {
if !self.cc.ast_type_is_defined_in_local_crate(ast_ty) {
// This is an error.
let session = self.cc.crate_context.tcx.sess;
session.span_err(item.span,
"cannot associate methods with a type outside the \
crate the type is defined in; define and implement \
a trait or new type instead");
}
}
item_impl(_, Some(ref trait_ref), _, _) => {
// `for_ty` is `Type` in `impl Trait for Type`
let for_ty =
ty::node_id_to_type(self.cc.crate_context.tcx,
item.id);
if !type_is_defined_in_local_crate(for_ty) {
// This implementation is not in scope of its base
// type. This still might be OK if the trait is
// defined in the same crate.
let trait_def_id =
self.cc.trait_ref_to_trait_def_id(trait_ref);
let trait_def_id =
self.cc.trait_ref_to_trait_def_id(trait_ref);
if trait_def_id.crate != LOCAL_CRATE {
let session = self.cc.crate_context.tcx.sess;
session.span_err(item.span,
"cannot provide an extension implementation \
where both trait and type are not defined in this crate");
}
}
visit::walk_item(self, item, ());
}
_ => {
visit::walk_item(self, item, ());
if trait_def_id.crate != LOCAL_CRATE {
let session = self.cc.crate_context.tcx.sess;
session.span_err(item.span,
"cannot provide an extension implementation \
where both trait and type are not defined in this crate");
}
}
visit::walk_item(self, item, ());
}
_ => {
visit::walk_item(self, item, ());
}
}
}
}
@ -257,7 +258,7 @@ impl CoherenceChecker {
}
pub fn check_implementation(&self,
item: @item,
item: &item,
associated_traits: &[trait_ref]) {
let tcx = self.crate_context.tcx;
let self_type = ty::lookup_item_type(tcx, local_def(item.id));
@ -592,7 +593,7 @@ impl CoherenceChecker {
}
// Converts an implementation in the AST to an Impl structure.
pub fn create_impl_from_item(&self, item: @item) -> @Impl {
pub fn create_impl_from_item(&self, item: &item) -> @Impl {
let tcx = self.crate_context.tcx;
match item.node {
item_impl(_, ref trait_refs, _, ref ast_methods) => {

4
src/librustc/middle/typeck/collect.rs
View File

@ -61,11 +61,11 @@ struct CollectItemTypesVisitor {
}
impl visit::Visitor<()> for CollectItemTypesVisitor {
fn visit_item(&mut self, i:@ast::item, _:()) {
fn visit_item(&mut self, i: &ast::item, _: ()) {
convert(self.ccx, i);
visit::walk_item(self, i, ());
}
fn visit_foreign_item(&mut self, i:@ast::foreign_item, _:()) {
fn visit_foreign_item(&mut self, i: &ast::foreign_item, _: ()) {
convert_foreign(self.ccx, i);
visit::walk_foreign_item(self, i, ());
}

5
src/librustc/middle/typeck/infer/mod.rs
View File

@ -109,7 +109,8 @@ pub enum TypeOrigin {
MethodCompatCheck(Span),
// Checking that this expression can be assigned where it needs to be
ExprAssignable(@ast::Expr),
// FIXME(eddyb) #11161 is the original Expr required?
ExprAssignable(Span),
// Relating trait refs when resolving vtables
RelateTraitRefs(Span),
@ -845,7 +846,7 @@ impl TypeOrigin {
pub fn span(&self) -> Span {
match *self {
MethodCompatCheck(span) => span,
ExprAssignable(expr) => expr.span,
ExprAssignable(span) => span,
Misc(span) => span,
RelateTraitRefs(span) => span,
RelateSelfType(span) => span,

25
src/librustc/middle/typeck/infer/region_inference/mod.rs
View File

@ -534,8 +534,7 @@ impl RegionVarBindings {
impl RegionVarBindings {
fn is_subregion_of(&self, sub: Region, sup: Region) -> bool {
let rm = self.tcx.region_maps;
rm.is_subregion_of(sub, sup)
self.tcx.region_maps.is_subregion_of(sub, sup)
}
fn lub_concrete_regions(&self, a: Region, b: Region) -> Region {
@ -571,8 +570,7 @@ impl RegionVarBindings {
// A "free" region can be interpreted as "some region
// at least as big as the block fr.scope_id". So, we can
// reasonably compare free regions and scopes:
let rm = self.tcx.region_maps;
match rm.nearest_common_ancestor(fr.scope_id, s_id) {
match self.tcx.region_maps.nearest_common_ancestor(fr.scope_id, s_id) {
// if the free region's scope `fr.scope_id` is bigger than
// the scope region `s_id`, then the LUB is the free
// region itself:
@ -588,8 +586,7 @@ impl RegionVarBindings {
// The region corresponding to an outer block is a
// subtype of the region corresponding to an inner
// block.
let rm = self.tcx.region_maps;
match rm.nearest_common_ancestor(a_id, b_id) {
match self.tcx.region_maps.nearest_common_ancestor(a_id, b_id) {
Some(r_id) => ReScope(r_id),
_ => ReStatic
}
@ -628,10 +625,9 @@ impl RegionVarBindings {
a: &FreeRegion,
b: &FreeRegion) -> ty::Region
{
let rm = this.tcx.region_maps;
if rm.sub_free_region(*a, *b) {
if this.tcx.region_maps.sub_free_region(*a, *b) {
ty::ReFree(*b)
} else if rm.sub_free_region(*b, *a) {
} else if this.tcx.region_maps.sub_free_region(*b, *a) {
ty::ReFree(*a)
} else {
ty::ReStatic
@ -681,8 +677,7 @@ impl RegionVarBindings {
// than the scope `s_id`, then we can say that the GLB
// is the scope `s_id`. Otherwise, as we do not know
// big the free region is precisely, the GLB is undefined.
let rm = self.tcx.region_maps;
match rm.nearest_common_ancestor(fr.scope_id, s_id) {
match self.tcx.region_maps.nearest_common_ancestor(fr.scope_id, s_id) {
Some(r_id) if r_id == fr.scope_id => Ok(s),
_ => Err(ty::terr_regions_no_overlap(b, a))
}
@ -729,10 +724,9 @@ impl RegionVarBindings {
a: &FreeRegion,
b: &FreeRegion) -> cres<ty::Region>
{
let rm = this.tcx.region_maps;
if rm.sub_free_region(*a, *b) {
if this.tcx.region_maps.sub_free_region(*a, *b) {
Ok(ty::ReFree(*a))
} else if rm.sub_free_region(*b, *a) {
} else if this.tcx.region_maps.sub_free_region(*b, *a) {
Ok(ty::ReFree(*b))
} else {
this.intersect_scopes(ty::ReFree(*a), ty::ReFree(*b),
@ -753,8 +747,7 @@ impl RegionVarBindings {
// it. Otherwise fail.
debug!("intersect_scopes(scope_a={:?}, scope_b={:?}, region_a={:?}, region_b={:?})",
scope_a, scope_b, region_a, region_b);
let rm = self.tcx.region_maps;
match rm.nearest_common_ancestor(scope_a, scope_b) {
match self.tcx.region_maps.nearest_common_ancestor(scope_a, scope_b) {
Some(r_id) if scope_a == r_id => Ok(ReScope(scope_b)),
Some(r_id) if scope_b == r_id => Ok(ReScope(scope_a)),
_ => Err(ty::terr_regions_no_overlap(region_a, region_b))

8
src/librustc/middle/typeck/variance.rs
View File

@ -327,9 +327,7 @@ impl<'a> TermsContext<'a> {
}
impl<'a> Visitor<()> for TermsContext<'a> {
fn visit_item(&mut self,
item: @ast::item,
(): ()) {
fn visit_item(&mut self, item: &ast::item, _: ()) {
debug!("add_inferreds for item {}", item.repr(self.tcx));
let inferreds_on_entry = self.num_inferred();
@ -434,9 +432,7 @@ fn add_constraints_from_crate<'a>(terms_cx: TermsContext<'a>,
}
impl<'a> Visitor<()> for ConstraintContext<'a> {
fn visit_item(&mut self,
item: @ast::item,
(): ()) {
fn visit_item(&mut self, item: &ast::item, _: ()) {
let did = ast_util::local_def(item.id);
let tcx = self.terms_cx.tcx;

12
src/librustc/util/common.rs
View File

@ -74,7 +74,7 @@ struct LoopQueryVisitor<'a> {
}
impl<'a> Visitor<()> for LoopQueryVisitor<'a> {
fn visit_expr(&mut self, e: @ast::Expr, _: ()) {
fn visit_expr(&mut self, e: &ast::Expr, _: ()) {
self.flag |= (self.p)(&e.node);
match e.node {
// Skip inner loops, since a break in the inner loop isn't a
@ -87,7 +87,7 @@ impl<'a> Visitor<()> for LoopQueryVisitor<'a> {
// Takes a predicate p, returns true iff p is true for any subexpressions
// of b -- skipping any inner loops (loop, while, loop_body)
pub fn loop_query(b: ast::P<ast::Block>, p: |&ast::Expr_| -> bool) -> bool {
pub fn loop_query(b: &ast::Block, p: |&ast::Expr_| -> bool) -> bool {
let mut v = LoopQueryVisitor {
p: p,
flag: false,
@ -97,12 +97,12 @@ pub fn loop_query(b: ast::P<ast::Block>, p: |&ast::Expr_| -> bool) -> bool {
}
struct BlockQueryVisitor<'a> {
p: 'a |@ast::Expr| -> bool,
p: 'a |&ast::Expr| -> bool,
flag: bool,
}
impl<'a> Visitor<()> for BlockQueryVisitor<'a> {
fn visit_expr(&mut self, e: @ast::Expr, _:()) {
fn visit_expr(&mut self, e: &ast::Expr, _: ()) {
self.flag |= (self.p)(e);
visit::walk_expr(self, e, ())
}
@ -110,7 +110,7 @@ impl<'a> Visitor<()> for BlockQueryVisitor<'a> {
// Takes a predicate p, returns true iff p is true for any subexpressions
// of b -- skipping any inner loops (loop, while, loop_body)
pub fn block_query(b: ast::P<ast::Block>, p: |@ast::Expr| -> bool) -> bool {
pub fn block_query(b: ast::P<ast::Block>, p: |&ast::Expr| -> bool) -> bool {
let mut v = BlockQueryVisitor {
p: p,
flag: false,
@ -119,7 +119,7 @@ pub fn block_query(b: ast::P<ast::Block>, p: |@ast::Expr| -> bool) -> bool {
return v.flag;
}
pub fn local_rhs_span(l: @ast::Local, def: Span) -> Span {
pub fn local_rhs_span(l: &ast::Local, def: Span) -> Span {
match l.init {
Some(i) => return i.span,
_ => return def

6
src/librustdoc/core.rs
View File

@ -72,11 +72,11 @@ fn get_ast_and_resolve(cpath: &Path,
cfg.push(@dummy_spanned(ast::MetaWord(cfg_.to_managed())));
}
let mut crate = phase_1_parse_input(sess, cfg.clone(), &input);
crate = phase_2_configure_and_expand(sess, cfg, crate);
let crate = phase_1_parse_input(sess, cfg.clone(), &input);
let (crate, ast_map) = phase_2_configure_and_expand(sess, cfg, crate);
let driver::driver::CrateAnalysis {
exported_items, ty_cx, ..
} = phase_3_run_analysis_passes(sess, &crate);
} = phase_3_run_analysis_passes(sess, &crate, ast_map);
debug!("crate: {:?}", crate);
return (DocContext { crate: crate, tycx: Some(ty_cx), sess: sess },

4
src/librustdoc/test.rs
View File

@ -57,8 +57,8 @@ pub fn run(input: &str, matches: &getopts::Matches) -> int {
span_diagnostic_handler);
let cfg = driver::build_configuration(sess);
let mut crate = driver::phase_1_parse_input(sess, cfg.clone(), &input);
crate = driver::phase_2_configure_and_expand(sess, cfg, crate);
let crate = driver::phase_1_parse_input(sess, cfg.clone(), &input);
let (crate, _) = driver::phase_2_configure_and_expand(sess, cfg, crate);
let ctx = @core::DocContext {
crate: crate,

12
src/librustpkg/lib.rs
View File

@ -86,8 +86,8 @@ struct PkgScript<'a> {
sess: session::Session,
/// The config for compiling the custom build script
cfg: ast::CrateConfig,
/// The crate for the custom build script
crate: Option<ast::Crate>,
/// The crate and ast_map for the custom build script
crate_and_map: Option<(ast::Crate, syntax::ast_map::map)>,
/// Directory in which to store build output
build_dir: Path
}
@ -117,7 +117,7 @@ impl<'a> PkgScript<'a> {
@diagnostic::Emitter);
let cfg = driver::build_configuration(sess);
let crate = driver::phase_1_parse_input(sess, cfg.clone(), &input);
let crate = driver::phase_2_configure_and_expand(sess, cfg.clone(), crate);
let crate_and_map = driver::phase_2_configure_and_expand(sess, cfg.clone(), crate);
let work_dir = build_pkg_id_in_workspace(id, workspace);
debug!("Returning package script with id {}", id.to_str());
@ -127,7 +127,7 @@ impl<'a> PkgScript<'a> {
input: script,
sess: sess,
cfg: cfg,
crate: Some(crate),
crate_and_map: Some(crate_and_map),
build_dir: work_dir
}
}
@ -137,7 +137,8 @@ impl<'a> PkgScript<'a> {
debug!("Working directory = {}", self.build_dir.display());
// Collect together any user-defined commands in the package script
let crate = util::ready_crate(sess, self.crate.take_unwrap());
let (crate, ast_map) = self.crate_and_map.take_unwrap();
let crate = util::ready_crate(sess, crate);
debug!("Building output filenames with script name {}",
driver::source_name(&driver::file_input(self.input.clone())));
let exe = self.build_dir.join("pkg" + util::exe_suffix());
@ -147,6 +148,7 @@ impl<'a> PkgScript<'a> {
&self.build_dir,
sess,
crate,
ast_map,
Main);
// Discover the output
// FIXME (#9639): This needs to handle non-utf8 paths

10
src/librustpkg/util.rs
View File

@ -18,7 +18,7 @@ use std::io::fs;
use extra::workcache;
use rustc::driver::{driver, session};
use extra::getopts::groups::getopts;
use syntax::ast_util::*;
use syntax;
use syntax::codemap::{DUMMY_SP, Spanned};
use syntax::ext::base::ExtCtxt;
use syntax::{ast, attr, codemap, diagnostic, fold, visit};
@ -283,8 +283,8 @@ pub fn compile_input(context: &BuildContext,
// Infer dependencies that rustpkg needs to build, by scanning for
// `extern mod` directives.
let cfg = driver::build_configuration(sess);
let mut crate = driver::phase_1_parse_input(sess, cfg.clone(), &input);
crate = driver::phase_2_configure_and_expand(sess, cfg.clone(), crate);
let crate = driver::phase_1_parse_input(sess, cfg.clone(), &input);
let (mut crate, ast_map) = driver::phase_2_configure_and_expand(sess, cfg.clone(), crate);
debug!("About to call find_and_install_dependencies...");
@ -323,6 +323,7 @@ pub fn compile_input(context: &BuildContext,
&out_dir,
sess,
crate,
ast_map,
what);
// Discover the output
let discovered_output = if what == Lib {
@ -359,6 +360,7 @@ pub fn compile_crate_from_input(input: &Path,
// Returns None if one of the flags that suppresses compilation output was
// given
crate: ast::Crate,
ast_map: syntax::ast_map::map,
what: OutputType) -> Option<Path> {
debug!("Calling build_output_filenames with {}, building library? {:?}",
out_dir.display(), sess.building_library);
@ -394,7 +396,7 @@ pub fn compile_crate_from_input(input: &Path,
debug!("an additional library: {}", lib.display());
}
}
let analysis = driver::phase_3_run_analysis_passes(sess, &crate);
let analysis = driver::phase_3_run_analysis_passes(sess, &crate, ast_map);
if driver::stop_after_phase_3(sess) { return None; }
let translation = driver::phase_4_translate_to_llvm(sess, crate,
&analysis,

375
src/libsyntax/ast_map.rs
View File

@ -11,21 +11,19 @@
use abi::AbiSet;
use ast::*;
use ast;
use ast_util::{inlined_item_utils, stmt_id};
use ast_util;
use codemap::Span;
use codemap;
use diagnostic::SpanHandler;
use fold::ast_fold;
use fold;
use parse::token::get_ident_interner;
use parse::token::ident_interner;
use parse::token::special_idents;
use print::pprust;
use visit::{Visitor, fn_kind};
use visit;
use util::small_vector::SmallVector;
use std::cell::RefCell;
use std::hashmap::HashMap;
use std::vec;
#[deriving(Clone, Eq)]
pub enum path_elt {
@ -165,7 +163,10 @@ pub enum ast_node {
node_expr(@Expr),
node_stmt(@Stmt),
node_arg(@Pat),
node_local(Ident),
// HACK(eddyb) should always be a pattern, but `self` is not, and thus it
// is identified only by an ident and no span is available. In all other
// cases, node_span will return the proper span (required by borrowck).
node_local(Ident, Option<@Pat>),
node_block(P<Block>),
/// node_struct_ctor represents a tuple struct.
@ -195,164 +196,75 @@ impl ast_node {
pub type map = @RefCell<HashMap<NodeId, ast_node>>;
pub struct Ctx {
pub trait FoldOps {
fn new_id(&self, id: ast::NodeId) -> ast::NodeId {
id
}
fn new_span(&self, span: Span) -> Span {
span
}
}
pub struct Ctx<F> {
map: map,
path: RefCell<path>,
path: path,
diag: @SpanHandler,
fold_ops: F
}
impl Ctx {
fn extend(&self, elt: path_elt) -> @path {
@vec::append(self.path.get(), [elt])
}
fn map_method(&mut self,
impl_did: DefId,
impl_path: @path,
m: @method,
is_provided: bool) {
let entry = if is_provided {
node_trait_method(@provided(m), impl_did, impl_path)
} else {
node_method(m, impl_did, impl_path)
};
impl<F> Ctx<F> {
fn insert(&self, id: ast::NodeId, node: ast_node) {
let mut map = self.map.borrow_mut();
map.get().insert(m.id, entry);
map.get().insert(m.self_id, node_local(special_idents::self_));
map.get().insert(id, node);
}
fn map_struct_def(&mut self,
struct_def: @ast::struct_def,
parent_node: ast_node,
ident: ast::Ident) {
let p = self.extend(path_name(ident));
// If this is a tuple-like struct, register the constructor.
match struct_def.ctor_id {
None => {}
Some(ctor_id) => {
match parent_node {
node_item(item, _) => {
let mut map = self.map.borrow_mut();
map.get().insert(ctor_id,
node_struct_ctor(struct_def,
item,
p));
}
_ => fail!("struct def parent wasn't an item")
}
}
}
}
fn map_expr(&mut self, ex: @Expr) {
{
let mut map = self.map.borrow_mut();
map.get().insert(ex.id, node_expr(ex));
}
// Expressions which are or might be calls:
{
let r = ex.get_callee_id();
for callee_id in r.iter() {
let mut map = self.map.borrow_mut();
map.get().insert(*callee_id, node_callee_scope(ex));
}
}
visit::walk_expr(self, ex, ());
}
fn map_fn(&mut self,
fk: &visit::fn_kind,
decl: &fn_decl,
body: P<Block>,
sp: codemap::Span,
id: NodeId) {
for a in decl.inputs.iter() {
let mut map = self.map.borrow_mut();
map.get().insert(a.id, node_arg(a.pat));
}
match *fk {
visit::fk_method(name, _, _) => {
let mut path = self.path.borrow_mut();
path.get().push(path_name(name))
}
_ => {}
}
visit::walk_fn(self, fk, decl, body, sp, id, ());
match *fk {
visit::fk_method(..) => {
let mut path = self.path.borrow_mut();
path.get().pop();
}
_ => {}
}
}
fn map_stmt(&mut self, stmt: @Stmt) {
{
let mut map = self.map.borrow_mut();
map.get().insert(stmt_id(stmt), node_stmt(stmt));
}
visit::walk_stmt(self, stmt, ());
}
fn map_block(&mut self, b: P<Block>) {
{
let mut map = self.map.borrow_mut();
map.get().insert(b.id, node_block(b));
}
visit::walk_block(self, b, ());
}
fn map_pat(&mut self, pat: &Pat) {
match pat.node {
PatIdent(_, ref path, _) => {
// Note: this is at least *potentially* a pattern...
let mut map = self.map.borrow_mut();
map.get().insert(pat.id,
node_local(ast_util::path_to_ident(path)));
}
_ => ()
}
visit::walk_pat(self, pat, ());
fn map_self(&self, m: @method) {
self.insert(m.self_id, node_local(special_idents::self_, None));
}
}
impl Visitor<()> for Ctx {
fn visit_item(&mut self, i: @item, _: ()) {
impl<F: FoldOps> ast_fold for Ctx<F> {
fn new_id(&mut self, id: ast::NodeId) -> ast::NodeId {
self.fold_ops.new_id(id)
}
fn new_span(&mut self, span: Span) -> Span {
self.fold_ops.new_span(span)
}
fn fold_item(&mut self, i: @item) -> SmallVector<@item> {
// clone is FIXME #2543
let item_path = @self.path.get();
{
let mut map = self.map.borrow_mut();
map.get().insert(i.id, node_item(i, item_path));
}
match i.node {
item_impl(_, ref maybe_trait, ty, ref ms) => {
let item_path = @self.path.clone();
self.path.push(match i.node {
item_impl(_, ref maybe_trait, ty, _) => {
// Right now the ident on impls is __extensions__ which isn't
// very pretty when debugging, so attempt to select a better
// name to use.
let elt = impl_pretty_name(maybe_trait, ty);
impl_pretty_name(maybe_trait, ty)
}
item_mod(_) | item_foreign_mod(_) => path_mod(i.ident),
_ => path_name(i.ident)
});
let i = fold::noop_fold_item(i, self).expect_one("expected one item");
self.insert(i.id, node_item(i, item_path));
match i.node {
item_impl(_, _, _, ref ms) => {
// clone is FIXME #2543
let p = @self.path.clone();
let impl_did = ast_util::local_def(i.id);
for m in ms.iter() {
let extended = { self.extend(elt) };
self.map_method(impl_did, extended, *m, false)
for &m in ms.iter() {
self.insert(m.id, node_method(m, impl_did, p));
self.map_self(m);
}
let mut path = self.path.borrow_mut();
path.get().push(elt);
}
item_enum(ref enum_definition, _) => {
// clone is FIXME #2543
let p = @self.path.clone();
for &v in enum_definition.variants.iter() {
let elt = path_name(i.ident);
let mut map = self.map.borrow_mut();
map.get().insert(v.node.id,
node_variant(v, i, self.extend(elt)));
self.insert(v.node.id, node_variant(v, i, p));
}
}
item_foreign_mod(ref nm) => {
@ -364,41 +276,38 @@ impl Visitor<()> for Ctx {
inherited => i.vis
};
let mut map = self.map.borrow_mut();
map.get().insert(nitem.id,
node_foreign_item(*nitem,
nm.abis,
visibility,
// FIXME (#2543)
// Anonymous extern
// mods go in the
// parent scope.
@self.path.get()
));
self.insert(nitem.id,
// Anonymous extern mods go in the parent scope.
node_foreign_item(*nitem, nm.abis, visibility, item_path));
}
}
item_struct(struct_def, _) => {
self.map_struct_def(struct_def,
node_item(i, item_path),
i.ident)
// If this is a tuple-like struct, register the constructor.
match struct_def.ctor_id {
None => {}
Some(ctor_id) => {
// clone is FIXME #2543
let p = @self.path.clone();
self.insert(ctor_id, node_struct_ctor(struct_def, i, p));
}
}
}
item_trait(_, ref traits, ref methods) => {
for p in traits.iter() {
let mut map = self.map.borrow_mut();
map.get().insert(p.ref_id, node_item(i, item_path));
for t in traits.iter() {
self.insert(t.ref_id, node_item(i, item_path));
}
// clone is FIXME #2543
let p = @self.path.clone();
for tm in methods.iter() {
let ext = { self.extend(path_name(i.ident)) };
let d_id = ast_util::local_def(i.id);
match *tm {
required(ref m) => {
let entry =
node_trait_method(@(*tm).clone(), d_id, ext);
let mut map = self.map.borrow_mut();
map.get().insert(m.id, entry);
self.insert(m.id, node_trait_method(@(*tm).clone(), d_id, p));
}
provided(m) => {
self.map_method(d_id, ext, m, true);
self.insert(m.id, node_trait_method(@provided(m), d_id, p));
self.map_self(m);
}
}
}
@ -406,100 +315,123 @@ impl Visitor<()> for Ctx {
_ => {}
}
match i.node {
item_mod(_) | item_foreign_mod(_) => {
let mut path = self.path.borrow_mut();
path.get().push(path_mod(i.ident));
self.path.pop();
SmallVector::one(i)
}
fn fold_pat(&mut self, pat: @Pat) -> @Pat {
let pat = fold::noop_fold_pat(pat, self);
match pat.node {
PatIdent(_, ref path, _) => {
// Note: this is at least *potentially* a pattern...
self.insert(pat.id, node_local(ast_util::path_to_ident(path), Some(pat)));
}
item_impl(..) => {} // this was guessed above.
_ => {
let mut path = self.path.borrow_mut();
path.get().push(path_name(i.ident))
_ => {}
}
pat
}
fn fold_expr(&mut self, expr: @Expr) -> @Expr {
let expr = fold::noop_fold_expr(expr, self);
self.insert(expr.id, node_expr(expr));
// Expressions which are or might be calls:
{
let r = expr.get_callee_id();
for callee_id in r.iter() {
self.insert(*callee_id, node_callee_scope(expr));
}
}
visit::walk_item(self, i, ());
let mut path = self.path.borrow_mut();
path.get().pop();
expr
}
fn visit_pat(&mut self, pat: &Pat, _: ()) {
self.map_pat(pat);
visit::walk_pat(self, pat, ())
fn fold_stmt(&mut self, stmt: &Stmt) -> SmallVector<@Stmt> {
let stmt = fold::noop_fold_stmt(stmt, self).expect_one("expected one statement");
self.insert(ast_util::stmt_id(stmt), node_stmt(stmt));
SmallVector::one(stmt)
}
fn visit_expr(&mut self, expr: @Expr, _: ()) {
self.map_expr(expr)
fn fold_method(&mut self, m: @method) -> @method {
self.path.push(path_name(m.ident));
let m = fold::noop_fold_method(m, self);
self.path.pop();
m
}
fn visit_stmt(&mut self, stmt: @Stmt, _: ()) {
self.map_stmt(stmt)
fn fold_fn_decl(&mut self, decl: &fn_decl) -> P<fn_decl> {
let decl = fold::noop_fold_fn_decl(decl, self);
for a in decl.inputs.iter() {
self.insert(a.id, node_arg(a.pat));
}
decl
}
fn visit_fn(&mut self,
function_kind: &fn_kind,
function_declaration: &fn_decl,
block: P<Block>,
span: Span,
node_id: NodeId,
_: ()) {
self.map_fn(function_kind, function_declaration, block, span, node_id)
}
fn visit_block(&mut self, block: P<Block>, _: ()) {
self.map_block(block)
}
fn visit_ty(&mut self, typ: &Ty, _: ()) {
visit::walk_ty(self, typ, ())
fn fold_block(&mut self, block: P<Block>) -> P<Block> {
let block = fold::noop_fold_block(block, self);
self.insert(block.id, node_block(block));
block
}
}
pub fn map_crate(diag: @SpanHandler, c: &Crate) -> map {
pub fn map_crate<F: 'static + FoldOps>(diag: @SpanHandler, c: Crate,
fold_ops: F) -> (Crate, map) {
let mut cx = Ctx {
map: @RefCell::new(HashMap::new()),
path: RefCell::new(~[]),
path: ~[],
diag: diag,
fold_ops: fold_ops
};
visit::walk_crate(&mut cx, c, ());
cx.map
(cx.fold_crate(c), cx.map)
}
// Used for items loaded from external crate that are being inlined into this
// crate. The `path` should be the path to the item but should not include
// the item itself.
pub fn map_decoded_item(diag: @SpanHandler,
map: map,
path: path,
ii: &inlined_item) {
pub fn map_decoded_item<F: 'static + FoldOps>(diag: @SpanHandler,
map: map,
path: path,
fold_ops: F,
fold_ii: |&mut Ctx<F>| -> inlined_item)
-> inlined_item {
// I believe it is ok for the local IDs of inlined items from other crates
// to overlap with the local ids from this crate, so just generate the ids
// starting from 0.
let mut cx = Ctx {
map: map,
path: RefCell::new(path.clone()),
path: path.clone(),
diag: diag,
fold_ops: fold_ops
};
let ii = fold_ii(&mut cx);
// Methods get added to the AST map when their impl is visited. Since we
// don't decode and instantiate the impl, but just the method, we have to
// add it to the table now. Likewise with foreign items.
match *ii {
match ii {
ii_item(..) => {} // fallthrough
ii_foreign(i) => {
let mut map = cx.map.borrow_mut();
map.get().insert(i.id, node_foreign_item(i,
AbiSet::Intrinsic(),
i.vis, // Wrong but OK
@path));
cx.insert(i.id, node_foreign_item(i,
AbiSet::Intrinsic(),
i.vis, // Wrong but OK
@path));
}
ii_method(impl_did, is_provided, m) => {
cx.map_method(impl_did, @path, m, is_provided);
let entry = if is_provided {
node_trait_method(@provided(m), impl_did, @path)
} else {
node_method(m, impl_did, @path)
};
cx.insert(m.id, entry);
cx.map_self(m);
}
}
// visit the item / method contents and add those to the map:
ii.accept((), &mut cx);
ii
}
pub fn node_id_to_str(map: map, id: NodeId, itr: @ident_interner) -> ~str {
@ -554,7 +486,7 @@ pub fn node_id_to_str(map: map, id: NodeId, itr: @ident_interner) -> ~str {
Some(&node_arg(pat)) => {
format!("arg {} (id={})", pprust::pat_to_str(pat, itr), id)
}
Some(&node_local(ident)) => {
Some(&node_local(ident, _)) => {
format!("local (id={}, name={})", id, itr.get(ident.name))
}
Some(&node_block(block)) => {
@ -589,7 +521,10 @@ pub fn node_span(items: map,
Some(&node_expr(expr)) => expr.span,
Some(&node_stmt(stmt)) => stmt.span,
Some(&node_arg(pat)) => pat.span,
Some(&node_local(_)) => fail!("node_span: cannot get span from node_local"),
Some(&node_local(_, pat)) => match pat {
Some(pat) => pat.span,
None => fail!("node_span: cannot get span from node_local (likely `self`)")
},
Some(&node_block(block)) => block.span,
Some(&node_struct_ctor(_, item, _)) => item.span,
Some(&node_callee_scope(expr)) => expr.span,

55
src/libsyntax/ast_util.rs
View File

@ -292,38 +292,6 @@ pub fn struct_field_visibility(field: ast::struct_field) -> visibility {
}
}
pub trait inlined_item_utils {
fn ident(&self) -> Ident;
fn id(&self) -> ast::NodeId;
fn accept<E: Clone, V:Visitor<E>>(&self, e: E, v: &mut V);
}
impl inlined_item_utils for inlined_item {
fn ident(&self) -> Ident {
match *self {
ii_item(i) => i.ident,
ii_foreign(i) => i.ident,
ii_method(_, _, m) => m.ident,
}
}
fn id(&self) -> ast::NodeId {
match *self {
ii_item(i) => i.id,
ii_foreign(i) => i.id,
ii_method(_, _, m) => m.id,
}
}
fn accept<E: Clone, V:Visitor<E>>(&self, e: E, v: &mut V) {
match *self {
ii_item(i) => v.visit_item(i, e),
ii_foreign(i) => v.visit_foreign_item(i, e),
ii_method(_, _, m) => visit::walk_method_helper(v, m, e),
}
}
}
/* True if d is either a def_self, or a chain of def_upvars
referring to a def_self */
pub fn is_self(d: ast::Def) -> bool {
@ -443,12 +411,12 @@ impl<'a, O: IdVisitingOperation> Visitor<()> for IdVisitor<'a, O> {
visit::walk_view_item(self, view_item, env)
}
fn visit_foreign_item(&mut self, foreign_item: @foreign_item, env: ()) {
fn visit_foreign_item(&mut self, foreign_item: &foreign_item, env: ()) {
self.operation.visit_id(foreign_item.id);
visit::walk_foreign_item(self, foreign_item, env)
}
fn visit_item(&mut self, item: @item, env: ()) {
fn visit_item(&mut self, item: &item, env: ()) {
if !self.pass_through_items {
if self.visited_outermost {
return
@ -472,17 +440,17 @@ impl<'a, O: IdVisitingOperation> Visitor<()> for IdVisitor<'a, O> {
self.visited_outermost = false
}
fn visit_local(&mut self, local: @Local, env: ()) {
fn visit_local(&mut self, local: &Local, env: ()) {
self.operation.visit_id(local.id);
visit::walk_local(self, local, env)
}
fn visit_block(&mut self, block: P<Block>, env: ()) {
fn visit_block(&mut self, block: &Block, env: ()) {
self.operation.visit_id(block.id);
visit::walk_block(self, block, env)
}
fn visit_stmt(&mut self, statement: @Stmt, env: ()) {
fn visit_stmt(&mut self, statement: &Stmt, env: ()) {
self.operation.visit_id(ast_util::stmt_id(statement));
visit::walk_stmt(self, statement, env)
}
@ -493,7 +461,7 @@ impl<'a, O: IdVisitingOperation> Visitor<()> for IdVisitor<'a, O> {
}
fn visit_expr(&mut self, expression: @Expr, env: ()) {
fn visit_expr(&mut self, expression: &Expr, env: ()) {
{
let optional_callee_id = expression.get_callee_id();
for callee_id in optional_callee_id.iter() {
@ -521,7 +489,7 @@ impl<'a, O: IdVisitingOperation> Visitor<()> for IdVisitor<'a, O> {
fn visit_fn(&mut self,
function_kind: &visit::fn_kind,
function_declaration: &fn_decl,
block: P<Block>,
block: &Block,
span: Span,
node_id: NodeId,
env: ()) {
@ -572,7 +540,7 @@ impl<'a, O: IdVisitingOperation> Visitor<()> for IdVisitor<'a, O> {
}
fn visit_struct_def(&mut self,
struct_def: @struct_def,
struct_def: &struct_def,
ident: ast::Ident,
generics: &ast::Generics,
id: NodeId,
@ -598,7 +566,12 @@ pub fn visit_ids_for_inlined_item<O: IdVisitingOperation>(item: &inlined_item,
pass_through_items: true,
visited_outermost: false,
};
item.accept((), &mut id_visitor);
match *item {
ii_item(i) => id_visitor.visit_item(i, ()),
ii_foreign(i) => id_visitor.visit_foreign_item(i, ()),
ii_method(_, _, m) => visit::walk_method_helper(&mut id_visitor, m, ()),
}
}
struct IdRangeComputingVisitor {

2
src/libsyntax/ext/expand.rs
View File

@ -1128,7 +1128,7 @@ mod test {
impl Visitor<()> for NewPathExprFinderContext {
fn visit_expr(&mut self, expr: @ast::Expr, _: ()) {
fn visit_expr(&mut self, expr: &ast::Expr, _: ()) {
match *expr {
ast::Expr{id:_,span:_,node:ast::ExprPath(ref p)} => {
self.path_accumulator.push(p.clone());

263
src/libsyntax/fold.rs
View File

@ -84,32 +84,7 @@ pub trait ast_fold {
}
fn fold_foreign_item(&mut self, ni: @foreign_item) -> @foreign_item {
let fold_attribute = |x| fold_attribute_(x, self);
@ast::foreign_item {
ident: self.fold_ident(ni.ident),
attrs: ni.attrs.map(|x| fold_attribute(*x)),
node:
match ni.node {
foreign_item_fn(ref fdec, ref generics) => {
foreign_item_fn(
P(fn_decl {
inputs: fdec.inputs.map(|a| fold_arg_(a,
self)),
output: self.fold_ty(fdec.output),
cf: fdec.cf,
variadic: fdec.variadic
}),
fold_generics(generics, self))
}
foreign_item_static(t, m) => {
foreign_item_static(self.fold_ty(t), m)
}
},
id: self.new_id(ni.id),
span: self.new_span(ni.span),
vis: ni.vis,
}
noop_fold_foreign_item(ni, self)
}
fn fold_item(&mut self, i: @item) -> SmallVector<@item> {
@ -134,24 +109,16 @@ pub trait ast_fold {
noop_fold_item_underscore(i, self)
}
fn fold_fn_decl(&mut self, d: &fn_decl) -> P<fn_decl> {
noop_fold_fn_decl(d, self)
}
fn fold_type_method(&mut self, m: &TypeMethod) -> TypeMethod {
noop_fold_type_method(m, self)
}
fn fold_method(&mut self, m: @method) -> @method {
@ast::method {
ident: self.fold_ident(m.ident),
attrs: m.attrs.map(|a| fold_attribute_(*a, self)),
generics: fold_generics(&m.generics, self),
explicit_self: self.fold_explicit_self(&m.explicit_self),
purity: m.purity,
decl: fold_fn_decl(m.decl, self),
body: self.fold_block(m.body),
id: self.new_id(m.id),
span: self.new_span(m.span),
self_id: self.new_id(m.self_id),
vis: m.vis,
}
noop_fold_method(m, self)
}
fn fold_block(&mut self, b: P<Block>) -> P<Block> {
@ -171,48 +138,7 @@ pub trait ast_fold {
}
fn fold_pat(&mut self, p: @Pat) -> @Pat {
let node = match p.node {
PatWild => PatWild,
PatWildMulti => PatWildMulti,
PatIdent(binding_mode, ref pth, ref sub) => {
PatIdent(binding_mode,
self.fold_path(pth),
sub.map(|x| self.fold_pat(x)))
}
PatLit(e) => PatLit(self.fold_expr(e)),
PatEnum(ref pth, ref pats) => {
PatEnum(self.fold_path(pth),
pats.as_ref().map(|pats| pats.map(|x| self.fold_pat(*x))))
}
PatStruct(ref pth, ref fields, etc) => {
let pth_ = self.fold_path(pth);
let fs = fields.map(|f| {
ast::FieldPat {
ident: f.ident,
pat: self.fold_pat(f.pat)
}
});
PatStruct(pth_, fs, etc)
}
PatTup(ref elts) => PatTup(elts.map(|x| self.fold_pat(*x))),
PatBox(inner) => PatBox(self.fold_pat(inner)),
PatUniq(inner) => PatUniq(self.fold_pat(inner)),
PatRegion(inner) => PatRegion(self.fold_pat(inner)),
PatRange(e1, e2) => {
PatRange(self.fold_expr(e1), self.fold_expr(e2))
},
PatVec(ref before, ref slice, ref after) => {
PatVec(before.map(|x| self.fold_pat(*x)),
slice.map(|x| self.fold_pat(x)),
after.map(|x| self.fold_pat(*x)))
}
};
@Pat {
id: self.new_id(p.id),
span: self.new_span(p.span),
node: node,
}
noop_fold_pat(p, self)
}
fn fold_decl(&mut self, d: @Decl) -> SmallVector<@Decl> {
@ -252,7 +178,7 @@ pub trait ast_fold {
region: fold_opt_lifetime(&f.region, self),
onceness: f.onceness,
bounds: fold_opt_bounds(&f.bounds, self),
decl: fold_fn_decl(f.decl, self),
decl: self.fold_fn_decl(f.decl),
lifetimes: f.lifetimes.map(|l| fold_lifetime(l, self)),
})
}
@ -261,7 +187,7 @@ pub trait ast_fold {
lifetimes: f.lifetimes.map(|l| fold_lifetime(l, self)),
purity: f.purity,
abis: f.abis,
decl: fold_fn_decl(f.decl, self)
decl: self.fold_fn_decl(f.decl)
})
}
ty_tup(ref tys) => ty_tup(tys.map(|&ty| self.fold_ty(ty))),
@ -410,7 +336,7 @@ pub trait ast_fold {
/* some little folds that probably aren't useful to have in ast_fold itself*/
//used in noop_fold_item and noop_fold_crate and noop_fold_crate_directive
fn fold_meta_item_<T:ast_fold>(mi: @MetaItem, fld: &mut T) -> @MetaItem {
fn fold_meta_item_<T: ast_fold>(mi: @MetaItem, fld: &mut T) -> @MetaItem {
@Spanned {
node:
match mi.node {
@ -428,7 +354,7 @@ fn fold_meta_item_<T:ast_fold>(mi: @MetaItem, fld: &mut T) -> @MetaItem {
}
//used in noop_fold_item and noop_fold_crate
fn fold_attribute_<T:ast_fold>(at: Attribute, fld: &mut T) -> Attribute {
fn fold_attribute_<T: ast_fold>(at: Attribute, fld: &mut T) -> Attribute {
Spanned {
span: fld.new_span(at.span),
node: ast::Attribute_ {
@ -440,7 +366,7 @@ fn fold_attribute_<T:ast_fold>(at: Attribute, fld: &mut T) -> Attribute {
}
//used in noop_fold_foreign_item and noop_fold_fn_decl
fn fold_arg_<T:ast_fold>(a: &arg, fld: &mut T) -> arg {
fn fold_arg_<T: ast_fold>(a: &arg, fld: &mut T) -> arg {
ast::arg {
ty: fld.fold_ty(a.ty),
pat: fld.fold_pat(a.pat),
@ -450,7 +376,7 @@ fn fold_arg_<T:ast_fold>(a: &arg, fld: &mut T) -> arg {
// build a new vector of tts by appling the ast_fold's fold_ident to
// all of the identifiers in the token trees.
pub fn fold_tts<T:ast_fold>(tts: &[token_tree], fld: &mut T) -> ~[token_tree] {
pub fn fold_tts<T: ast_fold>(tts: &[token_tree], fld: &mut T) -> ~[token_tree] {
tts.map(|tt| {
match *tt {
tt_tok(span, ref tok) =>
@ -468,7 +394,7 @@ pub fn fold_tts<T:ast_fold>(tts: &[token_tree], fld: &mut T) -> ~[token_tree] {
}
// apply ident folder if it's an ident, otherwise leave it alone
fn maybe_fold_ident<T:ast_fold>(t: &token::Token, fld: &mut T) -> token::Token {
fn maybe_fold_ident<T: ast_fold>(t: &token::Token, fld: &mut T) -> token::Token {
match *t {
token::IDENT(id, followed_by_colons) => {
token::IDENT(fld.fold_ident(id), followed_by_colons)
@ -477,8 +403,8 @@ fn maybe_fold_ident<T:ast_fold>(t: &token::Token, fld: &mut T) -> token::Token {
}
}
pub fn fold_fn_decl<T:ast_fold>(decl: &ast::fn_decl, fld: &mut T)
-> P<fn_decl> {
pub fn noop_fold_fn_decl<T: ast_fold>(decl: &fn_decl, fld: &mut T)
-> P<fn_decl> {
P(fn_decl {
inputs: decl.inputs.map(|x| fold_arg_(x, fld)), // bad copy
output: fld.fold_ty(decl.output),
@ -487,15 +413,15 @@ pub fn fold_fn_decl<T:ast_fold>(decl: &ast::fn_decl, fld: &mut T)
})
}
fn fold_ty_param_bound<T:ast_fold>(tpb: &TyParamBound, fld: &mut T)
-> TyParamBound {
fn fold_ty_param_bound<T: ast_fold>(tpb: &TyParamBound, fld: &mut T)
-> TyParamBound {
match *tpb {
TraitTyParamBound(ref ty) => TraitTyParamBound(fold_trait_ref(ty, fld)),
RegionTyParamBound => RegionTyParamBound
}
}
pub fn fold_ty_param<T:ast_fold>(tp: &TyParam, fld: &mut T) -> TyParam {
pub fn fold_ty_param<T: ast_fold>(tp: &TyParam, fld: &mut T) -> TyParam {
TyParam {
ident: tp.ident,
id: fld.new_id(tp.id),
@ -503,12 +429,12 @@ pub fn fold_ty_param<T:ast_fold>(tp: &TyParam, fld: &mut T) -> TyParam {
}
}
pub fn fold_ty_params<T:ast_fold>(tps: &OptVec<TyParam>, fld: &mut T)
-> OptVec<TyParam> {
pub fn fold_ty_params<T: ast_fold>(tps: &OptVec<TyParam>, fld: &mut T)
-> OptVec<TyParam> {
tps.map(|tp| fold_ty_param(tp, fld))
}
pub fn fold_lifetime<T:ast_fold>(l: &Lifetime, fld: &mut T) -> Lifetime {
pub fn fold_lifetime<T: ast_fold>(l: &Lifetime, fld: &mut T) -> Lifetime {
Lifetime {
id: fld.new_id(l.id),
span: fld.new_span(l.span),
@ -516,37 +442,36 @@ pub fn fold_lifetime<T:ast_fold>(l: &Lifetime, fld: &mut T) -> Lifetime {
}
}
pub fn fold_lifetimes<T:ast_fold>(lts: &OptVec<Lifetime>, fld: &mut T)
-> OptVec<Lifetime> {
pub fn fold_lifetimes<T: ast_fold>(lts: &OptVec<Lifetime>, fld: &mut T)
-> OptVec<Lifetime> {
lts.map(|l| fold_lifetime(l, fld))
}
pub fn fold_opt_lifetime<T:ast_fold>(o_lt: &Option<Lifetime>, fld: &mut T)
-> Option<Lifetime> {
pub fn fold_opt_lifetime<T: ast_fold>(o_lt: &Option<Lifetime>, fld: &mut T)
-> Option<Lifetime> {
o_lt.as_ref().map(|lt| fold_lifetime(lt, fld))
}
pub fn fold_generics<T:ast_fold>(generics: &Generics, fld: &mut T) -> Generics {
pub fn fold_generics<T: ast_fold>(generics: &Generics, fld: &mut T) -> Generics {
Generics {ty_params: fold_ty_params(&generics.ty_params, fld),
lifetimes: fold_lifetimes(&generics.lifetimes, fld)}
}
fn fold_struct_def<T:ast_fold>(struct_def: @ast::struct_def, fld: &mut T)
-> @ast::struct_def {
fn fold_struct_def<T: ast_fold>(struct_def: @struct_def, fld: &mut T) -> @struct_def {
@ast::struct_def {
fields: struct_def.fields.map(|f| fold_struct_field(f, fld)),
ctor_id: struct_def.ctor_id.map(|cid| fld.new_id(cid)),
}
}
fn fold_trait_ref<T:ast_fold>(p: &trait_ref, fld: &mut T) -> trait_ref {
fn fold_trait_ref<T: ast_fold>(p: &trait_ref, fld: &mut T) -> trait_ref {
ast::trait_ref {
path: fld.fold_path(&p.path),
ref_id: fld.new_id(p.ref_id),
}
}
fn fold_struct_field<T:ast_fold>(f: &struct_field, fld: &mut T) -> struct_field {
fn fold_struct_field<T: ast_fold>(f: &struct_field, fld: &mut T) -> struct_field {
Spanned {
node: ast::struct_field_ {
kind: f.node.kind,
@ -558,7 +483,7 @@ fn fold_struct_field<T:ast_fold>(f: &struct_field, fld: &mut T) -> struct_field
}
}
fn fold_field_<T:ast_fold>(field: Field, folder: &mut T) -> Field {
fn fold_field_<T: ast_fold>(field: Field, folder: &mut T) -> Field {
ast::Field {
ident: respan(field.ident.span, folder.fold_ident(field.ident.node)),
expr: folder.fold_expr(field.expr),
@ -566,15 +491,15 @@ fn fold_field_<T:ast_fold>(field: Field, folder: &mut T) -> Field {
}
}
fn fold_mt<T:ast_fold>(mt: &mt, folder: &mut T) -> mt {
fn fold_mt<T: ast_fold>(mt: &mt, folder: &mut T) -> mt {
mt {
ty: folder.fold_ty(mt.ty),
mutbl: mt.mutbl,
}
}
fn fold_opt_bounds<T:ast_fold>(b: &Option<OptVec<TyParamBound>>, folder: &mut T)
-> Option<OptVec<TyParamBound>> {
fn fold_opt_bounds<T: ast_fold>(b: &Option<OptVec<TyParamBound>>, folder: &mut T)
-> Option<OptVec<TyParamBound>> {
b.as_ref().map(|bounds| {
bounds.map(|bound| {
fold_ty_param_bound(bound, folder)
@ -582,15 +507,14 @@ fn fold_opt_bounds<T:ast_fold>(b: &Option<OptVec<TyParamBound>>, folder: &mut T)
})
}
fn fold_variant_arg_<T:ast_fold>(va: &variant_arg, folder: &mut T)
-> variant_arg {
fn fold_variant_arg_<T: ast_fold>(va: &variant_arg, folder: &mut T) -> variant_arg {
ast::variant_arg {
ty: folder.fold_ty(va.ty),
id: folder.new_id(va.id)
}
}
pub fn noop_fold_block<T:ast_fold>(b: P<Block>, folder: &mut T) -> P<Block> {
pub fn noop_fold_block<T: ast_fold>(b: P<Block>, folder: &mut T) -> P<Block> {
let view_items = b.view_items.map(|x| folder.fold_view_item(x));
let stmts = b.stmts.iter().flat_map(|s| folder.fold_stmt(*s).move_iter()).collect();
P(Block {
@ -603,14 +527,14 @@ pub fn noop_fold_block<T:ast_fold>(b: P<Block>, folder: &mut T) -> P<Block> {
})
}
pub fn noop_fold_item_underscore<T:ast_fold>(i: &item_, folder: &mut T) -> item_ {
pub fn noop_fold_item_underscore<T: ast_fold>(i: &item_, folder: &mut T) -> item_ {
match *i {
item_static(t, m, e) => {
item_static(folder.fold_ty(t), m, folder.fold_expr(e))
}
item_fn(decl, purity, abi, ref generics, body) => {
item_fn(
fold_fn_decl(decl, folder),
folder.fold_fn_decl(decl),
purity,
abi,
fold_generics(generics, folder),
@ -660,13 +584,12 @@ pub fn noop_fold_item_underscore<T:ast_fold>(i: &item_, folder: &mut T) -> item_
}
}
pub fn noop_fold_type_method<T:ast_fold>(m: &TypeMethod, fld: &mut T)
-> TypeMethod {
pub fn noop_fold_type_method<T: ast_fold>(m: &TypeMethod, fld: &mut T) -> TypeMethod {
TypeMethod {
ident: fld.fold_ident(m.ident),
attrs: m.attrs.map(|a| fold_attribute_(*a, fld)),
purity: m.purity,
decl: fold_fn_decl(m.decl, fld),
decl: fld.fold_fn_decl(m.decl),
generics: fold_generics(&m.generics, fld),
explicit_self: fld.fold_explicit_self(&m.explicit_self),
id: fld.new_id(m.id),
@ -674,7 +597,7 @@ pub fn noop_fold_type_method<T:ast_fold>(m: &TypeMethod, fld: &mut T)
}
}
pub fn noop_fold_mod<T:ast_fold>(m: &_mod, folder: &mut T) -> _mod {
pub fn noop_fold_mod<T: ast_fold>(m: &_mod, folder: &mut T) -> _mod {
ast::_mod {
view_items: m.view_items
.iter()
@ -683,7 +606,7 @@ pub fn noop_fold_mod<T:ast_fold>(m: &_mod, folder: &mut T) -> _mod {
}
}
pub fn noop_fold_crate<T:ast_fold>(c: Crate, folder: &mut T) -> Crate {
pub fn noop_fold_crate<T: ast_fold>(c: Crate, folder: &mut T) -> Crate {
let fold_meta_item = |x| fold_meta_item_(x, folder);
let fold_attribute = |x| fold_attribute_(x, folder);
@ -695,11 +618,11 @@ pub fn noop_fold_crate<T:ast_fold>(c: Crate, folder: &mut T) -> Crate {
}
}
pub fn noop_fold_item<T:ast_fold>(i: @ast::item, folder: &mut T)
-> SmallVector<@ast::item> {
pub fn noop_fold_item<T: ast_fold>(i: &item, folder: &mut T)
-> SmallVector<@item> {
let fold_attribute = |x| fold_attribute_(x, folder);
SmallVector::one(@ast::item {
SmallVector::one(@item {
ident: folder.fold_ident(i.ident),
attrs: i.attrs.map(|e| fold_attribute(*e)),
id: folder.new_id(i.id),
@ -709,7 +632,92 @@ pub fn noop_fold_item<T:ast_fold>(i: @ast::item, folder: &mut T)
})
}
pub fn noop_fold_expr<T:ast_fold>(e: @ast::Expr, folder: &mut T) -> @ast::Expr {
pub fn noop_fold_foreign_item<T: ast_fold>(ni: &foreign_item, folder: &mut T)
-> @foreign_item {
@foreign_item {
ident: folder.fold_ident(ni.ident),
attrs: ni.attrs.map(|x| fold_attribute_(*x, folder)),
node: match ni.node {
foreign_item_fn(ref fdec, ref generics) => {
foreign_item_fn(P(fn_decl {
inputs: fdec.inputs.map(|a| fold_arg_(a, folder)),
output: folder.fold_ty(fdec.output),
cf: fdec.cf,
variadic: fdec.variadic
}), fold_generics(generics, folder))
}
foreign_item_static(t, m) => {
foreign_item_static(folder.fold_ty(t), m)
}
},
id: folder.new_id(ni.id),
span: folder.new_span(ni.span),
vis: ni.vis,
}
}
pub fn noop_fold_method<T: ast_fold>(m: &method, folder: &mut T) -> @method {
@method {
ident: folder.fold_ident(m.ident),
attrs: m.attrs.map(|a| fold_attribute_(*a, folder)),
generics: fold_generics(&m.generics, folder),
explicit_self: folder.fold_explicit_self(&m.explicit_self),
purity: m.purity,
decl: folder.fold_fn_decl(m.decl),
body: folder.fold_block(m.body),
id: folder.new_id(m.id),
span: folder.new_span(m.span),
self_id: folder.new_id(m.self_id),
vis: m.vis
}
}
pub fn noop_fold_pat<T: ast_fold>(p: @Pat, folder: &mut T) -> @Pat {
let node = match p.node {
PatWild => PatWild,
PatWildMulti => PatWildMulti,
PatIdent(binding_mode, ref pth, ref sub) => {
PatIdent(binding_mode,
folder.fold_path(pth),
sub.map(|x| folder.fold_pat(x)))
}
PatLit(e) => PatLit(folder.fold_expr(e)),
PatEnum(ref pth, ref pats) => {
PatEnum(folder.fold_path(pth),
pats.as_ref().map(|pats| pats.map(|x| folder.fold_pat(*x))))
}
PatStruct(ref pth, ref fields, etc) => {
let pth_ = folder.fold_path(pth);
let fs = fields.map(|f| {
ast::FieldPat {
ident: f.ident,
pat: folder.fold_pat(f.pat)
}
});
PatStruct(pth_, fs, etc)
}
PatTup(ref elts) => PatTup(elts.map(|x| folder.fold_pat(*x))),
PatBox(inner) => PatBox(folder.fold_pat(inner)),
PatUniq(inner) => PatUniq(folder.fold_pat(inner)),
PatRegion(inner) => PatRegion(folder.fold_pat(inner)),
PatRange(e1, e2) => {
PatRange(folder.fold_expr(e1), folder.fold_expr(e2))
},
PatVec(ref before, ref slice, ref after) => {
PatVec(before.map(|x| folder.fold_pat(*x)),
slice.map(|x| folder.fold_pat(x)),
after.map(|x| folder.fold_pat(*x)))
}
};
@Pat {
id: folder.new_id(p.id),
span: folder.new_span(p.span),
node: node,
}
}
pub fn noop_fold_expr<T: ast_fold>(e: @Expr, folder: &mut T) -> @Expr {
let fold_field = |x| fold_field_(x, folder);
let node = match e.node {
@ -776,13 +784,10 @@ pub fn noop_fold_expr<T:ast_fold>(e: @ast::Expr, folder: &mut T) -> @ast::Expr {
arms.map(|x| folder.fold_arm(x)))
}
ExprFnBlock(decl, body) => {
ExprFnBlock(
fold_fn_decl(decl, folder),
folder.fold_block(body)
)
ExprFnBlock(folder.fold_fn_decl(decl), folder.fold_block(body))
}
ExprProc(decl, body) => {
ExprProc(fold_fn_decl(decl, folder), folder.fold_block(body))
ExprProc(folder.fold_fn_decl(decl), folder.fold_block(body))
}
ExprBlock(blk) => ExprBlock(folder.fold_block(blk)),
ExprAssign(el, er) => {
@ -835,7 +840,7 @@ pub fn noop_fold_expr<T:ast_fold>(e: @ast::Expr, folder: &mut T) -> @ast::Expr {
}
}
pub fn noop_fold_stmt<T:ast_fold>(s: &Stmt, folder: &mut T) -> SmallVector<@Stmt> {
pub fn noop_fold_stmt<T: ast_fold>(s: &Stmt, folder: &mut T) -> SmallVector<@Stmt> {
let nodes = match s.node {
StmtDecl(d, nid) => {
folder.fold_decl(d).move_iter()

194
src/libsyntax/visit.rs
View File

@ -64,34 +64,34 @@ pub fn generics_of_fn(fk: &fn_kind) -> Generics {
}
}
pub trait Visitor<E:Clone> {
pub trait Visitor<E: Clone> {
fn visit_ident(&mut self, _sp: Span, _ident: Ident, _e: E) {
/*! Visit the idents */
}
fn visit_mod(&mut self, m:&_mod, _s:Span, _n:NodeId, e:E) { walk_mod(self, m, e) }
fn visit_view_item(&mut self, i:&view_item, e:E) { walk_view_item(self, i, e) }
fn visit_foreign_item(&mut self, i:@foreign_item, e:E) { walk_foreign_item(self, i, e) }
fn visit_item(&mut self, i:@item, e:E) { walk_item(self, i, e) }
fn visit_local(&mut self, l:@Local, e:E) { walk_local(self, l, e) }
fn visit_block(&mut self, b:P<Block>, e:E) { walk_block(self, b, e) }
fn visit_stmt(&mut self, s:@Stmt, e:E) { walk_stmt(self, s, e) }
fn visit_arm(&mut self, a:&Arm, e:E) { walk_arm(self, a, e) }
fn visit_pat(&mut self, p:&Pat, e:E) { walk_pat(self, p, e) }
fn visit_decl(&mut self, d:@Decl, e:E) { walk_decl(self, d, e) }
fn visit_expr(&mut self, ex:@Expr, e:E) { walk_expr(self, ex, e) }
fn visit_expr_post(&mut self, _ex:@Expr, _e:E) { }
fn visit_ty(&mut self, t:&Ty, e:E) { walk_ty(self, t, e) }
fn visit_generics(&mut self, g:&Generics, e:E) { walk_generics(self, g, e) }
fn visit_fn(&mut self, fk:&fn_kind, fd:&fn_decl, b:P<Block>, s:Span, n:NodeId, e:E) {
fn visit_mod(&mut self, m: &_mod, _s: Span, _n: NodeId, e: E) { walk_mod(self, m, e) }
fn visit_view_item(&mut self, i: &view_item, e: E) { walk_view_item(self, i, e) }
fn visit_foreign_item(&mut self, i: &foreign_item, e: E) { walk_foreign_item(self, i, e) }
fn visit_item(&mut self, i: &item, e: E) { walk_item(self, i, e) }
fn visit_local(&mut self, l: &Local, e: E) { walk_local(self, l, e) }
fn visit_block(&mut self, b: &Block, e: E) { walk_block(self, b, e) }
fn visit_stmt(&mut self, s: &Stmt, e: E) { walk_stmt(self, s, e) }
fn visit_arm(&mut self, a: &Arm, e: E) { walk_arm(self, a, e) }
fn visit_pat(&mut self, p: &Pat, e: E) { walk_pat(self, p, e) }
fn visit_decl(&mut self, d: &Decl, e: E) { walk_decl(self, d, e) }
fn visit_expr(&mut self, ex: &Expr, e: E) { walk_expr(self, ex, e) }
fn visit_expr_post(&mut self, _ex: &Expr, _e: E) { }
fn visit_ty(&mut self, t: &Ty, e: E) { walk_ty(self, t, e) }
fn visit_generics(&mut self, g: &Generics, e: E) { walk_generics(self, g, e) }
fn visit_fn(&mut self, fk: &fn_kind, fd: &fn_decl, b: &Block, s: Span, n: NodeId, e: E) {
walk_fn(self, fk, fd, b, s, n , e)
}
fn visit_ty_method(&mut self, t:&TypeMethod, e:E) { walk_ty_method(self, t, e) }
fn visit_trait_method(&mut self, t:&trait_method, e:E) { walk_trait_method(self, t, e) }
fn visit_struct_def(&mut self, s:@struct_def, i:Ident, g:&Generics, n:NodeId, e:E) {
fn visit_ty_method(&mut self, t: &TypeMethod, e: E) { walk_ty_method(self, t, e) }
fn visit_trait_method(&mut self, t: &trait_method, e: E) { walk_trait_method(self, t, e) }
fn visit_struct_def(&mut self, s: &struct_def, i: Ident, g: &Generics, n: NodeId, e: E) {
walk_struct_def(self, s, i, g, n, e)
}
fn visit_struct_field(&mut self, s:&struct_field, e:E) { walk_struct_field(self, s, e) }
fn visit_variant(&mut self, v:&variant, g:&Generics, e:E) { walk_variant(self, v, g, e) }
fn visit_struct_field(&mut self, s: &struct_field, e: E) { walk_struct_field(self, s, e) }
fn visit_variant(&mut self, v: &variant, g: &Generics, e: E) { walk_variant(self, v, g, e) }
fn visit_opt_lifetime_ref(&mut self,
_span: Span,
opt_lifetime: &Option<Lifetime>,
@ -115,7 +115,7 @@ pub trait Visitor<E:Clone> {
fn visit_explicit_self(&mut self, es: &explicit_self, e: E) {
walk_explicit_self(self, es, e)
}
fn visit_mac(&mut self, macro:&mac, e:E) {
fn visit_mac(&mut self, macro: &mac, e: E) {
walk_mac(self, macro, e)
}
fn visit_path(&mut self, path: &Path, _id: ast::NodeId, e: E) {
@ -123,11 +123,11 @@ pub trait Visitor<E:Clone> {
}
}
pub fn walk_crate<E:Clone, V:Visitor<E>>(visitor: &mut V, crate: &Crate, env: E) {
pub fn walk_crate<E: Clone, V: Visitor<E>>(visitor: &mut V, crate: &Crate, env: E) {
visitor.visit_mod(&crate.module, crate.span, CRATE_NODE_ID, env)
}
pub fn walk_mod<E:Clone, V:Visitor<E>>(visitor: &mut V, module: &_mod, env: E) {
pub fn walk_mod<E: Clone, V: Visitor<E>>(visitor: &mut V, module: &_mod, env: E) {
for view_item in module.view_items.iter() {
visitor.visit_view_item(view_item, env.clone())
}
@ -137,7 +137,7 @@ pub fn walk_mod<E:Clone, V:Visitor<E>>(visitor: &mut V, module: &_mod, env: E) {
}
}
pub fn walk_view_item<E:Clone, V:Visitor<E>>(visitor: &mut V, vi: &view_item, env: E) {
pub fn walk_view_item<E: Clone, V: Visitor<E>>(visitor: &mut V, vi: &view_item, env: E) {
match vi.node {
view_item_extern_mod(name, _, _) => {
visitor.visit_ident(vi.span, name, env)
@ -164,7 +164,7 @@ pub fn walk_view_item<E:Clone, V:Visitor<E>>(visitor: &mut V, vi: &view_item, en
}
}
pub fn walk_local<E:Clone, V:Visitor<E>>(visitor: &mut V, local: &Local, env: E) {
pub fn walk_local<E: Clone, V: Visitor<E>>(visitor: &mut V, local: &Local, env: E) {
visitor.visit_pat(local.pat, env.clone());
visitor.visit_ty(local.ty, env.clone());
match local.init {
@ -173,9 +173,9 @@ pub fn walk_local<E:Clone, V:Visitor<E>>(visitor: &mut V, local: &Local, env: E)
}
}
fn walk_explicit_self<E:Clone, V:Visitor<E>>(visitor: &mut V,
explicit_self: &explicit_self,
env: E) {
fn walk_explicit_self<E: Clone, V: Visitor<E>>(visitor: &mut V,
explicit_self: &explicit_self,
env: E) {
match explicit_self.node {
sty_static | sty_value(_) | sty_box(_) | sty_uniq(_) => {
}
@ -185,13 +185,13 @@ fn walk_explicit_self<E:Clone, V:Visitor<E>>(visitor: &mut V,
}
}
fn walk_trait_ref<E:Clone, V:Visitor<E>>(visitor: &mut V,
trait_ref: &ast::trait_ref,
env: E) {
fn walk_trait_ref<E: Clone, V: Visitor<E>>(visitor: &mut V,
trait_ref: &trait_ref,
env: E) {
visitor.visit_path(&trait_ref.path, trait_ref.ref_id, env)
}
pub fn walk_item<E:Clone, V:Visitor<E>>(visitor: &mut V, item: &item, env: E) {
pub fn walk_item<E: Clone, V: Visitor<E>>(visitor: &mut V, item: &item, env: E) {
visitor.visit_ident(item.span, item.ident, env.clone());
match item.node {
item_static(typ, _, expr) => {
@ -261,19 +261,19 @@ pub fn walk_item<E:Clone, V:Visitor<E>>(visitor: &mut V, item: &item, env: E) {
}
}
pub fn walk_enum_def<E:Clone, V:Visitor<E>>(visitor: &mut V,
enum_definition: &ast::enum_def,
generics: &Generics,
env: E) {
pub fn walk_enum_def<E: Clone, V:Visitor<E>>(visitor: &mut V,
enum_definition: &enum_def,
generics: &Generics,
env: E) {
for &variant in enum_definition.variants.iter() {
visitor.visit_variant(variant, generics, env.clone());
}
}
pub fn walk_variant<E:Clone, V:Visitor<E>>(visitor:&mut V,
variant: &variant,
generics: &Generics,
env: E) {
pub fn walk_variant<E: Clone, V: Visitor<E>>(visitor: &mut V,
variant: &variant,
generics: &Generics,
env: E) {
visitor.visit_ident(variant.span, variant.node.name, env.clone());
match variant.node.kind {
@ -296,11 +296,11 @@ pub fn walk_variant<E:Clone, V:Visitor<E>>(visitor:&mut V,
}
}
pub fn skip_ty<E, V:Visitor<E>>(_: &mut V, _: &Ty, _: E) {
pub fn skip_ty<E, V: Visitor<E>>(_: &mut V, _: &Ty, _: E) {
// Empty!
}
pub fn walk_ty<E:Clone, V:Visitor<E>>(visitor: &mut V, typ: &Ty, env: E) {
pub fn walk_ty<E: Clone, V: Visitor<E>>(visitor: &mut V, typ: &Ty, env: E) {
match typ.node {
ty_uniq(ty) | ty_vec(ty) | ty_box(ty) => {
visitor.visit_ty(ty, env)
@ -357,15 +357,15 @@ pub fn walk_ty<E:Clone, V:Visitor<E>>(visitor: &mut V, typ: &Ty, env: E) {
}
}
fn walk_lifetime_decls<E:Clone, V:Visitor<E>>(visitor: &mut V,
lifetimes: &OptVec<Lifetime>,
env: E) {
fn walk_lifetime_decls<E: Clone, V: Visitor<E>>(visitor: &mut V,
lifetimes: &OptVec<Lifetime>,
env: E) {
for l in lifetimes.iter() {
visitor.visit_lifetime_decl(l, env.clone());
}
}
pub fn walk_path<E:Clone, V:Visitor<E>>(visitor: &mut V, path: &Path, env: E) {
pub fn walk_path<E: Clone, V: Visitor<E>>(visitor: &mut V, path: &Path, env: E) {
for segment in path.segments.iter() {
visitor.visit_ident(path.span, segment.identifier, env.clone());
@ -378,7 +378,7 @@ pub fn walk_path<E:Clone, V:Visitor<E>>(visitor: &mut V, path: &Path, env: E) {
}
}
pub fn walk_pat<E:Clone, V:Visitor<E>>(visitor: &mut V, pattern: &Pat, env: E) {
pub fn walk_pat<E: Clone, V: Visitor<E>>(visitor: &mut V, pattern: &Pat, env: E) {
match pattern.node {
PatEnum(ref path, ref children) => {
visitor.visit_path(path, pattern.id, env.clone());
@ -431,9 +431,9 @@ pub fn walk_pat<E:Clone, V:Visitor<E>>(visitor: &mut V, pattern: &Pat, env: E) {
}
}
pub fn walk_foreign_item<E:Clone, V:Visitor<E>>(visitor: &mut V,
foreign_item: &foreign_item,
env: E) {
pub fn walk_foreign_item<E: Clone, V: Visitor<E>>(visitor: &mut V,
foreign_item: &foreign_item,
env: E) {
visitor.visit_ident(foreign_item.span, foreign_item.ident, env.clone());
match foreign_item.node {
@ -445,9 +445,9 @@ pub fn walk_foreign_item<E:Clone, V:Visitor<E>>(visitor: &mut V,
}
}
pub fn walk_ty_param_bounds<E:Clone, V:Visitor<E>>(visitor: &mut V,
bounds: &OptVec<TyParamBound>,
env: E) {
pub fn walk_ty_param_bounds<E: Clone, V: Visitor<E>>(visitor: &mut V,
bounds: &OptVec<TyParamBound>,
env: E) {
for bound in bounds.iter() {
match *bound {
TraitTyParamBound(ref typ) => {
@ -458,18 +458,18 @@ pub fn walk_ty_param_bounds<E:Clone, V:Visitor<E>>(visitor: &mut V,
}
}
pub fn walk_generics<E:Clone, V:Visitor<E>>(visitor: &mut V,
generics: &Generics,
env: E) {
pub fn walk_generics<E: Clone, V: Visitor<E>>(visitor: &mut V,
generics: &Generics,
env: E) {
for type_parameter in generics.ty_params.iter() {
walk_ty_param_bounds(visitor, &type_parameter.bounds, env.clone())
}
walk_lifetime_decls(visitor, &generics.lifetimes, env);
}
pub fn walk_fn_decl<E:Clone, V:Visitor<E>>(visitor: &mut V,
function_declaration: &fn_decl,
env: E) {
pub fn walk_fn_decl<E: Clone, V: Visitor<E>>(visitor: &mut V,
function_declaration: &fn_decl,
env: E) {
for argument in function_declaration.inputs.iter() {
visitor.visit_pat(argument.pat, env.clone());
visitor.visit_ty(argument.ty, env.clone())
@ -481,9 +481,9 @@ pub fn walk_fn_decl<E:Clone, V:Visitor<E>>(visitor: &mut V,
// visit_fn() and check for fk_method(). I named this visit_method_helper()
// because it is not a default impl of any method, though I doubt that really
// clarifies anything. - Niko
pub fn walk_method_helper<E:Clone, V:Visitor<E>>(visitor: &mut V,
method: &method,
env: E) {
pub fn walk_method_helper<E: Clone, V: Visitor<E>>(visitor: &mut V,
method: &method,
env: E) {
visitor.visit_ident(method.span, method.ident, env.clone());
visitor.visit_fn(&fk_method(method.ident, &method.generics, method),
method.decl,
@ -493,13 +493,13 @@ pub fn walk_method_helper<E:Clone, V:Visitor<E>>(visitor: &mut V,
env)
}
pub fn walk_fn<E:Clone, V:Visitor<E>>(visitor: &mut V,
function_kind: &fn_kind,
function_declaration: &fn_decl,
function_body: P<Block>,
_span: Span,
_: NodeId,
env: E) {
pub fn walk_fn<E: Clone, V: Visitor<E>>(visitor: &mut V,
function_kind: &fn_kind,
function_declaration: &fn_decl,
function_body: &Block,
_span: Span,
_: NodeId,
env: E) {
walk_fn_decl(visitor, function_declaration, env.clone());
match *function_kind {
@ -518,9 +518,9 @@ pub fn walk_fn<E:Clone, V:Visitor<E>>(visitor: &mut V,
visitor.visit_block(function_body, env)
}
pub fn walk_ty_method<E:Clone, V:Visitor<E>>(visitor: &mut V,
method_type: &TypeMethod,
env: E) {
pub fn walk_ty_method<E: Clone, V: Visitor<E>>(visitor: &mut V,
method_type: &TypeMethod,
env: E) {
visitor.visit_ident(method_type.span, method_type.ident, env.clone());
visitor.visit_explicit_self(&method_type.explicit_self, env.clone());
for argument_type in method_type.decl.inputs.iter() {
@ -530,9 +530,9 @@ pub fn walk_ty_method<E:Clone, V:Visitor<E>>(visitor: &mut V,
visitor.visit_ty(method_type.decl.output, env);
}
pub fn walk_trait_method<E:Clone, V:Visitor<E>>(visitor: &mut V,
trait_method: &trait_method,
env: E) {
pub fn walk_trait_method<E: Clone, V: Visitor<E>>(visitor: &mut V,
trait_method: &trait_method,
env: E) {
match *trait_method {
required(ref method_type) => {
visitor.visit_ty_method(method_type, env)
@ -541,20 +541,20 @@ pub fn walk_trait_method<E:Clone, V:Visitor<E>>(visitor: &mut V,
}
}
pub fn walk_struct_def<E:Clone, V:Visitor<E>>(visitor: &mut V,
struct_definition: @struct_def,
_: ast::Ident,
_: &Generics,
_: NodeId,
env: E) {
pub fn walk_struct_def<E: Clone, V: Visitor<E>>(visitor: &mut V,
struct_definition: &struct_def,
_: Ident,
_: &Generics,
_: NodeId,
env: E) {
for field in struct_definition.fields.iter() {
visitor.visit_struct_field(field, env.clone())
}
}
pub fn walk_struct_field<E:Clone, V:Visitor<E>>(visitor: &mut V,
struct_field: &struct_field,
env: E) {
pub fn walk_struct_field<E: Clone, V: Visitor<E>>(visitor: &mut V,
struct_field: &struct_field,
env: E) {
match struct_field.node.kind {
named_field(name, _) => {
visitor.visit_ident(struct_field.span, name, env.clone())
@ -565,7 +565,7 @@ pub fn walk_struct_field<E:Clone, V:Visitor<E>>(visitor: &mut V,
visitor.visit_ty(struct_field.node.ty, env)
}
pub fn walk_block<E:Clone, V:Visitor<E>>(visitor: &mut V, block: P<Block>, env: E) {
pub fn walk_block<E: Clone, V: Visitor<E>>(visitor: &mut V, block: &Block, env: E) {
for view_item in block.view_items.iter() {
visitor.visit_view_item(view_item, env.clone())
}
@ -575,7 +575,7 @@ pub fn walk_block<E:Clone, V:Visitor<E>>(visitor: &mut V, block: P<Block>, env:
walk_expr_opt(visitor, block.expr, env)
}
pub fn walk_stmt<E:Clone, V:Visitor<E>>(visitor: &mut V, statement: &Stmt, env: E) {
pub fn walk_stmt<E: Clone, V: Visitor<E>>(visitor: &mut V, statement: &Stmt, env: E) {
match statement.node {
StmtDecl(declaration, _) => visitor.visit_decl(declaration, env),
StmtExpr(expression, _) | StmtSemi(expression, _) => {
@ -585,35 +585,35 @@ pub fn walk_stmt<E:Clone, V:Visitor<E>>(visitor: &mut V, statement: &Stmt, env:
}
}
pub fn walk_decl<E:Clone, V:Visitor<E>>(visitor: &mut V, declaration: &Decl, env: E) {
pub fn walk_decl<E: Clone, V: Visitor<E>>(visitor: &mut V, declaration: &Decl, env: E) {
match declaration.node {
DeclLocal(ref local) => visitor.visit_local(*local, env),
DeclItem(item) => visitor.visit_item(item, env),
}
}
pub fn walk_expr_opt<E:Clone, V:Visitor<E>>(visitor: &mut V,
optional_expression: Option<@Expr>,
env: E) {
pub fn walk_expr_opt<E: Clone, V: Visitor<E>>(visitor: &mut V,
optional_expression: Option<@Expr>,
env: E) {
match optional_expression {
None => {}
Some(expression) => visitor.visit_expr(expression, env),
}
}
pub fn walk_exprs<E:Clone, V:Visitor<E>>(visitor: &mut V,
expressions: &[@Expr],
env: E) {
pub fn walk_exprs<E: Clone, V: Visitor<E>>(visitor: &mut V,
expressions: &[@Expr],
env: E) {
for expression in expressions.iter() {
visitor.visit_expr(*expression, env.clone())
}
}
pub fn walk_mac<E, V:Visitor<E>>(_: &mut V, _: &mac, _: E) {
pub fn walk_mac<E, V: Visitor<E>>(_: &mut V, _: &mac, _: E) {
// Empty!
}
pub fn walk_expr<E:Clone, V:Visitor<E>>(visitor: &mut V, expression: @Expr, env: E) {
pub fn walk_expr<E: Clone, V: Visitor<E>>(visitor: &mut V, expression: &Expr, env: E) {
match expression.node {
ExprVstore(subexpression, _) => {
visitor.visit_expr(subexpression, env.clone())
@ -745,7 +745,7 @@ pub fn walk_expr<E:Clone, V:Visitor<E>>(visitor: &mut V, expression: @Expr, env:
visitor.visit_expr_post(expression, env.clone())
}
pub fn walk_arm<E:Clone, V:Visitor<E>>(visitor: &mut V, arm: &Arm, env: E) {
pub fn walk_arm<E: Clone, V: Visitor<E>>(visitor: &mut V, arm: &Arm, env: E) {
for pattern in arm.pats.iter() {
visitor.visit_pat(*pattern, env.clone())
}