Skip to content

Commit 848e528

Browse files
nnethercotennethercote
committed
Rename Printer variables.
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.
1 parent e9383e9 commit 848e528

File tree

17 files changed

+279
-281
lines changed

17 files changed

+279
-281
lines changed

‎compiler/rustc_borrowck/src/diagnostics/mod.rs

Lines changed: 8 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -613,7 +613,7 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
613613
/// Return the name of the provided `Ty` (that must be a reference) with a synthesized lifetime
614614
/// name where required.
615615
pub(super) fn get_name_for_ty(&self, ty: Ty<'tcx>, counter: usize) -> String {
616-
let mut printer = ty::print::FmtPrinter::new(self.infcx.tcx, Namespace::TypeNS);
616+
let mut p = ty::print::FmtPrinter::new(self.infcx.tcx, Namespace::TypeNS);
617617

618618
// We need to add synthesized lifetimes where appropriate. We do
619619
// this by hooking into the pretty printer and telling it to label the
@@ -624,36 +624,36 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
624624
| ty::RePlaceholder(ty::PlaceholderRegion {
625625
bound: ty::BoundRegion { kind: br, .. },
626626
..
627-
}) => printer.region_highlight_mode.highlighting_bound_region(br, counter),
627+
}) => p.region_highlight_mode.highlighting_bound_region(br, counter),
628628
_ => {}
629629
}
630630
}
631631

632-
ty.print(&mut printer).unwrap();
633-
printer.into_buffer()
632+
ty.print(&mut p).unwrap();
633+
p.into_buffer()
634634
}
635635

636636
/// Returns the name of the provided `Ty` (that must be a reference)'s region with a
637637
/// synthesized lifetime name where required.
638638
pub(super) fn get_region_name_for_ty(&self, ty: Ty<'tcx>, counter: usize) -> String {
639-
let mut printer = ty::print::FmtPrinter::new(self.infcx.tcx, Namespace::TypeNS);
639+
let mut p = ty::print::FmtPrinter::new(self.infcx.tcx, Namespace::TypeNS);
640640

641641
let region = if let ty::Ref(region, ..) = ty.kind() {
642642
match region.kind() {
643643
ty::ReBound(_, ty::BoundRegion { kind: br, .. })
644644
| ty::RePlaceholder(ty::PlaceholderRegion {
645645
bound: ty::BoundRegion { kind: br, .. },
646646
..
647-
}) => printer.region_highlight_mode.highlighting_bound_region(br, counter),
647+
}) => p.region_highlight_mode.highlighting_bound_region(br, counter),
648648
_ => {}
649649
}
650650
region
651651
} else {
652652
bug!("ty for annotation of borrow region is not a reference");
653653
};
654654

655-
region.print(&mut printer).unwrap();
656-
printer.into_buffer()
655+
region.print(&mut p).unwrap();
656+
p.into_buffer()
657657
}
658658

659659
/// Add a note to region errors and borrow explanations when higher-ranked regions in predicates

‎compiler/rustc_const_eval/src/interpret/operand.rs

