+ FieldId, LocalFieldId, StaticId, UnionId, VariantId,

+use macros::{TypeFoldable, TypeVisitable};

+use stdx::impl_from;

+#[derive(Debug, Clone, PartialEq, Eq, Hash)]

+/// The index of a field (whether of a struct/enum variant, tuple, or closure).

+/// For a struct/enum it converts from and to the LocalFieldId, for a tuple or closure it's simply the index.

+#[derive(Copy, Clone, PartialEq, Eq, Hash, salsa::Update, PartialOrd, Ord, Debug)]

+pub struct FieldIndex(pub u32);

+

+impl FieldIndex {

+ pub fn to_local_field_id(self) -> LocalFieldId {

+ LocalFieldId::from_raw(RawIdx::from_u32(self.0))

+ }

+}

+

+impl From<LocalFieldId> for FieldIndex {

+ fn from(value: LocalFieldId) -> Self {

+ FieldIndex(value.into_raw().into_u32())

+ }

+}

+

+ /// A field (e.g., `f` in `_1.f`).

+ Field(FieldIndex),

+ /// Index into a slice/array.

+ /// These indices are generated by slice patterns.

+ ConstantIndex {

+ offset: u64,

+ from_end: bool,

+ },

+ /// These indices are generated by slice patterns.

+ Subslice {

+ from: u64,

+ to: u64,

+ },

+ /// "Downcast" to a variant of an enum or a coroutine.

+ Downcast(VariantId),

