add FRTs to HIR

Author: BennoLossin

compiler/rustc_hir/src/hir.rs

@@ -3710,6 +3710,8 @@ pub enum TyKind<'hir, Unambig = ()> {
     /// We use pointer tagging to represent a `&'hir Lifetime` and `TraitObjectSyntax` pair
     /// as otherwise this type being `repr(C)` would result in `TyKind` increasing in size.
     TraitObject(&'hir [PolyTraitRef<'hir>], TaggedRef<'hir, Lifetime, TraitObjectSyntax>),
+    /// Field representing type (`field_of!`)
+    FieldOf(&'hir Ty<'hir>, &'hir [Ident]),
     /// Unused for now.
     Typeof(&'hir AnonConst),
     /// Placeholder for a type that has failed to be defined.

compiler/rustc_hir/src/intravisit.rs

@@ -1026,6 +1026,12 @@ pub fn walk_ty<'v, V: Visitor<'v>>(visitor: &mut V, typ: &'v Ty<'v, AmbigArg>) -
             }
             try_visit!(visitor.visit_lifetime(lifetime));
         }
+        TyKind::FieldOf(ty, fields) => {
+            try_visit!(visitor.visit_ty_unambig(ty));
+            for field in fields {
+                try_visit!(visitor.visit_ident(*field));
+            }
+        }
         TyKind::Typeof(ref expression) => try_visit!(visitor.visit_anon_const(expression)),
         TyKind::InferDelegation(..) | TyKind::Err(_) => {}
         TyKind::Pat(ty, pat) => {

compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs

@@ -2558,6 +2558,9 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                 let length = self.lower_const_arg(length, FeedConstTy::No);
                 Ty::new_array_with_const_len(tcx, self.lower_ty(ty), length)
             }
+            hir::TyKind::FieldOf(container, fields) => {
+                self.lower_field_of(hir_ty, container, fields)
+            }
             hir::TyKind::Typeof(e) => tcx.type_of(e.def_id).instantiate_identity(),
             hir::TyKind::Infer(()) => {
                 // Infer also appears as the type of arguments or return
@@ -2724,6 +2727,24 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         fn_ptr_ty
     }
 
+    fn lower_field_of(
+        &self,
+        hir_ty: &hir::Ty<'tcx>,
+        container: &hir::Ty<'tcx>,
+        fields: &[Ident],
+    ) -> Ty<'tcx> {
+        match self.lower_field_path(
+            container,
+            fields,
+            hir_ty.span,
+            hir_ty.hir_id,
+            FieldPathKind::FieldOf,
+        ) {
+            Ok((container, field_path)) => Ty::new_field_type(self.tcx(), container, field_path),
+            Err(err) => Ty::new_error(self.tcx(), err),
+        }
+    }
+
     /// Given a fn_hir_id for a impl function, suggest the type that is found on the
     /// corresponding function in the trait that the impl implements, if it exists.
     /// If arg_idx is Some, then it corresponds to an input type index, otherwise it

compiler/rustc_hir_pretty/src/lib.rs

@@ -445,6 +445,23 @@ impl<'a> State<'a> {
                 self.print_const_arg(length);
                 self.word("]");
             }
+            hir::TyKind::FieldOf(container, fields) => {
+                self.word("field_of!(");
+                self.print_type(container);
+                self.word(",");
+                self.space();
+
+                if let Some((&first, rest)) = fields.split_first() {
+                    self.print_ident(first);
+
+                    for &field in rest {
+                        self.word(".");
+                        self.print_ident(field);
+                    }
+                }
+
+                self.word(")");
+            }
             hir::TyKind::Typeof(ref e) => {
                 self.word("typeof(");
                 self.print_anon_const(e);

compiler/rustc_passes/src/input_stats.rs

@@ -408,6 +408,7 @@ impl<'v> hir_visit::Visitor<'v> for StatCollector<'v> {
                 OpaqueDef,
                 TraitAscription,
                 TraitObject,
+                FieldOf,
                 Typeof,
                 Infer,
                 Pat,
@@ -683,6 +684,7 @@ impl<'v> ast_visit::Visitor<'v> for StatCollector<'v> {
                 TraitObject,
                 ImplTrait,
                 Paren,
+                FieldOf,
                 Typeof,
                 Infer,
                 ImplicitSelf,

src/tools/clippy/clippy_lints/src/dereference.rs

@@ -818,6 +818,7 @@ impl TyCoercionStability {
                 | TyKind::FnPtr(_)
                 | TyKind::Pat(..)
                 | TyKind::Never
+                | TyKind::FieldOf(..)
                 | TyKind::Tup(_)
                 | TyKind::Path(_) => Self::Deref,
                 TyKind::OpaqueDef(..)

src/tools/clippy/clippy_utils/src/hir_utils.rs

@@ -1306,6 +1306,12 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> {
             TyKind::TraitObject(_, lifetime) => {
                 self.hash_lifetime(lifetime);
             },
+            TyKind::FieldOf(container, fields) => {
+                self.hash_ty(container);
+                for field in *fields {
+                    self.hash_name(field.name);
+                }
+            },
             TyKind::Typeof(anon_const) => {
                 self.hash_body(anon_const.body);
             },