user0/rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Rename Printer variables.

Browse source 
Currently they are mostly named `cx`, which is a terrible name for a
type that impls `Printer`/`PrettyPrinter`, and is easy to confuse with
other types like `TyCtxt`. This commit changes them to `p`. A couple of
existing `p` variables had to be renamed to make way.
This commit is contained in:
Nicholas Nethercote 2025-08-01 10:41:11 +10:00
parent e7d6a0776b
commit 1698c8e322
17 changed files with 279 additions and 281 deletions
Download patch file Download diff file Expand all files Collapse all files

16
compiler/rustc_borrowck/src/diagnostics/mod.rs
View file

@ -613,7 +613,7 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
/// Return the name of the provided `Ty` (that must be a reference) with a synthesized lifetime
/// name where required.
pub(super) fn get_name_for_ty(&self, ty: Ty<'tcx>, counter: usize) -> String {
let mut printer = ty::print::FmtPrinter::new(self.infcx.tcx, Namespace::TypeNS);
let mut p = ty::print::FmtPrinter::new(self.infcx.tcx, Namespace::TypeNS);
// We need to add synthesized lifetimes where appropriate. We do
// this by hooking into the pretty printer and telling it to label the
@ -624,19 +624,19 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
| ty::RePlaceholder(ty::PlaceholderRegion {
bound: ty::BoundRegion { kind: br, .. },
..
}) => printer.region_highlight_mode.highlighting_bound_region(br, counter),
}) => p.region_highlight_mode.highlighting_bound_region(br, counter),
_ => {}
}
}
ty.print(&mut printer).unwrap();
printer.into_buffer()
ty.print(&mut p).unwrap();
p.into_buffer()
}
/// Returns the name of the provided `Ty` (that must be a reference)'s region with a
/// synthesized lifetime name where required.
pub(super) fn get_region_name_for_ty(&self, ty: Ty<'tcx>, counter: usize) -> String {
let mut printer = ty::print::FmtPrinter::new(self.infcx.tcx, Namespace::TypeNS);
let mut p = ty::print::FmtPrinter::new(self.infcx.tcx, Namespace::TypeNS);
let region = if let ty::Ref(region, ..) = ty.kind() {
match region.kind() {
@ -644,7 +644,7 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
| ty::RePlaceholder(ty::PlaceholderRegion {
bound: ty::BoundRegion { kind: br, .. },
..
}) => printer.region_highlight_mode.highlighting_bound_region(br, counter),
}) => p.region_highlight_mode.highlighting_bound_region(br, counter),
_ => {}
}
region
@ -652,8 +652,8 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
bug!("ty for annotation of borrow region is not a reference");
};
region.print(&mut printer).unwrap();
printer.into_buffer()
region.print(&mut p).unwrap();
p.into_buffer()
}
/// Add a note to region errors and borrow explanations when higher-ranked regions in predicates

13
compiler/rustc_const_eval/src/interpret/operand.rs
View file

@ -188,18 +188,18 @@ pub struct ImmTy<'tcx, Prov: Provenance = CtfeProvenance> {
impl<Prov: Provenance> std::fmt::Display for ImmTy<'_, Prov> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
/// Helper function for printing a scalar to a FmtPrinter
fn p<'a, 'tcx, Prov: Provenance>(
cx: &mut FmtPrinter<'a, 'tcx>,
fn print_scalar<'a, 'tcx, Prov: Provenance>(
p: &mut FmtPrinter<'a, 'tcx>,
s: Scalar<Prov>,
ty: Ty<'tcx>,
) -> Result<(), std::fmt::Error> {
match s {
Scalar::Int(int) => cx.pretty_print_const_scalar_int(int, ty, true),
Scalar::Int(int) => p.pretty_print_const_scalar_int(int, ty, true),
Scalar::Ptr(ptr, _sz) => {
// Just print the ptr value. `pretty_print_const_scalar_ptr` would also try to
// print what is points to, which would fail since it has no access to the local
// memory.
cx.pretty_print_const_pointer(ptr, ty)
p.pretty_print_const_pointer(ptr, ty)
}
}
}
@ -207,8 +207,9 @@ impl<Prov: Provenance> std::fmt::Display for ImmTy<'_, Prov> {
match self.imm {
Immediate::Scalar(s) => {
if let Some(ty) = tcx.lift(self.layout.ty) {
let s =
FmtPrinter::print_string(tcx, Namespace::ValueNS, |cx| p(cx, s, ty))?;
let s = FmtPrinter::print_string(tcx, Namespace::ValueNS, |p| {
print_scalar(p, s, ty)
})?;
f.write_str(&s)?;
return Ok(());
}

6
compiler/rustc_const_eval/src/util/type_name.rs
View file

@ -166,7 +166,7 @@ impl Write for AbsolutePathPrinter<'_> {
}
pub fn type_name<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> String {
let mut printer = AbsolutePathPrinter { tcx, path: String::new() };
printer.print_type(ty).unwrap();
printer.path
let mut p = AbsolutePathPrinter { tcx, path: String::new() };
p.print_type(ty).unwrap();
p.path
}

6
compiler/rustc_lint/src/context.rs
View file

@ -854,9 +854,9 @@ impl<'tcx> LateContext<'tcx> {
}
}
let mut printer = AbsolutePathPrinter { tcx: self.tcx, path: vec![] };
printer.print_def_path(def_id, &[]).unwrap();
printer.path
let mut p = AbsolutePathPrinter { tcx: self.tcx, path: vec![] };
p.print_def_path(def_id, &[]).unwrap();
p.path
}
/// Returns the associated type `name` for `self_ty` as an implementation of `trait_id`.

34
compiler/rustc_middle/src/mir/pretty.rs
View file

