Trait rustc_middle::ty::print::pretty::PrettyPrinter[−][src]

pub trait PrettyPrinter<'tcx>: Printer<'tcx, Error = Error, Path = Self, Region = Self, Type = Self, DynExistential = Self, Const = Self> + Write {

Show 24 methods    fn generic_delimiters(
        self, 
        f: impl FnOnce(Self) -> Result<Self, Self::Error>
    ) -> Result<Self, Self::Error>;

    fn region_should_not_be_omitted(&self, region: Region<'_>) -> bool;

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

    fn in_binder<T>(self, value: &Binder<'tcx, T>) -> Result<Self, Self::Error>
    where
        T: Print<'tcx, Self, Output = Self, Error = Self::Error> + TypeFoldable<'tcx>,
    { ... }

    fn wrap_binder<T, F: Fn(&T, Self) -> Result<Self, Error>>(
        self, 
        value: &Binder<'tcx, T>, 
        f: F
    ) -> Result<Self, Self::Error>
    where
        T: Print<'tcx, Self, Output = Self, Error = Self::Error> + TypeFoldable<'tcx>,
    { ... }

    fn comma_sep<T>(
        self, 
        elems: impl Iterator<Item = T>
    ) -> Result<Self, Self::Error>
    where
        T: Print<'tcx, Self, Output = Self, Error = Self::Error>,
    { ... }

    fn typed_value(
        self, 
        f: impl FnOnce(Self) -> Result<Self, Self::Error>, 
        t: impl FnOnce(Self) -> Result<Self, Self::Error>, 
        conversion: &str
    ) -> Result<Self::Const, Self::Error> { ... }

    fn try_print_visible_def_path(
        self, 
        def_id: DefId
    ) -> Result<(Self, bool), Self::Error> { ... }

    fn try_print_trimmed_def_path(
        self, 
        def_id: DefId
    ) -> Result<(Self::Path, bool), Self::Error> { ... }

    fn try_print_visible_def_path_recur(
        self, 
        def_id: DefId, 
        callers: &mut Vec<DefId>
    ) -> Result<(Self, bool), Self::Error> { ... }

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

    fn pretty_path_append_impl(
        self, 
        print_prefix: impl FnOnce(Self) -> Result<Self::Path, Self::Error>, 
        self_ty: Ty<'tcx>, 
        trait_ref: Option<TraitRef<'tcx>>
    ) -> Result<Self::Path, Self::Error> { ... }

    fn pretty_print_type(self, ty: Ty<'tcx>) -> Result<Self::Type, Self::Error> { ... }

    fn pretty_print_bound_var(
        &mut self, 
        debruijn: DebruijnIndex, 
        var: BoundVar
    ) -> Result<(), Self::Error> { ... }

    fn infer_ty_name(&self, _: TyVid) -> Option<String> { ... }

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

    fn pretty_fn_sig(
        self, 
        inputs: &[Ty<'tcx>], 
        c_variadic: bool, 
        output: Ty<'tcx>
    ) -> Result<Self, Self::Error> { ... }

    fn pretty_print_const(
        self, 
        ct: &'tcx Const<'tcx>, 
        print_ty: bool
    ) -> Result<Self::Const, Self::Error> { ... }

    fn pretty_print_const_scalar(
        self, 
        scalar: Scalar, 
        ty: Ty<'tcx>, 
        print_ty: bool
    ) -> Result<Self::Const, Self::Error> { ... }

    fn pretty_print_const_scalar_ptr(
        self, 
        ptr: Pointer, 
        ty: Ty<'tcx>, 
        print_ty: bool
    ) -> Result<Self::Const, Self::Error> { ... }

    fn pretty_print_const_scalar_int(
        self, 
        int: ScalarInt, 
        ty: Ty<'tcx>, 
        print_ty: bool
    ) -> Result<Self::Const, Self::Error> { ... }

    fn pretty_print_const_pointer<Tag: Provenance>(
        self, 
        _: Pointer<Tag>, 
        ty: Ty<'tcx>, 
        print_ty: bool
    ) -> Result<Self::Const, Self::Error> { ... }

    fn pretty_print_byte_str(
        self, 
        byte_str: &'tcx [u8]
    ) -> Result<Self::Const, Self::Error> { ... }

    fn pretty_print_const_value(
        self, 
        ct: ConstValue<'tcx>, 
        ty: Ty<'tcx>, 
        print_ty: bool
    ) -> Result<Self::Const, Self::Error> { ... }

}
Expand description

Trait for printers that pretty-print using fmt::Write to the printer.

Required methods

Prints <...> around what f prints.

Returns true if the region should be printed in optional positions, e.g., &'a T or dyn Tr + 'b. This is typically the case for all non-'_ regions.

Provided methods

Like print_def_path but for value paths.

Prints comma-separated elements.

Prints {f: t} or {f as t} depending on the cast argument

If possible, this returns a global path resolving to def_id that is visible from at least one local module, and returns true. If the crate defining def_id is declared with an extern crate, the path is guaranteed to use the extern crate.

Try to see if this path can be trimmed to a unique symbol name.

Does the work of try_print_visible_def_path, building the full definition path recursively before attempting to post-process it into the valid and visible version that accounts for re-exports.

This method should only be called by itself or try_print_visible_def_path.

callers is a chain of visible_parent’s leading to def_id, to support cycle detection during recursion.

This is overridden for MIR printing because we only want to hide alloc ids from users, not from MIR where it is actually useful.

Implementors