Struct rustc_symbol_mangling::v0::SymbolMangler

struct SymbolMangler<'tcx> {
    tcx: TyCtxt<'tcx>,
    compress: Option<Box<CompressionCaches<'tcx>>>,
    binders: Vec<BinderLevel>,
    out: String,
}

Fields

tcx: TyCtxt<'tcx>

compress: Option<Box<CompressionCaches<'tcx>>>

binders: Vec<BinderLevel>

out: String

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

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

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

Trait Implementations

impl<'tcx> Printer<'tcx> for 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: &'tcx [GenericArg<'tcx>]
) -> Result<Self::Path, Self::Error>

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

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

Layout

Note: Most layout information is completely unstable and may be different between compiler versions and platforms. 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: 64 bytes