Skip to content

Commit 108ef8b

Browse files
RalfJungRalfJung
committed
consistently use VTable over Vtable (matching stable stdlib API RawWakerVTable)
1 parent e9b1721 commit 108ef8b

File tree

34 files changed

+90
-88
lines changed

34 files changed

+90
-88
lines changed

‎compiler/rustc_codegen_cranelift/src/constant.rs

+4-4
Original file line numberDiff line numberDiff line change
@@ -197,7 +197,7 @@ pub(crate) fn codegen_const_value<'tcx>(
197197
let (alloc_id, offset) = ptr.into_parts(); // we know the `offset` is relative
198198
// For vtables, get the underlying data allocation.
199199
let alloc_id = match fx.tcx.global_alloc(alloc_id) {
200-
GlobalAlloc::Vtable(ty, trait_ref) => fx.tcx.vtable_allocation((ty, trait_ref)),
200+
GlobalAlloc::VTable(ty, trait_ref) => fx.tcx.vtable_allocation((ty, trait_ref)),
201201
_ => alloc_id,
202202
};
203203
let base_addr = match fx.tcx.global_alloc(alloc_id) {
@@ -221,7 +221,7 @@ pub(crate) fn codegen_const_value<'tcx>(
221221
fx.module.declare_func_in_func(func_id, &mut fx.bcx.func);
222222
fx.bcx.ins().func_addr(fx.pointer_type, local_func_id)
223223
}
224-
GlobalAlloc::Vtable(..) => bug!("vtables are already handled"),
224+
GlobalAlloc::VTable(..) => bug!("vtables are already handled"),
225225
GlobalAlloc::Static(def_id) => {
226226
assert!(fx.tcx.is_static(def_id));
227227
let data_id = data_id_for_static(fx.tcx, fx.module, def_id, false);
@@ -364,7 +364,7 @@ fn define_all_allocs(tcx: TyCtxt<'_>, module: &mut dyn Module, cx: &mut Constant
364364
//println!("alloc_id {}", alloc_id);
365365
let alloc = match tcx.global_alloc(alloc_id) {
366366
GlobalAlloc::Memory(alloc) => alloc,
367-
GlobalAlloc::Function(_) | GlobalAlloc::Static(_) | GlobalAlloc::Vtable(..) => {
367+
GlobalAlloc::Function(_) | GlobalAlloc::Static(_) | GlobalAlloc::VTable(..) => {
368368
unreachable!()
369369
}
370370
};
@@ -442,7 +442,7 @@ fn define_all_allocs(tcx: TyCtxt<'_>, module: &mut dyn Module, cx: &mut Constant
442442
GlobalAlloc::Memory(target_alloc) => {
443443
data_id_for_alloc_id(cx, module, alloc_id, target_alloc.inner().mutability)
444444
}
445-
GlobalAlloc::Vtable(ty, trait_ref) => {
445+
GlobalAlloc::VTable(ty, trait_ref) => {
446446
let alloc_id = tcx.vtable_allocation((ty, trait_ref));
447447
data_id_for_alloc_id(cx, module, alloc_id, Mutability::Not)
448448
}

‎compiler/rustc_codegen_gcc/src/common.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -185,7 +185,7 @@ impl<'gcc, 'tcx> ConstMethods<'tcx> for CodegenCx<'gcc, 'tcx> {
185185
let (alloc_id, offset) = ptr.into_parts();
186186
// For vtables, get the underlying data allocation.
187187
let alloc_id = match self.tcx.global_alloc(alloc_id) {
188-
GlobalAlloc::Vtable(ty, trait_ref) => {
188+
GlobalAlloc::VTable(ty, trait_ref) => {
189189
self.tcx.vtable_allocation((ty, trait_ref))
190190
}
191191
_ => alloc_id,
@@ -208,7 +208,7 @@ impl<'gcc, 'tcx> ConstMethods<'tcx> for CodegenCx<'gcc, 'tcx> {
208208
GlobalAlloc::Function(fn_instance) => {
209209
self.get_fn_addr(fn_instance)
210210
},
211-
GlobalAlloc::Vtable(..) => panic!("vtables are already handled"),
211+
GlobalAlloc::VTable(..) => panic!("vtables are already handled"),
212212
GlobalAlloc::Static(def_id) => {
213213
assert!(self.tcx.is_static(def_id));
214214
self.get_static(def_id).get_address(None)

‎compiler/rustc_codegen_llvm/src/common.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -242,7 +242,7 @@ impl<'ll, 'tcx> ConstMethods<'tcx> for CodegenCx<'ll, 'tcx> {
242242
let (alloc_id, offset) = ptr.into_parts();
243243
// For vtables, get the underlying data allocation.
244244
let alloc_id = match self.tcx.global_alloc(alloc_id) {
245-
GlobalAlloc::Vtable(ty, trait_ref) => {
245+
GlobalAlloc::VTable(ty, trait_ref) => {
246246
self.tcx.vtable_allocation((ty, trait_ref))
247247
}
248248
_ => alloc_id,
@@ -264,7 +264,7 @@ impl<'ll, 'tcx> ConstMethods<'tcx> for CodegenCx<'ll, 'tcx> {
264264
self.get_fn_addr(fn_instance.polymorphize(self.tcx)),
265265
self.data_layout().instruction_address_space,
266266
),
267-
GlobalAlloc::Vtable(..) => bug!("vtables are already handled"),
267+
GlobalAlloc::VTable(..) => bug!("vtables are already handled"),
268268
GlobalAlloc::Static(def_id) => {
269269
assert!(self.tcx.is_static(def_id));
270270
assert!(!self.tcx.is_thread_local_static(def_id));

‎compiler/rustc_codegen_llvm/src/consts.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -101,7 +101,7 @@ pub fn const_alloc_to_llvm<'ll>(cx: &CodegenCx<'ll, '_>, alloc: ConstAllocation<
101101

102102
let address_space = match cx.tcx.global_alloc(alloc_id) {
103103
GlobalAlloc::Function(..) => cx.data_layout().instruction_address_space,
104-
GlobalAlloc::Static(..) | GlobalAlloc::Memory(..) | GlobalAlloc::Vtable(..) => {
104+
GlobalAlloc::Static(..) | GlobalAlloc::Memory(..) | GlobalAlloc::VTable(..) => {
105105
AddressSpace::DATA
106106
}
107107
};

‎compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -1420,7 +1420,7 @@ fn build_vtable_type_di_node<'ll, 'tcx>(
14201420
cx,
14211421
type_map::stub(
14221422
cx,
1423-
Stub::VtableTy { vtable_holder },
1423+
Stub::VTableTy { vtable_holder },
14241424
unique_type_id,
14251425
&vtable_type_name,
14261426
(size, pointer_align),

‎compiler/rustc_codegen_llvm/src/debuginfo/metadata/type_map.rs

+3-3
Original file line numberDiff line numberDiff line change
@@ -146,7 +146,7 @@ impl<'ll> DINodeCreationResult<'ll> {
146146
pub enum Stub<'ll> {
147147
Struct,
148148
Union,
149-
VtableTy { vtable_holder: &'ll DIType },
149+
VTableTy { vtable_holder: &'ll DIType },
150150
}
151151

152152
pub struct StubInfo<'ll, 'tcx> {
@@ -180,9 +180,9 @@ pub(super) fn stub<'ll, 'tcx>(
180180
let unique_type_id_str = unique_type_id.generate_unique_id_string(cx.tcx);
181181

182182
let metadata = match kind {
183-
Stub::Struct | Stub::VtableTy { .. } => {
183+
Stub::Struct | Stub::VTableTy { .. } => {
184184
let vtable_holder = match kind {
185-
Stub::VtableTy { vtable_holder } => Some(vtable_holder),
185+
Stub::VTableTy { vtable_holder } => Some(vtable_holder),
186186
_ => None,
187187
};
188188
unsafe {

‎compiler/rustc_codegen_ssa/src/base.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -171,7 +171,7 @@ pub fn unsized_info<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
171171
);
172172
let new_vptr = bx.load(ptr_ty, gep, ptr_align);
173173
bx.nonnull_metadata(new_vptr);
174-
// Vtable loads are invariant.
174+
// VTable loads are invariant.
175175
bx.set_invariant_load(new_vptr);
176176
new_vptr
177177
} else {

‎compiler/rustc_codegen_ssa/src/meth.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -39,7 +39,7 @@ impl<'a, 'tcx> VirtualIndex {
3939
let gep = bx.inbounds_gep(llty, llvtable, &[bx.const_usize(self.0)]);
4040
let ptr = bx.load(llty, gep, ptr_align);
4141
bx.nonnull_metadata(ptr);
42-
// Vtable loads are invariant.
42+
// VTable loads are invariant.
4343
bx.set_invariant_load(ptr);
4444
ptr
4545
}
@@ -58,7 +58,7 @@ impl<'a, 'tcx> VirtualIndex {
5858
let usize_align = bx.tcx().data_layout.pointer_align.abi;
5959
let gep = bx.inbounds_gep(llty, llvtable, &[bx.const_usize(self.0)]);
6060
let ptr = bx.load(llty, gep, usize_align);
61-
// Vtable loads are invariant.
61+
// VTable loads are invariant.
6262
bx.set_invariant_load(ptr);
6363
ptr
6464
}

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

+10-10
Original file line numberDiff line numberDiff line change
@@ -63,7 +63,7 @@ pub enum AllocKind {
6363
/// A function allocation (that fn ptrs point to).
6464
Function,
6565
/// A (symbolic) vtable allocation.
66-
Vtable,
66+
VTable,
6767
/// A dead allocation.
6868
Dead,
6969
}
@@ -293,7 +293,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
293293
Some(GlobalAlloc::Function(..)) => {
294294
err_ub_format!("deallocating {alloc_id:?}, which is a function")
295295
}
296-
Some(GlobalAlloc::Vtable(..)) => {
296+
Some(GlobalAlloc::VTable(..)) => {
297297
err_ub_format!("deallocating {alloc_id:?}, which is a vtable")
298298
}
299299
Some(GlobalAlloc::Static(..) | GlobalAlloc::Memory(..)) => {
@@ -480,7 +480,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
480480
(mem, None)
481481
}
482482
Some(GlobalAlloc::Function(..)) => throw_ub!(DerefFunctionPointer(id)),
483-
Some(GlobalAlloc::Vtable(..)) => throw_ub!(DerefVtablePointer(id)),
483+
Some(GlobalAlloc::VTable(..)) => throw_ub!(DerefVTablePointer(id)),
484484
None => throw_ub!(PointerUseAfterFree(id)),
485485
Some(GlobalAlloc::Static(def_id)) => {
486486
assert!(self.tcx.is_static(def_id));
@@ -684,9 +684,9 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
684684
(alloc.size(), alloc.align, AllocKind::LiveData)
685685
}
686686
Some(GlobalAlloc::Function(_)) => bug!("We already checked function pointers above"),
687-
Some(GlobalAlloc::Vtable(..)) => {
687+
Some(GlobalAlloc::VTable(..)) => {
688688
// No data to be accessed here. But vtables are pointer-aligned.
689-
return (Size::ZERO, self.tcx.data_layout.pointer_align.abi, AllocKind::Vtable);
689+
return (Size::ZERO, self.tcx.data_layout.pointer_align.abi, AllocKind::VTable);
690690
}
691691
// The rest must be dead.
692692
None => {
@@ -742,11 +742,11 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
742742
trace!("get_ptr_vtable({:?})", ptr);
743743
let (alloc_id, offset, _tag) = self.ptr_get_alloc_id(ptr)?;
744744
if offset.bytes() != 0 {
745-
throw_ub!(InvalidVtablePointer(Pointer::new(alloc_id, offset)))
745+
throw_ub!(InvalidVTablePointer(Pointer::new(alloc_id, offset)))
746746
}
747747
match self.tcx.try_get_global_alloc(alloc_id) {
748-
Some(GlobalAlloc::Vtable(ty, trait_ref)) => Ok((ty, trait_ref)),
749-
_ => throw_ub!(InvalidVtablePointer(Pointer::new(alloc_id, offset))),
748+
Some(GlobalAlloc::VTable(ty, trait_ref)) => Ok((ty, trait_ref)),
749+
_ => throw_ub!(InvalidVTablePointer(Pointer::new(alloc_id, offset))),
750750
}
751751
}
752752

@@ -867,10 +867,10 @@ impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> std::fmt::Debug for DumpAllocs<'a,
867867
Some(GlobalAlloc::Function(func)) => {
868868
write!(fmt, " (fn: {func})")?;
869869
}
870-
Some(GlobalAlloc::Vtable(ty, Some(trait_ref))) => {
870+
Some(GlobalAlloc::VTable(ty, Some(trait_ref))) => {
871871
write!(fmt, " (vtable: impl {trait_ref} for {ty})")?;
872872
}
873-
Some(GlobalAlloc::Vtable(ty, None)) => {
873+
Some(GlobalAlloc::VTable(ty, None)) => {
874874
write!(fmt, " (vtable: impl <auto trait> for {ty})")?;
875875
}
876876
Some(GlobalAlloc::Static(did)) => {

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

+1-1
Original file line numberDiff line numberDiff line change
@@ -364,7 +364,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
364364
// caller_fn_abi is not relevant here, we interpret the arguments directly for each intrinsic.
365365
M::call_intrinsic(self, instance, args, destination, target, unwind)
366366
}
367-
ty::InstanceDef::VtableShim(..)
367+
ty::InstanceDef::VTableShim(..)
368368
| ty::InstanceDef::ReifyShim(..)
369369
| ty::InstanceDef::ClosureOnceShim { .. }
370370
| ty::InstanceDef::FnPtrShim(..)

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

+1-1
Original file line numberDiff line numberDiff line change
@@ -318,7 +318,7 @@ impl<'rt, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> ValidityVisitor<'rt, 'mir, '
318318
self.ecx.get_ptr_vtable(vtable),
319319
self.path,
320320
err_ub!(DanglingIntPointer(..)) |
321-
err_ub!(InvalidVtablePointer(..)) =>
321+
err_ub!(InvalidVTablePointer(..)) =>
322322
{ "{vtable}" } expected { "a vtable pointer" },
323323
);
324324
// FIXME: check if the type/trait match what ty::Dynamic says?

‎compiler/rustc_middle/src/mir/interpret/error.rs

+4-4
Original file line numberDiff line numberDiff line change
@@ -266,7 +266,7 @@ pub enum UndefinedBehaviorInfo {
266266
// Trying to access the data behind a function pointer.
267267
DerefFunctionPointer(AllocId),
268268
// Trying to access the data behind a vtable pointer.
269-
DerefVtablePointer(AllocId),
269+
DerefVTablePointer(AllocId),
270270
/// The value validity check found a problem.
271271
/// Should only be thrown by `validity.rs` and always point out which part of the value
272272
/// is the problem.
@@ -285,7 +285,7 @@ pub enum UndefinedBehaviorInfo {
285285
/// Using a pointer-not-to-a-function as function pointer.
286286
InvalidFunctionPointer(Pointer),
287287
/// Using a pointer-not-to-a-vtable as vtable pointer.
288-
InvalidVtablePointer(Pointer),
288+
InvalidVTablePointer(Pointer),
289289
/// Using a string that is not valid UTF-8,
290290
InvalidStr(std::str::Utf8Error),
291291
/// Using uninitialized data where it is not allowed.
@@ -349,7 +349,7 @@ impl fmt::Display for UndefinedBehaviorInfo {
349349
),
350350
WriteToReadOnly(a) => write!(f, "writing to {a:?} which is read-only"),
351351
DerefFunctionPointer(a) => write!(f, "accessing {a:?} which contains a function"),
352-
DerefVtablePointer(a) => write!(f, "accessing {a:?} which contains a vtable"),
352+
DerefVTablePointer(a) => write!(f, "accessing {a:?} which contains a vtable"),
353353
ValidationFailure { path: None, msg } => {
354354
write!(f, "constructing invalid value: {msg}")
355355
}
@@ -366,7 +366,7 @@ impl fmt::Display for UndefinedBehaviorInfo {
366366
InvalidFunctionPointer(p) => {
367367
write!(f, "using {p:?} as function pointer but it does not point to a function")
368368
}
369-
InvalidVtablePointer(p) => {
369+
InvalidVTablePointer(p) => {
370370
write!(f, "using {p:?} as vtable pointer but it does not point to a vtable")
371371
}
372372
InvalidStr(err) => write!(f, "this string is not valid UTF-8: {err}"),

‎compiler/rustc_middle/src/mir/interpret/mod.rs

+10-10
Original file line numberDiff line numberDiff line change
@@ -196,7 +196,7 @@ impl fmt::Debug for AllocId {
196196
enum AllocDiscriminant {
197197
Alloc,
198198
Fn,
199-
Vtable,
199+
VTable,
200200
Static,
201201
}
202202

@@ -216,9 +216,9 @@ pub fn specialized_encode_alloc_id<'tcx, E: TyEncoder<I = TyCtxt<'tcx>>>(
216216
AllocDiscriminant::Fn.encode(encoder);
217217
fn_instance.encode(encoder);
218218
}
219-
GlobalAlloc::Vtable(ty, poly_trait_ref) => {
219+
GlobalAlloc::VTable(ty, poly_trait_ref) => {
220220
trace!("encoding {:?} with {ty:#?}, {poly_trait_ref:#?}", alloc_id);
221-
AllocDiscriminant::Vtable.encode(encoder);
221+
AllocDiscriminant::VTable.encode(encoder);
222222
ty.encode(encoder);
223223
poly_trait_ref.encode(encoder);
224224
}
@@ -314,7 +314,7 @@ impl<'s> AllocDecodingSession<'s> {
314314
}
315315
AllocDiscriminant::Fn
316316
| AllocDiscriminant::Static
317-
| AllocDiscriminant::Vtable => {
317+
| AllocDiscriminant::VTable => {
318318
// Fns and statics cannot be cyclic, and their `AllocId`
319319
// is determined later by interning.
320320
*entry =
@@ -364,7 +364,7 @@ impl<'s> AllocDecodingSession<'s> {
364364
let alloc_id = decoder.interner().create_fn_alloc(instance);
365365
alloc_id
366366
}
367-
AllocDiscriminant::Vtable => {
367+
AllocDiscriminant::VTable => {
368368
assert!(alloc_id.is_none());
369369
trace!("creating static alloc ID");
370370
let ty = <Ty<'_> as Decodable<D>>::decode(decoder);
@@ -400,7 +400,7 @@ pub enum GlobalAlloc<'tcx> {
400400
/// The alloc ID is used as a function pointer.
401401
Function(Instance<'tcx>),
402402
/// This alloc ID points to a symbolic (not-reified) vtable.
403-
Vtable(Ty<'tcx>, Option<ty::PolyExistentialTraitRef<'tcx>>),
403+
VTable(Ty<'tcx>, Option<ty::PolyExistentialTraitRef<'tcx>>),
404404
/// The alloc ID points to a "lazy" static variable that did not get computed (yet).
405405
/// This is also used to break the cycle in recursive statics.
406406
Static(DefId),
@@ -429,12 +429,12 @@ impl<'tcx> GlobalAlloc<'tcx> {
429429
}
430430
}
431431

432-
/// Panics if the `GlobalAlloc` is not `GlobalAlloc::Vtable`
432+
/// Panics if the `GlobalAlloc` is not `GlobalAlloc::VTable`
433433
#[track_caller]
434434
#[inline]
435435
pub fn unwrap_vtable(&self) -> (Ty<'tcx>, Option<ty::PolyExistentialTraitRef<'tcx>>) {
436436
match *self {
437-
GlobalAlloc::Vtable(ty, poly_trait_ref) => (ty, poly_trait_ref),
437+
GlobalAlloc::VTable(ty, poly_trait_ref) => (ty, poly_trait_ref),
438438
_ => bug!("expected vtable, got {:?}", self),
439439
}
440440
}
@@ -490,7 +490,7 @@ impl<'tcx> TyCtxt<'tcx> {
490490
fn reserve_and_set_dedup(self, alloc: GlobalAlloc<'tcx>) -> AllocId {
491491
let mut alloc_map = self.alloc_map.lock();
492492
match alloc {
493-
GlobalAlloc::Function(..) | GlobalAlloc::Static(..) | GlobalAlloc::Vtable(..) => {}
493+
GlobalAlloc::Function(..) | GlobalAlloc::Static(..) | GlobalAlloc::VTable(..) => {}
494494
GlobalAlloc::Memory(..) => bug!("Trying to dedup-reserve memory with real data!"),
495495
}
496496
if let Some(&alloc_id) = alloc_map.dedup.get(&alloc) {
@@ -541,7 +541,7 @@ impl<'tcx> TyCtxt<'tcx> {
541541
ty: Ty<'tcx>,
542542
poly_trait_ref: Option<ty::PolyExistentialTraitRef<'tcx>>,
543543
) -> AllocId {
544-
self.reserve_and_set_dedup(GlobalAlloc::Vtable(ty, poly_trait_ref))
544+
self.reserve_and_set_dedup(GlobalAlloc::VTable(ty, poly_trait_ref))
545545
}
546546

547547
/// Interns the `Allocation` and return a new `AllocId`, even if there's already an identical

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

+1-1
Original file line numberDiff line numberDiff line change
@@ -362,7 +362,7 @@ impl<'tcx> CodegenUnit<'tcx> {
362362
// the codegen tests and can even make item order
363363
// unstable.
364364
InstanceDef::Item(def) => def.did.as_local().map(Idx::index),
365-
InstanceDef::VtableShim(..)
365+
InstanceDef::VTableShim(..)
366366
| InstanceDef::ReifyShim(..)
367367
| InstanceDef::Intrinsic(..)
368368
| InstanceDef::FnPtrShim(..)

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

+4-2
Original file line numberDiff line numberDiff line change
@@ -725,10 +725,12 @@ pub fn write_allocations<'tcx>(
725725
// gracefully handle it and allow buggy rustc to be debugged via allocation printing.
726726
None => write!(w, " (deallocated)")?,
727727
Some(GlobalAlloc::Function(inst)) => write!(w, " (fn: {inst})")?,
728-
Some(GlobalAlloc::Vtable(ty, Some(trait_ref))) => {
728+
Some(GlobalAlloc::VTable(ty, Some(trait_ref))) => {
729729
write!(w, " (vtable: impl {trait_ref} for {ty})")?
730730
}
731-
Some(GlobalAlloc::Vtable(ty, None)) => write!(w, " (vtable: impl <auto trait> for {ty})")?,
731+
Some(GlobalAlloc::VTable(ty, None)) => {
732+
write!(w, " (vtable: impl <auto trait> for {ty})")?
733+
}
732734
Some(GlobalAlloc::Static(did)) if !tcx.is_foreign_item(did) => {
733735
match tcx.eval_static_initializer(did) {
734736
Ok(alloc) => {

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

+1-1
Original file line numberDiff line numberDiff line change
@@ -394,7 +394,7 @@ macro_rules! make_mir_visitor {
394394
ty::InstanceDef::Item(_def_id) => {}
395395

396396
ty::InstanceDef::Intrinsic(_def_id) |
397-
ty::InstanceDef::VtableShim(_def_id) |
397+
ty::InstanceDef::VTableShim(_def_id) |
398398
ty::InstanceDef::ReifyShim(_def_id) |
399399
ty::InstanceDef::Virtual(_def_id, _) |
400400
ty::InstanceDef::ClosureOnceShim { call_once: _def_id, track_caller: _ } |

0 commit comments

Comments
 (0)