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

rustc_public/unstable/convert/
internal.rs
