Implement the conversion between internal things and stable things related to AssocItem.

Author: makai410

compiler/rustc_smir/src/rustc_internal/internal.rs

@@ -12,10 +12,11 @@ use stable_mir::mir::alloc::AllocId;
 use stable_mir::mir::mono::{Instance, MonoItem, StaticDef};
 use stable_mir::mir::{BinOp, Mutability, Place, ProjectionElem, RawPtrKind, Safety, UnOp};
 use stable_mir::ty::{
-    Abi, AdtDef, Binder, BoundRegionKind, BoundTyKind, BoundVariableKind, ClosureKind, DynKind,
-    ExistentialPredicate, ExistentialProjection, ExistentialTraitRef, FloatTy, FnSig,
-    GenericArgKind, GenericArgs, IndexedVal, IntTy, MirConst, Movability, Pattern, Region, RigidTy,
-    Span, TermKind, TraitRef, Ty, TyConst, UintTy, VariantDef, VariantIdx,
+    Abi, AdtDef, AssocItem, AssocItemContainer, AssocKind, Binder, BoundRegionKind, BoundTyKind,
+    BoundVariableKind, ClosureKind, DynKind, ExistentialPredicate, ExistentialProjection,
+    ExistentialTraitRef, FloatTy, FnSig, GenericArgKind, GenericArgs, ImplTraitInTraitData,
+    IndexedVal, IntTy, MirConst, Movability, Pattern, Region, RigidTy, Span, TermKind, TraitRef,
+    Ty, TyConst, UintTy, VariantDef, VariantIdx,
 };
 use stable_mir::{CrateItem, CrateNum, DefId};
 
@@ -570,6 +571,65 @@ impl RustcInternal for ProjectionElem {
     }
 }
 
+impl RustcInternal for AssocItem {
+    type T<'tcx> = rustc_middle::ty::AssocItem;
+
+    fn internal<'tcx>(&self, tables: &mut Tables<'_>, tcx: TyCtxt<'tcx>) -> Self::T<'tcx> {
+        rustc_middle::ty::AssocItem {
+            def_id: self.def_id.0.internal(tables, tcx),
+            name: Symbol::intern(&self.name),
+            kind: self.kind.internal(tables, tcx),
+            container: self.container.internal(tables, tcx),
+            trait_item_def_id: self.trait_item_def_id.map(|did| did.0.internal(tables, tcx)),
+            fn_has_self_parameter: self.fn_has_self_parameter,
+            opt_rpitit_info: self.opt_rpitit_info.map(|did| did.internal(tables, tcx)),
+        }
+    }
+}
+
+impl RustcInternal for AssocItemContainer {
+    type T<'tcx> = rustc_middle::ty::AssocItemContainer;
+
+    fn internal<'tcx>(&self, _tables: &mut Tables<'_>, _tcx: TyCtxt<'tcx>) -> Self::T<'tcx> {
+        match self {
+            AssocItemContainer::Trait => rustc_middle::ty::AssocItemContainer::Trait,
+            AssocItemContainer::Impl => rustc_middle::ty::AssocItemContainer::Impl,
+        }
+    }
+}
+
+impl RustcInternal for AssocKind {
+    type T<'tcx> = rustc_middle::ty::AssocKind;
+
+    fn internal<'tcx>(&self, _tables: &mut Tables<'_>, _tcx: TyCtxt<'tcx>) -> Self::T<'tcx> {
+        match self {
+            AssocKind::Const => rustc_middle::ty::AssocKind::Const,
+            AssocKind::Fn => rustc_middle::ty::AssocKind::Fn,
+            AssocKind::Type => rustc_middle::ty::AssocKind::Type,
+        }
+    }
+}
+
+impl RustcInternal for ImplTraitInTraitData {
+    type T<'tcx> = rustc_middle::ty::ImplTraitInTraitData;
+
+    fn internal<'tcx>(&self, tables: &mut Tables<'_>, tcx: TyCtxt<'tcx>) -> Self::T<'tcx> {
+        match self {
+            ImplTraitInTraitData::Trait { fn_def_id, opaque_def_id } => {
+                rustc_middle::ty::ImplTraitInTraitData::Trait {
+                    fn_def_id: fn_def_id.0.internal(tables, tcx),
+                    opaque_def_id: opaque_def_id.0.internal(tables, tcx),
+                }
+            }
+            ImplTraitInTraitData::Impl { fn_def_id } => {
+                rustc_middle::ty::ImplTraitInTraitData::Impl {
+                    fn_def_id: fn_def_id.0.internal(tables, tcx),
+                }
+            }
+        }
+    }
+}
+
 impl RustcInternal for BinOp {
     type T<'tcx> = rustc_middle::mir::BinOp;
 

compiler/rustc_smir/src/rustc_smir/convert/ty.rs

@@ -890,3 +890,63 @@ impl<'tcx> Stable<'tcx> for rustc_session::cstore::ForeignModule {
         }
     }
 }
