Struct rustc_symbol_mangling::v0::SymbolMangler

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

Fields

tcx: TyCtxt<'tcx>

binders: Vec<BinderLevel>

out: String

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<&'tcx Const<'tcx>, usize>

Implementations

impl<'tcx> SymbolMangler<'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<'a>(
    &'a mut self,
    print_prefix: impl FnOnce(&'a mut Self) -> Result<&'a mut Self, !>,
    ns: char,
    disambiguator: u64,
    name: &str
) -> Result<&'a mut Self, !>

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

fn in_binder<'a, T>(
    &'a mut self,
    value: &Binder<'tcx, T>,
    print_value: impl FnOnce(&'a mut Self, &T) -> Result<&'a mut Self, !>
) -> Result<&'a mut Self, !> where
    T: TypeFoldable<'tcx>, 

Trait Implementations

impl<'tcx> Printer<'tcx> for &mut SymbolMangler<'tcx>

type Error = !

type Path = Self

type Region = Self

type Type = Self

type DynExistential = Self

type Const = Self

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

fn print_def_path(
    self,
    def_id: DefId,
    substs: &'tcx [GenericArg<'tcx>]
) -> Result<Self::Path, Self::Error>

fn print_impl_path(
    self,
    impl_def_id: DefId,
    substs: &'tcx [GenericArg<'tcx>],
    self_ty: Ty<'tcx>,
    impl_trait_ref: Option<TraitRef<'tcx>>
) -> Result<Self::Path, Self::Error>

fn print_region(self, region: Region<'_>) -> Result<Self::Region, Self::Error>

fn print_type(self, ty: Ty<'tcx>) -> Result<Self::Type, Self::Error>

fn print_dyn_existential(
    self,
    predicates: &'tcx List<Binder<'tcx, ExistentialPredicate<'tcx>>>
) -> Result<Self::DynExistential, Self::Error>

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

fn path_crate(self, cnum: CrateNum) -> Result<Self::Path, Self::Error>

fn path_qualified(
    self,
    self_ty: Ty<'tcx>,
    trait_ref: Option<TraitRef<'tcx>>
) -> Result<Self::Path, Self::Error>

fn path_append_impl(
    self,
    _: impl FnOnce(Self) -> Result<Self::Path, Self::Error>,
    _: &DisambiguatedDefPathData,
    _: Ty<'tcx>,
    _: Option<TraitRef<'tcx>>
) -> Result<Self::Path, Self::Error>

fn path_append(
    self,
    print_prefix: impl FnOnce(Self) -> Result<Self::Path, Self::Error>,
    disambiguated_data: &DisambiguatedDefPathData
) -> Result<Self::Path, Self::Error>

fn path_generic_args(
    self,
    print_prefix: impl FnOnce(Self) -> Result<Self::Path, Self::Error>,
    args: &[GenericArg<'tcx>]
) -> Result<Self::Path, Self::Error>

fn default_print_def_path(
    self,
    def_id: DefId,
    substs: &[GenericArg]
) -> Result<Self::Path, Self::Error>

fn generic_args_to_print(
    &self,
    generics: &Generics,
    substs: &[GenericArg]
) -> &[GenericArg]

fn default_print_impl_path(
    self,
    impl_def_id: DefId,
    _substs: &[GenericArg],
    self_ty: &TyS,
    impl_trait_ref: Option<TraitRef>
) -> Result<Self::Path, Self::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: 160 bytes