self.save_ctxt.span_from_span(span)
}
+ fn lookup_def_id(&self, ref_id: NodeId) -> Option<DefId> {
+ self.save_ctxt.lookup_def_id(ref_id)
+ }
+
pub fn dump_crate_info(&mut self, name: &str, krate: &ast::Crate) {
let source_file = self.tcx.sess.local_crate_source_file.as_ref();
let crate_root = source_file.map(|source_file| {
}
}
- fn lookup_def_id(&self, ref_id: NodeId) -> Option<DefId> {
- match self.save_ctxt.get_path_res(ref_id) {
- Res::PrimTy(..) | Res::SelfTy(..) | Res::Err => None,
- def => Some(def.def_id()),
- }
- }
-
fn process_formals(&mut self, formals: &'l [ast::Param], qualname: &str) {
for arg in formals {
self.visit_pat(&arg.pat);
}
if let ast::FunctionRetTy::Ty(ref ret_ty) = decl.output {
- v.visit_ty(&ret_ty);
+ if let ast::TyKind::ImplTrait(..) = ret_ty.kind {
+ // FIXME: Opaque type desugaring prevents us from easily
+ // processing trait bounds. See `visit_ty` for more details.
+ } else {
+ v.visit_ty(&ret_ty);
+ }
}
v.visit_block(&body);
let qualname = format!("::{}",
self.tcx.def_path_str(self.tcx.hir().local_def_id_from_node_id(item.id)));
- let kind = match item.node {
+ let kind = match item.kind {
ast::ItemKind::Struct(_, _) => DefKind::Struct,
ast::ItemKind::Union(_, _) => DefKind::Union,
_ => unreachable!(),
};
- let (value, fields) = match item.node {
+ let (value, fields) = match item.kind {
ast::ItemKind::Struct(ast::VariantData::Struct(ref fields, ..), ..) |
ast::ItemKind::Union(ast::VariantData::Struct(ref fields, ..), ..) => {
let include_priv_fields = !self.save_ctxt.config.pub_only;
}
fn process_pat(&mut self, p: &'l ast::Pat) {
- match p.node {
+ match p.kind {
PatKind::Struct(ref _path, ref fields, _) => {
// FIXME do something with _path?
let hir_id = self.tcx.hir().node_to_hir_id(p.id);
fn process_trait_item(&mut self, trait_item: &'l ast::TraitItem, trait_id: DefId) {
self.process_macro_use(trait_item.span);
let vis_span = trait_item.span.shrink_to_lo();
- match trait_item.node {
+ match trait_item.kind {
ast::TraitItemKind::Const(ref ty, ref expr) => {
self.process_assoc_const(
trait_item.id,
fn process_impl_item(&mut self, impl_item: &'l ast::ImplItem, impl_id: DefId) {
self.process_macro_use(impl_item.span);
- match impl_item.node {
+ match impl_item.kind {
ast::ImplItemKind::Const(ref ty, ref expr) => {
self.process_assoc_const(
impl_item.id,
fn visit_item(&mut self, item: &'l ast::Item) {
use syntax::ast::ItemKind::*;
self.process_macro_use(item.span);
- match item.node {
+ match item.kind {
Use(ref use_tree) => {
let prefix = ast::Path {
segments: vec![],
fn visit_ty(&mut self, t: &'l ast::Ty) {
self.process_macro_use(t.span);
- match t.node {
+ match t.kind {
ast::TyKind::Path(_, ref path) => {
if generated_code(t.span) {
return;
self.visit_ty(element);
self.nest_tables(length.id, |v| v.visit_expr(&length.value));
}
+ ast::TyKind::ImplTrait(id, ref bounds) => {
+ // FIXME: As of writing, the opaque type lowering introduces
+ // another DefPath scope/segment (used to declare the resulting
+ // opaque type item).
+ // However, the synthetic scope does *not* have associated
+ // typeck tables, which means we can't nest it and we fire an
+ // assertion when resolving the qualified type paths in trait
+ // bounds...
+ // This will panic if called on return type `impl Trait`, which
+ // we guard against in `process_fn`.
+ self.nest_tables(id, |v| v.process_bounds(bounds));
+ }
_ => visit::walk_ty(self, t),
}
}
fn visit_expr(&mut self, ex: &'l ast::Expr) {
- debug!("visit_expr {:?}", ex.node);
+ debug!("visit_expr {:?}", ex.kind);
self.process_macro_use(ex.span);
- match ex.node {
+ match ex.kind {
ast::ExprKind::Struct(ref path, ref fields, ref base) => {
let expr_hir_id = self.save_ctxt.tcx.hir().node_to_hir_id(ex.id);
let hir_expr = self.save_ctxt.tcx.hir().expect_expr(expr_hir_id);
}
ast::ExprKind::ForLoop(ref pattern, ref subexpression, ref block, _) => {
self.process_var_decl(pattern);
- debug!("for loop, walk sub-expr: {:?}", subexpression.node);
+ debug!("for loop, walk sub-expr: {:?}", subexpression.kind);
self.visit_expr(subexpression);
visit::walk_block(self, block);
}