partial enum & union support

Author: BennoLossin

compiler/rustc_hir_typeck/src/fn_ctxt/mod.rs

@@ -288,21 +288,24 @@ impl<'tcx> HirTyLowerer<'tcx> for FnCtxt<'_, 'tcx> {
             let container = self.structurally_resolve_type(span, current_container);
 
             match container.kind() {
-                ty::Adt(container_def, args)
-                    if container_def.is_enum() && field_path_kind == FieldPathKind::OffsetOf =>
-                {
+                ty::Adt(container_def, args) if container_def.is_enum() => {
                     let block = self.tcx.local_def_id_to_hir_id(self.body_id);
                     let (ident, _def_scope) =
                         self.tcx.adjust_ident_and_get_scope(field, container_def.did(), block);
 
-                    if !self.tcx.features().offset_of_enum() {
-                        rustc_session::parse::feature_err(
-                            &self.tcx.sess,
-                            sym::offset_of_enum,
-                            ident.span,
-                            "using enums in offset_of is experimental",
-                        )
-                        .emit();
+                    match field_path_kind {
+                        FieldPathKind::OffsetOf => {
+                            if !self.tcx.features().offset_of_enum() {
+                                rustc_session::parse::feature_err(
+                                    &self.tcx.sess,
+                                    sym::offset_of_enum,
+                                    ident.span,
+                                    "using enums in offset_of is experimental",
+                                )
+                                .emit();
+                            }
+                        }
+                        FieldPathKind::FieldOf => {}
                     }
 
                     let Some((index, variant)) = container_def

library/std/tests/field-projections-basic.rs

@@ -11,7 +11,10 @@ pub struct Foo {
     pub z: (usize, usize),
 }
 
-pub fn project_ref<F: Field>(r: &F::Base) -> &F::Type
+/// # Safety
+///
+/// All container types of `F` must be structs or tuples.
+pub unsafe fn project_ref<F: Field>(r: &F::Base) -> &F::Type
 where
     F::Type: Sized,
 {
@@ -21,10 +24,10 @@ where
 #[test]
 fn foo() {
     let foo = Foo { x: 42, y: 24, z: (43, 44) };
-    let x = project_ref::<field_of!(Foo, x)>(&foo);
-    let y = project_ref::<field_of!(Foo, y)>(&foo);
-    let z0 = project_ref::<field_of!(Foo, z.0)>(&foo);
-    let z1 = project_ref::<field_of!(Foo, z.1)>(&foo);
+    let x = unsafe { project_ref::<field_of!(Foo, x)>(&foo) };
+    let y = unsafe { project_ref::<field_of!(Foo, y)>(&foo) };
+    let z0 = unsafe { project_ref::<field_of!(Foo, z.0)>(&foo) };
+    let z1 = unsafe { project_ref::<field_of!(Foo, z.1)>(&foo) };
     assert_eq!(*x, 42);
     assert_eq!(*y, 24);
     assert_eq!(<field_of!(Foo, x)>::OFFSET, offset_of!(Foo, x));

tests/ui/field_projections/enum.rs

@@ -0,0 +1,13 @@
+//@ run-fail
+#![allow(incomplete_features)]
+#![feature(field_projections)]
+
+use std::field::{UnalignedField, field_of};
+
+pub enum Foo {
+    A { a: isize, b: usize },
+}
+
+fn main() {
+    assert_eq!(<field_of!(Foo, A.a)>::OFFSET, <field_of!(Foo, A.b)>::OFFSET);
+}

tests/ui/field_projections/union.rs

@@ -0,0 +1,16 @@
+//@ run-pass
+#![allow(incomplete_features, dead_code)]
+#![feature(field_projections)]
+
+use std::field::{UnalignedField, field_of};
+
+pub union Foo {
+    a: isize,
+    b: usize,
+}
+
+type X = field_of!(Foo, a);
+
+fn main() {
+    assert_eq!(X::OFFSET, <field_of!(Foo, b)>::OFFSET);
+}