Auto merge of #146307 - BennoLossin:field-projections, r=<try>

Add field representing types


try-job: test-various

Author: bors

Cargo.lock

@@ -3431,6 +3431,7 @@ dependencies = [
  "rustc_macros",
  "rustc_serialize",
  "rustc_span",
+ "serde",
  "tracing",
 ]
 
@@ -4250,6 +4251,7 @@ dependencies = [
  "rustc_target",
  "rustc_thread_pool",
  "rustc_type_ir",
+ "serde",
  "smallvec",
  "thin-vec",
  "tracing",

compiler/rustc_abi/Cargo.toml

@@ -15,6 +15,7 @@ rustc_index = { path = "../rustc_index", default-features = false }
 rustc_macros = { path = "../rustc_macros", optional = true }
 rustc_serialize = { path = "../rustc_serialize", optional = true }
 rustc_span = { path = "../rustc_span", optional = true }
+serde = { version = "1.0.125", features = ["derive"] }
 tracing = "0.1"
 # tidy-alphabetical-end
 

compiler/rustc_abi/src/layout/ty.rs

@@ -33,7 +33,7 @@ rustc_index::newtype_index! {
     /// `b` is `FieldIdx(1)` in `VariantIdx(0)`,
     /// `d` is `FieldIdx(1)` in `VariantIdx(1)`, and
     /// `f` is `FieldIdx(1)` in `VariantIdx(0)`.
-    #[derive(HashStable_Generic)]
+    #[derive(HashStable_Generic, serde::Serialize)]
     #[encodable]
     #[orderable]
     pub struct FieldIdx {}
@@ -57,7 +57,7 @@ rustc_index::newtype_index! {
     ///
     /// `struct`s, `tuples`, and `unions`s are considered to have a single variant
     /// with variant index zero, aka [`FIRST_VARIANT`].
-    #[derive(HashStable_Generic)]
+    #[derive(HashStable_Generic, serde::Serialize)]
     #[encodable]
     #[orderable]
     pub struct VariantIdx {

compiler/rustc_ast/src/ast.rs

@@ -2553,6 +2553,11 @@ pub enum TyKind {
     /// Pattern types like `pattern_type!(u32 is 1..=)`, which is the same as `NonZero<u32>`,
     /// just as part of the type system.
     Pat(Box<Ty>, Box<TyPat>),
+    /// A `field_of` expression (e.g., `builtin # field_of(Struct, field)`).
+    ///
+    /// Usually not written directly in user code but indirectly via the macro
+    /// `core::field::field_of!(...)`.
+    FieldOf(Box<Ty>, Option<Ident>, Ident),
     /// Sometimes we need a dummy value when no error has occurred.
     Dummy,
     /// Placeholder for a kind that has failed to be defined.

compiler/rustc_ast/src/util/classify.rs

@@ -298,6 +298,7 @@ fn type_trailing_braced_mac_call(mut ty: &ast::Ty) -> Option<&ast::MacCall> {
             | ast::TyKind::ImplicitSelf
             | ast::TyKind::CVarArgs
             | ast::TyKind::Pat(..)
+            | ast::TyKind::FieldOf(..)
             | ast::TyKind::Dummy
             | ast::TyKind::Err(..) => break None,
         }

compiler/rustc_ast_lowering/src/lib.rs

@@ -1497,6 +1497,14 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             TyKind::Pat(ty, pat) => {
                 hir::TyKind::Pat(self.lower_ty_alloc(ty, itctx), self.lower_ty_pat(pat, ty.span))
             }
+            TyKind::FieldOf(ty, variant, field) => hir::TyKind::FieldOf(
+                self.lower_ty_alloc(ty, itctx),
+                self.arena.alloc(hir::TyFieldPath {
+                    variant: variant.map(|variant| self.lower_ident(variant)),
+                    field: self.lower_ident(*field),
+                }),
+            ),
+
             TyKind::MacCall(_) => {
                 span_bug!(t.span, "`TyKind::MacCall` should have been expanded by now")
             }

compiler/rustc_ast_pretty/src/pprust/state.rs

@@ -1377,6 +1377,23 @@ impl<'a> State<'a> {
                 self.word(" is ");
                 self.print_ty_pat(pat);
             }
+            ast::TyKind::FieldOf(ty, variant, field) => {
+                self.word("builtin # field_of");
+                self.popen();
+                let ib = self.ibox(0);
+                self.print_type(ty);
+                self.word(",");
+                self.space();
+
+                if let Some(variant) = variant {
+                    self.print_ident(*variant);
+                    self.word(".");
+                }
+                self.print_ident(*field);
+
+                self.end(ib);
+                self.pclose();
+            }
         }
         self.end(ib);
     }

compiler/rustc_borrowck/src/lib.rs

@@ -1890,6 +1890,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, '_, 'tcx> {
                     | ty::Str
                     | ty::Array(_, _)
                     | ty::Pat(_, _)
+                    | ty::FRT(..)
                     | ty::Slice(_)
                     | ty::FnDef(_, _)
                     | ty::FnPtr(..)
@@ -1934,6 +1935,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, '_, 'tcx> {
                     | ty::Str
                     | ty::Array(_, _)
                     | ty::Pat(_, _)
+                    | ty::FRT(..)
                     | ty::Slice(_)
                     | ty::RawPtr(_, _)
                     | ty::Ref(_, _, _)

compiler/rustc_codegen_ssa/src/debuginfo/type_names.rs

@@ -216,6 +216,8 @@ fn push_debuginfo_type_name<'tcx>(
                 write!(output, "{:?}", t).unwrap();
             }
         }
+        // FIXME(FRTs): implement debuginfo for field representing types
+        ty::FRT(..) => todo!(),
         ty::Slice(inner_type) => {
             if cpp_like_debuginfo {
                 output.push_str("slice2$<");

compiler/rustc_const_eval/src/const_eval/type_info.rs

@@ -136,6 +136,7 @@ impl<'tcx> InterpCx<'tcx, CompileTimeMachine<'tcx>> {
                             variant
                         }
                         ty::Adt(_, _)
+                        | ty::FRT(_, _)
                         | ty::Foreign(_)
                         | ty::Pat(_, _)
                         | ty::FnDef(..)