+
+impl<'tcx> Stable<'tcx> for ty::AssocKind {
+    type T = stable_mir::ty::AssocKind;
+
+    fn stable(&self, _tables: &mut Tables<'_>) -> Self::T {
+        use stable_mir::ty::AssocKind;
+        match self {
+            ty::AssocKind::Const => AssocKind::Const,
+            ty::AssocKind::Fn => AssocKind::Fn,
+            ty::AssocKind::Type => AssocKind::Type,
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for ty::AssocItemContainer {
+    type T = stable_mir::ty::AssocItemContainer;
+
+    fn stable(&self, _tables: &mut Tables<'_>) -> Self::T {
+        use stable_mir::ty::AssocItemContainer;
+        match self {
+            ty::AssocItemContainer::Trait => AssocItemContainer::Trait,
+            ty::AssocItemContainer::Impl => AssocItemContainer::Impl,
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for ty::AssocItem {
+    type T = stable_mir::ty::AssocItem;
+
+    fn stable(&self, tables: &mut Tables<'_>) -> Self::T {
+        stable_mir::ty::AssocItem {
+            def_id: tables.assoc_def(self.def_id),
+            name: self.name.to_string(),
+            kind: self.kind.stable(tables),
+            container: self.container.stable(tables),
+            trait_item_def_id: self.trait_item_def_id.map(|did| tables.assoc_def(did)),
+            fn_has_self_parameter: self.fn_has_self_parameter,
+            opt_rpitit_info: self.opt_rpitit_info.map(|rpitit| rpitit.stable(tables)),
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for ty::ImplTraitInTraitData {
+    type T = stable_mir::ty::ImplTraitInTraitData;
+
+    fn stable(&self, tables: &mut Tables<'_>) -> Self::T {
+        use stable_mir::ty::ImplTraitInTraitData;
+        match self {
+            ty::ImplTraitInTraitData::Trait { fn_def_id, opaque_def_id } => {
+                ImplTraitInTraitData::Trait {
+                    fn_def_id: tables.fn_def(*fn_def_id),
+                    opaque_def_id: tables.opaque_def(*opaque_def_id),
+                }
+            }
+            ty::ImplTraitInTraitData::Impl { fn_def_id } => {
+                ImplTraitInTraitData::Impl { fn_def_id: tables.fn_def(*fn_def_id) }
+            }
+        }
+    }
+}

compiler/stable_mir/src/lib.rs

@@ -23,7 +23,7 @@ use std::{fmt, io};
 use serde::Serialize;
 
 use crate::compiler_interface::with;
-pub use crate::crate_def::{CrateDef, CrateDefType, DefId};
+pub use crate::crate_def::{CrateDef, CrateDefItems, CrateDefType, DefId};
 pub use crate::error::*;
 use crate::mir::mono::StaticDef;
 use crate::mir::{Body, Mutability};