Struct rustc_metadata::rmeta::encoder::EncodeContext

pub(super) struct EncodeContext<'a, 'tcx> {

    opaque: FileEncoder,
    tcx: TyCtxt<'tcx>,
    feat: &'tcx Features,
    tables: TableBuilders,
    lazy_state: LazyState,
    type_shorthands: FxHashMap<Ty<'tcx>, usize>,
    predicate_shorthands: FxHashMap<PredicateKind<'tcx>, usize>,
    interpret_allocs: FxIndexSet<AllocId>,
    source_file_cache: (Lrc<SourceFile>, usize),
    required_source_files: Option<FxIndexSet<usize>>,
    is_proc_macro: bool,
    hygiene_ctxt: &'a HygieneEncodeContext,
    symbol_table: FxHashMap<Symbol, usize>,
}

Fields

opaque: FileEncoder

tcx: TyCtxt<'tcx>

feat: &'tcx Features

tables: TableBuilders

lazy_state: LazyState

type_shorthands: FxHashMap<Ty<'tcx>, usize>

predicate_shorthands: FxHashMap<PredicateKind<'tcx>, usize>

interpret_allocs: FxIndexSet<AllocId>

source_file_cache: (Lrc<SourceFile>, usize)

required_source_files: Option<FxIndexSet<usize>>

is_proc_macro: bool

hygiene_ctxt: &'a HygieneEncodeContext

symbol_table: FxHashMap<Symbol, usize>

Implementations

impl<'a, 'tcx> EncodeContext<'a, 'tcx>

fn emit_lazy_distance(&mut self, position: NonZeroUsize)

fn lazy<T: ParameterizedOverTcx, B: Borrow<T::Value<'tcx>>>(
    &mut self,
    value: B
) -> LazyValue<T>where
    T::Value<'tcx>: Encodable<EncodeContext<'a, 'tcx>>,

fn lazy_array<T: ParameterizedOverTcx, I: IntoIterator<Item = B>, B: Borrow<T::Value<'tcx>>>(
    &mut self,
    values: I
) -> LazyArray<T>where
    T::Value<'tcx>: Encodable<EncodeContext<'a, 'tcx>>,

fn encode_info_for_items(&mut self)

fn encode_def_path_table(&mut self)

fn encode_def_path_hash_map(&mut self) -> LazyValue<DefPathHashMapRef<'static>>

fn encode_source_map(&mut self) -> LazyTable<u32, LazyValue<SourceFile>>

fn encode_crate_root(&mut self) -> LazyValue<CrateRoot>

impl<'a, 'tcx> EncodeContext<'a, 'tcx>

fn encode_attrs(&mut self, def_id: LocalDefId)

fn encode_def_ids(&mut self)