Lines changed: 7 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -186,27 +186,28 @@ pub struct ImmTy<'tcx, Prov: Provenance = CtfeProvenance> {
186186
impl<Prov: Provenance> std::fmt::Display for ImmTy<'_, Prov> {
187187
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
188188
/// Helper function for printing a scalar to a FmtPrinter
189-
fn p<'a, 'tcx, Prov: Provenance>(
190-
cx: &mut FmtPrinter<'a, 'tcx>,
189+
fn print_scalar<'a, 'tcx, Prov: Provenance>(
190+
p: &mut FmtPrinter<'a, 'tcx>,
191191
s: Scalar<Prov>,
192192
ty: Ty<'tcx>,
193193
) -> Result<(), std::fmt::Error> {
194194
match s {
195-
Scalar::Int(int) => cx.pretty_print_const_scalar_int(int, ty, true),
195+
Scalar::Int(int) => p.pretty_print_const_scalar_int(int, ty, true),
196196
Scalar::Ptr(ptr, _sz) => {
197197
// Just print the ptr value. `pretty_print_const_scalar_ptr` would also try to
198198
// print what is points to, which would fail since it has no access to the local
199199
// memory.
200-
cx.pretty_print_const_pointer(ptr, ty)
200+
p.pretty_print_const_pointer(ptr, ty)
201201
}
202202
}
203203
}
204204
ty::tls::with(|tcx| {
205205
match self.imm {
206206
Immediate::Scalar(s) => {
207207
if let Some(ty) = tcx.lift(self.layout.ty) {
208-
let s =
209-
FmtPrinter::print_string(tcx, Namespace::ValueNS, |cx| p(cx, s, ty))?;
208+
let s = FmtPrinter::print_string(tcx, Namespace::ValueNS, |p| {
209+
print_scalar(p, s, ty)
210+
})?;
210211
f.write_str(&s)?;
211212
return Ok(());
212213
}

‎compiler/rustc_const_eval/src/util/type_name.rs

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -166,7 +166,7 @@ impl Write for AbsolutePathPrinter<'_> {
166166
}
167167

168168
pub fn type_name<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> String {
169-
let mut printer = AbsolutePathPrinter { tcx, path: String::new() };
170-
printer.print_type(ty).unwrap();
171-
printer.path
169+
let mut p = AbsolutePathPrinter { tcx, path: String::new() };
170+
p.print_type(ty).unwrap();
171+
p.path
172172
}

‎compiler/rustc_lint/src/context.rs

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -847,9 +847,9 @@ impl<'tcx> LateContext<'tcx> {
847847
}
848848
}
849849

850-
let mut printer = AbsolutePathPrinter { tcx: self.tcx, path: vec![] };
851-
printer.print_def_path(def_id, &[]).unwrap();
852-
printer.path
850+
let mut p = AbsolutePathPrinter { tcx: self.tcx, path: vec![] };
851+
p.print_def_path(def_id, &[]).unwrap();
852+
p.path
853853
}
854854

855855
/// Returns the associated type `name` for `self_ty` as an implementation of `trait_id`.

‎compiler/rustc_middle/src/mir/pretty.rs

Lines changed: 17 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -1197,8 +1197,8 @@ impl<'tcx> Debug for Rvalue<'tcx> {
11971197
ty::tls::with(|tcx| {
11981198
let variant_def = &tcx.adt_def(adt_did).variant(variant);
11991199
let args = tcx.lift(args).expect("could not lift for printing");
1200-
let name = FmtPrinter::print_string(tcx, Namespace::ValueNS, |cx| {
1201-
cx.print_def_path(variant_def.def_id, args)
1200+
let name = FmtPrinter::print_string(tcx, Namespace::ValueNS, |p| {
1201+
p.print_def_path(variant_def.def_id, args)
12021202
})?;
12031203

12041204
match variant_def.ctor_kind() {
@@ -1473,9 +1473,9 @@ impl<'tcx> Visitor<'tcx> for ExtraComments<'tcx> {
14731473
};
14741474

14751475
let fmt_valtree = |cv: &ty::Value<'tcx>| {
1476-
let mut cx = FmtPrinter::new(self.tcx, Namespace::ValueNS);
1477-
cx.pretty_print_const_valtree(*cv, /*print_ty*/ true).unwrap();
1478-
cx.into_buffer()
1476+
let mut p = FmtPrinter::new(self.tcx, Namespace::ValueNS);
1477+
p.pretty_print_const_valtree(*cv, /*print_ty*/ true).unwrap();
1478+
p.into_buffer()
14791479
};
14801480

14811481
let val = match const_ {
@@ -1967,10 +1967,10 @@ fn pretty_print_const_value_tcx<'tcx>(
19671967
.expect("destructed mir constant of adt without variant idx");
19681968
let variant_def = &def.variant(variant_idx);
19691969
let args = tcx.lift(args).unwrap();
1970-
let mut cx = FmtPrinter::new(tcx, Namespace::ValueNS);
1971-
cx.print_alloc_ids = true;
1972-
cx.print_value_path(variant_def.def_id, args)?;
1973-
fmt.write_str(&cx.into_buffer())?;
1970+
let mut p = FmtPrinter::new(tcx, Namespace::ValueNS);
1971+
p.print_alloc_ids = true;
1972+
p.print_value_path(variant_def.def_id, args)?;
1973+
fmt.write_str(&p.into_buffer())?;
19741974

19751975
match variant_def.ctor_kind() {
19761976
Some(CtorKind::Const) => {}
@@ -2001,18 +2001,18 @@ fn pretty_print_const_value_tcx<'tcx>(
20012001
}
20022002
}
20032003
(ConstValue::Scalar(scalar), _) => {
2004-
let mut cx = FmtPrinter::new(tcx, Namespace::ValueNS);
2005-
cx.print_alloc_ids = true;
2004+
let mut p = FmtPrinter::new(tcx, Namespace::ValueNS);
2005+
p.print_alloc_ids = true;
20062006
let ty = tcx.lift(ty).unwrap();
2007-
cx.pretty_print_const_scalar(scalar, ty)?;
2008-
fmt.write_str(&cx.into_buffer())?;
2007+
p.pretty_print_const_scalar(scalar, ty)?;
2008+
fmt.write_str(&p.into_buffer())?;
20092009
return Ok(());
20102010
}
20112011
(ConstValue::ZeroSized, ty::FnDef(d, s)) => {
2012-
let mut cx = FmtPrinter::new(tcx, Namespace::ValueNS);
2013-
cx.print_alloc_ids = true;
2014-
cx.print_value_path(*d, s)?;
2015-
fmt.write_str(&cx.into_buffer())?;
2012+
let mut p = FmtPrinter::new(tcx, Namespace::ValueNS);
2013+
p.print_alloc_ids = true;
2014+
p.print_value_path(*d, s)?;
2015+
fmt.write_str(&p.into_buffer())?;
20162016
return Ok(());
20172017
}
20182018
// FIXME(oli-obk): also pretty print arrays and other aggregate constants by reading

‎compiler/rustc_middle/src/ty/error.rs

Lines changed: 12 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -213,13 +213,13 @@ impl<'tcx> Ty<'tcx> {
213213
}
214214

215215
impl<'tcx> TyCtxt<'tcx> {
216-
pub fn string_with_limit<T>(self, p: T, length_limit: usize) -> String
216+
pub fn string_with_limit<T>(self, t: T, length_limit: usize) -> String
217217
where
218218
T: Copy + for<'a, 'b> Lift<TyCtxt<'b>, Lifted: Print<'b, FmtPrinter<'a, 'b>>>,
219219
{
220220
let mut type_limit = 50;
221-
let regular = FmtPrinter::print_string(self, hir::def::Namespace::TypeNS, |cx| {
222-
self.lift(p).expect("could not lift for printing").print(cx)
221+
let regular = FmtPrinter::print_string(self, hir::def::Namespace::TypeNS, |p| {
222+
self.lift(t).expect("could not lift for printing").print(p)
223223
})
224224
.expect("could not write to `String`");
225225
if regular.len() <= length_limit {
@@ -229,16 +229,16 @@ impl<'tcx> TyCtxt<'tcx> {
229229
loop {
230230
// Look for the longest properly trimmed path that still fits in length_limit.
231231
short = with_forced_trimmed_paths!({
232-
let mut cx = FmtPrinter::new_with_limit(
232+
let mut p = FmtPrinter::new_with_limit(
233233
self,
234234
hir::def::Namespace::TypeNS,
235235
rustc_session::Limit(type_limit),
236236
);
237-
self.lift(p)
237+
self.lift(t)
238238
.expect("could not lift for printing")
239-
.print(&mut cx)
239+
.print(&mut p)
240240
.expect("could not print type");
241-
cx.into_buffer()
241+
p.into_buffer()
242242
});
243243
if short.len() <= length_limit || type_limit == 0 {
244244
break;
@@ -252,12 +252,12 @@ impl<'tcx> TyCtxt<'tcx> {
252252
/// `tcx.short_string(ty, diag.long_ty_path())`. The diagnostic itself is the one that keeps
253253
/// the existence of a "long type" anywhere in the diagnostic, so the note telling the user
254254
/// where we wrote the file to is only printed once.
255-
pub fn short_string<T>(self, p: T, path: &mut Option<PathBuf>) -> String
255+
pub fn short_string<T>(self, t: T, path: &mut Option<PathBuf>) -> String
256256
where
257257
T: Copy + Hash + for<'a, 'b> Lift<TyCtxt<'b>, Lifted: Print<'b, FmtPrinter<'a, 'b>>>,
258258
{
259-
let regular = FmtPrinter::print_string(self, hir::def::Namespace::TypeNS, |cx| {
260-
self.lift(p).expect("could not lift for printing").print(cx)
259+
let regular = FmtPrinter::print_string(self, hir::def::Namespace::TypeNS, |p| {
260+
self.lift(t).expect("could not lift for printing").print(p)
261261
})
262262
.expect("could not write to `String`");
263263

@@ -270,13 +270,13 @@ impl<'tcx> TyCtxt<'tcx> {
270270
if regular.len() <= width * 2 / 3 {
271271
return regular;
272272
}
273-
let short = self.string_with_limit(p, length_limit);
273+
let short = self.string_with_limit(t, length_limit);
274274
if regular == short {
275275
return regular;
276276
}
277277
// Ensure we create an unique file for the type passed in when we create a file.
278278
let mut s = DefaultHasher::new();
279-
p.hash(&mut s);
279+
t.hash(&mut s);
280280
let hash = s.finish();
281281
*path = Some(path.take().unwrap_or_else(|| {
282282
self.output_filenames(()).temp_path_for_diagnostic(&format!("long-type-{hash}.txt"))

‎compiler/rustc_middle/src/ty/instance.rs

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -397,13 +397,13 @@ pub fn fmt_instance(
397397
ty::tls::with(|tcx| {
398398
let args = tcx.lift(instance.args).expect("could not lift for printing");
399399

400-
let mut cx = if let Some(type_length) = type_length {
400+
let mut p = if let Some(type_length) = type_length {
401401
FmtPrinter::new_with_limit(tcx, Namespace::ValueNS, type_length)
402402
} else {
403403
FmtPrinter::new(tcx, Namespace::ValueNS)
404404
};
405-
cx.print_def_path(instance.def_id(), args)?;
406-
let s = cx.into_buffer();
405+
p.print_def_path(instance.def_id(), args)?;
406+
let s = p.into_buffer();
407407
f.write_str(&s)
408408
})?;
409409

‎compiler/rustc_middle/src/ty/print/mod.rs

Lines changed: 19 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -18,7 +18,7 @@ use super::Lift;
1818
pub type PrintError = std::fmt::Error;
1919

2020
pub trait Print<'tcx, P> {
21-
fn print(&self, cx: &mut P) -> Result<(), PrintError>;
21+
fn print(&self, p: &mut P) -> Result<(), PrintError>;
2222
}
2323

2424
/// Interface for outputting user-facing "type-system entities"
@@ -148,7 +148,7 @@ pub trait Printer<'tcx>: Sized {
148148
&& args.len() > parent_args.len()
149149
{
150150
return self.path_generic_args(
151-
|cx| cx.print_def_path(def_id, parent_args),
151+
|p| p.print_def_path(def_id, parent_args),
152152
&args[..parent_args.len() + 1][..1],
153153
);
154154
} else {
@@ -170,7 +170,7 @@ pub trait Printer<'tcx>: Sized {
170170
if !generics.is_own_empty() && args.len() >= generics.count() {
171171
let args = generics.own_args_no_defaults(self.tcx(), args);
172172
return self.path_generic_args(
173-
|cx| cx.print_def_path(def_id, parent_args),
173+
|p| p.print_def_path(def_id, parent_args),
174174
args,
175175
);
176176
}
@@ -186,16 +186,16 @@ pub trait Printer<'tcx>: Sized {
186186
}
187187

188188
self.path_append(
189-
|cx: &mut Self| {
189+
|p: &mut Self| {
190190
if trait_qualify_parent {
191191
let trait_ref = ty::TraitRef::new(
192-
cx.tcx(),
192+
p.tcx(),
193193
parent_def_id,
194194
parent_args.iter().copied(),
195195
);
196-
cx.path_qualified(trait_ref.self_ty(), Some(trait_ref))
196+
p.path_qualified(trait_ref.self_ty(), Some(trait_ref))
197197
} else {
198-
cx.print_def_path(parent_def_id, parent_args)
198+
p.print_def_path(parent_def_id, parent_args)
199199
}
200200
},
201201
&key.disambiguated_data,
@@ -237,7 +237,7 @@ pub trait Printer<'tcx>: Sized {
237237
// trait-type, then fallback to a format that identifies
238238
// the module more clearly.
239239
self.path_append_impl(
240-
|cx| cx.print_def_path(parent_def_id, &[]),
240+
|p| p.print_def_path(parent_def_id, &[]),
241241
&key.disambiguated_data,
242242
self_ty,
243243
impl_trait_ref,
@@ -312,26 +312,26 @@ pub fn characteristic_def_id_of_type(ty: Ty<'_>) -> Option<DefId> {
312312
}
313313

314314
impl<'tcx, P: Printer<'tcx>> Print<'tcx, P> for ty::Region<'tcx> {
315-
fn print(&self, cx: &mut P) -> Result<(), PrintError> {
316-
cx.print_region(*self)
315+
fn print(&self, p: &mut P) -> Result<(), PrintError> {
316+
p.print_region(*self)
317317
}
318318
}
319319

320320
impl<'tcx, P: Printer<'tcx>> Print<'tcx, P> for Ty<'tcx> {
321-
fn print(&self, cx: &mut P) -> Result<(), PrintError> {
322-
cx.print_type(*self)
321+
fn print(&self, p: &mut P) -> Result<(), PrintError> {
322+
p.print_type(*self)
323323
}
324324
}
325325

326326
impl<'tcx, P: Printer<'tcx>> Print<'tcx, P> for &'tcx ty::List<ty::PolyExistentialPredicate<'tcx>> {
327-
fn print(&self, cx: &mut P) -> Result<(), PrintError> {
328-
cx.print_dyn_existential(self)
327+
fn print(&self, p: &mut P) -> Result<(), PrintError> {
328+
p.print_dyn_existential(self)
329329
}
330330
}
331331

332332
impl<'tcx, P: Printer<'tcx>> Print<'tcx, P> for ty::Const<'tcx> {
333-
fn print(&self, cx: &mut P) -> Result<(), PrintError> {
334-
cx.print_const(*self)
333+
fn print(&self, p: &mut P) -> Result<(), PrintError> {
334+
p.print_const(*self)
335335
}
336336
}
337337

@@ -351,9 +351,9 @@ where
351351
{
352352
fn print(t: &T, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
353353
ty::tls::with(|tcx| {
354-
let mut cx = FmtPrinter::new(tcx, Namespace::TypeNS);
355-
tcx.lift(*t).expect("could not lift for printing").print(&mut cx)?;
356-
fmt.write_str(&cx.into_buffer())?;
354+
let mut p = FmtPrinter::new(tcx, Namespace::TypeNS);
355+
tcx.lift(*t).expect("could not lift for printing").print(&mut p)?;
356+
fmt.write_str(&p.into_buffer())?;
357357
Ok(())
358358
})
359359
}

0 commit comments

Comments
 (0)