rustc_public/unstable/convert/
internal.rs

1//! Module containing the translation from rustc_public constructs to the rustc counterpart.
2//!
3//! This module will only include a few constructs to allow users to invoke internal rustc APIs
4//! due to incomplete stable coverage.
5
6// Prefer importing rustc_public over internal rustc constructs to make this file more readable.
7
8use rustc_middle::ty::{self as rustc_ty, Const as InternalConst, Ty as InternalTy};
9use rustc_public_bridge::Tables;
10
11use crate::abi::Layout;
12use crate::compiler_interface::BridgeTys;
13use crate::mir::alloc::AllocId;
14use crate::mir::mono::{Instance, MonoItem, StaticDef};
15use crate::mir::{BinOp, Mutability, Place, ProjectionElem, RawPtrKind, Safety, UnOp};
16use crate::ty::{
17    Abi, AdtDef, Asyncness, Binder, BoundRegionKind, BoundTyKind, BoundVariableKind, ClosureKind,
18    Constness, ExistentialPredicate, ExistentialProjection, ExistentialTraitRef, FloatTy, FnSig,
19    GenericArgKind, GenericArgs, IntTy, MirConst, Movability, Pattern, Region, RigidTy, Span,
20    TermKind, TraitRef, Ty, TyConst, UintTy, VariantDef, VariantIdx,
21};
22use crate::unstable::{InternalCx, RustcInternal};
23use crate::{CrateItem, CrateNum, DefId, IndexedVal};
24
25impl RustcInternal for CrateItem {
26    type T<'tcx> = rustc_span::def_id::DefId;
27    fn internal<'tcx>(
28        &self,
29        tables: &mut Tables<'_, BridgeTys>,
30        tcx: impl InternalCx<'tcx>,
31    ) -> Self::T<'tcx> {
32        self.0.internal(tables, tcx)
33    }
34}
35
36impl RustcInternal for CrateNum {
37    type T<'tcx> = rustc_span::def_id::CrateNum;
38    fn internal<'tcx>(
39        &self,
40        _tables: &mut Tables<'_, BridgeTys>,
41        _tcx: impl InternalCx<'tcx>,
42    ) -> Self::T<'tcx> {
43        rustc_span::def_id::CrateNum::from_usize(self.0)
44    }
45}
46
47impl RustcInternal for DefId {
48    type T<'tcx> = rustc_span::def_id::DefId;
49    fn internal<'tcx>(
50        &self,
51        tables: &mut Tables<'_, BridgeTys>,
52        _tcx: impl InternalCx<'tcx>,
53    ) -> Self::T<'tcx> {
54        tables.def_ids[*self]
55    }
56}
57
58impl RustcInternal for GenericArgs {
59    type T<'tcx> = rustc_ty::GenericArgsRef<'tcx>;
60    fn internal<'tcx>(
61        &self,
62        tables: &mut Tables<'_, BridgeTys>,
63        tcx: impl InternalCx<'tcx>,
64    ) -> Self::T<'tcx> {
65        InternalCx::mk_args_from_iter(tcx, self.0.iter().map(|arg| arg.internal(tables, tcx)))
66    }
67}
68
69impl RustcInternal for GenericArgKind {
70    type T<'tcx> = rustc_ty::GenericArg<'tcx>;
71    fn internal<'tcx>(
72        &self,
73        tables: &mut Tables<'_, BridgeTys>,
74        tcx: impl InternalCx<'tcx>,
75    ) -> Self::T<'tcx> {
76        let arg: rustc_ty::GenericArg<'tcx> = match self {
77            GenericArgKind::Lifetime(reg) => reg.internal(tables, tcx).into(),
78            GenericArgKind::Type(ty) => ty.internal(tables, tcx).into(),
79            GenericArgKind::Const(cnst) => cnst.internal(tables, tcx).into(),
80        };
81        arg
82    }
83}
84
85impl RustcInternal for Region {
86    type T<'tcx> = rustc_ty::Region<'tcx>;
87    fn internal<'tcx>(
88        &self,
89        _tables: &mut Tables<'_, BridgeTys>,
90        tcx: impl InternalCx<'tcx>,
91    ) -> Self::T<'tcx> {
92        // Cannot recover region. Use erased for now.
93        tcx.lifetimes_re_erased()
94    }
95}
96
97impl RustcInternal for Ty {
98    type T<'tcx> = InternalTy<'tcx>;
99    fn internal<'tcx>(
100        &self,
101        tables: &mut Tables<'_, BridgeTys>,
102        tcx: impl InternalCx<'tcx>,
103    ) -> Self::T<'tcx> {
104        tcx.lift(tables.types[*self])
105    }
106}
107
108impl RustcInternal for TyConst {
109    type T<'tcx> = InternalConst<'tcx>;
110    fn internal<'tcx>(
111        &self,
112        tables: &mut Tables<'_, BridgeTys>,
113        tcx: impl InternalCx<'tcx>,
114    ) -> Self::T<'tcx> {
115        tcx.lift(tables.ty_consts[self.id])
116    }
117}
118
119impl RustcInternal for Pattern {
120    type T<'tcx> = rustc_ty::Pattern<'tcx>;
121    fn internal<'tcx>(
122        &self,
123        tables: &mut Tables<'_, BridgeTys>,
124        tcx: impl InternalCx<'tcx>,
125    ) -> Self::T<'tcx> {
126        tcx.mk_pat(match self {
127            Pattern::Range { start, end, include_end: _ } => rustc_ty::PatternKind::Range {
128                start: start.internal(tables, tcx),
129                end: end.internal(tables, tcx),
130            },
131            Pattern::NotNull => rustc_ty::PatternKind::NotNull,
132            Pattern::Or(patterns) => rustc_ty::PatternKind::Or(
133                tcx.mk_patterns_from_iter(patterns.iter().map(|p| p.internal(tables, tcx))),
134            ),
135        })
136    }
137}
138
139impl RustcInternal for RigidTy {
140    type T<'tcx> = rustc_ty::TyKind<'tcx>;
141
142    fn internal<'tcx>(
143        &self,
144        tables: &mut Tables<'_, BridgeTys>,
145        tcx: impl InternalCx<'tcx>,
146    ) -> Self::T<'tcx> {
147        match self {
148            RigidTy::Bool => rustc_ty::TyKind::Bool,
149            RigidTy::Char => rustc_ty::TyKind::Char,
150            RigidTy::Int(int_ty) => rustc_ty::TyKind::Int(int_ty.internal(tables, tcx)),
151            RigidTy::Uint(uint_ty) => rustc_ty::TyKind::Uint(uint_ty.internal(tables, tcx)),
152            RigidTy::Float(float_ty) => rustc_ty::TyKind::Float(float_ty.internal(tables, tcx)),
153            RigidTy::Never => rustc_ty::TyKind::Never,
154            RigidTy::Array(ty, cnst) => {
155                rustc_ty::TyKind::Array(ty.internal(tables, tcx), cnst.internal(tables, tcx))
156            }
157            RigidTy::Pat(ty, pat) => {
158                rustc_ty::TyKind::Pat(ty.internal(tables, tcx), pat.internal(tables, tcx))
159            }
160            RigidTy::Adt(def, args) => {
161                rustc_ty::TyKind::Adt(def.internal(tables, tcx), args.internal(tables, tcx))
162            }
163            RigidTy::Str => rustc_ty::TyKind::Str,
164            RigidTy::Slice(ty) => rustc_ty::TyKind::Slice(ty.internal(tables, tcx)),
165            RigidTy::RawPtr(ty, mutability) => {
166                rustc_ty::TyKind::RawPtr(ty.internal(tables, tcx), mutability.internal(tables, tcx))
167            }
168            RigidTy::Ref(region, ty, mutability) => rustc_ty::TyKind::Ref(
169                region.internal(tables, tcx),
170                ty.internal(tables, tcx),
171                mutability.internal(tables, tcx),
172            ),
173            RigidTy::Foreign(def) => rustc_ty::TyKind::Foreign(def.0.internal(tables, tcx)),
174            RigidTy::FnDef(def, args) => {
175                rustc_ty::TyKind::FnDef(def.0.internal(tables, tcx), args.internal(tables, tcx))
176            }
177            RigidTy::FnPtr(sig) => {
178                let (sig_tys, hdr) = sig.internal(tables, tcx).split();
179                rustc_ty::TyKind::FnPtr(sig_tys, hdr)
180            }
181            RigidTy::Closure(def, args) => {
182                rustc_ty::TyKind::Closure(def.0.internal(tables, tcx), args.internal(tables, tcx))
183            }
184            RigidTy::Coroutine(def, args) => {
185                rustc_ty::TyKind::Coroutine(def.0.internal(tables, tcx), args.internal(tables, tcx))
186            }
187            RigidTy::CoroutineClosure(def, args) => rustc_ty::TyKind::CoroutineClosure(
188                def.0.internal(tables, tcx),
189                args.internal(tables, tcx),
190            ),
191            RigidTy::CoroutineWitness(def, args) => rustc_ty::TyKind::CoroutineWitness(
192                def.0.internal(tables, tcx),
193                args.internal(tables, tcx),
194            ),
195            RigidTy::Dynamic(predicate, region) => rustc_ty::TyKind::Dynamic(
196                tcx.mk_poly_existential_predicates(&predicate.internal(tables, tcx)),
197                region.internal(tables, tcx),
198            ),
199            RigidTy::Tuple(tys) => {
200                rustc_ty::TyKind::Tuple(tcx.mk_type_list(&tys.internal(tables, tcx)))
201            }
202        }
203    }
204}
205
206impl RustcInternal for IntTy {
207    type T<'tcx> = rustc_ty::IntTy;
208
209    fn internal<'tcx>(
210        &self,
211        _tables: &mut Tables<'_, BridgeTys>,
212        _tcx: impl InternalCx<'tcx>,
213    ) -> Self::T<'tcx> {
214        match self {
215            IntTy::Isize => rustc_ty::IntTy::Isize,
216            IntTy::I8 => rustc_ty::IntTy::I8,
217            IntTy::I16 => rustc_ty::IntTy::I16,
218            IntTy::I32 => rustc_ty::IntTy::I32,
219            IntTy::I64 => rustc_ty::IntTy::I64,
220            IntTy::I128 => rustc_ty::IntTy::I128,
221        }
222    }
223}
224
225impl RustcInternal for UintTy {
226    type T<'tcx> = rustc_ty::UintTy;
227
228    fn internal<'tcx>(
229        &self,
230        _tables: &mut Tables<'_, BridgeTys>,
231        _tcx: impl InternalCx<'tcx>,
232    ) -> Self::T<'tcx> {
233        match self {
234            UintTy::Usize => rustc_ty::UintTy::Usize,
235            UintTy::U8 => rustc_ty::UintTy::U8,
236            UintTy::U16 => rustc_ty::UintTy::U16,
237            UintTy::U32 => rustc_ty::UintTy::U32,
238            UintTy::U64 => rustc_ty::UintTy::U64,
239            UintTy::U128 => rustc_ty::UintTy::U128,
240        }
241    }
242}
243
244impl RustcInternal for FloatTy {
245    type T<'tcx> = rustc_ty::FloatTy;
246
247    fn internal<'tcx>(
248        &self,
249        _tables: &mut Tables<'_, BridgeTys>,
250        _tcx: impl InternalCx<'tcx>,
251    ) -> Self::T<'tcx> {
252        match self {
253            FloatTy::F16 => rustc_ty::FloatTy::F16,
254            FloatTy::F32 => rustc_ty::FloatTy::F32,
255            FloatTy::F64 => rustc_ty::FloatTy::F64,
256            FloatTy::F128 => rustc_ty::FloatTy::F128,
257        }
258    }
259}
260
261impl RustcInternal for Mutability {
262    type T<'tcx> = rustc_ty::Mutability;
263
264    fn internal<'tcx>(
265        &self,
266        _tables: &mut Tables<'_, BridgeTys>,
267        _tcx: impl InternalCx<'tcx>,
268    ) -> Self::T<'tcx> {
269        match self {
270            Mutability::Not => rustc_ty::Mutability::Not,
271            Mutability::Mut => rustc_ty::Mutability::Mut,
272        }
273    }
274}
275
276impl RustcInternal for Movability {
277    type T<'tcx> = rustc_ty::Movability;
278
279    fn internal<'tcx>(
280        &self,
281        _tables: &mut Tables<'_, BridgeTys>,
282        _tcx: impl InternalCx<'tcx>,
283    ) -> Self::T<'tcx> {
284        match self {
285            Movability::Static => rustc_ty::Movability::Static,
286            Movability::Movable => rustc_ty::Movability::Movable,
287        }
288    }
289}
290
291impl RustcInternal for RawPtrKind {
292    type T<'tcx> = rustc_middle::mir::RawPtrKind;
293
294    fn internal<'tcx>(
295        &self,
296        _tables: &mut Tables<'_, BridgeTys>,
297        _tcx: impl InternalCx<'tcx>,
298    ) -> Self::T<'tcx> {
299        match self {
300            RawPtrKind::Mut => rustc_middle::mir::RawPtrKind::Mut,
301            RawPtrKind::Const => rustc_middle::mir::RawPtrKind::Const,
302            RawPtrKind::FakeForPtrMetadata => rustc_middle::mir::RawPtrKind::FakeForPtrMetadata,
303        }
304    }
305}
306
307impl RustcInternal for FnSig {
308    type T<'tcx> = rustc_ty::FnSig<'tcx>;
309
310    fn internal<'tcx>(
311        &self,
312        tables: &mut Tables<'_, BridgeTys>,
313        tcx: impl InternalCx<'tcx>,
314    ) -> Self::T<'tcx> {
315        // FIXME(splat): When `#[splat]` is complete (or stable), add splatted to the public FnSig
316        let fn_sig_kind = rustc_ty::FnSigKind::default()
317            .set_abi(self.abi.internal(tables, tcx))
318            .set_safety(self.safety.internal(tables, tcx))
319            .set_c_variadic(self.c_variadic);
320        rustc_ty::FnSig {
321            inputs_and_output: tcx.mk_type_list(&self.inputs_and_output.internal(tables, tcx)),
322            fn_sig_kind,
323        }
324    }
325}
326
327impl RustcInternal for VariantIdx {
328    type T<'tcx> = rustc_abi::VariantIdx;
329
330    fn internal<'tcx>(
331        &self,
332        _tables: &mut Tables<'_, BridgeTys>,
333        _tcx: impl InternalCx<'tcx>,
334    ) -> Self::T<'tcx> {
335        rustc_abi::VariantIdx::from(self.to_index())
336    }
337}
338
339impl RustcInternal for VariantDef {
340    type T<'tcx> = &'tcx rustc_ty::VariantDef;
341
342    fn internal<'tcx>(
343        &self,
344        tables: &mut Tables<'_, BridgeTys>,
345        tcx: impl InternalCx<'tcx>,
346    ) -> Self::T<'tcx> {
347        self.adt_def.internal(tables, tcx).variant(self.idx.internal(tables, tcx))
348    }
349}
350
351impl RustcInternal for MirConst {
352    type T<'tcx> = rustc_middle::mir::Const<'tcx>;
353    fn internal<'tcx>(
354        &self,
355        tables: &mut Tables<'_, BridgeTys>,
356        tcx: impl InternalCx<'tcx>,
357    ) -> Self::T<'tcx> {
358        let constant = tables.mir_consts[self.id];
359        match constant {
360            rustc_middle::mir::Const::Ty(ty, ct) => {
361                rustc_middle::mir::Const::Ty(tcx.lift(ty), tcx.lift(ct))
362            }
363            rustc_middle::mir::Const::Unevaluated(uneval, ty) => {
364                rustc_middle::mir::Const::Unevaluated(tcx.lift(uneval), tcx.lift(ty))
365            }
366            rustc_middle::mir::Const::Val(const_val, ty) => {
367                rustc_middle::mir::Const::Val(tcx.lift(const_val), tcx.lift(ty))
368            }
369        }
370    }
371}
372
373impl RustcInternal for MonoItem {
374    type T<'tcx> = rustc_middle::mono::MonoItem<'tcx>;
375
376    fn internal<'tcx>(
377        &self,
378        tables: &mut Tables<'_, BridgeTys>,
379        tcx: impl InternalCx<'tcx>,
380    ) -> Self::T<'tcx> {
381        use rustc_middle::mono as rustc_mono;
382        match self {
383            MonoItem::Fn(instance) => rustc_mono::MonoItem::Fn(instance.internal(tables, tcx)),
384            MonoItem::Static(def) => rustc_mono::MonoItem::Static(def.internal(tables, tcx)),
385            MonoItem::GlobalAsm(_) => {
386                ::core::panicking::panic("not implemented")unimplemented!()
387            }
388        }
389    }
390}
391
392impl RustcInternal for Instance {
393    type T<'tcx> = rustc_ty::Instance<'tcx>;
394
395    fn internal<'tcx>(
396        &self,
397        tables: &mut Tables<'_, BridgeTys>,
398        tcx: impl InternalCx<'tcx>,
399    ) -> Self::T<'tcx> {
400        tcx.lift(tables.instances[self.def])
401    }
402}
403
404impl RustcInternal for StaticDef {
405    type T<'tcx> = rustc_span::def_id::DefId;
406
407    fn internal<'tcx>(
408        &self,
409        tables: &mut Tables<'_, BridgeTys>,
410        tcx: impl InternalCx<'tcx>,
411    ) -> Self::T<'tcx> {
412        self.0.internal(tables, tcx)
413    }
414}
415
416#[allow(rustc::usage_of_qualified_ty)]
417impl<T> RustcInternal for Binder<T>
418where
419    T: RustcInternal,
420    for<'tcx> T::T<'tcx>: rustc_ty::TypeVisitable<rustc_ty::TyCtxt<'tcx>>,
421{
422    type T<'tcx> = rustc_ty::Binder<'tcx, T::T<'tcx>>;
423
424    fn internal<'tcx>(
425        &self,
426        tables: &mut Tables<'_, BridgeTys>,
427        tcx: impl InternalCx<'tcx>,
428    ) -> Self::T<'tcx> {
429        rustc_ty::Binder::bind_with_vars(
430            self.value.internal(tables, tcx),
431            tcx.mk_bound_variable_kinds_from_iter(
432                self.bound_vars.iter().map(|bound| bound.internal(tables, tcx)),
433            ),
434        )
435    }
436}
437
438impl RustcInternal for BoundVariableKind {
439    type T<'tcx> = rustc_ty::BoundVariableKind<'tcx>;
440
441    fn internal<'tcx>(
442        &self,
443        tables: &mut Tables<'_, BridgeTys>,
444        tcx: impl InternalCx<'tcx>,
445    ) -> Self::T<'tcx> {
446        match self {
447            BoundVariableKind::Ty(kind) => rustc_ty::BoundVariableKind::Ty(match kind {
448                BoundTyKind::Anon => rustc_ty::BoundTyKind::Anon,
449                BoundTyKind::Param(def, _symbol) => {
450                    rustc_ty::BoundTyKind::Param(def.0.internal(tables, tcx))
451                }
452            }),
453            BoundVariableKind::Region(kind) => rustc_ty::BoundVariableKind::Region(match kind {
454                BoundRegionKind::BrAnon => rustc_ty::BoundRegionKind::Anon,
455                BoundRegionKind::BrNamed(def, _symbol) => {
456                    rustc_ty::BoundRegionKind::Named(def.0.internal(tables, tcx))
457                }
458                BoundRegionKind::BrEnv => rustc_ty::BoundRegionKind::ClosureEnv,
459            }),
460            BoundVariableKind::Const => rustc_ty::BoundVariableKind::Const,
461        }
462    }
463}
464
465impl RustcInternal for ExistentialPredicate {
466    type T<'tcx> = rustc_ty::ExistentialPredicate<'tcx>;
467
468    fn internal<'tcx>(
469        &self,
470        tables: &mut Tables<'_, BridgeTys>,
471        tcx: impl InternalCx<'tcx>,
472    ) -> Self::T<'tcx> {
473        match self {
474            ExistentialPredicate::Trait(trait_ref) => {
475                rustc_ty::ExistentialPredicate::Trait(trait_ref.internal(tables, tcx))
476            }
477            ExistentialPredicate::Projection(proj) => {
478                rustc_ty::ExistentialPredicate::Projection(proj.internal(tables, tcx))
479            }
480            ExistentialPredicate::AutoTrait(trait_def) => {
481                rustc_ty::ExistentialPredicate::AutoTrait(trait_def.0.internal(tables, tcx))
482            }
483        }
484    }
485}
486
487impl RustcInternal for ExistentialProjection {
488    type T<'tcx> = rustc_ty::ExistentialProjection<'tcx>;
489
490    fn internal<'tcx>(
491        &self,
492        tables: &mut Tables<'_, BridgeTys>,
493        tcx: impl InternalCx<'tcx>,
494    ) -> Self::T<'tcx> {
495        use crate::unstable::internal_cx::ExistentialProjectionHelpers;
496        tcx.new_from_args(
497            self.def_id.0.internal(tables, tcx),
498            self.generic_args.internal(tables, tcx),
499            self.term.internal(tables, tcx),
500        )
501    }
502}
503
504impl RustcInternal for TermKind {
505    type T<'tcx> = rustc_ty::Term<'tcx>;
506
507    fn internal<'tcx>(
508        &self,
509        tables: &mut Tables<'_, BridgeTys>,
510        tcx: impl InternalCx<'tcx>,
511    ) -> Self::T<'tcx> {
512        match self {
513            TermKind::Type(ty) => ty.internal(tables, tcx).into(),
514            TermKind::Const(cnst) => cnst.internal(tables, tcx).into(),
515        }
516    }
517}
518
519impl RustcInternal for ExistentialTraitRef {
520    type T<'tcx> = rustc_ty::ExistentialTraitRef<'tcx>;
521
522    fn internal<'tcx>(
523        &self,
524        tables: &mut Tables<'_, BridgeTys>,
525        tcx: impl InternalCx<'tcx>,
526    ) -> Self::T<'tcx> {
527        use crate::unstable::internal_cx::ExistentialTraitRefHelpers;
528        tcx.new_from_args(
529            self.def_id.0.internal(tables, tcx),
530            self.generic_args.internal(tables, tcx),
531        )
532    }
533}
534
535impl RustcInternal for TraitRef {
536    type T<'tcx> = rustc_ty::TraitRef<'tcx>;
537
538    fn internal<'tcx>(
539        &self,
540        tables: &mut Tables<'_, BridgeTys>,
541        tcx: impl InternalCx<'tcx>,
542    ) -> Self::T<'tcx> {
543        use crate::unstable::internal_cx::TraitRefHelpers;
544        tcx.new_from_args(self.def_id.0.internal(tables, tcx), self.args().internal(tables, tcx))
545    }
546}
547
548impl RustcInternal for AllocId {
549    type T<'tcx> = rustc_middle::mir::interpret::AllocId;
550    fn internal<'tcx>(
551        &self,
552        tables: &mut Tables<'_, BridgeTys>,
553        _tcx: impl InternalCx<'tcx>,
554    ) -> Self::T<'tcx> {
555        tables.alloc_ids[*self]
556    }
557}
558
559impl RustcInternal for ClosureKind {
560    type T<'tcx> = rustc_ty::ClosureKind;
561
562    fn internal<'tcx>(
563        &self,
564        _tables: &mut Tables<'_, BridgeTys>,
565        _tcx: impl InternalCx<'tcx>,
566    ) -> Self::T<'tcx> {
567        match self {
568            ClosureKind::Fn => rustc_ty::ClosureKind::Fn,
569            ClosureKind::FnMut => rustc_ty::ClosureKind::FnMut,
570            ClosureKind::FnOnce => rustc_ty::ClosureKind::FnOnce,
571        }
572    }
573}
574
575impl RustcInternal for AdtDef {
576    type T<'tcx> = rustc_ty::AdtDef<'tcx>;
577    fn internal<'tcx>(
578        &self,
579        tables: &mut Tables<'_, BridgeTys>,
580        tcx: impl InternalCx<'tcx>,
581    ) -> Self::T<'tcx> {
582        InternalCx::adt_def(tcx, self.0.internal(tables, tcx))
583    }
584}
585
586impl RustcInternal for Abi {
587    type T<'tcx> = rustc_abi::ExternAbi;
588
589    fn internal<'tcx>(
590        &self,
591        _tables: &mut Tables<'_, BridgeTys>,
592        _tcx: impl InternalCx<'tcx>,
593    ) -> Self::T<'tcx> {
594        match *self {
595            Abi::Rust => rustc_abi::ExternAbi::Rust,
596            Abi::C { unwind } => rustc_abi::ExternAbi::C { unwind },
597            Abi::Cdecl { unwind } => rustc_abi::ExternAbi::Cdecl { unwind },
598            Abi::Stdcall { unwind } => rustc_abi::ExternAbi::Stdcall { unwind },
599            Abi::Fastcall { unwind } => rustc_abi::ExternAbi::Fastcall { unwind },
600            Abi::Vectorcall { unwind } => rustc_abi::ExternAbi::Vectorcall { unwind },
601            Abi::Thiscall { unwind } => rustc_abi::ExternAbi::Thiscall { unwind },
602            Abi::Aapcs { unwind } => rustc_abi::ExternAbi::Aapcs { unwind },
603            Abi::CCmseNonSecureCall => rustc_abi::ExternAbi::CmseNonSecureCall,
604            Abi::CCmseNonSecureEntry => rustc_abi::ExternAbi::CmseNonSecureEntry,
605            Abi::Win64 { unwind } => rustc_abi::ExternAbi::Win64 { unwind },
606            Abi::SysV64 { unwind } => rustc_abi::ExternAbi::SysV64 { unwind },
607            Abi::PtxKernel => rustc_abi::ExternAbi::PtxKernel,
608            Abi::Msp430Interrupt => rustc_abi::ExternAbi::Msp430Interrupt,
609            Abi::X86Interrupt => rustc_abi::ExternAbi::X86Interrupt,
610            Abi::GpuKernel => rustc_abi::ExternAbi::GpuKernel,
611            Abi::EfiApi => rustc_abi::ExternAbi::EfiApi,
612            Abi::AvrInterrupt => rustc_abi::ExternAbi::AvrInterrupt,
613            Abi::AvrNonBlockingInterrupt => rustc_abi::ExternAbi::AvrNonBlockingInterrupt,
614            Abi::System { unwind } => rustc_abi::ExternAbi::System { unwind },
615            Abi::RustCall => rustc_abi::ExternAbi::RustCall,
616            Abi::Unadjusted => rustc_abi::ExternAbi::Unadjusted,
617            Abi::RustCold => rustc_abi::ExternAbi::RustCold,
618            Abi::RustInvalid => rustc_abi::ExternAbi::RustInvalid,
619            Abi::RiscvInterruptM => rustc_abi::ExternAbi::RiscvInterruptM,
620            Abi::RiscvInterruptS => rustc_abi::ExternAbi::RiscvInterruptS,
621            Abi::RustPreserveNone => rustc_abi::ExternAbi::RustPreserveNone,
622            Abi::RustTail => rustc_abi::ExternAbi::RustTail,
623            Abi::Custom => rustc_abi::ExternAbi::Custom,
624            Abi::Swift => rustc_abi::ExternAbi::Swift,
625        }
626    }
627}
628
629impl RustcInternal for Safety {
630    type T<'tcx> = rustc_hir::Safety;
631
632    fn internal<'tcx>(
633        &self,
634        _tables: &mut Tables<'_, BridgeTys>,
635        _tcx: impl InternalCx<'tcx>,
636    ) -> Self::T<'tcx> {
637        match self {
638            Safety::Unsafe => rustc_hir::Safety::Unsafe,
639            Safety::Safe => rustc_hir::Safety::Safe,
640        }
641    }
642}
643
644impl RustcInternal for Constness {
645    type T<'tcx> = rustc_hir::Constness;
646
647    fn internal<'tcx>(
648        &self,
649        _tables: &mut Tables<'_, BridgeTys>,
650        _tcx: impl InternalCx<'tcx>,
651    ) -> Self::T<'tcx> {
652        match *self {
653            Constness::Const { always } => rustc_hir::Constness::Const { always },
654            Constness::NotConst => rustc_hir::Constness::NotConst,
655        }
656    }
657}
658
659impl RustcInternal for Asyncness {
660    type T<'tcx> = rustc_ty::Asyncness;
661
662    fn internal<'tcx>(
663        &self,
664        _tables: &mut Tables<'_, BridgeTys>,
665        _tcx: impl InternalCx<'tcx>,
666    ) -> Self::T<'tcx> {
667        match self {
668            Asyncness::Async => rustc_ty::Asyncness::Yes,
669            Asyncness::NotAsync => rustc_ty::Asyncness::No,
670        }
671    }
672}
673impl RustcInternal for Span {
674    type T<'tcx> = rustc_span::Span;
675
676    fn internal<'tcx>(
677        &self,
678        tables: &mut Tables<'_, BridgeTys>,
679        _tcx: impl InternalCx<'tcx>,
680    ) -> Self::T<'tcx> {
681        tables.spans[*self]
682    }
683}
684
685impl RustcInternal for Layout {
686    type T<'tcx> = rustc_abi::Layout<'tcx>;
687
688    fn internal<'tcx>(
689        &self,
690        tables: &mut Tables<'_, BridgeTys>,
691        tcx: impl InternalCx<'tcx>,
692    ) -> Self::T<'tcx> {
693        tcx.lift(tables.layouts[*self])
694    }
695}
696
697impl RustcInternal for Place {
698    type T<'tcx> = rustc_middle::mir::Place<'tcx>;
699
700    fn internal<'tcx>(
701        &self,
702        tables: &mut Tables<'_, BridgeTys>,
703        tcx: impl InternalCx<'tcx>,
704    ) -> Self::T<'tcx> {
705        rustc_middle::mir::Place {
706            local: rustc_middle::mir::Local::from_usize(self.local),
707            projection: tcx.mk_place_elems(&self.projection.internal(tables, tcx)),
708        }
709    }
710}
711
712impl RustcInternal for ProjectionElem {
713    type T<'tcx> = rustc_middle::mir::PlaceElem<'tcx>;
714
715    fn internal<'tcx>(
716        &self,
717        tables: &mut Tables<'_, BridgeTys>,
718        tcx: impl InternalCx<'tcx>,
719    ) -> Self::T<'tcx> {
720        match self {
721            ProjectionElem::Deref => rustc_middle::mir::PlaceElem::Deref,
722            ProjectionElem::Field(idx, ty) => {
723                rustc_middle::mir::PlaceElem::Field((*idx).into(), ty.internal(tables, tcx))
724            }
725            ProjectionElem::Index(idx) => rustc_middle::mir::PlaceElem::Index((*idx).into()),
726            ProjectionElem::ConstantIndex { offset, min_length, from_end } => {
727                rustc_middle::mir::PlaceElem::ConstantIndex {
728                    offset: *offset,
729                    min_length: *min_length,
730                    from_end: *from_end,
731                }
732            }
733            ProjectionElem::Subslice { from, to, from_end } => {
734                rustc_middle::mir::PlaceElem::Subslice { from: *from, to: *to, from_end: *from_end }
735            }
736            ProjectionElem::Downcast(idx) => {
737                rustc_middle::mir::PlaceElem::Downcast(None, idx.internal(tables, tcx))
738            }
739            ProjectionElem::OpaqueCast(ty) => {
740                rustc_middle::mir::PlaceElem::OpaqueCast(ty.internal(tables, tcx))
741            }
742        }
743    }
744}
745
746impl RustcInternal for BinOp {
747    type T<'tcx> = rustc_middle::mir::BinOp;
748
749    fn internal<'tcx>(
750        &self,
751        _tables: &mut Tables<'_, BridgeTys>,
752        _tcx: impl InternalCx<'tcx>,
753    ) -> Self::T<'tcx> {
754        match self {
755            BinOp::Add => rustc_middle::mir::BinOp::Add,
756            BinOp::AddUnchecked => rustc_middle::mir::BinOp::AddUnchecked,
757            BinOp::Sub => rustc_middle::mir::BinOp::Sub,
758            BinOp::SubUnchecked => rustc_middle::mir::BinOp::SubUnchecked,
759            BinOp::Mul => rustc_middle::mir::BinOp::Mul,
760            BinOp::MulUnchecked => rustc_middle::mir::BinOp::MulUnchecked,
761            BinOp::Div => rustc_middle::mir::BinOp::Div,
762            BinOp::Rem => rustc_middle::mir::BinOp::Rem,
763            BinOp::BitXor => rustc_middle::mir::BinOp::BitXor,
764            BinOp::BitAnd => rustc_middle::mir::BinOp::BitAnd,
765            BinOp::BitOr => rustc_middle::mir::BinOp::BitOr,
766            BinOp::Shl => rustc_middle::mir::BinOp::Shl,
767            BinOp::ShlUnchecked => rustc_middle::mir::BinOp::ShlUnchecked,
768            BinOp::Shr => rustc_middle::mir::BinOp::Shr,
769            BinOp::ShrUnchecked => rustc_middle::mir::BinOp::ShrUnchecked,
770            BinOp::Eq => rustc_middle::mir::BinOp::Eq,
771            BinOp::Lt => rustc_middle::mir::BinOp::Lt,
772            BinOp::Le => rustc_middle::mir::BinOp::Le,
773            BinOp::Ne => rustc_middle::mir::BinOp::Ne,
774            BinOp::Ge => rustc_middle::mir::BinOp::Ge,
775            BinOp::Gt => rustc_middle::mir::BinOp::Gt,
776            BinOp::Cmp => rustc_middle::mir::BinOp::Cmp,
777            BinOp::Offset => rustc_middle::mir::BinOp::Offset,
778        }
779    }
780}
781
782impl RustcInternal for UnOp {
783    type T<'tcx> = rustc_middle::mir::UnOp;
784
785    fn internal<'tcx>(
786        &self,
787        _tables: &mut Tables<'_, BridgeTys>,
788        _tcx: impl InternalCx<'tcx>,
789    ) -> Self::T<'tcx> {
790        match self {
791            UnOp::Not => rustc_middle::mir::UnOp::Not,
792            UnOp::Neg => rustc_middle::mir::UnOp::Neg,
793            UnOp::PtrMetadata => rustc_middle::mir::UnOp::PtrMetadata,
794        }
795    }
796}
797
798impl<T> RustcInternal for &T
799where
800    T: RustcInternal,
801{
802    type T<'tcx> = T::T<'tcx>;
803
804    fn internal<'tcx>(
805        &self,
806        tables: &mut Tables<'_, BridgeTys>,
807        tcx: impl InternalCx<'tcx>,
808    ) -> Self::T<'tcx> {
809        (*self).internal(tables, tcx)
810    }
811}
812
813impl<T> RustcInternal for Option<T>
814where
815    T: RustcInternal,
816{
817    type T<'tcx> = Option<T::T<'tcx>>;
818
819    fn internal<'tcx>(
820        &self,
821        tables: &mut Tables<'_, BridgeTys>,
822        tcx: impl InternalCx<'tcx>,
823    ) -> Self::T<'tcx> {
824        self.as_ref().map(|inner| inner.internal(tables, tcx))
825    }
826}
827
828impl<T> RustcInternal for Vec<T>
829where
830    T: RustcInternal,
831{
832    type T<'tcx> = Vec<T::T<'tcx>>;
833
834    fn internal<'tcx>(
835        &self,
836        tables: &mut Tables<'_, BridgeTys>,
837        tcx: impl InternalCx<'tcx>,
838    ) -> Self::T<'tcx> {
839        self.iter().map(|e| e.internal(tables, tcx)).collect()
840    }
841}
rustc_public/unstable/convert/internal.rs

rustc_public/unstable/convert/
internal.rs
