Struct rustc_symbol_mangling::v0::SymbolMangler

pub(in v0) 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>

pub(in v0) fn push(
    &mut self,
    s: &str
)

pub(in v0) 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.

pub(in v0) 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.

pub(in v0) fn push_disambiguator(
    &mut self,
    dis: u64
)

pub(in v0) fn push_ident(
    &mut self,
    ident: &str
)

pub(in v0) fn path_append_ns(
    self,
    print_prefix: impl FnOnce(Self) -> Result<Self, !>,
    ns: char,
    disambiguator: u64,
    name: &str
) -> Result<Self, !>

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

pub(in v0) fn in_binder<T>(
    self,
    value: &Binder<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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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