+ pub fn map<V2: PartialEq>(self, v: impl FnOnce(V) -> V2) -> ProjectionElem<V2> {

+ match self {

+ ProjectionElem::Deref => ProjectionElem::Deref,

+ ProjectionElem::Field(field_index) => ProjectionElem::Field(field_index),

+ ProjectionElem::Index(idx) => ProjectionElem::Index(v(idx)),

+ ProjectionElem::ConstantIndex { offset, from_end } => {

+ ProjectionElem::ConstantIndex { offset, from_end }

+ ProjectionElem::Subslice { from, to } => ProjectionElem::Subslice { from, to },

+ ProjectionElem::Downcast(variant_id) => ProjectionElem::Downcast(variant_id),

+ }

+ pub fn try_map<V2: PartialEq>(

+ self,

+ v: impl FnOnce(V) -> Option<V2>,

+ ) -> Option<ProjectionElem<V2>> {

+ Some(match self {

+ ProjectionElem::Deref => ProjectionElem::Deref,

+ ProjectionElem::Field(field_index) => ProjectionElem::Field(field_index),

+ ProjectionElem::Index(idx) => ProjectionElem::Index(v(idx)?),

+ ProjectionElem::ConstantIndex { offset, from_end } => {

+ ProjectionElem::ConstantIndex { offset, from_end }

+ ProjectionElem::Subslice { from, to } => ProjectionElem::Subslice { from, to },

+ ProjectionElem::Downcast(variant_id) => ProjectionElem::Downcast(variant_id),

+ })

+ pub fn ty(&self, body: &MirBody, infcx: &InferCtxt<'db>, env: ParamEnv<'db>) -> PlaceTy<'db> {

+ PlaceTy::from_ty(body.locals[self.local].ty.as_ref()).multi_projection_ty(

+ infcx,

+ env,

+ self.projection.as_slice(),

+ )

+ }

+

+impl<'tcx> PlaceRef<'tcx> {

+ /// If this place represents a local variable like `_X` with no

+ /// projections, return `Some(_X)`.

+ #[inline]

+ pub fn as_local(&self) -> Option<LocalId> {

+ match *self {

+ PlaceRef { local, projection } if projection.as_slice().is_empty() => Some(local),

+ _ => None,

+ }

+ }

+}

+

+/// To determine the type of a place, we need to keep track of the variant that has been downcast to, in order to find the correct fields.

+/// This type does that.

+#[derive(Copy, Clone, Debug, TypeFoldable, TypeVisitable, Hash, PartialEq, Eq)]

+pub struct PlaceTy<'db> {

+ pub ty: Ty<'db>,

+ /// Downcast to a particular variant of an enum or a coroutine, if included.

+ #[type_foldable(identity)]

+ #[type_visitable(ignore)]

+ pub variant_id: Option<VariantId>,

+}

+

+impl<'db> PlaceTy<'db> {

+ #[inline]

+ pub fn from_ty(ty: Ty<'db>) -> PlaceTy<'db> {

+ PlaceTy { ty, variant_id: None }

+ }

+

+ pub fn multi_projection_ty(

+ self,

+ infcx: &InferCtxt<'db>,

+ env: ParamEnv<'db>,

+ elems: &[PlaceElem],

+ ) -> PlaceTy<'db> {

+ elems.iter().fold(self, |place_ty, elem| place_ty.projection_ty(infcx, elem, env))

+ }

+

+ fn field_ty(

+ infcx: &InferCtxt<'db>,

+ self_ty: Ty<'db>,

+ variant: Option<VariantId>,

+ f: FieldIndex,

+ ) -> Ty<'db> {

+ if let Some(variant_id) = variant {

+ match self_ty.kind() {

+ TyKind::Adt(adt_def, args) if adt_def.is_enum() => {

+ infcx.interner.db().field_types(variant_id)[f.to_local_field_id()]

+ .get()

+ .instantiate(infcx.interner, args)

+ .skip_norm_wip()

+ }

+ // FIXME TyKind::Coroutine...

+ _ => panic!("can't downcast non-adt non-coroutine type: {self_ty:?}"),

+ }

+ } else {

+ match self_ty.kind() {

+ TyKind::Adt(adt_def, args) if !adt_def.is_enum() => {

+ let variant_id = VariantId::from_non_enum(adt_def.def_id()).unwrap();

+ infcx.interner.db().field_types(variant_id)[f.to_local_field_id()]

+ .get()

+ .instantiate(infcx.interner, args)

+ .skip_norm_wip()

+ }

+ TyKind::Closure(_, args) => {

+ args.as_closure().tupled_upvars_ty().tuple_fields()[f.0 as usize]

+ }

+ // FIXME TyKind::Coroutine / TyKind::CoroutineClosure...

+ TyKind::Tuple(tys) => tys

+ .get(f.0 as usize)

+ .cloned()

+ .unwrap_or_else(|| panic!("field {f:?} out of range: {self_ty:?}")),

+ _ => panic!("can't project out of {self_ty:?}"),

+ }

+ }

+ }

+

+ /// Convenience wrapper around `projection_ty_core` for `PlaceElem`.

+ pub fn projection_ty<V: ::std::fmt::Debug + PartialEq>(

+ self,

+ infcx: &InferCtxt<'db>,

+ elem: &ProjectionElem<V>,

+ env: ParamEnv<'db>,

+ ) -> PlaceTy<'db> {

+ self.projection_ty_core(

+ infcx.interner,

+ elem,

+ |ty| {

+ if matches!(ty.kind(), TyKind::Alias(..)) {

+ let mut ocx = ObligationCtxt::new(infcx);

+ match ocx.structurally_normalize_ty(&ObligationCause::dummy(), env, ty) {

+ Ok(it) => it,

+ Err(_) => Ty::new_error(infcx.interner, ErrorGuaranteed),

+ }

+ } else {

+ ty

+ }

+ },

+ |self_ty, variant, field_id| Self::field_ty(infcx, self_ty, variant, field_id),

+ )

+ }

+

+ /// `place_ty.projection_ty_core(tcx, elem, |...| { ... })`

+ /// projects `place_ty` onto `elem`, returning the appropriate

+ /// `Ty` or downcast variant corresponding to that projection.

+ /// The `handle_field` callback must map a `FieldIndex` to its `Ty`

+ pub fn projection_ty_core<V: PartialEq + ::std::fmt::Debug>(

+ self,

+ tcx: DbInterner<'db>,

+ elem: &ProjectionElem<V>,

+ mut structurally_normalize: impl FnMut(Ty<'db>) -> Ty<'db>,

+ mut handle_field: impl FnMut(Ty<'db>, Option<VariantId>, FieldIndex /*, T*/) -> Ty<'db>,

+ ) -> PlaceTy<'db> {

+ // we only bail on mir building when there are type mismatches

+ // but error types may pop up resulting in us still attempting to build the mir

+ // so just propagate the error type

+ if self.ty.is_ty_error() {

+ return PlaceTy::from_ty(Ty::new_error(tcx, ErrorGuaranteed));

+ }

+ if self.variant_id.is_some() && !matches!(elem, ProjectionElem::Field(..)) {

+ panic!("cannot use non field projection on downcasted place")

+ }

+ match *elem {

+ ProjectionElem::Deref => {

+ let ty = structurally_normalize(self.ty).builtin_deref(true).unwrap_or_else(|| {

+ panic!("deref projection of non-dereferenceable ty {:?}", self)

+ });

+ PlaceTy::from_ty(ty)

+ }

+ ProjectionElem::Index(_) | ProjectionElem::ConstantIndex { .. } => {

+ PlaceTy::from_ty(structurally_normalize(self.ty).builtin_index().unwrap())

+ }

+ ProjectionElem::Subslice { from, to /*, from_end*/ } => {

+ PlaceTy::from_ty(match structurally_normalize(self.ty).kind() {

+ TyKind::Slice(..) => self.ty,

+ TyKind::Array(inner, _) /*if !from_end*/ => Ty::new_array_opt(tcx, inner, to.checked_sub(from).map(|x| x.into())),

+ // TyKind::Array(inner, size) if from_end => {

+ // let size = size

+ // .try_to_target_usize(tcx)

+ // .expect("expected subslice projection on fixed-size array");

+ // let len = size - from - to;

+ // Ty::new_array(tcx, *inner, len)

+ // }

+ _ => panic!("cannot subslice non-array type: `{:?}`", self),

+ })

+ }

+ ProjectionElem::Downcast(index) => PlaceTy { ty: self.ty, variant_id: Some(index) },

+ ProjectionElem::Field(f) => {

+ PlaceTy::from_ty(handle_field(structurally_normalize(self.ty), self.variant_id, f))

+ }

+ }

+ }

+}