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, Binder, BoundRegionKind, BoundTyKind, BoundVariableKind, ClosureKind,
18    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)
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        tcx.lift(tables.def_ids[*self]).unwrap()
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        tcx.lift(arg).unwrap()
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]).unwrap()
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]).unwrap()
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.as_ref().unwrap().internal(tables, tcx),
129                end: end.as_ref().unwrap().internal(tables, tcx),
130            },
131        })
132    }
133}
134
135impl RustcInternal for RigidTy {
136    type T<'tcx> = rustc_ty::TyKind<'tcx>;
137
138    fn internal<'tcx>(
139        &self,
140        tables: &mut Tables<'_, BridgeTys>,
141        tcx: impl InternalCx<'tcx>,
142    ) -> Self::T<'tcx> {
143        match self {
144            RigidTy::Bool => rustc_ty::TyKind::Bool,
145            RigidTy::Char => rustc_ty::TyKind::Char,
146            RigidTy::Int(int_ty) => rustc_ty::TyKind::Int(int_ty.internal(tables, tcx)),
147            RigidTy::Uint(uint_ty) => rustc_ty::TyKind::Uint(uint_ty.internal(tables, tcx)),
148            RigidTy::Float(float_ty) => rustc_ty::TyKind::Float(float_ty.internal(tables, tcx)),
149            RigidTy::Never => rustc_ty::TyKind::Never,
150            RigidTy::Array(ty, cnst) => {
151                rustc_ty::TyKind::Array(ty.internal(tables, tcx), cnst.internal(tables, tcx))
152            }
153            RigidTy::Pat(ty, pat) => {
154                rustc_ty::TyKind::Pat(ty.internal(tables, tcx), pat.internal(tables, tcx))
155            }
156            RigidTy::Adt(def, args) => {
157                rustc_ty::TyKind::Adt(def.internal(tables, tcx), args.internal(tables, tcx))
158            }
159            RigidTy::Str => rustc_ty::TyKind::Str,
160            RigidTy::Slice(ty) => rustc_ty::TyKind::Slice(ty.internal(tables, tcx)),
161            RigidTy::RawPtr(ty, mutability) => {
162                rustc_ty::TyKind::RawPtr(ty.internal(tables, tcx), mutability.internal(tables, tcx))
163            }
164            RigidTy::Ref(region, ty, mutability) => rustc_ty::TyKind::Ref(
165                region.internal(tables, tcx),
166                ty.internal(tables, tcx),
167                mutability.internal(tables, tcx),
168            ),
169            RigidTy::Foreign(def) => rustc_ty::TyKind::Foreign(def.0.internal(tables, tcx)),
170            RigidTy::FnDef(def, args) => {
171                rustc_ty::TyKind::FnDef(def.0.internal(tables, tcx), args.internal(tables, tcx))
172            }
173            RigidTy::FnPtr(sig) => {
174                let (sig_tys, hdr) = sig.internal(tables, tcx).split();
175                rustc_ty::TyKind::FnPtr(sig_tys, hdr)
176            }
177            RigidTy::Closure(def, args) => {
178                rustc_ty::TyKind::Closure(def.0.internal(tables, tcx), args.internal(tables, tcx))
179            }
180            RigidTy::Coroutine(def, args) => {
181                rustc_ty::TyKind::Coroutine(def.0.internal(tables, tcx), args.internal(tables, tcx))
182            }
183            RigidTy::CoroutineClosure(def, args) => rustc_ty::TyKind::CoroutineClosure(
184                def.0.internal(tables, tcx),
185                args.internal(tables, tcx),
186            ),
187            RigidTy::CoroutineWitness(def, args) => rustc_ty::TyKind::CoroutineWitness(
188                def.0.internal(tables, tcx),
189                args.internal(tables, tcx),
190            ),
191            RigidTy::Dynamic(predicate, region) => rustc_ty::TyKind::Dynamic(
192                tcx.mk_poly_existential_predicates(&predicate.internal(tables, tcx)),
193                region.internal(tables, tcx),
194            ),
195            RigidTy::Tuple(tys) => {
196                rustc_ty::TyKind::Tuple(tcx.mk_type_list(&tys.internal(tables, tcx)))
197            }
198        }
199    }
200}
201
202impl RustcInternal for IntTy {
203    type T<'tcx> = rustc_ty::IntTy;
204
205    fn internal<'tcx>(
206        &self,
207        _tables: &mut Tables<'_, BridgeTys>,
208        _tcx: impl InternalCx<'tcx>,
209    ) -> Self::T<'tcx> {
210        match self {
211            IntTy::Isize => rustc_ty::IntTy::Isize,
212            IntTy::I8 => rustc_ty::IntTy::I8,
213            IntTy::I16 => rustc_ty::IntTy::I16,
214            IntTy::I32 => rustc_ty::IntTy::I32,
215            IntTy::I64 => rustc_ty::IntTy::I64,
216            IntTy::I128 => rustc_ty::IntTy::I128,
217        }
218    }
219}
220
221impl RustcInternal for UintTy {
222    type T<'tcx> = rustc_ty::UintTy;
223
224    fn internal<'tcx>(
225        &self,
226        _tables: &mut Tables<'_, BridgeTys>,
227        _tcx: impl InternalCx<'tcx>,
228    ) -> Self::T<'tcx> {
229        match self {
230            UintTy::Usize => rustc_ty::UintTy::Usize,
231            UintTy::U8 => rustc_ty::UintTy::U8,
232            UintTy::U16 => rustc_ty::UintTy::U16,
233            UintTy::U32 => rustc_ty::UintTy::U32,
234            UintTy::U64 => rustc_ty::UintTy::U64,
235            UintTy::U128 => rustc_ty::UintTy::U128,
236        }
237    }
238}
239
240impl RustcInternal for FloatTy {
241    type T<'tcx> = rustc_ty::FloatTy;
242
243    fn internal<'tcx>(
244        &self,
245        _tables: &mut Tables<'_, BridgeTys>,
246        _tcx: impl InternalCx<'tcx>,
247    ) -> Self::T<'tcx> {
248        match self {
249            FloatTy::F16 => rustc_ty::FloatTy::F16,
250            FloatTy::F32 => rustc_ty::FloatTy::F32,
251            FloatTy::F64 => rustc_ty::FloatTy::F64,
252            FloatTy::F128 => rustc_ty::FloatTy::F128,
253        }
254    }
255}
256
257impl RustcInternal for Mutability {
258    type T<'tcx> = rustc_ty::Mutability;
259
260    fn internal<'tcx>(
261        &self,
262        _tables: &mut Tables<'_, BridgeTys>,
263        _tcx: impl InternalCx<'tcx>,
264    ) -> Self::T<'tcx> {
265        match self {
266            Mutability::Not => rustc_ty::Mutability::Not,
267            Mutability::Mut => rustc_ty::Mutability::Mut,
268        }
269    }
270}
271
272impl RustcInternal for Movability {
273    type T<'tcx> = rustc_ty::Movability;
274
275    fn internal<'tcx>(
276        &self,
277        _tables: &mut Tables<'_, BridgeTys>,
278        _tcx: impl InternalCx<'tcx>,
279    ) -> Self::T<'tcx> {
280        match self {
281            Movability::Static => rustc_ty::Movability::Static,
282            Movability::Movable => rustc_ty::Movability::Movable,
283        }
284    }
285}
286
287impl RustcInternal for RawPtrKind {
288    type T<'tcx> = rustc_middle::mir::RawPtrKind;
289
290    fn internal<'tcx>(
291        &self,
292        _tables: &mut Tables<'_, BridgeTys>,
293        _tcx: impl InternalCx<'tcx>,
294    ) -> Self::T<'tcx> {
295        match self {
296            RawPtrKind::Mut => rustc_middle::mir::RawPtrKind::Mut,
297            RawPtrKind::Const => rustc_middle::mir::RawPtrKind::Const,
298            RawPtrKind::FakeForPtrMetadata => rustc_middle::mir::RawPtrKind::FakeForPtrMetadata,
299        }
300    }
301}
302
303impl RustcInternal for FnSig {
304    type T<'tcx> = rustc_ty::FnSig<'tcx>;
305
306    fn internal<'tcx>(
307        &self,
308        tables: &mut Tables<'_, BridgeTys>,
309        tcx: impl InternalCx<'tcx>,
310    ) -> Self::T<'tcx> {
311        tcx.lift(rustc_ty::FnSig {
312            inputs_and_output: tcx.mk_type_list(&self.inputs_and_output.internal(tables, tcx)),
313            c_variadic: self.c_variadic,
314            safety: self.safety.internal(tables, tcx),
315            abi: self.abi.internal(tables, tcx),
316        })
317        .unwrap()
318    }
319}
320
321impl RustcInternal for VariantIdx {
322    type T<'tcx> = rustc_abi::VariantIdx;
323
324    fn internal<'tcx>(
325        &self,
326        _tables: &mut Tables<'_, BridgeTys>,
327        _tcx: impl InternalCx<'tcx>,
328    ) -> Self::T<'tcx> {
329        rustc_abi::VariantIdx::from(self.to_index())
330    }
331}
332
333impl RustcInternal for VariantDef {
334    type T<'tcx> = &'tcx rustc_ty::VariantDef;
335
336    fn internal<'tcx>(
337        &self,
338        tables: &mut Tables<'_, BridgeTys>,
339        tcx: impl InternalCx<'tcx>,
340    ) -> Self::T<'tcx> {
341        self.adt_def.internal(tables, tcx).variant(self.idx.internal(tables, tcx))
342    }
343}
344
345impl RustcInternal for MirConst {
346    type T<'tcx> = rustc_middle::mir::Const<'tcx>;
347    fn internal<'tcx>(
348        &self,
349        tables: &mut Tables<'_, BridgeTys>,
350        tcx: impl InternalCx<'tcx>,
351    ) -> Self::T<'tcx> {
352        let constant = tables.mir_consts[self.id];
353        match constant {
354            rustc_middle::mir::Const::Ty(ty, ct) => {
355                rustc_middle::mir::Const::Ty(tcx.lift(ty).unwrap(), tcx.lift(ct).unwrap())
356            }
357            rustc_middle::mir::Const::Unevaluated(uneval, ty) => {
358                rustc_middle::mir::Const::Unevaluated(
359                    tcx.lift(uneval).unwrap(),
360                    tcx.lift(ty).unwrap(),
361                )
362            }
363            rustc_middle::mir::Const::Val(const_val, ty) => {
364                rustc_middle::mir::Const::Val(tcx.lift(const_val).unwrap(), tcx.lift(ty).unwrap())
365            }
366        }
367    }
368}
369
370impl RustcInternal for MonoItem {
371    type T<'tcx> = rustc_middle::mir::mono::MonoItem<'tcx>;
372
373    fn internal<'tcx>(
374        &self,
375        tables: &mut Tables<'_, BridgeTys>,
376        tcx: impl InternalCx<'tcx>,
377    ) -> Self::T<'tcx> {
378        use rustc_middle::mir::mono as rustc_mono;
379        match self {
380            MonoItem::Fn(instance) => rustc_mono::MonoItem::Fn(instance.internal(tables, tcx)),
381            MonoItem::Static(def) => rustc_mono::MonoItem::Static(def.internal(tables, tcx)),
382            MonoItem::GlobalAsm(_) => {
383                unimplemented!()
384            }
385        }
386    }
387}
388
389impl RustcInternal for Instance {
390    type T<'tcx> = rustc_ty::Instance<'tcx>;
391
392    fn internal<'tcx>(
393        &self,
394        tables: &mut Tables<'_, BridgeTys>,
395        tcx: impl InternalCx<'tcx>,
396    ) -> Self::T<'tcx> {
397        tcx.lift(tables.instances[self.def]).unwrap()
398    }
399}
400
401impl RustcInternal for StaticDef {
402    type T<'tcx> = rustc_span::def_id::DefId;
403
404    fn internal<'tcx>(
405        &self,
406        tables: &mut Tables<'_, BridgeTys>,
407        tcx: impl InternalCx<'tcx>,
408    ) -> Self::T<'tcx> {
409        self.0.internal(tables, tcx)
410    }
411}
412
413#[allow(rustc::usage_of_qualified_ty)]
414impl<T> RustcInternal for Binder<T>
415where
416    T: RustcInternal,
417    for<'tcx> T::T<'tcx>: rustc_ty::TypeVisitable<rustc_ty::TyCtxt<'tcx>>,
418{
419    type T<'tcx> = rustc_ty::Binder<'tcx, T::T<'tcx>>;
420
421    fn internal<'tcx>(
422        &self,
423        tables: &mut Tables<'_, BridgeTys>,
424        tcx: impl InternalCx<'tcx>,
425    ) -> Self::T<'tcx> {
426        rustc_ty::Binder::bind_with_vars(
427            self.value.internal(tables, tcx),
428            tcx.mk_bound_variable_kinds_from_iter(
429                self.bound_vars.iter().map(|bound| bound.internal(tables, tcx)),
430            ),
431        )
432    }
433}
434
435impl RustcInternal for BoundVariableKind {
436    type T<'tcx> = rustc_ty::BoundVariableKind;
437
438    fn internal<'tcx>(
439        &self,
440        tables: &mut Tables<'_, BridgeTys>,
441        tcx: impl InternalCx<'tcx>,
442    ) -> Self::T<'tcx> {
443        match self {
444            BoundVariableKind::Ty(kind) => rustc_ty::BoundVariableKind::Ty(match kind {
445                BoundTyKind::Anon => rustc_ty::BoundTyKind::Anon,
446                BoundTyKind::Param(def, _symbol) => {
447                    rustc_ty::BoundTyKind::Param(def.0.internal(tables, tcx))
448                }
449            }),
450            BoundVariableKind::Region(kind) => rustc_ty::BoundVariableKind::Region(match kind {
451                BoundRegionKind::BrAnon => rustc_ty::BoundRegionKind::Anon,
452                BoundRegionKind::BrNamed(def, _symbol) => {
453                    rustc_ty::BoundRegionKind::Named(def.0.internal(tables, tcx))
454                }
455                BoundRegionKind::BrEnv => rustc_ty::BoundRegionKind::ClosureEnv,
456            }),
457            BoundVariableKind::Const => rustc_ty::BoundVariableKind::Const,
458        }
459    }
460}
461
462impl RustcInternal for ExistentialPredicate {
463    type T<'tcx> = rustc_ty::ExistentialPredicate<'tcx>;
464
465    fn internal<'tcx>(
466        &self,
467        tables: &mut Tables<'_, BridgeTys>,
468        tcx: impl InternalCx<'tcx>,
469    ) -> Self::T<'tcx> {
470        match self {
471            ExistentialPredicate::Trait(trait_ref) => {
472                rustc_ty::ExistentialPredicate::Trait(trait_ref.internal(tables, tcx))
473            }
474            ExistentialPredicate::Projection(proj) => {
475                rustc_ty::ExistentialPredicate::Projection(proj.internal(tables, tcx))
476            }
477            ExistentialPredicate::AutoTrait(trait_def) => {
478                rustc_ty::ExistentialPredicate::AutoTrait(trait_def.0.internal(tables, tcx))
479            }
480        }
481    }
482}
483
484impl RustcInternal for ExistentialProjection {
485    type T<'tcx> = rustc_ty::ExistentialProjection<'tcx>;
486
487    fn internal<'tcx>(
488        &self,
489        tables: &mut Tables<'_, BridgeTys>,
490        tcx: impl InternalCx<'tcx>,
491    ) -> Self::T<'tcx> {
492        use crate::unstable::internal_cx::ExistentialProjectionHelpers;
493        tcx.new_from_args(
494            self.def_id.0.internal(tables, tcx),
495            self.generic_args.internal(tables, tcx),
496            self.term.internal(tables, tcx),
497        )
498    }
499}
500
501impl RustcInternal for TermKind {
502    type T<'tcx> = rustc_ty::Term<'tcx>;
503
504    fn internal<'tcx>(
505        &self,
506        tables: &mut Tables<'_, BridgeTys>,
507        tcx: impl InternalCx<'tcx>,
508    ) -> Self::T<'tcx> {
509        match self {
510            TermKind::Type(ty) => ty.internal(tables, tcx).into(),
511            TermKind::Const(cnst) => cnst.internal(tables, tcx).into(),
512        }
513    }
514}
515
516impl RustcInternal for ExistentialTraitRef {
517    type T<'tcx> = rustc_ty::ExistentialTraitRef<'tcx>;
518
519    fn internal<'tcx>(
520        &self,
521        tables: &mut Tables<'_, BridgeTys>,
522        tcx: impl InternalCx<'tcx>,
523    ) -> Self::T<'tcx> {
524        use crate::unstable::internal_cx::ExistentialTraitRefHelpers;
525        tcx.new_from_args(
526            self.def_id.0.internal(tables, tcx),
527            self.generic_args.internal(tables, tcx),
528        )
529    }
530}
531
532impl RustcInternal for TraitRef {
533    type T<'tcx> = rustc_ty::TraitRef<'tcx>;
534
535    fn internal<'tcx>(
536        &self,
537        tables: &mut Tables<'_, BridgeTys>,
538        tcx: impl InternalCx<'tcx>,
539    ) -> Self::T<'tcx> {
540        use crate::unstable::internal_cx::TraitRefHelpers;
541        tcx.new_from_args(self.def_id.0.internal(tables, tcx), self.args().internal(tables, tcx))
542    }
543}
544
545impl RustcInternal for AllocId {
546    type T<'tcx> = rustc_middle::mir::interpret::AllocId;
547    fn internal<'tcx>(
548        &self,
549        tables: &mut Tables<'_, BridgeTys>,
550        tcx: impl InternalCx<'tcx>,
551    ) -> Self::T<'tcx> {
552        tcx.lift(tables.alloc_ids[*self]).unwrap()
553    }
554}
555
556impl RustcInternal for ClosureKind {
557    type T<'tcx> = rustc_ty::ClosureKind;
558
559    fn internal<'tcx>(
560        &self,
561        _tables: &mut Tables<'_, BridgeTys>,
562        _tcx: impl InternalCx<'tcx>,
563    ) -> Self::T<'tcx> {
564        match self {
565            ClosureKind::Fn => rustc_ty::ClosureKind::Fn,
566            ClosureKind::FnMut => rustc_ty::ClosureKind::FnMut,
567            ClosureKind::FnOnce => rustc_ty::ClosureKind::FnOnce,
568        }
569    }
570}
571
572impl RustcInternal for AdtDef {
573    type T<'tcx> = rustc_ty::AdtDef<'tcx>;
574    fn internal<'tcx>(
575        &self,
576        tables: &mut Tables<'_, BridgeTys>,
577        tcx: impl InternalCx<'tcx>,
578    ) -> Self::T<'tcx> {
579        InternalCx::adt_def(tcx, self.0.internal(tables, tcx))
580    }
581}
582
583impl RustcInternal for Abi {
584    type T<'tcx> = rustc_abi::ExternAbi;
585
586    fn internal<'tcx>(
587        &self,
588        _tables: &mut Tables<'_, BridgeTys>,
589        _tcx: impl InternalCx<'tcx>,
590    ) -> Self::T<'tcx> {
591        match *self {
592            Abi::Rust => rustc_abi::ExternAbi::Rust,
593            Abi::C { unwind } => rustc_abi::ExternAbi::C { unwind },
594            Abi::Cdecl { unwind } => rustc_abi::ExternAbi::Cdecl { unwind },
595            Abi::Stdcall { unwind } => rustc_abi::ExternAbi::Stdcall { unwind },
596            Abi::Fastcall { unwind } => rustc_abi::ExternAbi::Fastcall { unwind },
597            Abi::Vectorcall { unwind } => rustc_abi::ExternAbi::Vectorcall { unwind },
598            Abi::Thiscall { unwind } => rustc_abi::ExternAbi::Thiscall { unwind },
599            Abi::Aapcs { unwind } => rustc_abi::ExternAbi::Aapcs { unwind },
600            Abi::CCmseNonSecureCall => rustc_abi::ExternAbi::CmseNonSecureCall,
601            Abi::CCmseNonSecureEntry => rustc_abi::ExternAbi::CmseNonSecureEntry,
602            Abi::Win64 { unwind } => rustc_abi::ExternAbi::Win64 { unwind },
603            Abi::SysV64 { unwind } => rustc_abi::ExternAbi::SysV64 { unwind },
604            Abi::PtxKernel => rustc_abi::ExternAbi::PtxKernel,
605            Abi::Msp430Interrupt => rustc_abi::ExternAbi::Msp430Interrupt,
606            Abi::X86Interrupt => rustc_abi::ExternAbi::X86Interrupt,
607            Abi::GpuKernel => rustc_abi::ExternAbi::GpuKernel,
608            Abi::EfiApi => rustc_abi::ExternAbi::EfiApi,
609            Abi::AvrInterrupt => rustc_abi::ExternAbi::AvrInterrupt,
610            Abi::AvrNonBlockingInterrupt => rustc_abi::ExternAbi::AvrNonBlockingInterrupt,
611            Abi::System { unwind } => rustc_abi::ExternAbi::System { unwind },
612            Abi::RustCall => rustc_abi::ExternAbi::RustCall,
613            Abi::Unadjusted => rustc_abi::ExternAbi::Unadjusted,
614            Abi::RustCold => rustc_abi::ExternAbi::RustCold,
615            Abi::RustInvalid => rustc_abi::ExternAbi::RustInvalid,
616            Abi::RiscvInterruptM => rustc_abi::ExternAbi::RiscvInterruptM,
617            Abi::RiscvInterruptS => rustc_abi::ExternAbi::RiscvInterruptS,
618            Abi::Custom => rustc_abi::ExternAbi::Custom,
619        }
620    }
621}
622
623impl RustcInternal for Safety {
624    type T<'tcx> = rustc_hir::Safety;
625
626    fn internal<'tcx>(
627        &self,
628        _tables: &mut Tables<'_, BridgeTys>,
629        _tcx: impl InternalCx<'tcx>,
630    ) -> Self::T<'tcx> {
631        match self {
632            Safety::Unsafe => rustc_hir::Safety::Unsafe,
633            Safety::Safe => rustc_hir::Safety::Safe,
634        }
635    }
636}
637impl RustcInternal for Span {
638    type T<'tcx> = rustc_span::Span;
639
640    fn internal<'tcx>(
641        &self,
642        tables: &mut Tables<'_, BridgeTys>,
643        _tcx: impl InternalCx<'tcx>,
644    ) -> Self::T<'tcx> {
645        tables.spans[*self]
646    }
647}
648
649impl RustcInternal for Layout {
650    type T<'tcx> = rustc_abi::Layout<'tcx>;
651
652    fn internal<'tcx>(
653        &self,
654        tables: &mut Tables<'_, BridgeTys>,
655        tcx: impl InternalCx<'tcx>,
656    ) -> Self::T<'tcx> {
657        tcx.lift(tables.layouts[*self]).unwrap()
658    }
659}
660
661impl RustcInternal for Place {
662    type T<'tcx> = rustc_middle::mir::Place<'tcx>;
663
664    fn internal<'tcx>(
665        &self,
666        tables: &mut Tables<'_, BridgeTys>,
667        tcx: impl InternalCx<'tcx>,
668    ) -> Self::T<'tcx> {
669        rustc_middle::mir::Place {
670            local: rustc_middle::mir::Local::from_usize(self.local),
671            projection: tcx.mk_place_elems(&self.projection.internal(tables, tcx)),
672        }
673    }
674}
675
676impl RustcInternal for ProjectionElem {
677    type T<'tcx> = rustc_middle::mir::PlaceElem<'tcx>;
678
679    fn internal<'tcx>(
680        &self,
681        tables: &mut Tables<'_, BridgeTys>,
682        tcx: impl InternalCx<'tcx>,
683    ) -> Self::T<'tcx> {
684        match self {
685            ProjectionElem::Deref => rustc_middle::mir::PlaceElem::Deref,
686            ProjectionElem::Field(idx, ty) => {
687                rustc_middle::mir::PlaceElem::Field((*idx).into(), ty.internal(tables, tcx))
688            }
689            ProjectionElem::Index(idx) => rustc_middle::mir::PlaceElem::Index((*idx).into()),
690            ProjectionElem::ConstantIndex { offset, min_length, from_end } => {
691                rustc_middle::mir::PlaceElem::ConstantIndex {
692                    offset: *offset,
693                    min_length: *min_length,
694                    from_end: *from_end,
695                }
696            }
697            ProjectionElem::Subslice { from, to, from_end } => {
698                rustc_middle::mir::PlaceElem::Subslice { from: *from, to: *to, from_end: *from_end }
699            }
700            ProjectionElem::Downcast(idx) => {
701                rustc_middle::mir::PlaceElem::Downcast(None, idx.internal(tables, tcx))
702            }
703            ProjectionElem::OpaqueCast(ty) => {
704                rustc_middle::mir::PlaceElem::OpaqueCast(ty.internal(tables, tcx))
705            }
706        }
707    }
708}
709
710impl RustcInternal for BinOp {
711    type T<'tcx> = rustc_middle::mir::BinOp;
712
713    fn internal<'tcx>(
714        &self,
715        _tables: &mut Tables<'_, BridgeTys>,
716        _tcx: impl InternalCx<'tcx>,
717    ) -> Self::T<'tcx> {
718        match self {
719            BinOp::Add => rustc_middle::mir::BinOp::Add,
720            BinOp::AddUnchecked => rustc_middle::mir::BinOp::AddUnchecked,
721            BinOp::Sub => rustc_middle::mir::BinOp::Sub,
722            BinOp::SubUnchecked => rustc_middle::mir::BinOp::SubUnchecked,
723            BinOp::Mul => rustc_middle::mir::BinOp::Mul,
724            BinOp::MulUnchecked => rustc_middle::mir::BinOp::MulUnchecked,
725            BinOp::Div => rustc_middle::mir::BinOp::Div,
726            BinOp::Rem => rustc_middle::mir::BinOp::Rem,
727            BinOp::BitXor => rustc_middle::mir::BinOp::BitXor,
728            BinOp::BitAnd => rustc_middle::mir::BinOp::BitAnd,
729            BinOp::BitOr => rustc_middle::mir::BinOp::BitOr,
730            BinOp::Shl => rustc_middle::mir::BinOp::Shl,
731            BinOp::ShlUnchecked => rustc_middle::mir::BinOp::ShlUnchecked,
732            BinOp::Shr => rustc_middle::mir::BinOp::Shr,
733            BinOp::ShrUnchecked => rustc_middle::mir::BinOp::ShrUnchecked,
734            BinOp::Eq => rustc_middle::mir::BinOp::Eq,
735            BinOp::Lt => rustc_middle::mir::BinOp::Lt,
736            BinOp::Le => rustc_middle::mir::BinOp::Le,
737            BinOp::Ne => rustc_middle::mir::BinOp::Ne,
738            BinOp::Ge => rustc_middle::mir::BinOp::Ge,
739            BinOp::Gt => rustc_middle::mir::BinOp::Gt,
740            BinOp::Cmp => rustc_middle::mir::BinOp::Cmp,
741            BinOp::Offset => rustc_middle::mir::BinOp::Offset,
742        }
743    }
744}
745
746impl RustcInternal for UnOp {
747    type T<'tcx> = rustc_middle::mir::UnOp;
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            UnOp::Not => rustc_middle::mir::UnOp::Not,
756            UnOp::Neg => rustc_middle::mir::UnOp::Neg,
757            UnOp::PtrMetadata => rustc_middle::mir::UnOp::PtrMetadata,
758        }
759    }
760}
761
762impl<T> RustcInternal for &T
763where
764    T: RustcInternal,
765{
766    type T<'tcx> = T::T<'tcx>;
767
768    fn internal<'tcx>(
769        &self,
770        tables: &mut Tables<'_, BridgeTys>,
771        tcx: impl InternalCx<'tcx>,
772    ) -> Self::T<'tcx> {
773        (*self).internal(tables, tcx)
774    }
775}
776
777impl<T> RustcInternal for Option<T>
778where
779    T: RustcInternal,
780{
781    type T<'tcx> = Option<T::T<'tcx>>;
782
783    fn internal<'tcx>(
784        &self,
785        tables: &mut Tables<'_, BridgeTys>,
786        tcx: impl InternalCx<'tcx>,
787    ) -> Self::T<'tcx> {
788        self.as_ref().map(|inner| inner.internal(tables, tcx))
789    }
790}
791
792impl<T> RustcInternal for Vec<T>
793where
794    T: RustcInternal,
795{
796    type T<'tcx> = Vec<T::T<'tcx>>;
797
798    fn internal<'tcx>(
799        &self,
800        tables: &mut Tables<'_, BridgeTys>,
801        tcx: impl InternalCx<'tcx>,
802    ) -> Self::T<'tcx> {
803        self.iter().map(|e| e.internal(tables, tcx)).collect()
804    }
805}
rustc_public/unstable/convert/internal.rs

rustc_public/unstable/convert/
internal.rs
