gccrs: Support ZST type checking for #[repr(transparent)]

gcc/rust/ChangeLog:

	* typecheck/rust-tyty.h (BaseType::is_zero_sized): New function.
	* typecheck/rust-tyty.cc (BaseType::is_zero_sized): Implement checking of
	whether a type is zero-sized.
	* typecheck/rust-hir-type-check-item.cc (TypeCheckItem::visit (StructStruct)): Update
	transparent repr type-checking to check for zero-sized members.
	* backend/rust-compile-type.cc (TyTyResolveCompile::visit (TyTy::ADTType)): Support
	compilation of transparent repr structs with more than 1 fields.

gcc/testsuite/ChangeLog:

	* rust/compile/repr_transparent_fields.rs: Add new test case with PhantomData.

Signed-Off-By: Yap Zhi Heng <yapzhhg@gmail.com>

Author: Polygonalr

gcc/rust/backend/rust-compile-type.cc

@@ -302,7 +302,6 @@ TyTyResolveCompile::visit (const TyTy::ADTType &type)
       rust_assert (type.number_of_variants () == 1);
       TyTy::VariantDef &variant = *type.get_variants ().at (0);
 
-      rust_assert (variant.num_fields () <= 1);
       if (variant.num_fields () == 0)
 	{
 	  // 0-field transparent repr
@@ -313,13 +312,27 @@ TyTyResolveCompile::visit (const TyTy::ADTType &type)
 	  // For now, treat it as a unit struct
 	  type_record = Backend::struct_type ({});
 	}
-      else
+      else if (variant.num_fields () == 1)
 	{
 	  // single field transparent repr
 	  const TyTy::StructFieldType *field = variant.get_field_at_index (0);
 	  type_record
 	    = TyTyResolveCompile::compile (ctx, field->get_field_type ());
 	}
+      else
+	{
+	  // more than one field - typechecking already ensures there's only one
+	  // non-zero-sized field, just compile accessor for that
+	  // non-zero-sized.
+	  for (size_t i = 0; i < variant.num_fields (); i++)
+	    {
+	      auto field_ty = variant.get_field_at_index (i)->get_field_type ();
+	      if (!field_ty->is_zero_sized ())
+		{
+		  type_record = TyTyResolveCompile::compile (ctx, field_ty);
+		}
+	    }
+	}
     }
 
   // compilation of non-transparent ADTs below

gcc/rust/typecheck/rust-hir-type-check-item.cc

@@ -343,14 +343,6 @@ TypeCheckItem::visit (HIR::StructStruct &struct_decl)
   const AST::AttrVec &attrs = struct_decl.get_outer_attrs ();
   TyTy::ADTType::ReprOptions repr
     = parse_repr_options (attrs, struct_decl.get_locus ());
-  if (repr.repr_kind == TyTy::ADTType::ReprKind::TRANSPARENT
-      && struct_decl.get_fields ().size () > 1)
-    {
-      rust_error_at (struct_decl.get_locus (), ErrorCode::E0690,
-		     "transparent struct needs at most one field with "
-		     "non-trivial size or alignment, but has %lu",
-		     (unsigned long) struct_decl.get_fields ().size ());
-    }
 
   std::vector<TyTy::StructFieldType *> fields;
   for (auto &field : struct_decl.get_fields ())
@@ -373,6 +365,24 @@ TypeCheckItem::visit (HIR::StructStruct &struct_decl)
       context->insert_type (field.get_mappings (), ty_field->get_field_type ());
     }
 
+  if (repr.repr_kind == TyTy::ADTType::ReprKind::TRANSPARENT)
+    {
+      size_t num_non_zst = 0;
+      for (auto &field : fields)
+	{
+	  if (!field->get_field_type ()->is_zero_sized ())
+	    num_non_zst++;
+	}
+      if (num_non_zst > 1)
+	{
+	  rust_error_at (struct_decl.get_locus (), ErrorCode::E0690,
+			 "transparent struct needs at most one field with "
+			 "non-trivial size or alignment, but has %lu",
+			 (unsigned long) struct_decl.get_fields ().size ());
+	  return;
+	}
+    }
+
   auto &nr_ctx = Resolver2_0::FinalizedNameResolutionContext::get ();
 
   CanonicalPath path

