stable_mir/unstable/convert/
internal.rs

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

stable_mir/unstable/convert/
internal.rs
