// in the HIR, especially for multiple identifiers.
use hir;
+use hir::map::Definitions;
+use hir::map::definitions::DefPathData;
+use hir::def_id::DefIndex;
use std::collections::BTreeMap;
use std::collections::HashMap;
// A copy of cached_id, but is also set to an id while a node is lowered for
// the first time.
gensym_key: Cell<u32>,
+ // We must keep the set of definitions up to date as we add nodes that
+ // weren't in the AST.
+ definitions: Option<&'a RefCell<Definitions>>,
+ // As we walk the AST we must keep track of the current 'parent' def id (in
+ // the form of a DefIndex) so that if we create a new node which introduces
+ // a definition, then we can properly create the def id.
+ parent_def: Cell<Option<DefIndex>>,
}
impl<'a, 'hir> LoweringContext<'a> {
- pub fn new(id_assigner: &'a NodeIdAssigner, c: Option<&Crate>) -> LoweringContext<'a> {
+ pub fn new(id_assigner: &'a NodeIdAssigner,
+ c: Option<&Crate>,
+ defs: &'a RefCell<Definitions>)
+ -> LoweringContext<'a> {
let crate_root = c.and_then(|c| {
if std_inject::no_core(c) {
None
cached_id: Cell::new(0),
gensym_cache: RefCell::new(HashMap::new()),
gensym_key: Cell::new(0),
+ definitions: Some(defs),
+ parent_def: Cell::new(None),
+ }
+ }
+
+ // Only use this when you want a LoweringContext for testing and won't look
+ // up def ids for anything created during lowering.
+ pub fn testing_context(id_assigner: &'a NodeIdAssigner) -> LoweringContext<'a> {
+ LoweringContext {
+ crate_root: None,
+ id_cache: RefCell::new(HashMap::new()),
+ id_assigner: id_assigner,
+ cached_id: Cell::new(0),
+ gensym_cache: RefCell::new(HashMap::new()),
+ gensym_key: Cell::new(0),
+ definitions: None,
+ parent_def: Cell::new(None),
}
}
fn diagnostic(&self) -> &Handler {
self.id_assigner.diagnostic()
}
+
+ fn with_parent_def<T, F: FnOnce() -> T>(&self, parent_id: NodeId, f: F) -> T {
+ if self.definitions.is_none() {
+ // This should only be used for testing.
+ return f();
+ }
+
+ let old_def = self.parent_def.get();
+ self.parent_def.set(Some(self.get_def(parent_id)));
+ let result = f();
+ self.parent_def.set(old_def);
+
+ result
+ }
+
+ fn get_def(&self, id: NodeId) -> DefIndex {
+ let defs = self.definitions.unwrap().borrow();
+ defs.opt_def_index(id).unwrap()
+ }
}
// Utility fn for setting and unsetting the cached id.
}
pub fn lower_trait_item(lctx: &LoweringContext, i: &TraitItem) -> hir::TraitItem {
- hir::TraitItem {
- id: i.id,
- name: i.ident.name,
- attrs: lower_attrs(lctx, &i.attrs),
- node: match i.node {
- TraitItemKind::Const(ref ty, ref default) => {
- hir::ConstTraitItem(lower_ty(lctx, ty),
- default.as_ref().map(|x| lower_expr(lctx, x)))
- }
- TraitItemKind::Method(ref sig, ref body) => {
- hir::MethodTraitItem(lower_method_sig(lctx, sig),
- body.as_ref().map(|x| lower_block(lctx, x)))
- }
- TraitItemKind::Type(ref bounds, ref default) => {
- hir::TypeTraitItem(lower_bounds(lctx, bounds),
- default.as_ref().map(|x| lower_ty(lctx, x)))
- }
- },
- span: i.span,
- }
+ lctx.with_parent_def(i.id, || {
+ hir::TraitItem {
+ id: i.id,
+ name: i.ident.name,
+ attrs: lower_attrs(lctx, &i.attrs),
+ node: match i.node {
+ TraitItemKind::Const(ref ty, ref default) => {
+ hir::ConstTraitItem(lower_ty(lctx, ty),
+ default.as_ref().map(|x| lower_expr(lctx, x)))
+ }
+ TraitItemKind::Method(ref sig, ref body) => {
+ hir::MethodTraitItem(lower_method_sig(lctx, sig),
+ body.as_ref().map(|x| lower_block(lctx, x)))
+ }
+ TraitItemKind::Type(ref bounds, ref default) => {
+ hir::TypeTraitItem(lower_bounds(lctx, bounds),
+ default.as_ref().map(|x| lower_ty(lctx, x)))
+ }
+ },
+ span: i.span,
+ }
+ })
}
pub fn lower_impl_item(lctx: &LoweringContext, i: &ImplItem) -> hir::ImplItem {
- hir::ImplItem {
- id: i.id,
- name: i.ident.name,
- attrs: lower_attrs(lctx, &i.attrs),
- vis: lower_visibility(lctx, &i.vis),
- defaultness: lower_defaultness(lctx, i.defaultness),
- node: match i.node {
- ImplItemKind::Const(ref ty, ref expr) => {
- hir::ImplItemKind::Const(lower_ty(lctx, ty), lower_expr(lctx, expr))
- }
- ImplItemKind::Method(ref sig, ref body) => {
- hir::ImplItemKind::Method(lower_method_sig(lctx, sig), lower_block(lctx, body))
- }
- ImplItemKind::Type(ref ty) => hir::ImplItemKind::Type(lower_ty(lctx, ty)),
- ImplItemKind::Macro(..) => panic!("Shouldn't exist any more"),
- },
- span: i.span,
- }
+ lctx.with_parent_def(i.id, || {
+ hir::ImplItem {
+ id: i.id,
+ name: i.ident.name,
+ attrs: lower_attrs(lctx, &i.attrs),
+ vis: lower_visibility(lctx, &i.vis),
+ defaultness: lower_defaultness(lctx, i.defaultness),
+ node: match i.node {
+ ImplItemKind::Const(ref ty, ref expr) => {
+ hir::ImplItemKind::Const(lower_ty(lctx, ty), lower_expr(lctx, expr))
+ }
+ ImplItemKind::Method(ref sig, ref body) => {
+ hir::ImplItemKind::Method(lower_method_sig(lctx, sig), lower_block(lctx, body))
+ }
+ ImplItemKind::Type(ref ty) => hir::ImplItemKind::Type(lower_ty(lctx, ty)),
+ ImplItemKind::Macro(..) => panic!("Shouldn't exist any more"),
+ },
+ span: i.span,
+ }
+ })
}
pub fn lower_mod(lctx: &LoweringContext, m: &Mod) -> hir::Mod {
}
pub fn lower_item(lctx: &LoweringContext, i: &Item) -> hir::Item {
- let node = lower_item_kind(lctx, &i.node);
+ let node = lctx.with_parent_def(i.id, || {
+ lower_item_kind(lctx, &i.node)
+ });
hir::Item {
id: i.id,
}
pub fn lower_foreign_item(lctx: &LoweringContext, i: &ForeignItem) -> hir::ForeignItem {
- hir::ForeignItem {
- id: i.id,
- name: i.ident.name,
- attrs: lower_attrs(lctx, &i.attrs),
- node: match i.node {
- ForeignItemKind::Fn(ref fdec, ref generics) => {
- hir::ForeignItemFn(lower_fn_decl(lctx, fdec), lower_generics(lctx, generics))
- }
- ForeignItemKind::Static(ref t, m) => {
- hir::ForeignItemStatic(lower_ty(lctx, t), m)
- }
- },
- vis: lower_visibility(lctx, &i.vis),
- span: i.span,
- }
+ lctx.with_parent_def(i.id, || {
+ hir::ForeignItem {
+ id: i.id,
+ name: i.ident.name,
+ attrs: lower_attrs(lctx, &i.attrs),
+ node: match i.node {
+ ForeignItemKind::Fn(ref fdec, ref generics) => {
+ hir::ForeignItemFn(lower_fn_decl(lctx, fdec), lower_generics(lctx, generics))
+ }
+ ForeignItemKind::Static(ref t, m) => {
+ hir::ForeignItemStatic(lower_ty(lctx, t), m)
+ }
+ },
+ vis: lower_visibility(lctx, &i.vis),
+ span: i.span,
+ }
+ })
}
pub fn lower_method_sig(lctx: &LoweringContext, sig: &MethodSig) -> hir::MethodSig {
node: match p.node {
PatKind::Wild => hir::PatKind::Wild,
PatKind::Ident(ref binding_mode, pth1, ref sub) => {
- hir::PatKind::Ident(lower_binding_mode(lctx, binding_mode),
- respan(pth1.span, lower_ident(lctx, pth1.node)),
- sub.as_ref().map(|x| lower_pat(lctx, x)))
+ lctx.with_parent_def(p.id, || {
+ hir::PatKind::Ident(lower_binding_mode(lctx, binding_mode),
+ respan(pth1.span, lower_ident(lctx, pth1.node)),
+ sub.as_ref().map(|x| lower_pat(lctx, x)))
+ })
}
PatKind::Lit(ref e) => hir::PatKind::Lit(lower_expr(lctx, e)),
PatKind::TupleStruct(ref pth, ref pats) => {
hir::MatchSource::Normal)
}
ExprKind::Closure(capture_clause, ref decl, ref body) => {
- hir::ExprClosure(lower_capture_clause(lctx, capture_clause),
- lower_fn_decl(lctx, decl),
- lower_block(lctx, body))
+ lctx.with_parent_def(e.id, || {
+ hir::ExprClosure(lower_capture_clause(lctx, capture_clause),
+ lower_fn_decl(lctx, decl),
+ lower_block(lctx, body))
+ })
}
ExprKind::Block(ref blk) => hir::ExprBlock(lower_block(lctx, blk)),
ExprKind::Assign(ref el, ref er) => {
// `{ let _result = ...; _result }`
// underscore prevents an unused_variables lint if the head diverges
let result_ident = lctx.str_to_ident("_result");
- let let_stmt = stmt_let(lctx, e.span, false, result_ident, match_expr, None);
+ let let_stmt = stmt_let(lctx,
+ e.span,
+ false,
+ result_ident,
+ match_expr,
+ None);
let result = expr_ident(lctx, e.span, result_ident, None);
let block = block_all(lctx, e.span, hir_vec![let_stmt], Some(result));
// add the attributes to the outer returned expr node
let err_ctor = expr_path(lctx, path, None);
expr_call(lctx, e.span, err_ctor, hir_vec![from_expr], None)
};
- let err_pat = pat_err(lctx, e.span, pat_ident(lctx, e.span, err_ident));
+ let err_pat = pat_err(lctx, e.span,
+ pat_ident(lctx, e.span, err_ident));
let ret_expr = expr(lctx, e.span,
hir::Expr_::ExprRet(Some(err_expr)), None);
bm: hir::BindingMode)
-> P<hir::Pat> {
let pat_ident = hir::PatKind::Ident(bm,
- Spanned {
- span: span,
- node: ident,
- },
- None);
- pat(lctx, span, pat_ident)
+ Spanned {
+ span: span,
+ node: ident,
+ },
+ None);
+
+ let pat = pat(lctx, span, pat_ident);
+
+ if let Some(defs) = lctx.definitions {
+ let mut defs = defs.borrow_mut();
+ defs.create_def_with_parent(lctx.parent_def.get(),
+ pat.id,
+ DefPathData::Binding(ident.name));
+ }
+
+ pat
}
fn pat_wild(lctx: &LoweringContext, span: Span) -> P<hir::Pat> {
let ast_in = quote_expr!(&cx, in HEAP { foo() });
let ast_in = assigner.fold_expr(ast_in);
- let lctx = LoweringContext::new(&assigner, None);
+ let lctx = LoweringContext::testing_context(&assigner);
+
let hir1 = lower_expr(&lctx, &ast_if_let);
let hir2 = lower_expr(&lctx, &ast_if_let);
assert!(hir1 == hir2);
}
fn visit_pat(&mut self, pat: &'ast Pat) {
- self.insert(pat.id, NodeLocal(pat));
+ let node = if let PatKind::Ident(..) = pat.node {
+ NodeLocal(pat)
+ } else {
+ NodePat(pat)
+ };
+ self.insert(pat.id, node);
self.with_parent(pat.id, |this| {
intravisit::walk_pat(this, pat);
use syntax::ast::*;
use syntax::visit;
+use syntax::parse::token;
/// Creates def ids for nodes in the HIR.
pub struct DefCollector<'ast> {
definitions: Definitions::new(),
parent_def: None,
};
- let result = collector.create_def_with_parent(None, CRATE_NODE_ID, DefPathData::CrateRoot);
- assert_eq!(result, CRATE_DEF_INDEX);
+ let root = collector.create_def_with_parent(None, CRATE_NODE_ID, DefPathData::CrateRoot);
+ assert_eq!(root, CRATE_DEF_INDEX);
+ collector.parent_def = Some(root);
collector.create_def_with_parent(Some(CRATE_DEF_INDEX), DUMMY_NODE_ID, DefPathData::Misc);
this.create_def(v.node.data.id(),
DefPathData::EnumVariant(v.node.name.name));
- for field in v.node.data.fields() {
- if let Some(ident) = field.ident {
- this.create_def_with_parent(Some(variant_def_index),
- field.id,
- DefPathData::Field(ident.name));
- }
+ for (index, field) in v.node.data.fields().iter().enumerate() {
+ let name = field.ident.map(|ident| ident.name)
+ .unwrap_or(token::intern(&index.to_string()));
+ this.create_def_with_parent(Some(variant_def_index),
+ field.id,
+ DefPathData::Field(name));
}
}
}
DefPathData::StructCtor);
}
- for field in struct_def.fields() {
- if let Some(ident) = field.ident {
- this.create_def(field.id, DefPathData::Field(ident.name));
- }
+ for (index, field) in struct_def.fields().iter().enumerate() {
+ let name = field.ident.map(|ident| ident.name)
+ .unwrap_or(token::intern(&index.to_string()));
+ this.create_def(field.id, DefPathData::Field(name));
}
}
_ => {}
}
fn visit_pat(&mut self, pat: &'ast Pat) {
- let maybe_binding = match pat.node {
- PatKind::Ident(_, id, _) => Some(id.node),
- _ => None
- };
-
let parent_def = self.parent_def;
- if let Some(id) = maybe_binding {
- let def = self.create_def(pat.id, DefPathData::Binding(id.name));
+
+ if let PatKind::Ident(_, id, _) = pat.node {
+ let def = self.create_def(pat.id, DefPathData::Binding(id.node.name));
self.parent_def = Some(def);
}
}
fn visit_pat(&mut self, pat: &'ast hir::Pat) {
- let maybe_binding = match pat.node {
- hir::PatKind::Ident(_, id, _) => Some(id.node),
- _ => None
- };
-
let parent_def = self.parent_def;
- if let Some(id) = maybe_binding {
- let def = self.create_def(pat.id, DefPathData::Binding(id.name));
+
+ if let hir::PatKind::Ident(_, id, _) = pat.node {
+ let def = self.create_def(pat.id, DefPathData::Binding(id.node.name));
self.parent_def = Some(def);
}
/// plain old integers.
map: RefCell<Vec<MapEntry<'ast>>>,
- definitions: RefCell<Definitions>,
+ definitions: &'ast RefCell<Definitions>,
}
impl<'ast> Map<'ast> {
def_collector.definitions
}
-pub fn map_crate<'ast>(forest: &'ast mut Forest, definitions: Definitions) -> Map<'ast> {
+pub fn map_crate<'ast>(forest: &'ast mut Forest,
+ definitions: &'ast RefCell<Definitions>)
+ -> Map<'ast> {
let mut collector = NodeCollector::root(&forest.krate);
intravisit::walk_crate(&mut collector, &forest.krate);
let map = collector.map;
forest: forest,
dep_graph: forest.dep_graph.clone(),
map: RefCell::new(map),
- definitions: RefCell::new(definitions),
+ definitions: definitions,
}
}
use serialize::json;
+use std::cell::RefCell;
use std::collections::HashMap;
use std::env;
use std::ffi::{OsString, OsStr};
let dep_graph = DepGraph::new(sess.opts.build_dep_graph);
// Collect defintions for def ids.
- let defs = time(sess.time_passes(),
- "collecting defs",
- || hir_map::collect_definitions(&expanded_crate));
+ let defs = &RefCell::new(time(sess.time_passes(),
+ "collecting defs",
+ || hir_map::collect_definitions(&expanded_crate)));
time(sess.time_passes(),
"external crate/lib resolution",
.read_crates(&dep_graph));
// Lower ast -> hir.
- let lcx = LoweringContext::new(sess, Some(&expanded_crate));
+ let lcx = LoweringContext::new(sess, Some(&expanded_crate), defs);
let hir_forest = &mut time(sess.time_passes(),
"lowering ast -> hir",
|| hir_map::Forest::new(lower_crate(&lcx, &expanded_crate),
// It is somewhat unfortunate that this is hardwired in - this is forced by
// the fact that pretty_print_input requires the session by value.
let pretty = callbacks.parse_pretty(&sess, &matches);
- match pretty {
- Some((ppm, opt_uii)) => {
- pretty::pretty_print_input(sess, &cstore, cfg, &input, ppm, opt_uii, ofile);
- return (Ok(()), None);
- }
- None => {
- // continue
- }
+ if let Some((ppm, opt_uii)) = pretty {
+ pretty::pretty_print_input(sess, &cstore, cfg, &input, ppm, opt_uii, ofile);
+ return (Ok(()), None);
}
let plugins = sess.opts.debugging_opts.extra_plugins.clone();
use rustc_borrowck::graphviz as borrowck_dot;
use rustc_resolve as resolve;
use rustc_metadata::cstore::CStore;
+use rustc_metadata::creader::LocalCrateReader;
use rustc_mir::pretty::write_mir_pretty;
use rustc_mir::graphviz::write_mir_graphviz;
use graphviz as dot;
+use std::cell::RefCell;
use std::fs::File;
use std::io::{self, Write};
use std::iter;
let is_expanded = needs_expansion(&ppm);
let compute_ast_map = needs_ast_map(&ppm, &opt_uii);
let krate = if compute_ast_map {
- match driver::phase_2_configure_and_expand(&sess, &cstore, krate, &id[..], None) {
+ match driver::phase_2_configure_and_expand(&sess, &cstore, krate, &id, None) {
Err(_) => return,
Ok(k) => driver::assign_node_ids(&sess, k),
}
// There is some twisted, god-forsaken tangle of lifetimes here which makes
// the ordering of stuff super-finicky.
let mut hir_forest;
- let lcx = LoweringContext::new(&sess, Some(&krate));
- let arenas = ty::CtxtArenas::new();
+ let mut _defs = None;
let dep_graph = DepGraph::new(false);
+ let arenas = ty::CtxtArenas::new();
let _ignore = dep_graph.in_ignore();
let ast_map = if compute_ast_map {
- let defs = hir_map::collect_definitions(&krate);
+ _defs = Some(RefCell::new(hir_map::collect_definitions(&krate)));
+ let defs = _defs.as_ref().unwrap();
+ LocalCrateReader::new(&sess, &cstore, defs, &krate, &id).read_crates(&dep_graph);
+ let lcx = LoweringContext::new(&sess, Some(&krate), defs);
+
hir_forest = hir_map::Forest::new(lower_crate(&lcx, &krate), dep_graph.clone());
- let map = hir_map::map_crate(&mut hir_forest, defs);
- Some(map)
+ Some(hir_map::map_crate(&mut hir_forest, defs))
} else {
None
};
.unwrap()
.as_bytes()
.to_vec();
- let mut rdr = &src[..];
+ let mut rdr = &*src;
let mut out = Vec::new();
use rustc::ty::relate::TypeRelation;
use rustc::infer::{self, InferOk, InferResult, TypeOrigin};
use rustc_metadata::cstore::CStore;
+use rustc_metadata::creader::LocalCrateReader;
use rustc::hir::map as hir_map;
use rustc::session::{self, config};
+use std::cell::RefCell;
use std::rc::Rc;
use syntax::ast;
use syntax::abi::Abi;
let krate = driver::phase_2_configure_and_expand(&sess, &cstore, krate, "test", None)
.expect("phase 2 aborted");
- let krate = driver::assign_node_ids(&sess, krate);
- let lcx = LoweringContext::new(&sess, Some(&krate));
let dep_graph = DepGraph::new(false);
+ let krate = driver::assign_node_ids(&sess, krate);
+ let defs = &RefCell::new(hir_map::collect_definitions(&krate));
+ LocalCrateReader::new(&sess, &cstore, defs, &krate, "test_crate").read_crates(&dep_graph);
+ let lcx = LoweringContext::new(&sess, Some(&krate), defs);
let _ignore = dep_graph.in_ignore();
- let mut hir_forest = hir_map::Forest::new(lower_crate(&lcx, &krate), dep_graph.clone());
+ let mut hir_forest = &mut hir_map::Forest::new(lower_crate(&lcx, &krate), dep_graph.clone());
let arenas = ty::CtxtArenas::new();
- let ast_map = driver::make_map(&sess, &mut hir_forest);
+ let ast_map = hir_map::map_crate(hir_forest, defs);
// run just enough stuff to build a tcx:
let lang_items = lang_items::collect_language_items(&sess, &ast_map);
fn test_basic() {
let cx = mk_ctxt();
let fnia = FakeNodeIdAssigner;
- let lcx = LoweringContext::new(&fnia, None);
+ let lcx = LoweringContext::testing_context(&fnia);
roundtrip(lower_item(&lcx, "e_item!(&cx,
fn foo() {}
).unwrap()));
fn test_smalltalk() {
let cx = mk_ctxt();
let fnia = FakeNodeIdAssigner;
- let lcx = LoweringContext::new(&fnia, None);
+ let lcx = LoweringContext::testing_context(&fnia);
roundtrip(lower_item(&lcx, "e_item!(&cx,
fn foo() -> isize { 3 + 4 } // first smalltalk program ever executed.
).unwrap()));
fn test_more() {
let cx = mk_ctxt();
let fnia = FakeNodeIdAssigner;
- let lcx = LoweringContext::new(&fnia, None);
+ let lcx = LoweringContext::testing_context(&fnia);
roundtrip(lower_item(&lcx, "e_item!(&cx,
fn foo(x: usize, y: usize) -> usize {
let z = x + y;
}
).unwrap();
let fnia = FakeNodeIdAssigner;
- let lcx = LoweringContext::new(&fnia, None);
+ let lcx = LoweringContext::testing_context(&fnia);
let hir_item = lower_item(&lcx, &item);
let item_in = InlinedItemRef::Item(&hir_item);
let item_out = simplify_ast(item_in);
cstore: &'a CStore,
creader: CrateReader<'a>,
krate: &'a ast::Crate,
- defintions: &'a hir_map::Definitions,
+ defintions: &'a RefCell<hir_map::Definitions>,
}
pub struct CrateReader<'a> {
impl<'a, 'ast> visit::Visitor<'ast> for LocalCrateReader<'a> {
fn visit_item(&mut self, a: &'ast ast::Item) {
self.process_item(a);
+ visit::walk_item(self, a);
}
}
!attr::contains_name(&i.attrs, "no_link")
}
+#[derive(Debug)]
struct CrateInfo {
ident: String,
name: String,
impl<'a> LocalCrateReader<'a> {
pub fn new(sess: &'a Session,
cstore: &'a CStore,
- defs: &'a hir_map::Definitions,
+ defs: &'a RefCell<hir_map::Definitions>,
krate: &'a ast::Crate,
local_crate_name: &str)
-> LocalCrateReader<'a> {
i.span,
PathKind::Crate,
true);
- let def_id = self.defintions.opt_local_def_id(i.id).unwrap();
- let len = self.defintions.def_path(def_id.index).data.len();
+ let defs = self.defintions.borrow();
+ let def_id = defs.opt_local_def_id(i.id).unwrap();
+ let len = defs.def_path(def_id.index).data.len();
self.creader.update_extern_crate(cnum,
ExternCrate {
use super::dump::Dump;
use super::span_utils::SpanUtils;
-pub struct CsvDumper<'a, 'b, W: 'b> {
+pub struct CsvDumper<'tcx, 'b, W: 'b> {
output: &'b mut W,
dump_spans: bool,
- span: SpanUtils<'a>
+ span: SpanUtils<'tcx>
}
impl<'a, 'b, W: Write> CsvDumper<'a, 'b, W> {
use syntax::print::pprust::{path_to_string, ty_to_string};
use syntax::ptr::P;
-use rustc::hir::lowering::{lower_expr, LoweringContext};
+use rustc::hir::lowering::lower_expr;
use super::{escape, generated_code, SaveContext, PathCollector};
use super::data::*;
};
}
-pub struct DumpVisitor<'l, 'tcx: 'l, D: 'l> {
+pub struct DumpVisitor<'l, 'tcx: 'l, 'll, D: 'll> {
save_ctxt: SaveContext<'l, 'tcx>,
sess: &'l Session,
tcx: &'l TyCtxt<'tcx>,
analysis: &'l ty::CrateAnalysis<'l>,
- dumper: &'l mut D,
+ dumper: &'ll mut D,
span: SpanUtils<'l>,
// one macro use per unique callsite span.
mac_defs: HashSet<Span>,
mac_uses: HashSet<Span>,
-
}
-impl <'l, 'tcx, D> DumpVisitor<'l, 'tcx, D>
-where D: Dump
-{
+impl<'l, 'tcx: 'l, 'll, D: Dump + 'll> DumpVisitor<'l, 'tcx, 'll, D> {
pub fn new(tcx: &'l TyCtxt<'tcx>,
- lcx: &'l LoweringContext<'l>,
+ save_ctxt: SaveContext<'l, 'tcx>,
analysis: &'l ty::CrateAnalysis<'l>,
- dumper: &'l mut D)
- -> DumpVisitor<'l, 'tcx, D> {
+ dumper: &'ll mut D)
+ -> DumpVisitor<'l, 'tcx, 'll, D> {
let span_utils = SpanUtils::new(&tcx.sess);
DumpVisitor {
sess: &tcx.sess,
tcx: tcx,
- save_ctxt: SaveContext::from_span_utils(tcx, lcx, span_utils.clone()),
+ save_ctxt: save_ctxt,
analysis: analysis,
dumper: dumper,
span: span_utils.clone(),
}
fn nest<F>(&mut self, scope_id: NodeId, f: F)
- where F: FnOnce(&mut DumpVisitor<'l, 'tcx, D>)
+ where F: FnOnce(&mut DumpVisitor<'l, 'tcx, 'll, D>)
{
let parent_scope = self.cur_scope;
self.cur_scope = scope_id;
}
}
-impl<'l, 'tcx, 'v, D: Dump + 'l> Visitor<'v> for DumpVisitor<'l, 'tcx, D> {
+impl<'v, 'l, 'tcx: 'l, 'll, D: Dump +'ll> Visitor<'v> for DumpVisitor<'l, 'tcx, 'll, D> {
fn visit_item(&mut self, item: &ast::Item) {
use syntax::ast::ItemKind::*;
self.process_macro_use(item.span, item.id);
pub struct SaveContext<'l, 'tcx: 'l> {
tcx: &'l TyCtxt<'tcx>,
lcx: &'l lowering::LoweringContext<'l>,
- span_utils: SpanUtils<'l>,
+ span_utils: SpanUtils<'tcx>,
}
macro_rules! option_try(
pub fn from_span_utils(tcx: &'l TyCtxt<'tcx>,
lcx: &'l lowering::LoweringContext<'l>,
- span_utils: SpanUtils<'l>)
+ span_utils: SpanUtils<'tcx>)
-> SaveContext<'l, 'tcx> {
SaveContext {
tcx: tcx,
pub fn process_crate<'l, 'tcx>(tcx: &'l TyCtxt<'tcx>,
lcx: &'l lowering::LoweringContext<'l>,
krate: &ast::Crate,
- analysis: &ty::CrateAnalysis,
+ analysis: &'l ty::CrateAnalysis<'l>,
cratename: &str,
odir: Option<&Path>) {
let _ignore = tcx.dep_graph.in_ignore();
});
root_path.pop();
- let utils = SpanUtils::new(&tcx.sess);
+ let utils: SpanUtils<'tcx> = SpanUtils::new(&tcx.sess);
+ let save_ctxt = SaveContext::new(tcx, lcx);
let mut dumper = CsvDumper::new(&mut output_file, utils);
- let mut visitor = DumpVisitor::new(tcx, lcx, analysis, &mut dumper);
+ let mut visitor = DumpVisitor::new(tcx, save_ctxt, analysis, &mut dumper);
// FIXME: we don't write anything!
visitor.dump_crate_info(cratename, krate);
#[derive(Clone)]
pub struct SpanUtils<'a> {
pub sess: &'a Session,
+ // FIXME given that we clone SpanUtils all over the place, this err_count is
+ // probably useless and any logic relying on it is bogus.
pub err_count: Cell<isize>,
}
use rustc_resolve as resolve;
use rustc::hir::lowering::{lower_crate, LoweringContext};
use rustc_metadata::cstore::CStore;
+use rustc_metadata::creader::LocalCrateReader;
use syntax::{ast, codemap, errors};
use syntax::errors::emitter::ColorConfig;
.expect("phase_2_configure_and_expand aborted in rustdoc!");
let krate = driver::assign_node_ids(&sess, krate);
+ let dep_graph = DepGraph::new(false);
+
+ let defs = &RefCell::new(hir_map::collect_definitions(&krate));
+ LocalCrateReader::new(&sess, &cstore, &defs, &krate, &name).read_crates(&dep_graph);
+ let lcx = LoweringContext::new(&sess, Some(&krate), defs);
+
// Lower ast -> hir.
- let lcx = LoweringContext::new(&sess, Some(&krate));
- let mut hir_forest = hir_map::Forest::new(lower_crate(&lcx, &krate), DepGraph::new(false));
+ let mut hir_forest = hir_map::Forest::new(lower_crate(&lcx, &krate), dep_graph);
let arenas = ty::CtxtArenas::new();
- let hir_map = driver::make_map(&sess, &mut hir_forest);
+ let hir_map = hir_map::map_crate(&mut hir_forest, defs);
abort_on_err(driver::phase_3_run_analysis_passes(&sess,
- &cstore,
hir_map,
&arenas,
&name,
"rustdoc-test", None)
.expect("phase_2_configure_and_expand aborted in rustdoc!");
let krate = driver::assign_node_ids(&sess, krate);
- let lcx = LoweringContext::new(&sess, Some(&krate));
+ let dep_graph = DepGraph::new(false);
+ let defs = &RefCell::new(hir_map::collect_definitions(&krate));
+
+ let lcx = LoweringContext::new(&sess, Some(&krate), defs);
let krate = lower_crate(&lcx, &krate);
let opts = scrape_test_config(&krate);
- let dep_graph = DepGraph::new(false);
let _ignore = dep_graph.in_ignore();
let mut forest = hir_map::Forest::new(krate, dep_graph.clone());
- let map = hir_map::map_crate(&mut forest);
+ let map = hir_map::map_crate(&mut forest, defs);
let ctx = core::DocContext {
map: &map,
extern crate rustc_resolve;
#[macro_use] extern crate syntax;
+use std::cell::RefCell;
use std::ffi::{CStr, CString};
use std::mem::transmute;
use std::path::PathBuf;
use rustc_driver::{driver, abort_on_err};
use rustc::hir::lowering::{lower_crate, LoweringContext};
use rustc_resolve::MakeGlobMap;
+use rustc_metadata::creader::LocalCrateReader;
use rustc_metadata::cstore::CStore;
use libc::c_void;
let krate = driver::phase_2_configure_and_expand(&sess, &cstore, krate, &id, None)
.expect("phase_2 returned `None`");
+ let dep_graph = DepGraph::new(sess.opts.build_dep_graph);
let krate = driver::assign_node_ids(&sess, krate);
- let lcx = LoweringContext::new(&sess, Some(&krate));
- let dep_graph = DepGraph::new(sess.opts.build_dep_graph());
+ let defs = RefCell::new(ast_map::collect_definitions(&krate));
+ LocalCrateReader::new(&sess, &cstore, &defs, &krate, &id).read_crates(&dep_graph);
+ let lcx = LoweringContext::new(&sess, Some(&krate), &defs);
let mut hir_forest = ast_map::Forest::new(lower_crate(&lcx, &krate), dep_graph);
let arenas = ty::CtxtArenas::new();
- let ast_map = driver::make_map(&sess, &mut hir_forest);
+ let ast_map = ast_map::map_crate(&mut hir_forest, &defs);
abort_on_err(driver::phase_3_run_analysis_passes(
- &sess, &cstore, ast_map, &arenas, &id,
+ &sess, ast_map, &arenas, &id,
MakeGlobMap::No, |tcx, mir_map, analysis, _| {
let trans = driver::phase_4_translate_to_llvm(tcx, mir_map.unwrap(), analysis);