gcc/rust/typecheck/rust-tyty.cc

@@ -926,6 +926,94 @@ BaseType::is_concrete () const
   return false;
 }
 
+bool
+BaseType::is_zero_sized () const
+{
+  const TyTy::BaseType *x = destructure ();
+  switch (x->get_kind ())
+    {
+    // primitives that are always non-zero size
+    case FNPTR:
+    case FNDEF:
+    case SLICE:
+    case POINTER:
+    case REF:
+    case CLOSURE:
+    case INFER:
+    case BOOL:
+    case CHAR:
+    case INT:
+    case UINT:
+    case FLOAT:
+    case USIZE:
+    case ISIZE:
+    case OPAQUE:
+    case STR:
+    case DYNAMIC:
+    case CONST:
+    case PARAM:
+    case PROJECTION:
+    case PLACEHOLDER:
+    case ERROR:
+      return false;
+
+    case NEVER:
+      return true;
+    case TUPLE:
+      {
+	const TupleType *tuple_ty = static_cast<const TupleType *> (x);
+	if (tuple_ty->num_fields () == 0)
+	  return true;
+	for (size_t i = 0; i < tuple_ty->num_fields (); i++)
+	  {
+	    if (!tuple_ty->get_field (i)->is_zero_sized ())
+	      return false;
+	  }
+	return true;
+      }
+    case ARRAY:
+      {
+	const ArrayType *array_ty = static_cast<const ArrayType *> (x);
+	auto *capacity_ty = array_ty->get_capacity ();
+	if (capacity_ty != nullptr
+	    && capacity_ty->get_kind () == TyTy::TypeKind::CONST)
+	  {
+	    auto *capacity_const = capacity_ty->as_const_type ();
+	    auto &capacity_value
+	      = *static_cast<TyTy::ConstValueType *> (capacity_const);
+	    auto cap_tree = capacity_value.get_value ();
+	    size_t cap_wi = (size_t) wi::to_wide (cap_tree).to_uhwi ();
+	    if (cap_wi == 0)
+	      {
+		return true;
+	      }
+	  }
+	return false;
+      }
+    case ADT:
+      {
+	const ADTType *adt_ty = static_cast<const ADTType *> (x);
+	auto phantom = Analysis::Mappings::get ().lookup_lang_item (
+	  LangItem::Kind::PHANTOM_DATA);
+	if (phantom.has_value () && phantom.value () == adt_ty->get_id ())
+	  return true;
+
+	for (auto *variant : adt_ty->get_variants ())
+	  {
+	    for (size_t i = 0; i < variant->num_fields (); i++)
+	      {
+		if (!variant->get_field_at_index (i)
+		       ->get_field_type ()
+		       ->is_zero_sized ())
+		  return false;
+	      }
+	  }
+	return true;
+      }
+    }
+  return false;
+}
+
 bool
 BaseType::has_substitutions_defined () const
 {

gcc/rust/typecheck/rust-tyty.h

@@ -256,6 +256,10 @@ class BaseType : public TypeBoundsMappings
   // primitives
   bool is_concrete () const;
 
+  // returns if the type is a zero-sized type, which is a type that occupies no
+  // space in memory
+  bool is_zero_sized () const;
+
   // return the type-kind
   TypeKind get_kind () const;
 

gcc/testsuite/rust/compile/repr_transparent_fields.rs

@@ -1,6 +1,12 @@
-#![feature(no_core)]
+#![feature(no_core, lang_items)]
 #![no_core]
 
+#[lang = "sized"]
+trait Sized {}
+
+#[lang = "phantom_data"]
+pub struct PhantomData<T: ?Sized>;
+
 #[repr(transparent)]
 struct Foo { // { dg-error "transparent struct needs at most one field with non-trivial size or alignment, but has 2" }
     foo: i32,
@@ -14,3 +20,9 @@ struct Bar {}
 struct Baz {
     foo: i32
 }
+
+#[repr(transparent)]
+struct Qux {
+    foo: i32,
+    phantom: PhantomData<i32>,
+}