Struct V0SymbolMangler 

struct V0SymbolMangler<'tcx> {
    tcx: TyCtxt<'tcx>,
    binders: Vec<BinderLevel>,
    out: String,
    is_exportable: bool,
    start_offset: usize,
    paths: FxHashMap<(DefId, &'tcx [GenericArg<'tcx>]), usize>,
    types: FxHashMap<Ty<'tcx>, usize>,
    consts: FxHashMap<Const<'tcx>, usize>,
}

Fields

tcx: TyCtxt<'tcx>

binders: Vec<BinderLevel>

out: String

is_exportable: bool

start_offset: usize

The length of the prefix in out (e.g. 2 for _R).

paths: FxHashMap<(DefId, &'tcx [GenericArg<'tcx>]), usize>

The values are start positions in out, in bytes.

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

consts: FxHashMap<Const<'tcx>, usize>

Implementations

impl<'tcx> V0SymbolMangler<'tcx>

fn push(&mut self, s: &str)

fn push_integer_62(&mut self, x: u64)

Push a _-terminated base 62 integer, using the format specified in the RFC as <base-62-number>, that is:

• x = 0 is encoded as just the "_" terminator
• x > 0 is encoded as x - 1 in base 62, followed by "_", e.g. 1 becomes "0_", 62 becomes "Z_", etc.

fn push_opt_integer_62(&mut self, tag: &str, x: u64)

Push a tag-prefixed base 62 integer, when larger than 0, that is:

• x = 0 is encoded as "" (nothing)
• x > 0 is encoded as the tag followed by push_integer_62(x - 1) e.g. 1 becomes tag + "_", 2 becomes tag + "0_", etc.

fn push_disambiguator(&mut self, dis: u64)

fn push_ident(&mut self, ident: &str)

fn path_append_ns( &mut self, print_prefix: impl FnOnce(&mut Self) -> Result<(), PrintError>, ns: char, disambiguator: u64, name: &str, ) -> Result<(), PrintError>

fn print_backref(&mut self, i: usize) -> Result<(), PrintError>

fn wrap_binder<T>( &mut self, value: &Binder<'tcx, T>, print_value: impl FnOnce(&mut Self, &T) -> Result<(), PrintError>, ) -> Result<(), PrintError>

where T: TypeVisitable<TyCtxt<'tcx>>,

fn print_pat(&mut self, pat: Pattern<'tcx>) -> Result<(), Error>

Trait Implementations

impl<'tcx> Printer<'tcx> for V0SymbolMangler<'tcx>

fn tcx(&self) -> TyCtxt<'tcx>

fn print_def_path( &mut self, def_id: DefId, args: &'tcx [GenericArg<'tcx>], ) -> Result<(), PrintError>

Appends a representation of an entity with a normal path, e.g. “std::io::Read”.

fn print_impl_path( &mut self, impl_def_id: DefId, args: &'tcx [GenericArg<'tcx>], ) -> Result<(), PrintError>

Like print_def_path, but for DefPathData::Impl.

fn print_region(&mut self, region: Region<'_>) -> Result<(), PrintError>

Appends a representation of a region.

fn print_type(&mut self, ty: Ty<'tcx>) -> Result<(), PrintError>

Appends a representation of a type.

fn print_dyn_existential( &mut self, predicates: &'tcx List<PolyExistentialPredicate<'tcx>>, ) -> Result<(), PrintError>

Appends a representation of a list of PolyExistentialPredicates.

fn print_const(&mut self, ct: Const<'tcx>) -> Result<(), PrintError>

Appends a representation of a const.

fn print_crate_name(&mut self, cnum: CrateNum) -> Result<(), PrintError>

Appends a representation of a crate name, e.g. std, or even ``.

fn print_path_with_qualified( &mut self, self_ty: Ty<'tcx>, trait_ref: Option<TraitRef<'tcx>>, ) -> Result<(), PrintError>

Appends a representation of a qualified path segment, e.g. <OsString as From<&T>>. If trait_ref is None, it may fall back to simpler forms, e.g. <Vec<T>> or just Foo.

fn print_path_with_impl( &mut self, _: impl FnOnce(&mut Self) -> Result<(), PrintError>, _: Ty<'tcx>, _: Option<TraitRef<'tcx>>, ) -> Result<(), PrintError>

Similar to print_path_with_simple, but the final segment is an impl segment.

fn print_path_with_simple( &mut self, print_prefix: impl FnOnce(&mut Self) -> Result<(), PrintError>, disambiguated_data: &DisambiguatedDefPathData, ) -> Result<(), PrintError>

Appends a representation of a (full or partial) simple path, in two parts. print_prefix, when called, appends the representation of the leading segments. The rest of the method appends the representation of the final segment, the details of which are in disambiguated_data.

fn print_path_with_generic_args( &mut self, print_prefix: impl FnOnce(&mut Self) -> Result<(), PrintError>, args: &[GenericArg<'tcx>], ) -> Result<(), PrintError>

Appends a representation of a path ending in generic args, in two parts. print_prefix, when called, appends the leading segments. The rest of the method appends the representation of the generic args. (Some printers choose to skip appending the generic args.)

fn print_coroutine_with_kind( &mut self, def_id: DefId, parent_args: &'tcx [GenericArg<'tcx>], kind: Ty<'tcx>, ) -> Result<(), Error>

fn default_print_def_path( &mut self, def_id: DefId, args: &'tcx [GenericArg<'tcx>], ) -> Result<(), Error>

fn default_print_impl_path( &mut self, impl_def_id: DefId, self_ty: Ty<'tcx>, impl_trait_ref: Option<TraitRef<TyCtxt<'tcx>>>, ) -> Result<(), Error>

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: 168 bytes