[cxx-interop] Mark some zero-sized value types as unavailable

Currently, we do not support exporting zero-sized value types from Swift
to C++. It needs some work on our end as these types are not part of the
lowered signature. In the meantime, this PR makes sure that common (but
not all) zero sized types are properly marked as unavailable. This is
important as the proper diagnostic will give users a hint how to work
around this problem. Moreover, it is really easy to hit this when
someone is experimenting with interop, so it is important to not have a
cryptic failure mode.

rdar://138122545

Author: Gabor Horvath

include/swift/AST/DiagnosticsSema.def

@@ -2086,6 +2086,8 @@ ERROR(unexposed_other_decl_in_cxx,none,
       "%kind0 is not yet exposed to C++", (ValueDecl *))
 ERROR(unsupported_other_decl_in_cxx,none,
       "Swift %kind0 cannot be represented in C++", (ValueDecl *))
+ERROR(expose_zero_size_to_cxx,none,
+      "%0 is a zero sized value type, it cannot be exposed to C++ yet", (ValueDecl *))
 
 ERROR(attr_methods_only,none,
       "only methods can be declared %0", (DeclAttribute))

include/swift/AST/SwiftNameTranslation.h

@@ -14,8 +14,10 @@
 #define SWIFT_NAME_TRANSLATION_H
 
 #include "swift/AST/AttrKind.h"
+#include "swift/AST/Decl.h"
 #include "swift/AST/DiagnosticEngine.h"
 #include "swift/AST/Identifier.h"