@ -1197,8 +1197,8 @@ impl<'tcx> Debug for Rvalue<'tcx> {
ty::tls::with(|tcx| {
let variant_def = &tcx.adt_def(adt_did).variant(variant);
let args = tcx.lift(args).expect("could not lift for printing");
let name = FmtPrinter::print_string(tcx, Namespace::ValueNS, |cx| {
cx.print_def_path(variant_def.def_id, args)
let name = FmtPrinter::print_string(tcx, Namespace::ValueNS, |p| {
p.print_def_path(variant_def.def_id, args)
})?;
match variant_def.ctor_kind() {
@ -1473,9 +1473,9 @@ impl<'tcx> Visitor<'tcx> for ExtraComments<'tcx> {
};
let fmt_valtree = |cv: &ty::Value<'tcx>| {
let mut cx = FmtPrinter::new(self.tcx, Namespace::ValueNS);
cx.pretty_print_const_valtree(*cv, /*print_ty*/ true).unwrap();
cx.into_buffer()
let mut p = FmtPrinter::new(self.tcx, Namespace::ValueNS);
p.pretty_print_const_valtree(*cv, /*print_ty*/ true).unwrap();
p.into_buffer()
};
let val = match const_ {
@ -1967,10 +1967,10 @@ fn pretty_print_const_value_tcx<'tcx>(
.expect("destructed mir constant of adt without variant idx");
let variant_def = &def.variant(variant_idx);
let args = tcx.lift(args).unwrap();
let mut cx = FmtPrinter::new(tcx, Namespace::ValueNS);
cx.print_alloc_ids = true;
cx.print_value_path(variant_def.def_id, args)?;
fmt.write_str(&cx.into_buffer())?;
let mut p = FmtPrinter::new(tcx, Namespace::ValueNS);
p.print_alloc_ids = true;
p.print_value_path(variant_def.def_id, args)?;
fmt.write_str(&p.into_buffer())?;
match variant_def.ctor_kind() {
Some(CtorKind::Const) => {}
@ -2001,18 +2001,18 @@ fn pretty_print_const_value_tcx<'tcx>(
}
}
(ConstValue::Scalar(scalar), _) => {
let mut cx = FmtPrinter::new(tcx, Namespace::ValueNS);
cx.print_alloc_ids = true;
let mut p = FmtPrinter::new(tcx, Namespace::ValueNS);
p.print_alloc_ids = true;
let ty = tcx.lift(ty).unwrap();
cx.pretty_print_const_scalar(scalar, ty)?;
fmt.write_str(&cx.into_buffer())?;
p.pretty_print_const_scalar(scalar, ty)?;
fmt.write_str(&p.into_buffer())?;
return Ok(());
}
(ConstValue::ZeroSized, ty::FnDef(d, s)) => {
let mut cx = FmtPrinter::new(tcx, Namespace::ValueNS);
cx.print_alloc_ids = true;
cx.print_value_path(*d, s)?;
fmt.write_str(&cx.into_buffer())?;
let mut p = FmtPrinter::new(tcx, Namespace::ValueNS);
p.print_alloc_ids = true;
p.print_value_path(*d, s)?;
fmt.write_str(&p.into_buffer())?;
return Ok(());
}
// FIXME(oli-obk): also pretty print arrays and other aggregate constants by reading

24
compiler/rustc_middle/src/ty/error.rs
View file

@ -213,13 +213,13 @@ impl<'tcx> Ty<'tcx> {
}
impl<'tcx> TyCtxt<'tcx> {
pub fn string_with_limit<T>(self, p: T, length_limit: usize) -> String
pub fn string_with_limit<T>(self, t: T, length_limit: usize) -> String
where
T: Copy + for<'a, 'b> Lift<TyCtxt<'b>, Lifted: Print<'b, FmtPrinter<'a, 'b>>>,
{
let mut type_limit = 50;
let regular = FmtPrinter::print_string(self, hir::def::Namespace::TypeNS, |cx| {
self.lift(p).expect("could not lift for printing").print(cx)
let regular = FmtPrinter::print_string(self, hir::def::Namespace::TypeNS, |p| {
self.lift(t).expect("could not lift for printing").print(p)
})
.expect("could not write to `String`");
if regular.len() <= length_limit {
@ -229,16 +229,16 @@ impl<'tcx> TyCtxt<'tcx> {
loop {
// Look for the longest properly trimmed path that still fits in length_limit.
short = with_forced_trimmed_paths!({
let mut cx = FmtPrinter::new_with_limit(
let mut p = FmtPrinter::new_with_limit(
self,
hir::def::Namespace::TypeNS,
rustc_session::Limit(type_limit),
);
self.lift(p)
self.lift(t)
.expect("could not lift for printing")
.print(&mut cx)
.print(&mut p)
.expect("could not print type");
cx.into_buffer()
p.into_buffer()
});
if short.len() <= length_limit || type_limit == 0 {
break;
@ -252,12 +252,12 @@ impl<'tcx> TyCtxt<'tcx> {
/// `tcx.short_string(ty, diag.long_ty_path())`. The diagnostic itself is the one that keeps
/// the existence of a "long type" anywhere in the diagnostic, so the note telling the user
/// where we wrote the file to is only printed once.
pub fn short_string<T>(self, p: T, path: &mut Option<PathBuf>) -> String
pub fn short_string<T>(self, t: T, path: &mut Option<PathBuf>) -> String
where
T: Copy + Hash + for<'a, 'b> Lift<TyCtxt<'b>, Lifted: Print<'b, FmtPrinter<'a, 'b>>>,
{
let regular = FmtPrinter::print_string(self, hir::def::Namespace::TypeNS, |cx| {
self.lift(p).expect("could not lift for printing").print(cx)
let regular = FmtPrinter::print_string(self, hir::def::Namespace::TypeNS, |p| {
self.lift(t).expect("could not lift for printing").print(p)
})
.expect("could not write to `String`");
@ -270,13 +270,13 @@ impl<'tcx> TyCtxt<'tcx> {
if regular.len() <= width * 2 / 3 {
return regular;
}
let short = self.string_with_limit(p, length_limit);
let short = self.string_with_limit(t, length_limit);
if regular == short {
return regular;
}
// Ensure we create an unique file for the type passed in when we create a file.
let mut s = DefaultHasher::new();
p.hash(&mut s);
t.hash(&mut s);
let hash = s.finish();
*path = Some(path.take().unwrap_or_else(|| {
self.output_filenames(()).temp_path_for_diagnostic(&format!("long-type-{hash}.txt"))

6
compiler/rustc_middle/src/ty/instance.rs
View file

@ -397,13 +397,13 @@ pub fn fmt_instance(
ty::tls::with(|tcx| {
let args = tcx.lift(instance.args).expect("could not lift for printing");
let mut cx = if let Some(type_length) = type_length {
let mut p = if let Some(type_length) = type_length {
FmtPrinter::new_with_limit(tcx, Namespace::ValueNS, type_length)
} else {
FmtPrinter::new(tcx, Namespace::ValueNS)
};
cx.print_def_path(instance.def_id(), args)?;
let s = cx.into_buffer();
p.print_def_path(instance.def_id(), args)?;
let s = p.into_buffer();
f.write_str(&s)
})?;

38
compiler/rustc_middle/src/ty/print/mod.rs
View file

@ -18,7 +18,7 @@ use super::Lift;
pub type PrintError = std::fmt::Error;
pub trait Print<'tcx, P> {
fn print(&self, cx: &mut P) -> Result<(), PrintError>;
fn print(&self, p: &mut P) -> Result<(), PrintError>;
}
/// Interface for outputting user-facing "type-system entities"
@ -148,7 +148,7 @@ pub trait Printer<'tcx>: Sized {
&& args.len() > parent_args.len()
{
return self.path_generic_args(
|cx| cx.print_def_path(def_id, parent_args),
|p| p.print_def_path(def_id, parent_args),
&args[..parent_args.len() + 1][..1],
);
} else {
@ -170,7 +170,7 @@ pub trait Printer<'tcx>: Sized {
if !generics.is_own_empty() && args.len() >= generics.count() {
let args = generics.own_args_no_defaults(self.tcx(), args);
return self.path_generic_args(
|cx| cx.print_def_path(def_id, parent_args),
|p| p.print_def_path(def_id, parent_args),
args,
);
}
@ -186,16 +186,16 @@ pub trait Printer<'tcx>: Sized {
}
self.path_append(
|cx: &mut Self| {
|p: &mut Self| {
if trait_qualify_parent {
let trait_ref = ty::TraitRef::new(
cx.tcx(),
p.tcx(),
parent_def_id,
parent_args.iter().copied(),
);
cx.path_qualified(trait_ref.self_ty(), Some(trait_ref))
p.path_qualified(trait_ref.self_ty(), Some(trait_ref))
} else {
cx.print_def_path(parent_def_id, parent_args)
p.print_def_path(parent_def_id, parent_args)
}
},
&key.disambiguated_data,
@ -237,7 +237,7 @@ pub trait Printer<'tcx>: Sized {
// trait-type, then fallback to a format that identifies
// the module more clearly.
self.path_append_impl(
|cx| cx.print_def_path(parent_def_id, &[]),
|p| p.print_def_path(parent_def_id, &[]),
&key.disambiguated_data,
self_ty,
impl_trait_ref,
@ -312,26 +312,26 @@ pub fn characteristic_def_id_of_type(ty: Ty<'_>) -> Option<DefId> {
}
impl<'tcx, P: Printer<'tcx>> Print<'tcx, P> for ty::Region<'tcx> {
fn print(&self, cx: &mut P) -> Result<(), PrintError> {
cx.print_region(*self)
fn print(&self, p: &mut P) -> Result<(), PrintError> {
p.print_region(*self)
}
}
impl<'tcx, P: Printer<'tcx>> Print<'tcx, P> for Ty<'tcx> {
fn print(&self, cx: &mut P) -> Result<(), PrintError> {
cx.print_type(*self)
fn print(&self, p: &mut P) -> Result<(), PrintError> {
p.print_type(*self)
}
}
impl<'tcx, P: Printer<'tcx>> Print<'tcx, P> for &'tcx ty::List<ty::PolyExistentialPredicate<'tcx>> {
fn print(&self, cx: &mut P) -> Result<(), PrintError> {
cx.print_dyn_existential(self)
fn print(&self, p: &mut P) -> Result<(), PrintError> {
p.print_dyn_existential(self)
}
}
impl<'tcx, P: Printer<'tcx>> Print<'tcx, P> for ty::Const<'tcx> {
fn print(&self, cx: &mut P) -> Result<(), PrintError> {
cx.print_const(*self)
fn print(&self, p: &mut P) -> Result<(), PrintError> {
p.print_const(*self)
}
}
@ -351,9 +351,9 @@ where
{
fn print(t: &T, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
ty::tls::with(|tcx| {
let mut cx = FmtPrinter::new(tcx, Namespace::TypeNS);
tcx.lift(*t).expect("could not lift for printing").print(&mut cx)?;
fmt.write_str(&cx.into_buffer())?;
let mut p = FmtPrinter::new(tcx, Namespace::TypeNS);
tcx.lift(*t).expect("could not lift for printing").print(&mut p)?;
fmt.write_str(&p.into_buffer())?;
Ok(())
})
}

196
compiler/rustc_middle/src/ty/print/pretty.rs
View file

@ -31,26 +31,26 @@ use crate::ty::{
macro_rules! p {
(@$lit:literal) => {
write!(scoped_cx!(), $lit)?
write!(scoped_printer!(), $lit)?
};
(@write($($data:expr),+)) => {
write!(scoped_cx!(), $($data),+)?
write!(scoped_printer!(), $($data),+)?
};
(@print($x:expr)) => {
$x.print(scoped_cx!())?
$x.print(scoped_printer!())?
};
(@$method:ident($($arg:expr),*)) => {
scoped_cx!().$method($($arg),*)?
scoped_printer!().$method($($arg),*)?
};
($($elem:tt $(($($args:tt)*))?),+) => {{
$(p!(@ $elem $(($($args)*))?);)+
}};
}
macro_rules! define_scoped_cx {
($cx:ident) => {
macro_rules! scoped_cx {
macro_rules! define_scoped_printer {
($p:ident) => {
macro_rules! scoped_printer {
() => {
$cx
$p
};
}
};
@ -689,8 +689,8 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
}
}
self.generic_delimiters(|cx| {
define_scoped_cx!(cx);
self.generic_delimiters(|p| {
define_scoped_printer!(p);
p!(print(self_ty));
if let Some(trait_ref) = trait_ref {
@ -708,8 +708,8 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
) -> Result<(), PrintError> {
print_prefix(self)?;
self.generic_delimiters(|cx| {
define_scoped_cx!(cx);
self.generic_delimiters(|p| {
define_scoped_printer!(p);
p!("impl ");
if let Some(trait_ref) = trait_ref {
@ -722,7 +722,7 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
}
fn pretty_print_type(&mut self, ty: Ty<'tcx>) -> Result<(), PrintError> {
define_scoped_cx!(self);
define_scoped_printer!(self);
match *ty.kind() {
ty::Bool => p!("bool"),
@ -769,8 +769,8 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
}
ty::FnPtr(ref sig_tys, hdr) => p!(print(sig_tys.with(hdr))),
ty::UnsafeBinder(ref bound_ty) => {
self.wrap_binder(bound_ty, WrapBinderMode::Unsafe, |ty, cx| {
cx.pretty_print_type(*ty)
self.wrap_binder(bound_ty, WrapBinderMode::Unsafe, |ty, p| {
p.pretty_print_type(*ty)
})?;
}
ty::Infer(infer_ty) => {
@ -1137,8 +1137,8 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
self.wrap_binder(
&bound_args_and_self_ty,
WrapBinderMode::ForAll,
|(args, _), cx| {
define_scoped_cx!(cx);
|(args, _), p| {
define_scoped_printer!(p);
p!(write("{}", tcx.item_name(trait_def_id)));
p!("(");
@ -1181,8 +1181,8 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
for (trait_pred, assoc_items) in traits {
write!(self, "{}", if first { "" } else { " + " })?;
self.wrap_binder(&trait_pred, WrapBinderMode::ForAll, |trait_pred, cx| {
define_scoped_cx!(cx);
self.wrap_binder(&trait_pred, WrapBinderMode::ForAll, |trait_pred, p| {
define_scoped_printer!(p);
if trait_pred.polarity == ty::PredicatePolarity::Negative {
p!("!");
@ -1322,9 +1322,9 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
) -> Result<(), PrintError> {
let def_key = self.tcx().def_key(alias_ty.def_id);
self.path_generic_args(
|cx| {
cx.path_append(
|cx| cx.path_qualified(alias_ty.self_ty(), None),
|p| {
p.path_append(
|p| p.path_qualified(alias_ty.self_ty(), None),
&def_key.disambiguated_data,
)
},
@ -1388,15 +1388,15 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
let mut first = true;
if let Some(bound_principal) = predicates.principal() {
self.wrap_binder(&bound_principal, WrapBinderMode::ForAll, |principal, cx| {
define_scoped_cx!(cx);
self.wrap_binder(&bound_principal, WrapBinderMode::ForAll, |principal, p| {
define_scoped_printer!(p);
p!(print_def_path(principal.def_id, &[]));
let mut resugared = false;
// Special-case `Fn(...) -> ...` and re-sugar it.
let fn_trait_kind = cx.tcx().fn_trait_kind_from_def_id(principal.def_id);
if !cx.should_print_verbose() && fn_trait_kind.is_some() {
let fn_trait_kind = p.tcx().fn_trait_kind_from_def_id(principal.def_id);
if !p.should_print_verbose() && fn_trait_kind.is_some() {
if let ty::Tuple(tys) = principal.args.type_at(0).kind() {
let mut projections = predicates.projection_bounds();
if let (Some(proj), None) = (projections.next(), projections.next()) {
@ -1414,18 +1414,18 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
// in order to place the projections inside the `<...>`.
if !resugared {
let principal_with_self =
principal.with_self_ty(cx.tcx(), cx.tcx().types.trait_object_dummy_self);
principal.with_self_ty(p.tcx(), p.tcx().types.trait_object_dummy_self);
let args = cx
let args = p
.tcx()
.generics_of(principal_with_self.def_id)
.own_args_no_defaults(cx.tcx(), principal_with_self.args);
.own_args_no_defaults(p.tcx(), principal_with_self.args);
let bound_principal_with_self = bound_principal
.with_self_ty(cx.tcx(), cx.tcx().types.trait_object_dummy_self);
.with_self_ty(p.tcx(), p.tcx().types.trait_object_dummy_self);
let clause: ty::Clause<'tcx> = bound_principal_with_self.upcast(cx.tcx());
let super_projections: Vec<_> = elaborate::elaborate(cx.tcx(), [clause])
let clause: ty::Clause<'tcx> = bound_principal_with_self.upcast(p.tcx());
let super_projections: Vec<_> = elaborate::elaborate(p.tcx(), [clause])
.filter_only_self()
.filter_map(|clause| clause.as_projection_clause())
.collect();
@ -1436,15 +1436,15 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
// Filter out projections that are implied by the super predicates.
let proj_is_implied = super_projections.iter().any(|&super_proj| {
let super_proj = super_proj.map_bound(|super_proj| {
ty::ExistentialProjection::erase_self_ty(cx.tcx(), super_proj)
ty::ExistentialProjection::erase_self_ty(p.tcx(), super_proj)
});
// This function is sometimes called on types with erased and
// anonymized regions, but the super projections can still
// contain named regions. So we erase and anonymize everything
// here to compare the types modulo regions below.
let proj = cx.tcx().erase_regions(proj);
let super_proj = cx.tcx().erase_regions(super_proj);
let proj = p.tcx().erase_regions(proj);
let super_proj = p.tcx().erase_regions(super_proj);
proj == super_proj
});
@ -1458,15 +1458,15 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
.collect();
projections
.sort_by_cached_key(|proj| cx.tcx().item_name(proj.def_id).to_string());
.sort_by_cached_key(|proj| p.tcx().item_name(proj.def_id).to_string());
if !args.is_empty() || !projections.is_empty() {
p!(generic_delimiters(|cx| {
cx.comma_sep(args.iter().copied())?;
p!(generic_delimiters(|p| {
p.comma_sep(args.iter().copied())?;
if !args.is_empty() && !projections.is_empty() {
write!(cx, ", ")?;
write!(p, ", ")?;
}
cx.comma_sep(projections.iter().copied())
p.comma_sep(projections.iter().copied())
}));
}
}
@ -1476,11 +1476,11 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
first = false;
}
define_scoped_cx!(self);
define_scoped_printer!(self);
// Builtin bounds.
// FIXME(eddyb) avoid printing twice (needed to ensure
// that the auto traits are sorted *and* printed via cx).
// that the auto traits are sorted *and* printed via p).
let mut auto_traits: Vec<_> = predicates.auto_traits().collect();
// The auto traits come ordered by `DefPathHash`. While
@ -1510,7 +1510,7 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
c_variadic: bool,
output: Ty<'tcx>,
) -> Result<(), PrintError> {
define_scoped_cx!(self);
define_scoped_printer!(self);
p!("(", comma_sep(inputs.iter().copied()));
if c_variadic {
@ -1532,7 +1532,7 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
ct: ty::Const<'tcx>,
print_ty: bool,
) -> Result<(), PrintError> {
define_scoped_cx!(self);
define_scoped_printer!(self);
if self.should_print_verbose() {
p!(write("{:?}", ct));
@ -1595,7 +1595,7 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
expr: Expr<'tcx>,
print_ty: bool,
) -> Result<(), PrintError> {
define_scoped_cx!(self);
define_scoped_printer!(self);
match expr.kind {
ty::ExprKind::Binop(op) => {
let (_, _, c1, c2) = expr.binop_args();
@ -1718,7 +1718,7 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
ptr: Pointer,
ty: Ty<'tcx>,
) -> Result<(), PrintError> {
define_scoped_cx!(self);
define_scoped_printer!(self);
let (prov, offset) = ptr.prov_and_relative_offset();
match ty.kind() {
@ -1778,7 +1778,7 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
ty: Ty<'tcx>,
print_ty: bool,
) -> Result<(), PrintError> {
define_scoped_cx!(self);
define_scoped_printer!(self);
match ty.kind() {
// Bool
@ -1876,7 +1876,7 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
cv: ty::Value<'tcx>,
print_ty: bool,
) -> Result<(), PrintError> {
define_scoped_cx!(self);
define_scoped_printer!(self);
if with_reduced_queries() || self.should_print_verbose() {
p!(write("ValTree({:?}: ", cv.valtree), print(cv.ty), ")");
@ -2012,8 +2012,8 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
let kind = closure.kind_ty().to_opt_closure_kind().unwrap_or(ty::ClosureKind::Fn);
write!(self, "impl ")?;
self.wrap_binder(&sig, WrapBinderMode::ForAll, |sig, cx| {
define_scoped_cx!(cx);
self.wrap_binder(&sig, WrapBinderMode::ForAll, |sig, p| {
define_scoped_printer!(p);
p!(write("{kind}("));
for (i, arg) in sig.inputs()[0].tuple_fields().iter().enumerate() {
@ -2036,7 +2036,7 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
&mut self,
constness: ty::BoundConstness,
) -> Result<(), PrintError> {
define_scoped_cx!(self);
define_scoped_printer!(self);
match constness {
ty::BoundConstness::Const => {
@ -2061,10 +2061,10 @@ pub(crate) fn pretty_print_const<'tcx>(
) -> fmt::Result {
ty::tls::with(|tcx| {
let literal = tcx.lift(c).unwrap();
let mut cx = FmtPrinter::new(tcx, Namespace::ValueNS);
cx.print_alloc_ids = true;
cx.pretty_print_const(literal, print_types)?;
fmt.write_str(&cx.into_buffer())?;
let mut p = FmtPrinter::new(tcx, Namespace::ValueNS);
p.print_alloc_ids = true;
p.pretty_print_const(literal, print_types)?;
fmt.write_str(&p.into_buffer())?;
Ok(())
})
}
@ -2184,7 +2184,7 @@ impl<'t> TyCtxt<'t> {
let ns = guess_def_namespace(self, def_id);
debug!("def_path_str: def_id={:?}, ns={:?}", def_id, ns);
FmtPrinter::print_string(self, ns, |cx| cx.print_def_path(def_id, args)).unwrap()
FmtPrinter::print_string(self, ns, |p| p.print_def_path(def_id, args)).unwrap()
}
pub fn value_path_str_with_args(
@ -2196,7 +2196,7 @@ impl<'t> TyCtxt<'t> {
let ns = guess_def_namespace(self, def_id);
debug!("value_path_str: def_id={:?}, ns={:?}", def_id, ns);
FmtPrinter::print_string(self, ns, |cx| cx.print_value_path(def_id, args)).unwrap()
FmtPrinter::print_string(self, ns, |p| p.print_value_path(def_id, args)).unwrap()
}
}
@ -2363,10 +2363,10 @@ impl<'tcx> Printer<'tcx> for FmtPrinter<'_, 'tcx> {
trait_ref: Option<ty::TraitRef<'tcx>>,
) -> Result<(), PrintError> {
self.pretty_path_append_impl(
|cx| {
print_prefix(cx)?;
if !cx.empty_path {
write!(cx, "::")?;
|p| {
print_prefix(p)?;
if !p.empty_path {
write!(p, "::")?;
}
Ok(())
@ -2420,7 +2420,7 @@ impl<'tcx> Printer<'tcx> for FmtPrinter<'_, 'tcx> {
if self.in_value {
write!(self, "::")?;
}
self.generic_delimiters(|cx| cx.comma_sep(args.iter().copied()))
self.generic_delimiters(|p| p.comma_sep(args.iter().copied()))
} else {
Ok(())
}
@ -2562,7 +2562,7 @@ impl<'tcx> PrettyPrinter<'tcx> for FmtPrinter<'_, 'tcx> {
ty: Ty<'tcx>,
) -> Result<(), PrintError> {
let print = |this: &mut Self| {
define_scoped_cx!(this);
define_scoped_printer!(this);
if this.print_alloc_ids {
p!(write("{:?}", p));
} else {
@ -2577,7 +2577,7 @@ impl<'tcx> PrettyPrinter<'tcx> for FmtPrinter<'_, 'tcx> {
// HACK(eddyb) limited to `FmtPrinter` because of `region_highlight_mode`.
impl<'tcx> FmtPrinter<'_, 'tcx> {
pub fn pretty_print_region(&mut self, region: ty::Region<'tcx>) -> Result<(), fmt::Error> {
define_scoped_cx!(self);
define_scoped_printer!(self);
// Watch out for region highlights.
let highlight = self.region_highlight_mode;
@ -2755,17 +2755,17 @@ impl<'tcx> FmtPrinter<'_, 'tcx> {
debug!("self.used_region_names: {:?}", self.used_region_names);
let mut empty = true;
let mut start_or_continue = |cx: &mut Self, start: &str, cont: &str| {
let mut start_or_continue = |p: &mut Self, start: &str, cont: &str| {
let w = if empty {
empty = false;
start
} else {
cont
};
let _ = write!(cx, "{w}");
let _ = write!(p, "{w}");
};
let do_continue = |cx: &mut Self, cont: Symbol| {
let _ = write!(cx, "{cont}");
let do_continue = |p: &mut Self, cont: Symbol| {
let _ = write!(p, "{cont}");
};
let possible_names = ('a'..='z').rev().map(|s| Symbol::intern(&format!("'{s}")));
@ -2918,8 +2918,8 @@ impl<'tcx, T, P: PrettyPrinter<'tcx>> Print<'tcx, P> for ty::Binder<'tcx, T>
where
T: Print<'tcx, P> + TypeFoldable<TyCtxt<'tcx>>,
{
fn print(&self, cx: &mut P) -> Result<(), PrintError> {
cx.print_in_binder(self)
fn print(&self, p: &mut P) -> Result<(), PrintError> {
p.print_in_binder(self)
}
}
@ -2927,8 +2927,8 @@ impl<'tcx, T, P: PrettyPrinter<'tcx>> Print<'tcx, P> for ty::OutlivesPredicate<'
where
T: Print<'tcx, P>,
{
fn print(&self, cx: &mut P) -> Result<(), PrintError> {
define_scoped_cx!(cx);
fn print(&self, p: &mut P) -> Result<(), PrintError> {
define_scoped_printer!(p);
p!(print(self.0), ": ", print(self.1));
Ok(())
}
@ -3068,11 +3068,11 @@ macro_rules! forward_display_to_print {
$(#[allow(unused_lifetimes)] impl<'tcx> fmt::Display for $ty {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
ty::tls::with(|tcx| {
let mut cx = FmtPrinter::new(tcx, Namespace::TypeNS);
let mut p = FmtPrinter::new(tcx, Namespace::TypeNS);
tcx.lift(*self)
.expect("could not lift for printing")
.print(&mut cx)?;
f.write_str(&cx.into_buffer())?;
.print(&mut p)?;
f.write_str(&p.into_buffer())?;
Ok(())
})
}
@ -3081,10 +3081,10 @@ macro_rules! forward_display_to_print {
}
macro_rules! define_print {
(($self:ident, $cx:ident): $($ty:ty $print:block)+) => {
(($self:ident, $p:ident): $($ty:ty $print:block)+) => {
$(impl<'tcx, P: PrettyPrinter<'tcx>> Print<'tcx, P> for $ty {
fn print(&$self, $cx: &mut P) -> Result<(), PrintError> {
define_scoped_cx!($cx);
fn print(&$self, $p: &mut P) -> Result<(), PrintError> {
define_scoped_printer!($p);
let _: () = $print;
Ok(())
}
@ -3093,8 +3093,8 @@ macro_rules! define_print {
}
macro_rules! define_print_and_forward_display {
(($self:ident, $cx:ident): $($ty:ty $print:block)+) => {
define_print!(($self, $cx): $($ty $print)*);
(($self:ident, $p:ident): $($ty:ty $print:block)+) => {
define_print!(($self, $p): $($ty $print)*);
forward_display_to_print!($($ty),+);
};
}
@ -3107,7 +3107,7 @@ forward_display_to_print! {
}
define_print! {
(self, cx):
(self, p):
ty::FnSig<'tcx> {
p!(write("{}", self.safety.prefix_str()));
@ -3129,11 +3129,11 @@ define_print! {
}
ty::AliasTerm<'tcx> {
match self.kind(cx.tcx()) {
match self.kind(p.tcx()) {
ty::AliasTermKind::InherentTy | ty::AliasTermKind::InherentConst => p!(pretty_print_inherent_projection(*self)),
ty::AliasTermKind::ProjectionTy => {
if !(cx.should_print_verbose() || with_reduced_queries())
&& cx.tcx().is_impl_trait_in_trait(self.def_id)
if !(p.should_print_verbose() || with_reduced_queries())
&& p.tcx().is_impl_trait_in_trait(self.def_id)
{
p!(pretty_print_rpitit(self.def_id, self.args))
} else {
@ -3222,46 +3222,46 @@ define_print! {
ty::ExistentialTraitRef<'tcx> {
// Use a type that can't appear in defaults of type parameters.
let dummy_self = Ty::new_fresh(cx.tcx(), 0);
let trait_ref = self.with_self_ty(cx.tcx(), dummy_self);
let dummy_self = Ty::new_fresh(p.tcx(), 0);
let trait_ref = self.with_self_ty(p.tcx(), dummy_self);
p!(print(trait_ref.print_only_trait_path()))
}
ty::ExistentialProjection<'tcx> {
let name = cx.tcx().associated_item(self.def_id).name();
let name = p.tcx().associated_item(self.def_id).name();
// The args don't contain the self ty (as it has been erased) but the corresp.
// generics do as the trait always has a self ty param. We need to offset.
let args = &self.args[cx.tcx().generics_of(self.def_id).parent_count - 1..];
p!(path_generic_args(|cx| write!(cx, "{name}"), args), " = ", print(self.term))
let args = &self.args[p.tcx().generics_of(self.def_id).parent_count - 1..];
p!(path_generic_args(|p| write!(p, "{name}"), args), " = ", print(self.term))
}
ty::ProjectionPredicate<'tcx> {
p!(print(self.projection_term), " == ");
cx.reset_type_limit();
p.reset_type_limit();
p!(print(self.term))
}
ty::SubtypePredicate<'tcx> {
p!(print(self.a), " <: ");
cx.reset_type_limit();
p.reset_type_limit();
p!(print(self.b))
}
ty::CoercePredicate<'tcx> {
p!(print(self.a), " -> ");
cx.reset_type_limit();
p.reset_type_limit();
p!(print(self.b))
}
ty::NormalizesTo<'tcx> {
p!(print(self.alias), " normalizes-to ");
cx.reset_type_limit();
p.reset_type_limit();
p!(print(self.term))
}
}
define_print_and_forward_display! {
(self, cx):
(self, p):
&'tcx ty::List<Ty<'tcx>> {
p!("{{", comma_sep(self.iter()), "}}")
@ -3273,10 +3273,10 @@ define_print_and_forward_display! {
TraitRefPrintSugared<'tcx> {
if !with_reduced_queries()
&& cx.tcx().trait_def(self.0.def_id).paren_sugar
&& p.tcx().trait_def(self.0.def_id).paren_sugar
&& let ty::Tuple(args) = self.0.args.type_at(1).kind()
{
p!(write("{}", cx.tcx().item_name(self.0.def_id)), "(");
p!(write("{}", p.tcx().item_name(self.0.def_id)), "(");
for (i, arg) in args.iter().enumerate() {
if i > 0 {
p!(", ");
@ -3322,9 +3322,9 @@ define_print_and_forward_display! {
ty::PlaceholderType {
match self.bound.kind {
ty::BoundTyKind::Anon => p!(write("{self:?}")),
ty::BoundTyKind::Param(def_id) => match cx.should_print_verbose() {
ty::BoundTyKind::Param(def_id) => match p.should_print_verbose() {
true => p!(write("{self:?}")),
false => p!(write("{}", cx.tcx().item_name(def_id))),
false => p!(write("{}", p.tcx().item_name(def_id))),
},
}
}

14
compiler/rustc_middle/src/ty/structural_impls.rs
View file

@ -25,8 +25,8 @@ impl fmt::Debug for ty::TraitDef {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
ty::tls::with(|tcx| {
with_no_trimmed_paths!({
let s = FmtPrinter::print_string(tcx, Namespace::TypeNS, |cx| {
cx.print_def_path(self.def_id, &[])
let s = FmtPrinter::print_string(tcx, Namespace::TypeNS, |p| {
p.print_def_path(self.def_id, &[])
})?;
f.write_str(&s)
})
@ -38,8 +38,8 @@ impl<'tcx> fmt::Debug for ty::AdtDef<'tcx> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
ty::tls::with(|tcx| {
with_no_trimmed_paths!({
let s = FmtPrinter::print_string(tcx, Namespace::TypeNS, |cx| {
cx.print_def_path(self.did(), &[])
let s = FmtPrinter::print_string(tcx, Namespace::TypeNS, |p| {
p.print_def_path(self.did(), &[])
})?;
f.write_str(&s)
})
@ -170,9 +170,9 @@ impl<'tcx> fmt::Debug for ty::Const<'tcx> {
if let ConstKind::Value(cv) = self.kind() {
return ty::tls::with(move |tcx| {
let cv = tcx.lift(cv).unwrap();
let mut cx = FmtPrinter::new(tcx, Namespace::ValueNS);
cx.pretty_print_const_valtree(cv, /*print_ty*/ true)?;
f.write_str(&cx.into_buffer())
let mut p = FmtPrinter::new(tcx, Namespace::ValueNS);
p.pretty_print_const_valtree(cv, /*print_ty*/ true)?;
f.write_str(&p.into_buffer())
});
}
// Fall back to something verbose.

60
compiler/rustc_symbol_mangling/src/legacy.rs
View file

@ -58,59 +58,57 @@ pub(super) fn mangle<'tcx>(
let hash = get_symbol_hash(tcx, instance, instance_ty, instantiating_crate);
let mut printer = SymbolPrinter { tcx, path: SymbolPath::new(), keep_within_component: false };
printer
.print_def_path(
def_id,
if let ty::InstanceKind::DropGlue(_, _)
| ty::InstanceKind::AsyncDropGlueCtorShim(_, _)
| ty::InstanceKind::FutureDropPollShim(_, _, _) = instance.def
{
// Add the name of the dropped type to the symbol name
&*instance.args
} else if let ty::InstanceKind::AsyncDropGlue(_, ty) = instance.def {
let ty::Coroutine(_, cor_args) = ty.kind() else {
bug!();
};
let drop_ty = cor_args.first().unwrap().expect_ty();
tcx.mk_args(&[GenericArg::from(drop_ty)])
} else {
&[]
},
)
.unwrap();
let mut p = SymbolPrinter { tcx, path: SymbolPath::new(), keep_within_component: false };
p.print_def_path(
def_id,
if let ty::InstanceKind::DropGlue(_, _)
| ty::InstanceKind::AsyncDropGlueCtorShim(_, _)
| ty::InstanceKind::FutureDropPollShim(_, _, _) = instance.def
{
// Add the name of the dropped type to the symbol name
&*instance.args
} else if let ty::InstanceKind::AsyncDropGlue(_, ty) = instance.def {
let ty::Coroutine(_, cor_args) = ty.kind() else {
bug!();
};
let drop_ty = cor_args.first().unwrap().expect_ty();
tcx.mk_args(&[GenericArg::from(drop_ty)])
} else {
&[]
},
)
.unwrap();
match instance.def {
ty::InstanceKind::ThreadLocalShim(..) => {
printer.write_str("{{tls-shim}}").unwrap();
p.write_str("{{tls-shim}}").unwrap();
}
ty::InstanceKind::VTableShim(..) => {
printer.write_str("{{vtable-shim}}").unwrap();
p.write_str("{{vtable-shim}}").unwrap();
}
ty::InstanceKind::ReifyShim(_, reason) => {
printer.write_str("{{reify-shim").unwrap();
p.write_str("{{reify-shim").unwrap();
match reason {
Some(ReifyReason::FnPtr) => printer.write_str("-fnptr").unwrap(),
Some(ReifyReason::Vtable) => printer.write_str("-vtable").unwrap(),
Some(ReifyReason::FnPtr) => p.write_str("-fnptr").unwrap(),
Some(ReifyReason::Vtable) => p.write_str("-vtable").unwrap(),
None => (),
}
printer.write_str("}}").unwrap();
p.write_str("}}").unwrap();
}
// FIXME(async_closures): This shouldn't be needed when we fix
// `Instance::ty`/`Instance::def_id`.
ty::InstanceKind::ConstructCoroutineInClosureShim { receiver_by_ref, .. } => {
printer
.write_str(if receiver_by_ref { "{{by-move-shim}}" } else { "{{by-ref-shim}}" })
p.write_str(if receiver_by_ref { "{{by-move-shim}}" } else { "{{by-ref-shim}}" })
.unwrap();
}
_ => {}
}
if let ty::InstanceKind::FutureDropPollShim(..) = instance.def {
let _ = printer.write_str("{{drop-shim}}");
let _ = p.write_str("{{drop-shim}}");
}
printer.path.finish(hash)
p.path.finish(hash)
}
fn get_symbol_hash<'tcx>(

74
compiler/rustc_symbol_mangling/src/v0.rs
View file

@ -33,7 +33,7 @@ pub(super) fn mangle<'tcx>(
let args = tcx.normalize_erasing_regions(ty::TypingEnv::fully_monomorphized(), instance.args);
let prefix = "_R";
let mut cx: SymbolMangler<'_> = SymbolMangler {
let mut p: SymbolMangler<'_> = SymbolMangler {
tcx,
start_offset: prefix.len(),
is_exportable,
@ -69,16 +69,16 @@ pub(super) fn mangle<'tcx>(
bug!();
};
let drop_ty = cor_args.first().unwrap().expect_ty();
cx.print_def_path(def_id, tcx.mk_args(&[GenericArg::from(drop_ty)])).unwrap()
p.print_def_path(def_id, tcx.mk_args(&[GenericArg::from(drop_ty)])).unwrap()
} else if let Some(shim_kind) = shim_kind {
cx.path_append_ns(|cx| cx.print_def_path(def_id, args), 'S', 0, shim_kind).unwrap()
p.path_append_ns(|p| p.print_def_path(def_id, args), 'S', 0, shim_kind).unwrap()
} else {
cx.print_def_path(def_id, args).unwrap()
p.print_def_path(def_id, args).unwrap()
};
if let Some(instantiating_crate) = instantiating_crate {
cx.print_def_path(instantiating_crate.as_def_id(), &[]).unwrap();
p.print_def_path(instantiating_crate.as_def_id(), &[]).unwrap();
}
std::mem::take(&mut cx.out)
std::mem::take(&mut p.out)
}
pub fn mangle_internal_symbol<'tcx>(tcx: TyCtxt<'tcx>, item_name: &str) -> String {
@ -88,7 +88,7 @@ pub fn mangle_internal_symbol<'tcx>(tcx: TyCtxt<'tcx>, item_name: &str) -> Strin
}
let prefix = "_R";
let mut cx: SymbolMangler<'_> = SymbolMangler {
let mut p: SymbolMangler<'_> = SymbolMangler {
tcx,
start_offset: prefix.len(),
is_exportable: false,
@ -99,10 +99,10 @@ pub fn mangle_internal_symbol<'tcx>(tcx: TyCtxt<'tcx>, item_name: &str) -> Strin
out: String::from(prefix),
};
cx.path_append_ns(
|cx| {
cx.push("C");
cx.push_disambiguator({
p.path_append_ns(
|p| {
p.push("C");
p.push_disambiguator({
let mut hasher = StableHasher::new();
// Incorporate the rustc version to ensure #[rustc_std_internal_symbol] functions
// get a different symbol name depending on the rustc version.
@ -114,7 +114,7 @@ pub fn mangle_internal_symbol<'tcx>(tcx: TyCtxt<'tcx>, item_name: &str) -> Strin
let hash: Hash64 = hasher.finish();
hash.as_u64()
});
cx.push_ident("__rustc");
p.push_ident("__rustc");
Ok(())
},
'v',
@ -123,7 +123,7 @@ pub fn mangle_internal_symbol<'tcx>(tcx: TyCtxt<'tcx>, item_name: &str) -> Strin
)
.unwrap();
std::mem::take(&mut cx.out)
std::mem::take(&mut p.out)
}
pub(super) fn mangle_typeid_for_trait_ref<'tcx>(
@ -131,7 +131,7 @@ pub(super) fn mangle_typeid_for_trait_ref<'tcx>(
trait_ref: ty::ExistentialTraitRef<'tcx>,
) -> String {
// FIXME(flip1995): See comment in `mangle_typeid_for_fnabi`.
let mut cx = SymbolMangler {
let mut p = SymbolMangler {
tcx,
start_offset: 0,
is_exportable: false,
@ -141,8 +141,8 @@ pub(super) fn mangle_typeid_for_trait_ref<'tcx>(
binders: vec![],
out: String::new(),
};
cx.print_def_path(trait_ref.def_id, &[]).unwrap();
std::mem::take(&mut cx.out)
p.print_def_path(trait_ref.def_id, &[]).unwrap();
std::mem::take(&mut p.out)
}
struct BinderLevel {
@ -368,7 +368,7 @@ impl<'tcx> Printer<'tcx> for SymbolMangler<'tcx> {
self.path_generic_args(
|this| {
this.path_append_ns(
|cx| cx.print_def_path(parent_def_id, &[]),
|p| p.print_def_path(parent_def_id, &[]),
'I',
key.disambiguated_data.disambiguator as u64,
"",
@ -542,31 +542,31 @@ impl<'tcx> Printer<'tcx> for SymbolMangler<'tcx> {
ty::FnPtr(sig_tys, hdr) => {
let sig = sig_tys.with(hdr);
self.push("F");
self.wrap_binder(&sig, |cx, sig| {
self.wrap_binder(&sig, |p, sig| {
if sig.safety.is_unsafe() {
cx.push("U");
p.push("U");
}
match sig.abi {
ExternAbi::Rust => {}
ExternAbi::C { unwind: false } => cx.push("KC"),
ExternAbi::C { unwind: false } => p.push("KC"),
abi => {
cx.push("K");
p.push("K");
let name = abi.as_str();
if name.contains('-') {
cx.push_ident(&name.replace('-', "_"));
p.push_ident(&name.replace('-', "_"));
} else {
cx.push_ident(name);
p.push_ident(name);
}
}
}
for &ty in sig.inputs() {
ty.print(cx)?;
ty.print(p)?;
}
if sig.c_variadic {
cx.push("v");
p.push("v");
}
cx.push("E");
sig.output().print(cx)
p.push("E");
sig.output().print(p)
})?;
}
@ -623,7 +623,7 @@ impl<'tcx> Printer<'tcx> for SymbolMangler<'tcx> {
// [<Trait> [{<Projection>}]] [{<Auto>}]
// Since any predicates after the first one shouldn't change the binders,
// just put them all in the binders of the first.
self.wrap_binder(&predicates[0], |cx, _| {
self.wrap_binder(&predicates[0], |p, _| {
for predicate in predicates.iter() {
// It would be nice to be able to validate bound vars here, but
// projections can actually include bound vars from super traits
@ -632,21 +632,21 @@ impl<'tcx> Printer<'tcx> for SymbolMangler<'tcx> {
match predicate.as_ref().skip_binder() {
ty::ExistentialPredicate::Trait(trait_ref) => {
// Use a type that can't appear in defaults of type parameters.
let dummy_self = Ty::new_fresh(cx.tcx, 0);
let trait_ref = trait_ref.with_self_ty(cx.tcx, dummy_self);
cx.print_def_path(trait_ref.def_id, trait_ref.args)?;
let dummy_self = Ty::new_fresh(p.tcx, 0);
let trait_ref = trait_ref.with_self_ty(p.tcx, dummy_self);
p.print_def_path(trait_ref.def_id, trait_ref.args)?;
}
ty::ExistentialPredicate::Projection(projection) => {
let name = cx.tcx.associated_item(projection.def_id).name();
cx.push("p");
cx.push_ident(name.as_str());
let name = p.tcx.associated_item(projection.def_id).name();
p.push("p");
p.push_ident(name.as_str());
match projection.term.kind() {
ty::TermKind::Ty(ty) => ty.print(cx),
ty::TermKind::Const(c) => c.print(cx),
ty::TermKind::Ty(ty) => ty.print(p),
ty::TermKind::Const(c) => c.print(p),
}?;
}
ty::ExistentialPredicate::AutoTrait(def_id) => {
cx.print_def_path(*def_id, &[])?;
p.print_def_path(*def_id, &[])?;
}
}
}

4
compiler/rustc_trait_selection/src/error_reporting/infer/mod.rs
View file

@ -301,8 +301,8 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
// let _ = [{struct Foo; Foo}, {struct Foo; Foo}];
if did1.krate != did2.krate {
let abs_path = |def_id| {
let mut printer = AbsolutePathPrinter { tcx: self.tcx, segments: vec![] };
printer.print_def_path(def_id, &[]).map(|_| printer.segments)
let mut p = AbsolutePathPrinter { tcx: self.tcx, segments: vec![] };
p.print_def_path(def_id, &[]).map(|_| p.segments)
};
// We compare strings because DefPath can be different

51
compiler/rustc_trait_selection/src/error_reporting/infer/need_type_info.rs
View file

@ -244,7 +244,7 @@ impl<'a, 'tcx> TypeFolder<TyCtxt<'tcx>> for ClosureEraser<'a, 'tcx> {
}
fn fmt_printer<'a, 'tcx>(infcx: &'a InferCtxt<'tcx>, ns: Namespace) -> FmtPrinter<'a, 'tcx> {
let mut printer = FmtPrinter::new(infcx.tcx, ns);
let mut p = FmtPrinter::new(infcx.tcx, ns);
let ty_getter = move |ty_vid| {
if infcx.probe_ty_var(ty_vid).is_ok() {
warn!("resolved ty var in error message");
@ -270,11 +270,11 @@ fn fmt_printer<'a, 'tcx>(infcx: &'a InferCtxt<'tcx>, ns: Namespace) -> FmtPrinte
None
}
};
printer.ty_infer_name_resolver = Some(Box::new(ty_getter));
p.ty_infer_name_resolver = Some(Box::new(ty_getter));
let const_getter =
move |ct_vid| Some(infcx.tcx.item_name(infcx.const_var_origin(ct_vid)?.param_def_id?));
printer.const_infer_name_resolver = Some(Box::new(const_getter));
printer
p.const_infer_name_resolver = Some(Box::new(const_getter));
p
}
fn ty_to_string<'tcx>(
@ -282,7 +282,7 @@ fn ty_to_string<'tcx>(
ty: Ty<'tcx>,
called_method_def_id: Option<DefId>,
) -> String {
let mut printer = fmt_printer(infcx, Namespace::TypeNS);
let mut p = fmt_printer(infcx, Namespace::TypeNS);
let ty = infcx.resolve_vars_if_possible(ty);
// We use `fn` ptr syntax for closures, but this only works when the closure does not capture
// anything. We also remove all type parameters that are fully known to the type system.
@ -292,8 +292,8 @@ fn ty_to_string<'tcx>(
// We don't want the regular output for `fn`s because it includes its path in
// invalid pseudo-syntax, we want the `fn`-pointer output instead.
(ty::FnDef(..), _) => {
ty.fn_sig(infcx.tcx).print(&mut printer).unwrap();
printer.into_buffer()
ty.fn_sig(infcx.tcx).print(&mut p).unwrap();
p.into_buffer()
}
(_, Some(def_id))
if ty.is_ty_or_numeric_infer()
@ -303,8 +303,8 @@ fn ty_to_string<'tcx>(
}
_ if ty.is_ty_or_numeric_infer() => "/* Type */".to_string(),
_ => {
ty.print(&mut printer).unwrap();
printer.into_buffer()
ty.print(&mut p).unwrap();
p.into_buffer()
}
}
}
@ -561,21 +561,20 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
{
"Vec<_>".to_string()
} else {
let mut printer = fmt_printer(self, Namespace::TypeNS);
printer
.comma_sep(generic_args.iter().copied().map(|arg| {
if arg.is_suggestable(self.tcx, true) {
return arg;
}
let mut p = fmt_printer(self, Namespace::TypeNS);
p.comma_sep(generic_args.iter().copied().map(|arg| {
if arg.is_suggestable(self.tcx, true) {
return arg;
}
match arg.kind() {
GenericArgKind::Lifetime(_) => bug!("unexpected lifetime"),
GenericArgKind::Type(_) => self.next_ty_var(DUMMY_SP).into(),
GenericArgKind::Const(_) => self.next_const_var(DUMMY_SP).into(),
}
}))
.unwrap();
printer.into_buffer()
match arg.kind() {
GenericArgKind::Lifetime(_) => bug!("unexpected lifetime"),
GenericArgKind::Type(_) => self.next_ty_var(DUMMY_SP).into(),
GenericArgKind::Const(_) => self.next_const_var(DUMMY_SP).into(),
}
}))
.unwrap();
p.into_buffer()
};
if !have_turbofish {
@ -589,9 +588,9 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
InferSourceKind::FullyQualifiedMethodCall { receiver, successor, args, def_id } => {
let placeholder = Some(self.next_ty_var(DUMMY_SP));
if let Some(args) = args.make_suggestable(self.infcx.tcx, true, placeholder) {
let mut printer = fmt_printer(self, Namespace::ValueNS);
printer.print_def_path(def_id, args).unwrap();
let def_path = printer.into_buffer();
let mut p = fmt_printer(self, Namespace::ValueNS);
p.print_def_path(def_id, args).unwrap();
let def_path = p.into_buffer();
// We only care about whether we have to add `&` or `&mut ` for now.
// This is the case if the last adjustment is a borrow and the

8
compiler/rustc_trait_selection/src/error_reporting/infer/nice_region_error/placeholder_error.rs
View file

@ -47,11 +47,11 @@ where
T: for<'a> Print<'tcx, FmtPrinter<'a, 'tcx>>,
{
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let mut printer = ty::print::FmtPrinter::new(self.tcx, self.ns);
printer.region_highlight_mode = self.highlight;
let mut p = ty::print::FmtPrinter::new(self.tcx, self.ns);
p.region_highlight_mode = self.highlight;
self.value.print(&mut printer)?;
f.write_str(&printer.into_buffer())
self.value.print(&mut p)?;
f.write_str(&p.into_buffer())
}
}

4
compiler/rustc_trait_selection/src/error_reporting/infer/note_and_explain.rs
View file

@ -946,8 +946,8 @@ fn foo(&self) -> Self::T { String::new() }
}
pub fn format_generic_args(&self, args: &[ty::GenericArg<'tcx>]) -> String {
FmtPrinter::print_string(self.tcx, hir::def::Namespace::TypeNS, |cx| {
cx.path_generic_args(|_| Ok(()), args)
FmtPrinter::print_string(self.tcx, hir::def::Namespace::TypeNS, |p| {
p.path_generic_args(|_| Ok(()), args)
})
.expect("could not write to `String`.")
}

6
compiler/rustc_trait_selection/src/error_reporting/traits/overflow.rs
View file

@ -66,10 +66,10 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
if s.len() > 50 {
// We don't need to save the type to a file, we will be talking about this type already
// in a separate note when we explain the obligation, so it will be available that way.
let mut cx: FmtPrinter<'_, '_> =
let mut p: FmtPrinter<'_, '_> =
FmtPrinter::new_with_limit(tcx, Namespace::TypeNS, rustc_session::Limit(6));
value.print(&mut cx).unwrap();
cx.into_buffer()
value.print(&mut p).unwrap();
p.into_buffer()
} else {
s
}