add FRTs as ty::Field

BennoLossin · BennoLossin · commit f6a9247a34df · 2025-09-08T21:52:26.000+02:00
diff --git a/compiler/rustc_hir_analysis/src/variance/constraints.rs b/compiler/rustc_hir_analysis/src/variance/constraints.rs
@@ -273,6 +273,10 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> {
                 self.add_constraints_from_args(current, def.did(), args, variance);
             }
 
+            ty::Field(ty, _) => {
+                self.add_constraints_from_ty(current, ty, variance);
+            }
+
             ty::Alias(ty::Projection | ty::Inherent | ty::Opaque, ref data) => {
                 self.add_constraints_from_invariant_args(current, data.args, variance);
             }
diff --git a/compiler/rustc_hir_typeck/src/method/probe.rs b/compiler/rustc_hir_typeck/src/method/probe.rs
@@ -802,6 +802,7 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
             | ty::RawPtr(_, _)
             | ty::Ref(..)
             | ty::Never
+            | ty::Field(..)
             | ty::Tuple(..) => {
                 self.assemble_inherent_candidates_for_incoherent_ty(raw_self_ty, receiver_steps)
             }
diff --git a/compiler/rustc_infer/src/infer/canonical/canonicalizer.rs b/compiler/rustc_infer/src/infer/canonical/canonicalizer.rs
@@ -415,6 +415,7 @@ impl<'cx, 'tcx> TypeFolder<TyCtxt<'tcx>> for Canonicalizer<'cx, 'tcx> {
             | ty::Uint(..)
             | ty::Float(..)
             | ty::Adt(..)
+            | ty::Field(..)
             | ty::Str
             | ty::Error(_)
             | ty::Array(..)
diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
@@ -78,9 +78,9 @@ use crate::traits::solve::{
 };
 use crate::ty::predicate::ExistentialPredicateStableCmpExt as _;
 use crate::ty::{
-    self, AdtDef, AdtDefData, AdtKind, Binder, Clause, Clauses, Const, GenericArg, GenericArgs,
-    GenericArgsRef, GenericParamDefKind, List, ListWithCachedTypeInfo, ParamConst, ParamTy,
-    Pattern, PatternKind, PolyExistentialPredicate, PolyFnSig, Predicate, PredicateKind,
+    self, AdtDef, AdtDefData, AdtKind, Binder, Clause, Clauses, Const, FieldPath, GenericArg,
+    GenericArgs, GenericArgsRef, GenericParamDefKind, List, ListWithCachedTypeInfo, ParamConst,
+    ParamTy, Pattern, PatternKind, PolyExistentialPredicate, PolyFnSig, Predicate, PredicateKind,
     PredicatePolarity, Region, RegionKind, ReprOptions, TraitObjectVisitor, Ty, TyKind, TyVid,
     ValTree, ValTreeKind, Visibility,
 };
@@ -565,6 +565,7 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
             | ty::Uint(_)
             | ty::Float(_)
             | ty::Adt(_, _)
+            | ty::Field(_, _)
             | ty::Foreign(_)
             | ty::Str
             | ty::Array(_, _)
diff --git a/compiler/rustc_middle/src/ty/structural_impls.rs b/compiler/rustc_middle/src/ty/structural_impls.rs
@@ -390,6 +390,7 @@ impl<'tcx> TypeSuperFoldable<TyCtxt<'tcx>> for Ty<'tcx> {
             ty::Array(typ, sz) => ty::Array(typ.try_fold_with(folder)?, sz.try_fold_with(folder)?),
             ty::Slice(typ) => ty::Slice(typ.try_fold_with(folder)?),
             ty::Adt(tid, args) => ty::Adt(tid, args.try_fold_with(folder)?),
+            ty::Field(ty, field_path) => ty::Field(ty.try_fold_with(folder)?, field_path),
             ty::Dynamic(trait_ty, region, representation) => ty::Dynamic(
                 trait_ty.try_fold_with(folder)?,
                 region.try_fold_with(folder)?,
@@ -437,6 +438,7 @@ impl<'tcx> TypeSuperFoldable<TyCtxt<'tcx>> for Ty<'tcx> {
             ty::Array(typ, sz) => ty::Array(typ.fold_with(folder), sz.fold_with(folder)),
             ty::Slice(typ) => ty::Slice(typ.fold_with(folder)),
             ty::Adt(tid, args) => ty::Adt(tid, args.fold_with(folder)),
+            ty::Field(ty, field_path) => ty::Field(ty.fold_with(folder), field_path),
             ty::Dynamic(trait_ty, region, representation) => {
                 ty::Dynamic(trait_ty.fold_with(folder), region.fold_with(folder), representation)
             }
@@ -481,6 +483,7 @@ impl<'tcx> TypeSuperVisitable<TyCtxt<'tcx>> for Ty<'tcx> {
             }
             ty::Slice(typ) => typ.visit_with(visitor),
             ty::Adt(_, args) => args.visit_with(visitor),
