Struct rustc_save_analysis::dump_visitor::DumpVisitor

pub struct DumpVisitor<'tcx> {
    pub save_ctxt: SaveContext<'tcx>,
    tcx: TyCtxt<'tcx>,
    dumper: Dumper,
    span: SpanUtils<'tcx>,
}

Fields

save_ctxt: SaveContext<'tcx>

tcx: TyCtxt<'tcx>

dumper: Dumper

span: SpanUtils<'tcx>

Implementations

impl<'tcx> DumpVisitor<'tcx>

pub fn new(save_ctxt: SaveContext<'tcx>) -> DumpVisitor<'tcx>

pub fn analysis(&self) -> &Analysis

fn nest_typeck_results<F>(&mut self, item_def_id: LocalDefId, f: F) where
    F: FnOnce(&mut Self), 

fn span_from_span(&self, span: Span) -> SpanData

fn lookup_def_id(&self, ref_id: HirId) -> Option<DefId>

pub fn dump_crate_info(&mut self, name: &str, krate: &Crate<'_>)

pub fn dump_compilation_options(&mut self, input: &Input, crate_name: &str)

fn write_segments(
    &mut self,
    segments: impl IntoIterator<Item = &'tcx PathSegment<'tcx>>
)

fn write_sub_paths(&mut self, path: &'tcx Path<'tcx>)

fn write_sub_paths_truncated(&mut self, path: &'tcx Path<'tcx>)

fn process_formals(&mut self, formals: &'tcx [Param<'tcx>], qualname: &str)

fn process_method(
    &mut self,
    sig: &'tcx FnSig<'tcx>,
    body: Option<BodyId>,
    hir_id: HirId,
    ident: Ident,
    generics: &'tcx Generics<'tcx>,
    vis: &Visibility<'tcx>,
    span: Span
)

fn process_struct_field_def(
    &mut self,
    field: &'tcx FieldDef<'tcx>,
    parent_id: HirId
)

fn process_generic_params(
    &mut self,
    generics: &'tcx Generics<'tcx>,
    prefix: &str,
    id: HirId
)

fn process_fn(
    &mut self,
    item: &'tcx Item<'tcx>,
    decl: &'tcx FnDecl<'tcx>,
    _header: &'tcx FnHeader,
    ty_params: &'tcx Generics<'tcx>,
    body: BodyId
)

fn process_static_or_const_item(
    &mut self,
    item: &'tcx Item<'tcx>,
    typ: &'tcx Ty<'tcx>,
    expr: &'tcx Expr<'tcx>
)

fn process_assoc_const(
    &mut self,
    hir_id: HirId,
    ident: Ident,
    typ: &'tcx Ty<'tcx>,
    expr: Option<&'tcx Expr<'tcx>>,
    parent_id: DefId,
    vis: &Visibility<'tcx>,
    attrs: &'tcx [Attribute]
)

fn process_struct(
    &mut self,
    item: &'tcx Item<'tcx>,
    def: &'tcx VariantData<'tcx>,
    ty_params: &'tcx Generics<'tcx>
)

fn process_enum(
    &mut self,
    item: &'tcx Item<'tcx>,
    enum_definition: &'tcx EnumDef<'tcx>,
    ty_params: &'tcx Generics<'tcx>
)

fn process_impl(&mut self, item: &'tcx Item<'tcx>, impl_: &'tcx Impl<'tcx>)

fn process_trait(
    &mut self,
    item: &'tcx Item<'tcx>,
    generics: &'tcx Generics<'tcx>,
    trait_refs: GenericBounds<'tcx>,
    methods: &'tcx [TraitItemRef]
)

fn process_mod(&mut self, item: &'tcx Item<'tcx>)

fn dump_path_ref(&mut self, id: HirId, path: &QPath<'tcx>)

fn dump_path_segment_ref(&mut self, id: HirId, segment: &PathSegment<'tcx>)

fn process_path(&mut self, id: HirId, path: &QPath<'tcx>)

fn process_struct_lit(
    &mut self,
    ex: &'tcx Expr<'tcx>,
    path: &'tcx QPath<'tcx>,
    fields: &'tcx [ExprField<'tcx>],
    variant: &'tcx VariantDef,
    rest: Option<&'tcx Expr<'tcx>>
)

fn process_method_call(
    &mut self,
    ex: &'tcx Expr<'tcx>,
    seg: &'tcx PathSegment<'tcx>,
    args: &'tcx [Expr<'tcx>]
)

fn process_pat(&mut self, p: &'tcx Pat<'tcx>)

fn process_var_decl(&mut self, pat: &'tcx Pat<'tcx>)

fn process_macro_use(&mut self, _span: Span)

Extracts macro use and definition information from the AST node defined by the given NodeId, using the expansion information from the node’s span.

If the span is not macro-generated, do nothing, else use callee and callsite spans to record macro definition and use data, using the mac_uses and mac_defs sets to prevent multiples.

fn process_trait_item(
    &mut self,
    trait_item: &'tcx TraitItem<'tcx>,
    trait_id: DefId
)

fn process_impl_item(&mut self, impl_item: &'tcx ImplItem<'tcx>, impl_id: DefId)

pub(crate) fn process_crate(&mut self, krate: &'tcx Crate<'tcx>)

fn process_bounds(&mut self, bounds: GenericBounds<'tcx>)

Trait Implementations

impl<'tcx> Visitor<'tcx> for DumpVisitor<'tcx>

type Map = Map<'tcx>

fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map>

The default versions of the visit_nested_XXX routines invoke this method to get a map to use. By selecting an enum variant, you control which kinds of nested HIR are visited; see NestedVisitorMap for details. By “nested HIR”, we are referring to bits of HIR that are not directly embedded within one another but rather indirectly, through a table in the crate. This is done to control dependencies during incremental compilation: the non-inline bits of HIR can be tracked and hashed separately.

fn visit_item(&mut self, item: &'tcx Item<'tcx>)

Visits the top-level item and (optionally) nested items / impl items. See visit_nested_item for details.

fn visit_generics(&mut self, generics: &'tcx Generics<'tcx>)

fn visit_ty(&mut self, t: &'tcx Ty<'tcx>)

fn visit_expr(&mut self, ex: &'tcx Expr<'tcx>)

fn visit_pat(&mut self, p: &'tcx Pat<'tcx>)

fn visit_arm(&mut self, arm: &'tcx Arm<'tcx>)

fn visit_qpath(&mut self, path: &'tcx QPath<'tcx>, id: HirId, _: Span)

fn visit_stmt(&mut self, s: &'tcx Stmt<'tcx>)

fn visit_local(&mut self, l: &'tcx Local<'tcx>)

fn visit_foreign_item(&mut self, item: &'tcx ForeignItem<'tcx>)

fn visit_nested_item(&mut self, id: ItemId)

Invoked when a nested item is encountered. By default does nothing unless you override nested_visit_map to return other than None, in which case it will walk the item. You probably don’t want to override this method – instead, override nested_visit_map or use the “shallow” or “deep” visit patterns described on itemlikevisit::ItemLikeVisitor. The only reason to override this method is if you want a nested pattern but cannot supply a Map; see nested_visit_map for advice.

fn visit_nested_trait_item(&mut self, id: TraitItemId)

Like visit_nested_item(), but for trait items. See visit_nested_item() for advice on when to override this method.

fn visit_nested_impl_item(&mut self, id: ImplItemId)

Like visit_nested_item(), but for impl items. See visit_nested_item() for advice on when to override this method.

fn visit_nested_foreign_item(&mut self, id: ForeignItemId)

Like visit_nested_item(), but for foreign items. See visit_nested_item() for advice on when to override this method.

fn visit_nested_body(&mut self, id: BodyId)

Invoked to visit the body of a function, method or closure. Like visit_nested_item, does nothing by default unless you override nested_visit_map to return other than None, in which case it will walk the body.

fn visit_param(&mut self, param: &'v Param<'v>)

fn visit_body(&mut self, b: &'v Body<'v>)

fn as_deep_visitor(&mut self) -> DeepVisitor<'_, Self>

When invoking visit_all_item_likes(), you need to supply an item-like visitor. This method converts a “intra-visit” visitor into an item-like visitor that walks the entire tree. If you use this, you probably don’t want to process the contents of nested item-like things, since the outer loop will visit them as well.

fn visit_id(&mut self, _hir_id: HirId)

fn visit_name(&mut self, _span: Span, _name: Symbol)

fn visit_ident(&mut self, ident: Ident)

fn visit_mod(&mut self, m: &'v Mod<'v>, _s: Span, n: HirId)

fn visit_block(&mut self, b: &'v Block<'v>)

fn visit_anon_const(&mut self, c: &'v AnonConst)

fn visit_generic_param(&mut self, p: &'v GenericParam<'v>)

fn visit_const_param_default(&mut self, _param: HirId, ct: &'v AnonConst)

fn visit_where_predicate(&mut self, predicate: &'v WherePredicate<'v>)

fn visit_fn_decl(&mut self, fd: &'v FnDecl<'v>)

fn visit_fn(
    &mut self,
    fk: FnKind<'v>,
    fd: &'v FnDecl<'v>,
    b: BodyId,
    s: Span,
    id: HirId
)

fn visit_use(&mut self, path: &'v Path<'v>, hir_id: HirId)

fn visit_trait_item(&mut self, ti: &'v TraitItem<'v>)

fn visit_trait_item_ref(&mut self, ii: &'v TraitItemRef)

fn visit_impl_item(&mut self, ii: &'v ImplItem<'v>)

fn visit_foreign_item_ref(&mut self, ii: &'v ForeignItemRef<'v>)

fn visit_impl_item_ref(&mut self, ii: &'v ImplItemRef<'v>)

fn visit_trait_ref(&mut self, t: &'v TraitRef<'v>)

fn visit_param_bound(&mut self, bounds: &'v GenericBound<'v>)

fn visit_poly_trait_ref(
    &mut self,
    t: &'v PolyTraitRef<'v>,
    m: TraitBoundModifier
)

fn visit_variant_data(
    &mut self,
    s: &'v VariantData<'v>,
    Symbol,
    &'v Generics<'v>,
    _parent_id: HirId,
    Span
)

fn visit_field_def(&mut self, s: &'v FieldDef<'v>)

fn visit_enum_def(
    &mut self,
    enum_definition: &'v EnumDef<'v>,
    generics: &'v Generics<'v>,
    item_id: HirId,
    Span
)

fn visit_variant(
    &mut self,
    v: &'v Variant<'v>,
    g: &'v Generics<'v>,
    item_id: HirId
)

fn visit_label(&mut self, label: &'v Label)

fn visit_generic_arg(&mut self, generic_arg: &'v GenericArg<'v>)

fn visit_lifetime(&mut self, lifetime: &'v Lifetime)

fn visit_path(&mut self, path: &'v Path<'v>, _id: HirId)

fn visit_path_segment(
    &mut self,
    path_span: Span,
    path_segment: &'v PathSegment<'v>
)

fn visit_generic_args(
    &mut self,
    path_span: Span,
    generic_args: &'v GenericArgs<'v>
)

fn visit_assoc_type_binding(&mut self, type_binding: &'v TypeBinding<'v>)

fn visit_attribute(&mut self, _id: HirId, _attr: &'v Attribute)

fn visit_macro_def(&mut self, macro_def: &'v MacroDef<'v>)

fn visit_vis(&mut self, vis: &'v Spanned<VisibilityKind<'v>>)

fn visit_associated_item_kind(&mut self, kind: &'v AssocItemKind)

fn visit_defaultness(&mut self, defaultness: &'v Defaultness)