fn encode_enum_variant_info(&mut self, def: AdtDef<'tcx>, index: VariantIdx)

fn encode_enum_variant_ctor(&mut self, def: AdtDef<'tcx>, index: VariantIdx)

fn encode_info_for_mod(&mut self, local_def_id: LocalDefId, md: &Mod<'_>)

fn encode_struct_ctor(&mut self, adt_def: AdtDef<'tcx>)

fn encode_explicit_item_bounds(&mut self, def_id: DefId)

fn encode_info_for_trait_item(&mut self, def_id: DefId)

fn encode_info_for_impl_item(&mut self, def_id: DefId)

fn encode_mir(&mut self)

fn encode_stability(&mut self, def_id: DefId)

fn encode_const_stability(&mut self, def_id: DefId)

fn encode_default_body_stability(&mut self, def_id: DefId)

fn encode_deprecation(&mut self, def_id: DefId)

fn encode_rendered_const_for_body(&mut self, body_id: BodyId) -> String

fn encode_info_for_item(&mut self, def_id: DefId, item: &'tcx Item<'tcx>)

fn encode_info_for_closure(&mut self, def_id: LocalDefId)

fn encode_native_libraries(&mut self) -> LazyArray<NativeLib>

fn encode_foreign_modules(&mut self) -> LazyArray<ForeignModule>

fn encode_hygiene(
    &mut self
) -> (LazyTable<u32, LazyValue<SyntaxContextData>>, LazyTable<ExpnIndex, LazyValue<ExpnData>>, LazyTable<ExpnIndex, LazyValue<ExpnHash>>)

fn encode_proc_macros(&mut self) -> Option<ProcMacroData>

fn encode_debugger_visualizers(&mut self) -> LazyArray<DebuggerVisualizerFile>

fn encode_crate_deps(&mut self) -> LazyArray<CrateDep>

fn encode_lib_features(&mut self) -> LazyArray<(Symbol, Option<Symbol>)>

fn encode_stability_implications(&mut self) -> LazyArray<(Symbol, Symbol)>

fn encode_diagnostic_items(&mut self) -> LazyArray<(Symbol, DefIndex)>

fn encode_lang_items(&mut self) -> LazyArray<(DefIndex, LangItem)>

fn encode_lang_items_missing(&mut self) -> LazyArray<LangItem>

fn encode_traits(&mut self) -> LazyArray<DefIndex>

fn encode_impls(&mut self) -> LazyArray<TraitImpls>

Encodes an index, mapping each trait to its (local) implementations.

fn encode_incoherent_impls(&mut self) -> LazyArray<IncoherentImpls>

fn encode_exported_symbols(
    &mut self,
    exported_symbols: &[(ExportedSymbol<'tcx>, SymbolExportInfo)]
) -> LazyArray<(ExportedSymbol<'static>, SymbolExportInfo)>

fn encode_dylib_dependency_formats(
    &mut self
) -> LazyArray<Option<LinkagePreference>>

fn encode_info_for_foreign_item(&mut self, def_id: DefId, nitem: &ForeignItem<'_>)

impl<'a, 'tcx> EncodeContext<'a, 'tcx>

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

fn encode_info_for_expr(&mut self, expr: &Expr<'_>)

Trait Implementations

impl<'tcx, '__a> Encodable<EncodeContext<'__a, 'tcx>> for CrateRoot

fn encode(&self, __encoder: &mut EncodeContext<'__a, 'tcx>)

impl<'tcx, '__a> Encodable<EncodeContext<'__a, 'tcx>> for IncoherentImpls

fn encode(&self, __encoder: &mut EncodeContext<'__a, 'tcx>)

impl<'tcx, '__a> Encodable<EncodeContext<'__a, 'tcx>> for LazyTables

fn encode(&self, __encoder: &mut EncodeContext<'__a, 'tcx>)

impl<'tcx, '__a> Encodable<EncodeContext<'__a, 'tcx>> for ProcMacroData

fn encode(&self, __encoder: &mut EncodeContext<'__a, 'tcx>)

impl<'tcx, '__a> Encodable<EncodeContext<'__a, 'tcx>> for TraitImpls

fn encode(&self, __encoder: &mut EncodeContext<'__a, 'tcx>)

impl<'a, 'tcx> Encodable<EncodeContext<'a, 'tcx>> for CrateNum

fn encode(&self, s: &mut EncodeContext<'a, 'tcx>)

impl<'a, 'tcx> Encodable<EncodeContext<'a, 'tcx>> for DefIndex

fn encode(&self, s: &mut EncodeContext<'a, 'tcx>)

impl<'a, 'tcx> Encodable<EncodeContext<'a, 'tcx>> for DefPathHashMapRef<'tcx>

fn encode(&self, e: &mut EncodeContext<'a, 'tcx>)

impl<'a, 'tcx> Encodable<EncodeContext<'a, 'tcx>> for ExpnId

fn encode(&self, s: &mut EncodeContext<'a, 'tcx>)

impl<'a, 'tcx> Encodable<EncodeContext<'a, 'tcx>> for ExpnIndex

fn encode(&self, s: &mut EncodeContext<'a, 'tcx>)

impl<'a, 'tcx, T> Encodable<EncodeContext<'a, 'tcx>> for LazyArray<T>

fn encode(&self, e: &mut EncodeContext<'a, 'tcx>)

impl<'a, 'tcx, I, T> Encodable<EncodeContext<'a, 'tcx>> for LazyTable<I, T>

fn encode(&self, e: &mut EncodeContext<'a, 'tcx>)

impl<'a, 'tcx, T> Encodable<EncodeContext<'a, 'tcx>> for LazyValue<T>

fn encode(&self, e: &mut EncodeContext<'a, 'tcx>)

impl<'a, 'tcx> Encodable<EncodeContext<'a, 'tcx>> for Span

fn encode(&self, s: &mut EncodeContext<'a, 'tcx>)

impl<'a, 'tcx> Encodable<EncodeContext<'a, 'tcx>> for Symbol

fn encode(&self, s: &mut EncodeContext<'a, 'tcx>)

impl<'a, 'tcx> Encodable<EncodeContext<'a, 'tcx>> for SyntaxContext

fn encode(&self, s: &mut EncodeContext<'a, 'tcx>)

impl<'a, 'tcx> Encoder for EncodeContext<'a, 'tcx>

fn emit_usize(&mut self, value: usize)

fn emit_u128(&mut self, value: u128)

fn emit_u64(&mut self, value: u64)

fn emit_u32(&mut self, value: u32)

fn emit_u16(&mut self, value: u16)

fn emit_u8(&mut self, value: u8)

fn emit_isize(&mut self, value: isize)

fn emit_i128(&mut self, value: i128)

fn emit_i64(&mut self, value: i64)

fn emit_i32(&mut self, value: i32)

fn emit_i16(&mut self, value: i16)

fn emit_i8(&mut self, value: i8)

fn emit_bool(&mut self, value: bool)

fn emit_f64(&mut self, value: f64)

fn emit_f32(&mut self, value: f32)

fn emit_char(&mut self, value: char)

fn emit_str(&mut self, value: &str)

fn emit_raw_bytes(&mut self, value: &[u8])

fn emit_enum_variant<F>(&mut self, v_id: usize, f: F)where
    F: FnOnce(&mut Self),

fn emit_fieldless_enum_variant<const ID: usize>(&mut self)

impl<'a, 'tcx> TyEncoder for EncodeContext<'a, 'tcx>

const CLEAR_CROSS_CRATE: bool = true

type I = TyCtxt<'tcx>

fn position(&self) -> usize

fn type_shorthands(&mut self) -> &mut FxHashMap<Ty<'tcx>, usize>

fn predicate_shorthands(&mut self) -> &mut FxHashMap<PredicateKind<'tcx>, usize>

fn encode_alloc_id(&mut self, alloc_id: &AllocId)

impl<'a, 'tcx> Visitor<'tcx> for EncodeContext<'a, 'tcx>

type NestedFilter = OnlyBodies

Override this type to control which nested HIR are visited; see NestedFilter for details. If you override this type, you must also override nested_visit_map.

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

If type NestedFilter is set to visit nested items, this method must also be overridden to provide a map to retrieve nested items.

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

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_foreign_item(&mut self, ni: &'tcx ForeignItem<'tcx>)

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

type Map = <Self::NestedFilter as NestedFilter<'v>>::Map

fn visit_nested_item(&mut self, id: ItemId)

Invoked when a nested item is encountered. By default, when Self::NestedFilter is nested_filter::None, this method does nothing. You probably don’t want to override this method – instead, override Self::NestedFilter 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 Self::NestedFilter.

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

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

fn visit_id(&mut self, _hir_id: HirId)

fn visit_name(&mut self, _name: Symbol)

fn visit_ident(&mut self, ident: Ident)

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

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

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

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

fn visit_arm(&mut self, a: &'v Arm<'v>)

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

fn visit_pat_field(&mut self, f: &'v PatField<'v>)

fn visit_array_length(&mut self, len: &'v ArrayLen)

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

fn visit_let_expr(&mut self, lex: &'v Let<'v>)

fn visit_expr_field(&mut self, field: &'v ExprField<'v>)

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

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_ret_ty(&mut self, ret_ty: &'v FnRetTy<'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,
    _: 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)

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

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>)

fn visit_variant_data(&mut self, s: &'v VariantData<'v>)

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

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

fn visit_variant(&mut self, v: &'v Variant<'v>)

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

fn visit_infer(&mut self, inf: &'v InferArg)

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

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

fn visit_qpath(&mut self, qpath: &'v QPath<'v>, id: HirId, _span: Span)

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

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

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

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

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

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

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

fn visit_inline_asm(&mut self, asm: &'v InlineAsm<'v>, id: HirId)

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference’s “Type Layout” chapter for details on type layout guarantees.

Size: 1688 bytes