printing ty::Field

Author: BennoLossin

compiler/rustc_codegen_ssa/src/debuginfo/type_names.rs

@@ -119,6 +119,19 @@ fn push_debuginfo_type_name<'tcx>(
                 push_generic_params_internal(tcx, args, output, visited);
             }
         }
+        ty::Field(container, field_path) => {
+            output.push_str("field_of!(");
+            push_debuginfo_type_name(tcx, container, qualified, output, visited);
+            output.push_str(", ");
+            field_path.walk(tcx, container, |_, name, _, last| {
+                output.push_str(name.as_str());
+                if !last {
+                    output.push('.');
+                }
+                std::ops::ControlFlow::<()>::Continue(())
+            });
+            output.push(')');
+        }
         ty::Tuple(component_types) => {
             if cpp_like_debuginfo {
                 output.push_str("tuple$<");

compiler/rustc_middle/src/ty/error.rs

@@ -180,6 +180,7 @@ impl<'tcx> Ty<'tcx> {
             | ty::Float(_)
             | ty::Str
             | ty::Never => "type".into(),
+            ty::Field(..) => "field representing type".into(),
             ty::Tuple(tys) if tys.is_empty() => "unit type".into(),
             ty::Adt(def, _) => def.descr().into(),
             ty::Foreign(_) => "extern type".into(),

compiler/rustc_middle/src/ty/print/mod.rs

@@ -289,6 +289,7 @@ fn characteristic_def_id_of_type_cached<'a>(
 ) -> Option<DefId> {
     match *ty.kind() {
         ty::Adt(adt_def, _) => Some(adt_def.did()),
+        ty::Field(ty, _) => characteristic_def_id_of_type_cached(ty, visited),
 
         ty::Dynamic(data, ..) => data.principal_def_id(),
 

compiler/rustc_middle/src/ty/print/pretty.rs

@@ -1,7 +1,7 @@
 use std::cell::Cell;
 use std::fmt::{self, Write as _};
 use std::iter;
-use std::ops::{Deref, DerefMut};
+use std::ops::{ControlFlow, Deref, DerefMut};
 
 use rustc_abi::{ExternAbi, Size};
 use rustc_apfloat::Float;
@@ -784,6 +784,28 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
                 },
             },
             ty::Adt(def, args) => self.print_def_path(def.did(), args)?,
+            ty::Field(container, field_path) => {
+                write!(self, "field_of!(")?;
+                self.pretty_print_type(container)?;
+                write!(self, ", ")?;
+                field_path
+                    .walk(self.tcx(), container, |_, name, _, last| {
+                        match write!(self, "{name}") {
+                            Err(err) => ControlFlow::Break(Err(err)),
+                            Ok(()) => ControlFlow::Continue(()),
+                        }?;
+                        if !last {
+                            match write!(self, ".") {
+                                Err(err) => ControlFlow::Break(Err(err)),
+                                Ok(()) => ControlFlow::Continue(()),
+                            }
+                        } else {
+                            ControlFlow::Continue(())
+                        }
+                    })
+                    .unwrap_or(Ok(()))?;
+                write!(self, ")")?;
+            }
             ty::Dynamic(data, r, repr) => {
                 let print_r = self.should_print_optional_region(r);
                 if print_r {

compiler/rustc_type_ir/src/ty_kind.rs

@@ -360,6 +360,7 @@ impl<I: Interner> fmt::Debug for TyKind<I> {
 
                 write!(f, ">")
             }
+            Field(ty, field_path) => write!(f, "{ty:?}.{field_path:?}"),
             Foreign(d) => f.debug_tuple("Foreign").field(d).finish(),
             Str => write!(f, "str"),
             Array(t, c) => write!(f, "[{t:?}; {c:?}]"),