+            ty::Field(ty, _) => ty.visit_with(visitor),
             ty::Dynamic(trait_ty, reg, _) => {
                 try_visit!(trait_ty.visit_with(visitor));
                 reg.visit_with(visitor)
diff --git a/compiler/rustc_middle/src/ty/sty.rs b/compiler/rustc_middle/src/ty/sty.rs
@@ -25,8 +25,9 @@ use super::GenericParamDefKind;
 use crate::infer::canonical::Canonical;
 use crate::ty::InferTy::*;
 use crate::ty::{
-    self, AdtDef, BoundRegionKind, Discr, GenericArg, GenericArgs, GenericArgsRef, List, ParamEnv,
-    Region, Ty, TyCtxt, TypeFlags, TypeSuperVisitable, TypeVisitable, TypeVisitor, UintTy,
+    self, AdtDef, BoundRegionKind, Discr, FieldPath, GenericArg, GenericArgs, GenericArgsRef, List,
+    ParamEnv, Region, Ty, TyCtxt, TypeFlags, TypeSuperVisitable, TypeVisitable, TypeVisitor,
+    UintTy,
 };
 
 // Re-export and re-parameterize some `I = TyCtxt<'tcx>` types here
@@ -667,6 +668,15 @@ impl<'tcx> Ty<'tcx> {
         Ty::new(tcx, Adt(def, args))
     }
 
+    pub fn new_field_type(
+        tcx: TyCtxt<'tcx>,
+        container: Ty<'tcx>,
+        field_path: FieldPath<'tcx>,
+    ) -> Ty<'tcx> {
+        assert!(!field_path.0.is_empty());
+        Ty::new(tcx, Field(container, field_path))
+    }
+
     #[inline]
     pub fn new_foreign(tcx: TyCtxt<'tcx>, def_id: DefId) -> Ty<'tcx> {
         Ty::new(tcx, Foreign(def_id))
@@ -972,6 +982,14 @@ impl<'tcx> rustc_type_ir::inherent::Ty<TyCtxt<'tcx>> for Ty<'tcx> {
         Ty::new_adt(interner, adt_def, args)
     }
 
+    fn new_field_type(
+        interner: TyCtxt<'tcx>,
+        container: Ty<'tcx>,
+        field_path: FieldPath<'tcx>,
+    ) -> Self {
+        Ty::new_field_type(interner, container, field_path)
+    }
+
     fn new_foreign(interner: TyCtxt<'tcx>, def_id: DefId) -> Self {
         Ty::new_foreign(interner, def_id)
     }
@@ -1967,6 +1985,7 @@ impl<'tcx> Ty<'tcx> {
             },
 
             ty::Adt(_, _)
+            | ty::Field(_, _)
             | ty::Tuple(_)
             | ty::Array(..)
             | ty::Foreign(_)
diff --git a/compiler/rustc_middle/src/ty/util.rs b/compiler/rustc_middle/src/ty/util.rs
@@ -1409,7 +1409,7 @@ impl<'tcx> Ty<'tcx> {
     pub fn is_structural_eq_shallow(self, tcx: TyCtxt<'tcx>) -> bool {
         match self.kind() {
             // Look for an impl of `StructuralPartialEq`.
-            ty::Adt(..) => tcx.has_structural_eq_impl(self),
+            ty::Adt(..) | ty::Field(..) => tcx.has_structural_eq_impl(self),
 
             // Primitive types that satisfy `Eq`.
             ty::Bool | ty::Char | ty::Int(_) | ty::Uint(_) | ty::Str | ty::Never => true,
diff --git a/compiler/rustc_mir_dataflow/src/move_paths/builder.rs b/compiler/rustc_mir_dataflow/src/move_paths/builder.rs
@@ -165,6 +165,7 @@ impl<'a, 'tcx, F: Fn(Ty<'tcx>) -> bool> MoveDataBuilder<'a, 'tcx, F> {
                     | ty::Bound(_, _)
                     | ty::Infer(_)
                     | ty::Error(_)
+                    | ty::Field(..)
                     | ty::Placeholder(_) => {
                         bug!("When Place is Deref it's type shouldn't be {place_ty:#?}")
                     }
@@ -183,6 +184,7 @@ impl<'a, 'tcx, F: Fn(Ty<'tcx>) -> bool> MoveDataBuilder<'a, 'tcx, F> {
                     | ty::Coroutine(_, _)
                     | ty::Tuple(_) => (),
                     ty::Bool
+                    | ty::Field(..)
                     | ty::Char
                     | ty::Int(_)
                     | ty::Uint(_)
diff --git a/compiler/rustc_mir_transform/src/dataflow_const_prop.rs b/compiler/rustc_mir_transform/src/dataflow_const_prop.rs
@@ -937,6 +937,7 @@ fn try_write_constant<'tcx>(
         // Unsupported for now.
         ty::Array(_, _)
         | ty::Pat(_, _)
+        | ty::Field(..)
 
         // Do not attempt to support indirection in constants.
         | ty::Ref(..) | ty::RawPtr(..) | ty::FnPtr(..) | ty::Str | ty::Slice(_)
diff --git a/compiler/rustc_next_trait_solver/src/canonicalizer.rs b/compiler/rustc_next_trait_solver/src/canonicalizer.rs
@@ -364,6 +364,7 @@ impl<'a, D: SolverDelegate<Interner = I>, I: Interner> Canonicalizer<'a, D, I> {
             | ty::Uint(_)
             | ty::Float(_)
             | ty::Adt(_, _)
+            | ty::Field(_, _)
             | ty::Foreign(_)
             | ty::Str
             | ty::Array(_, _)
diff --git a/compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs b/compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs
@@ -661,6 +661,7 @@ where
             | ty::Uint(_)
             | ty::Float(_)
             | ty::Adt(_, _)
+            | ty::Field(_, _)
             | ty::Foreign(_)
             | ty::Str
             | ty::Array(_, _)
@@ -779,6 +780,7 @@ where
             | ty::Uint(_)
             | ty::Float(_)
             | ty::Adt(_, _)
+            | ty::Field(_, _)
             | ty::Foreign(_)
             | ty::Str
             | ty::Array(_, _)
diff --git a/compiler/rustc_next_trait_solver/src/solve/assembly/structural_traits.rs b/compiler/rustc_next_trait_solver/src/solve/assembly/structural_traits.rs
@@ -37,7 +37,8 @@ where
         | ty::FnPtr(..)
         | ty::Error(_)
         | ty::Never
-        | ty::Char => Ok(ty::Binder::dummy(vec![])),
+        | ty::Char
+        | ty::Field(..) => Ok(ty::Binder::dummy(vec![])),
 
         // This branch is only for `experimental_default_bounds`.
         // Other foreign types were rejected earlier in
@@ -377,6 +378,7 @@ pub(in crate::solve) fn extract_tupled_inputs_and_output_from_callable<I: Intern
         | ty::Uint(_)
         | ty::Float(_)
         | ty::Adt(_, _)
+        | ty::Field(_, _)
         | ty::Foreign(_)
         | ty::Str
         | ty::Array(_, _)
@@ -550,6 +552,7 @@ pub(in crate::solve) fn extract_tupled_inputs_and_output_from_async_callable<I:
         | ty::Uint(_)
         | ty::Float(_)
         | ty::Adt(_, _)
+        | ty::Field(_, _)
         | ty::Foreign(_)
         | ty::Str
         | ty::Array(_, _)
@@ -700,6 +703,7 @@ pub(in crate::solve) fn extract_fn_def_from_const_callable<I: Interner>(
         | ty::Uint(_)
         | ty::Float(_)
         | ty::Adt(_, _)
+        | ty::Field(_, _)
         | ty::Foreign(_)
         | ty::Str
         | ty::Array(_, _)
diff --git a/compiler/rustc_next_trait_solver/src/solve/trait_goals.rs b/compiler/rustc_next_trait_solver/src/solve/trait_goals.rs
@@ -1258,6 +1258,7 @@ where
             | ty::Never
             | ty::Tuple(_)
             | ty::Adt(_, _)
+            | ty::Field(_, _)
             | ty::UnsafeBinder(_) => check_impls(),
             ty::Error(_) => None,
         }
diff --git a/compiler/rustc_passes/src/check_export.rs b/compiler/rustc_passes/src/check_export.rs
@@ -292,6 +292,7 @@ impl<'tcx, 'a> TypeVisitor<TyCtxt<'tcx>> for ExportableItemsChecker<'tcx, 'a> {
             ty::Int(_) | ty::Uint(_) | ty::Float(_) | ty::Bool | ty::Char | ty::Error(_) => {}
 
             ty::Array(_, _)
+            | ty::Field(..)
             | ty::Ref(_, _, _)
             | ty::Param(_)
             | ty::Closure(_, _)
diff --git a/compiler/rustc_privacy/src/lib.rs b/compiler/rustc_privacy/src/lib.rs
@@ -273,6 +273,7 @@ where
             // These types don't have their own def-ids (but may have subcomponents
             // with def-ids that should be visited recursively).
             ty::Bool
+            | ty::Field(..)
             | ty::Char
             | ty::Int(..)
             | ty::Uint(..)
diff --git a/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs b/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
@@ -1761,6 +1761,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                 ty::CoroutineClosure(..) => Some(21),
                 ty::Pat(..) => Some(22),
                 ty::UnsafeBinder(..) => Some(23),
+                ty::Field(..) => Some(24),
                 ty::Placeholder(..) | ty::Bound(..) | ty::Infer(..) | ty::Error(_) => None,
             }
         }
diff --git a/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs b/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs
@@ -683,6 +683,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                 | ty::Uint(_)
                 | ty::Float(_)
                 | ty::Adt(_, _)
+                | ty::Field(_, _)
                 | ty::Foreign(_)
                 | ty::Str
                 | ty::Array(_, _)
@@ -863,6 +864,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                 | ty::Pat(_, _)
                 | ty::Slice(_)
                 | ty::Adt(..)
+                | ty::Field(..)
                 | ty::RawPtr(_, _)
                 | ty::Ref(..)
                 | ty::FnDef(..)
@@ -1317,6 +1319,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
             | ty::Uint(_)
             | ty::Float(_)
             | ty::Adt(_, _)
+            | ty::Field(_, _)
             | ty::Foreign(_)
             | ty::Str
             | ty::Array(_, _)
@@ -1357,6 +1360,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
             | ty::Uint(_)
             | ty::Float(_)
             | ty::Adt(..)
+            | ty::Field(..)
             | ty::Foreign(..)
             | ty::Str
             | ty::Array(..)
diff --git a/compiler/rustc_trait_selection/src/traits/select/mod.rs b/compiler/rustc_trait_selection/src/traits/select/mod.rs
@@ -2263,6 +2263,7 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
             | ty::Error(_)
             | ty::Infer(ty::IntVar(_) | ty::FloatVar(_))
             | ty::Never
+            | ty::Field(..)
             | ty::Char => {
                 ty::Binder::dummy(AutoImplConstituents { types: vec![], assumptions: vec![] })
             }
diff --git a/compiler/rustc_trait_selection/src/traits/wf.rs b/compiler/rustc_trait_selection/src/traits/wf.rs
@@ -737,6 +737,11 @@ impl<'a, 'tcx> TypeVisitor<TyCtxt<'tcx>> for WfPredicates<'a, 'tcx> {
                 // WfScalar, WfParameter, etc
             }
 
+            ty::Field(..) => {
+                // Only need to make sure that the container is well-formed, which is done by the
+                // recursive call below.
+            }
+
             // Can only infer to `ty::Int(_) | ty::Uint(_)`.
             ty::Infer(ty::IntVar(_)) => {}
 
diff --git a/compiler/rustc_type_ir/src/fast_reject.rs b/compiler/rustc_type_ir/src/fast_reject.rs
@@ -28,6 +28,7 @@ pub enum SimplifiedType<DefId> {
     Uint(ty::UintTy),
     Float(ty::FloatTy),
     Adt(DefId),
+    Field,
     Foreign(DefId),
     Str,
     Array,
@@ -123,6 +124,7 @@ pub fn simplify_type<I: Interner>(
         ty::Uint(uint_type) => Some(SimplifiedType::Uint(uint_type)),
         ty::Float(float_type) => Some(SimplifiedType::Float(float_type)),
         ty::Adt(def, _) => Some(SimplifiedType::Adt(def.def_id().into())),
+        ty::Field(..) => Some(SimplifiedType::Field),
         ty::Str => Some(SimplifiedType::Str),
         ty::Array(..) => Some(SimplifiedType::Array),
         ty::Slice(..) => Some(SimplifiedType::Slice),
@@ -292,6 +294,7 @@ impl<I: Interner, const INSTANTIATE_LHS_WITH_INFER: bool, const INSTANTIATE_RHS_
             | ty::Uint(_)
             | ty::Float(_)
             | ty::Adt(..)
+            | ty::Field(..)
             | ty::Str
             | ty::Array(..)
             | ty::Slice(..)
@@ -341,6 +344,14 @@ impl<I: Interner, const INSTANTIATE_LHS_WITH_INFER: bool, const INSTANTIATE_RHS_
                 _ => false,
             },
 
+            ty::Field(lhs_ty, lhs_field_path) => match rhs.kind() {
+                ty::Field(rhs_ty, rhs_field_path) => {
+                    self.types_may_unify_inner(lhs_ty, rhs_ty, depth)
+                        && lhs_field_path == rhs_field_path
+                }
+                _ => false,
+            },
+
             // Depending on the value of const generics, we either treat generic parameters
             // like placeholders or like inference variables.
             ty::Param(lhs) => {
diff --git a/compiler/rustc_type_ir/src/flags.rs b/compiler/rustc_type_ir/src/flags.rs
@@ -277,6 +277,10 @@ impl<I: Interner> FlagComputation<I> {
                 self.add_args(args.as_slice());
             }
 
+            ty::Field(ty, _) => {
+                self.add_kind(&ty.kind());
+            }
+
             ty::Alias(kind, data) => {
                 self.add_flags(match kind {
                     ty::Projection => TypeFlags::HAS_TY_PROJECTION,
diff --git a/compiler/rustc_type_ir/src/inherent.rs b/compiler/rustc_type_ir/src/inherent.rs
@@ -5,6 +5,7 @@
 
 use std::fmt::Debug;
 use std::hash::Hash;
+use std::ops::ControlFlow;
 
 use rustc_ast_ir::Mutability;
 
@@ -74,6 +75,8 @@ pub trait Ty<I: Interner<Ty = Self>>:
 
     fn new_adt(interner: I, adt_def: I::AdtDef, args: I::GenericArgs) -> Self;
 
+    fn new_field_type(interner: I, container: I::Ty, field_path: I::FieldPath) -> Self;
+
     fn new_foreign(interner: I, def_id: I::ForeignId) -> Self;
 
     fn new_dynamic(
diff --git a/compiler/rustc_type_ir/src/outlives.rs b/compiler/rustc_type_ir/src/outlives.rs
@@ -195,6 +195,7 @@ impl<I: Interner> TypeVisitor<I> for OutlivesCollector<'_, I> {
             }
 
             ty::Adt(_, _)
+            | ty::Field(_, _)
             | ty::Foreign(_)
             | ty::Array(_, _)
             | ty::Pat(_, _)
diff --git a/compiler/rustc_type_ir/src/relate.rs b/compiler/rustc_type_ir/src/relate.rs
@@ -410,6 +410,16 @@ pub fn structurally_relate_tys<I: Interner, R: TypeRelation<I>>(
             })
         }
 
+        (ty::Field(lcontainer, lpath), ty::Field(rcontainer, rpath)) => {
+            let t = relation.relate(lcontainer, rcontainer)?;
+            if lpath == rpath {
+                Ok(Ty::new_field_type(cx, t, lpath))
+            } else {
+                // FIXME(field_projections): improve error
+                Err(TypeError::Mismatch)
+            }
+        }
+
         (ty::Foreign(a_id), ty::Foreign(b_id)) if a_id == b_id => Ok(Ty::new_foreign(cx, a_id)),
 
         (ty::Dynamic(a_obj, a_region, a_repr), ty::Dynamic(b_obj, b_region, b_repr))
diff --git a/compiler/rustc_type_ir/src/ty_kind.rs b/compiler/rustc_type_ir/src/ty_kind.rs
diff --git a/compiler/rustc_type_ir/src/walk.rs b/compiler/rustc_type_ir/src/walk.rs
diff --git a/src/tools/clippy/clippy_lints/src/dereference.rs b/src/tools/clippy/clippy_lints/src/dereference.rs

Original file line number	Diff line number	Diff line change
`@@ -273,6 +273,10 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> {`
`273`	`273`	`self.add_constraints_from_args(current, def.did(), args, variance);`
`274`	`274`	`}`
`275`	`275`
	`276`	`+ ty::Field(ty, _) => {`
	`277`	`+ self.add_constraints_from_ty(current, ty, variance);`
	`278`	`+ }`
	`279`	`+`
`276`	`280`	`ty::Alias(ty::Projection \| ty::Inherent \| ty::Opaque, ref data) => {`
`277`	`281`	`self.add_constraints_from_invariant_args(current, data.args, variance);`
`278`	`282`	`}`
Original file line number	Diff line number	Diff line change
`@@ -802,6 +802,7 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {`
`802`	`802`	`\| ty::RawPtr(_, _)`
`803`	`803`	`\| ty::Ref(..)`
`804`	`804`	`\| ty::Never`
	`805`	`+ \| ty::Field(..)`
`805`	`806`	`\| ty::Tuple(..) => {`
`806`	`807`	`self.assemble_inherent_candidates_for_incoherent_ty(raw_self_ty, receiver_steps)`
`807`	`808`	`}`