+#include <optional>
 
 namespace swift {
 
@@ -84,6 +86,7 @@ enum RepresentationError {
   UnrepresentableMoveOnly,
   UnrepresentableNested,
   UnrepresentableMacro,
+  UnrepresentableZeroSizedValueType,
 };
 
 /// Constructs a diagnostic that describes the given C++ representation error.
@@ -99,11 +102,15 @@ struct DeclRepresentation {
 };
 
 /// Returns the C++ representation info for the given declaration.
-DeclRepresentation getDeclRepresentation(const ValueDecl *VD);
+DeclRepresentation getDeclRepresentation(
+    const ValueDecl *VD,
+    std::optional<std::function<bool(const NominalTypeDecl *)>> isZeroSized);
 
 /// Returns true if the given value decl is exposable to C++.
-inline bool isExposableToCxx(const ValueDecl *VD) {
-  return !getDeclRepresentation(VD).isUnsupported();
+inline bool isExposableToCxx(
+    const ValueDecl *VD,
+    std::optional<std::function<bool(const NominalTypeDecl *)>> isZeroSized) {
+  return !getDeclRepresentation(VD, isZeroSized).isUnsupported();
 }
 
 /// Returns true if the given value decl D is visible to C++ of its

lib/AST/SwiftNameTranslation.cpp

@@ -21,6 +21,8 @@
 #include "swift/AST/LazyResolver.h"
 #include "swift/AST/Module.h"
 #include "swift/AST/ParameterList.h"
+#include "swift/AST/Type.h"
+#include "swift/AST/Types.h"
 #include "swift/Basic/Assertions.h"
 #include "swift/Basic/StringExtras.h"
 
@@ -212,7 +214,9 @@ swift::cxx_translation::getNameForCxx(const ValueDecl *VD,
 }
 
 swift::cxx_translation::DeclRepresentation
-swift::cxx_translation::getDeclRepresentation(const ValueDecl *VD) {
+swift::cxx_translation::getDeclRepresentation(
+    const ValueDecl *VD,
+    std::optional<std::function<bool(const NominalTypeDecl *)>> isZeroSized) {
   if (getActorIsolation(const_cast<ValueDecl *>(VD)).isActorIsolated())
     return {Unsupported, UnrepresentableIsolatedInActor};
   if (isa<MacroDecl>(VD))
@@ -253,6 +257,8 @@ swift::cxx_translation::getDeclRepresentation(const ValueDecl *VD) {
         isa_and_nonnull<NominalTypeDecl>(
             typeDecl->getDeclContext()->getAsDecl()))
       return {Unsupported, UnrepresentableNested};
+    if (!isa<ClassDecl>(typeDecl) && isZeroSized && (*isZeroSized)(typeDecl))
+      return {Unsupported, UnrepresentableZeroSizedValueType};
   }
   if (const auto *varDecl = dyn_cast<VarDecl>(VD)) {
     // Check if any property accessor throws, do not expose it in that case.
@@ -393,5 +399,7 @@ swift::cxx_translation::diagnoseRepresenationError(RepresentationError error,
     return Diagnostic(diag::expose_nested_type_to_cxx, vd);
   case UnrepresentableMacro:
     return Diagnostic(diag::expose_macro_to_cxx, vd);
+  case UnrepresentableZeroSizedValueType:
+    return Diagnostic(diag::expose_zero_size_to_cxx, vd);
   }
 }

lib/PrintAsClang/DeclAndTypePrinter.cpp

@@ -2958,7 +2958,9 @@ bool DeclAndTypePrinter::shouldInclude(const ValueDecl *VD) {
   if (outputLang == OutputLanguageMode::Cxx) {
     if (!isExposedToThisModule(M, VD, exposedModules))
       return false;
-    if (!cxx_translation::isExposableToCxx(VD))
+    if (!cxx_translation::isExposableToCxx(
+            VD,
+            [this](const NominalTypeDecl *decl) { return isZeroSized(decl); }))
       return false;
     if (!isEnumExposableToCxx(VD, *this))
       return false;
@@ -2976,6 +2978,16 @@ bool DeclAndTypePrinter::shouldInclude(const ValueDecl *VD) {
   return true;
 }
 
+bool DeclAndTypePrinter::isZeroSized(const NominalTypeDecl *decl) {
+  if (decl->isResilient())
+    return false;
+  auto &abiDetails = interopContext.getIrABIDetails();
+  auto sizeAndAlignment = abiDetails.getTypeSizeAlignment(decl);
+  if (sizeAndAlignment)
+    return sizeAndAlignment->size == 0;
+  return false;
+}
+
 bool DeclAndTypePrinter::isVisible(const ValueDecl *vd) const {
   return outputLang == OutputLanguageMode::Cxx
              ? cxx_translation::isVisibleToCxx(vd, minRequiredAccess)

lib/PrintAsClang/DeclAndTypePrinter.h

@@ -118,6 +118,8 @@ class DeclAndTypePrinter {
   /// the options the printer was constructed with.
   bool shouldInclude(const ValueDecl *VD);
 
+  bool isZeroSized(const NominalTypeDecl *decl);
+
   /// Returns true if \p vd is visible given the current access level and thus
   /// can be included in the generated header.
   bool isVisible(const ValueDecl *vd) const;

lib/PrintAsClang/ModuleContentsWriter.cpp

@@ -952,7 +952,10 @@ class ModuleWriter {
 
       // Emit an unavailable stub for a Swift type.
       if (auto *nmtd = dyn_cast<NominalTypeDecl>(vd)) {
-        auto representation = cxx_translation::getDeclRepresentation(vd);
+        auto representation = cxx_translation::getDeclRepresentation(
+            vd, [this](const NominalTypeDecl *decl) {
+              return printer.isZeroSized(decl);
+            });
         if (nmtd->isGeneric()) {
           auto genericSignature =
               nmtd->getGenericSignature().getCanonicalSignature();

lib/PrintAsClang/PrintClangValueType.cpp

@@ -208,6 +208,8 @@ void ClangValueTypePrinter::printValueTypeDecl(
     // e.g. it has resilient fields.
     if (typeSizeAlign && typeSizeAlign->size == 0) {
       // FIXME: How to represent 0 sized structs?
+      declAndTypePrinter.getCxxDeclEmissionScope()
+          .additionalUnrepresentableDeclarations.push_back(typeDecl);
       return;
     }
   }

lib/Sema/TypeCheckAttr.cpp

@@ -50,6 +50,7 @@
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/Debug.h"
+#include <optional>
 
 using namespace swift;
 
@@ -2321,7 +2322,7 @@ void AttributeChecker::visitExposeAttr(ExposeAttr *attr) {
     }
 
     // Verify that the declaration is exposable.
-    auto repr = cxx_translation::getDeclRepresentation(VD);
+    auto repr = cxx_translation::getDeclRepresentation(VD, std::nullopt);
     if (repr.isUnsupported())
       diagnose(attr->getLocation(),
                cxx_translation::diagnoseRepresenationError(*repr.error, VD));

test/Interop/SwiftToCxx/structs/zero-sized-struct-in-cxx.swift

@@ -8,4 +8,45 @@
 
 public struct ZeroSizedStruct {}
 
+public struct ZeroSizedStruct2 {
+    var property: ZeroSizedStruct
+    var void: Void
+    var bar: ()
+    public init() {
+        property = .init()
+    }
+}
+
+public enum ZeroSizedEnum {
+}
+
+public enum ZeroSizedEnum2 {
+    case foo
+}
+
+public enum ZeroSizedEnum3 {
+    case foo(ZeroSizedStruct, ZeroSizedEnum, ZeroSizedStruct2)
+}
+
+public func f() -> ZeroSizedStruct {
+    ZeroSizedStruct()
+}
+
+public func g(x: ZeroSizedStruct) {
+}
+
+// CHECK: class ZeroSizedEnum { } SWIFT_UNAVAILABLE_MSG("'ZeroSizedEnum' is a zero sized value type, it cannot be exposed to C++ yet");
+
+// CHECK: class ZeroSizedEnum2 { } SWIFT_UNAVAILABLE_MSG("'ZeroSizedEnum2' is a zero sized value type, it cannot be exposed to C++ yet");
+
+// CHECK: class ZeroSizedEnum3 { } SWIFT_UNAVAILABLE_MSG("'ZeroSizedEnum3' is a zero sized value type, it cannot be exposed to C++ yet");
+
+// CHECK: class ZeroSizedStruct { } SWIFT_UNAVAILABLE_MSG("'ZeroSizedStruct' is a zero sized value type, it cannot be exposed to C++ yet");
+
+// CHECK: class ZeroSizedStruct2 { } SWIFT_UNAVAILABLE_MSG("'ZeroSizedStruct2' is a zero sized value type, it cannot be exposed to C++ yet");
+
+// CHECK: // Unavailable in C++: Swift global function 'f()'.
+
+// CHECK: // Unavailable in C++: Swift global function 'g(x:)'.
+
 // CHECK: } // namespace Structs