Merge pull request #82039 from xymus/cdecl-enum

PrintAsClang: Introduce `@cdecl` enums

Author: xymus

include/swift/AST/DeclAttr.def

@@ -365,7 +365,7 @@ SIMPLE_DECL_ATTR(_show_in_interface, ShowInInterface,
   62)
 
 DECL_ATTR(_cdecl, CDecl,
-  OnFunc | OnAccessor,
+  OnFunc | OnAccessor | OnEnum,
   LongAttribute | UserInaccessible | ABIStableToAdd | ABIStableToRemove | APIStableToAdd | APIStableToRemove | ForbiddenInABIAttr,
   63)
 DECL_ATTR_ALIAS(cdecl, CDecl)

include/swift/AST/DiagnosticsSema.def

@@ -2089,6 +2089,9 @@ ERROR(cdecl_empty_name,none,
       "%0 symbol name cannot be empty", (DeclAttribute))
 ERROR(cdecl_throws,none,
       "raising errors from %0 functions is not supported", (DeclAttribute))
+ERROR(cdecl_incompatible_with_objc,none,
+      "cannot apply both '@cdecl' and '@objc' to %kindonly0",
+      (const Decl *))
 ERROR(cdecl_feature_required,none,
       "'@cdecl' requires '-enable-experimental-feature CDecl'",
       ())
@@ -3771,9 +3774,9 @@ ERROR(enum_with_raw_type_case_with_argument,none,
 NOTE(enum_raw_type_here,none,
      "declared raw type %0 here", (Type))
 ERROR(objc_enum_no_raw_type,none,
-      "'@objc' enum must declare an integer raw type", ())
+      "'%0' enum must declare an integer raw type", (DeclAttribute))
 ERROR(objc_enum_raw_type_not_integer,none,
-      "'@objc' enum raw type %0 is not an integer type", (Type))
+      "'%0' enum raw type %1 is not an integer type", (DeclAttribute, Type))
 ERROR(enum_non_integer_raw_value_auto_increment,none,
       "enum case must declare a raw value when the preceding raw value is not an integer", ())
 ERROR(enum_non_integer_convertible_raw_type_no_value,none,
@@ -6630,6 +6633,10 @@ NOTE(not_objc_swift_struct,none,
      (ForeignLanguage))
 NOTE(not_objc_swift_enum,none,
       "non-'@objc' enums cannot be represented in Objective-C", ())
+NOTE(not_cdecl_or_objc_swift_enum,none,
+     "Swift enums not marked '@cdecl'%select{| or '@objc'}0 cannot be "
+     "represented in %" FOREIGN_LANG_SELECT "0",
+     (ForeignLanguage))
 NOTE(not_objc_generic_type_param,none,
      "generic type parameters cannot be represented in "
      "%" FOREIGN_LANG_SELECT "0", (ForeignLanguage))

include/swift/AST/TypeCheckRequests.h

@@ -4875,9 +4875,9 @@ class TypeCheckObjCImplementationRequest
   bool isCached() const { return true; }
 };
 
-/// Check @cdecl-style attributes for compatibility with the foreign language.
-class TypeCheckCDeclAttributeRequest
-    : public SimpleRequest<TypeCheckCDeclAttributeRequest,
+/// Check @cdecl functions for compatibility with the foreign language.
+class TypeCheckCDeclFunctionRequest
+    : public SimpleRequest<TypeCheckCDeclFunctionRequest,
                            evaluator::SideEffect(FuncDecl *FD,
                                                  CDeclAttr *attr),
                            RequestFlags::Cached> {
@@ -4894,6 +4894,25 @@ class TypeCheckCDeclAttributeRequest
   bool isCached() const { return true; }
 };
 
+/// Check @cdecl enums for compatibility with C.
+class TypeCheckCDeclEnumRequest
+    : public SimpleRequest<TypeCheckCDeclEnumRequest,
+                           evaluator::SideEffect(EnumDecl *ED,
+                                                 CDeclAttr *attr),
+                           RequestFlags::Cached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  evaluator::SideEffect
+  evaluate(Evaluator &evaluator, EnumDecl *ED, CDeclAttr *attr) const;
+
+public:
+  bool isCached() const { return true; }
+};
+
 void simple_display(llvm::raw_ostream &out, ASTNode node);
 void simple_display(llvm::raw_ostream &out, Type value);
 void simple_display(llvm::raw_ostream &out, const TypeRepr *TyR);

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -554,8 +554,11 @@ SWIFT_REQUEST(TypeChecker, IsNonUserModuleRequest,
 SWIFT_REQUEST(TypeChecker, TypeCheckObjCImplementationRequest,
               unsigned(ExtensionDecl *),
               Cached, NoLocationInfo)
-SWIFT_REQUEST(TypeChecker, TypeCheckCDeclAttributeRequest,
-              evaluator::SideEffect(FuncDecl *, CDeclAttr *),
+SWIFT_REQUEST(TypeChecker, TypeCheckCDeclFunctionRequest,
+              evaluator::SideEffect(FunctionDecl *, CDeclAttr *),
+              Cached, NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, TypeCheckCDeclEnumRequest,
+              evaluator::SideEffect(EnumDecl *, CDeclAttr *),
               Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, HasInitAccessorRequest,
               bool(AbstractStorageDecl *), Cached,

include/swift/PrintAsClang/ClangMacros.def

@@ -176,20 +176,46 @@ CLANG_MACRO_CONDITIONAL("SWIFT_ENUM_ATTR", "(_extensibility)", \
                         "__attribute__((enum_extensibility(_extensibility)))")
 
 CLANG_MACRO_BODY("SWIFT_ENUM", \
-    "# define SWIFT_ENUM(_type, _name, _extensibility) " \
+    "# if (defined(__cplusplus) && __cplusplus >= 201103L) || " \
+    "     (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L) || " \
+    "     __has_feature(objc_fixed_enum)\n" \
+    "#  define SWIFT_ENUM(_type, _name, _extensibility) " \
         "enum _name : _type _name; " \
         "enum SWIFT_ENUM_ATTR(_extensibility) SWIFT_ENUM_EXTRA _name : _type\n" \
-    "# if __has_feature(generalized_swift_name)\n" \
-    "#  define SWIFT_ENUM_NAMED(_type, _name, SWIFT_NAME, _extensibility) " \
-        "enum _name : _type _name SWIFT_COMPILE_NAME(SWIFT_NAME); " \
-        "enum SWIFT_COMPILE_NAME(SWIFT_NAME) SWIFT_ENUM_ATTR(_extensibility) " \
-            "SWIFT_ENUM_EXTRA _name : _type\n" \
+    "#  if __has_feature(generalized_swift_name)\n" \
+    "#   define SWIFT_ENUM_NAMED(_type, _name, SWIFT_NAME, _extensibility) " \
+         "enum _name : _type _name SWIFT_COMPILE_NAME(SWIFT_NAME); " \
+         "enum SWIFT_COMPILE_NAME(SWIFT_NAME) SWIFT_ENUM_ATTR(_extensibility) " \
+             "SWIFT_ENUM_EXTRA _name : _type\n" \
+    "#  else\n" \
+    "#   define SWIFT_ENUM_NAMED(_type, _name, SWIFT_NAME, _extensibility) " \
+         "SWIFT_ENUM(_type, _name, _extensibility)\n" \
+    "#  endif\n" \
     "# else\n" \
+    "#  define SWIFT_ENUM(_type, _name, _extensibility) _type _name; enum \n" \
     "#  define SWIFT_ENUM_NAMED(_type, _name, SWIFT_NAME, _extensibility) " \
         "SWIFT_ENUM(_type, _name, _extensibility)\n" \
     "# endif")
 CLANG_MACRO_DEFINED("SWIFT_ENUM_NAMED")
 
+CLANG_MACRO_BODY("SWIFT_ENUM_TAG", \
+    "# if (defined(__cplusplus) && __cplusplus >= 201103L) || " \
+    "     (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L) || " \
+    "     __has_feature(objc_fixed_enum)\n" \
+    "#  define SWIFT_ENUM_TAG enum\n" \
+    "# else\n" \
+    "#  define SWIFT_ENUM_TAG\n" \
+    "# endif")
+
+CLANG_MACRO_BODY("SWIFT_ENUM_FWD_DECL", \
+    "# if (defined(__cplusplus) && __cplusplus >= 201103L) || " \
+    "     (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L) || " \
+    "     __has_feature(objc_fixed_enum)\n" \
+    "#  define SWIFT_ENUM_FWD_DECL(_type, _name) enum _name : _type _name;\n" \
+    "# else\n" \
+    "#  define SWIFT_ENUM_FWD_DECL(_type, _name) _type _name;\n" \
+    "# endif")
+
 CLANG_MACRO("SWIFT_UNAVAILABLE", , "__attribute__((unavailable))")
 CLANG_MACRO("SWIFT_UNAVAILABLE_MSG", "(msg)", "__attribute__((unavailable(msg)))")
 

lib/AST/SwiftNameTranslation.cpp

@@ -16,6 +16,7 @@
 
 #include "swift/AST/SwiftNameTranslation.h"
 #include "swift/AST/ASTContext.h"
+#include "swift/AST/Attr.h"
 #include "swift/AST/Decl.h"
 #include "swift/AST/DiagnosticsSema.h"
 #include "swift/AST/LazyResolver.h"
@@ -48,6 +49,9 @@ getNameForObjC(const ValueDecl *VD, CustomNamesOnly_t customNamesOnly) {
     }
   }
 
+  if (auto cdeclAttr = VD->getAttrs().getAttribute<CDeclAttr>())
+    return cdeclAttr->Name;
+
   if (customNamesOnly)
     return StringRef();
 

lib/AST/Type.cpp

@@ -3096,6 +3096,12 @@ getForeignRepresentable(Type type, ForeignLanguage language,
       // Imported classes and protocols are not representable in C.
       if (isa<ClassDecl>(nominal) || isa<ProtocolDecl>(nominal))
         return failure();
+
+      // @objc enums are not representable in C, @cdecl ones and imported ones
+      // are ok.
+      if (!nominal->hasClangNode())
+        return failure();
+
       LLVM_FALLTHROUGH;
 
     case ForeignLanguage::ObjectiveC:
@@ -3134,6 +3140,11 @@ getForeignRepresentable(Type type, ForeignLanguage language,
     }
   }
 
+  // @cdecl enums are representable in C and Objective-C.
+  if (nominal->getAttrs().getAttribute<CDeclAttr>()) {
+    return { ForeignRepresentableKind::Trivial, nullptr };
+  }
+
   // Pointers may be representable in ObjC.
   PointerTypeKind pointerKind;
   if (auto pointerElt = type->getAnyPointerElementType(pointerKind)) {

lib/PrintAsClang/DeclAndTypePrinter.cpp

@@ -2388,8 +2388,14 @@ class DeclAndTypePrinter::Implementation
   }
 
   void maybePrintTagKeyword(const TypeDecl *NTD) {
-    if (isa<EnumDecl>(NTD) && !NTD->hasClangNode()) {
-      os << "enum ";
+    if (auto *ED = dyn_cast<EnumDecl>(NTD); !NTD->hasClangNode()) {
+      if (ED->getAttrs().hasAttribute<CDeclAttr>()) {
+        // We should be able to use the tag macro for all printed enums but
+        // for now restrict it to @cdecl to guard it behind the feature flag.
+        os << "SWIFT_ENUM_TAG ";
+      } else {
+        os << "enum ";
+      }
       return;
     }
 
@@ -3019,9 +3025,17 @@ bool DeclAndTypePrinter::shouldInclude(const ValueDecl *VD) {
        (outputLang == OutputLanguageMode::C))
     return false;
 
-  // C output mode only accepts @cdecl functions.
+  // C output mode only prints @cdecl functions and enums.
   if (outputLang == OutputLanguageMode::C &&
-      !cdeclKind) {
+      !cdeclKind && !isa<EnumDecl>(VD)) {
+    return false;
+  }
+
+  // The C mode prints @cdecl enums and reject other enums,
+  // while other modes accept other enums and reject @cdecl ones.
+  if (isa<EnumDecl>(VD) &&
+      VD->getAttrs().hasAttribute<CDeclAttr>() !=
+        (outputLang == OutputLanguageMode::C)) {
     return false;
   }
 

lib/PrintAsClang/ModuleContentsWriter.cpp

@@ -457,6 +457,14 @@ class ModuleWriter {
       }
     }
 
+    if (isa<EnumDecl>(D) && !D->hasClangNode() &&
+        outputLangMode != OutputLanguageMode::Cxx) {
+      // We don't want to add an import for a @cdecl or @objc enum declared
+      // in Swift. We either do nothing for special enums like Optional as
+      // done in the prologue here, or we forward declare them.
+      return false;
+    }
+
     imports.insert(otherModule);
     return true;
   }
@@ -530,12 +538,20 @@ class ModuleWriter {
   }
 
   void forwardDeclare(const EnumDecl *ED) {
-    assert(ED->isObjC() || ED->hasClangNode());
+    assert(ED->isObjC() || ED->getAttrs().getAttribute<CDeclAttr>() ||
+           ED->hasClangNode());
 
     forwardDeclare(ED, [&]{
-      os << "enum " << getNameForObjC(ED) << " : ";
-      printer.print(ED->getRawType());
-      os << ";\n";
+      if (ED->getASTContext().LangOpts.hasFeature(Feature::CDecl)) {
+        // Forward declare in a way to be compatible with older C standards.
+        os << "typedef SWIFT_ENUM_FWD_DECL(";
+        printer.print(ED->getRawType());
+        os << ", " << getNameForObjC(ED) << ")\n";
+      } else {
+        os << "enum " << getNameForObjC(ED) << " : ";
+        printer.print(ED->getRawType());
+        os << ";\n";
+      }
     });
   }
 
@@ -604,6 +620,7 @@ class ModuleWriter {
     } else if (addImport(TD)) {
       return;
     } else if (auto ED = dyn_cast<EnumDecl>(TD)) {
+      // Treat this after addImport to filter out special enums from the stdlib.
       forwardDeclare(ED);
     } else if (isa<GenericTypeParamDecl>(TD)) {
       llvm_unreachable("should not see generic parameters here");
@@ -864,7 +881,7 @@ class ModuleWriter {
 
     SmallVector<ProtocolConformance *, 1> conformances;
     auto errorTypeProto = ctx.getProtocol(KnownProtocolKind::Error);
-    if (outputLangMode != OutputLanguageMode::Cxx
+    if (outputLangMode == OutputLanguageMode::ObjC
         && ED->lookupConformance(errorTypeProto, conformances)) {
       bool hasDomainCase = std::any_of(ED->getAllElements().begin(),
                                        ED->getAllElements().end(),

lib/Sema/TypeCheckAttr.cpp

@@ -2398,9 +2398,21 @@ void AttributeChecker::visitCDeclAttr(CDeclAttr *attr) {
                attr->Name);
   }
 
+  // @_cdecl was never accepted on enums. Keep the previous diagnostic.
+  if (isa<EnumDecl>(D) && attr->Underscored) {
+    diagnose(attr->getLocation(), diag::attr_only_one_decl_kind,
+             attr, "func");
+  }
+
+  // Reject using both @cdecl and @objc on the same decl.
+  if (D->getAttrs().getAttribute<ObjCAttr>()) {
+    diagnose(attr->getLocation(), diag::cdecl_incompatible_with_objc, D);
+  }
+
+  // @cdecl needs to be enabled via a feature flag.
   if (!attr->Underscored &&
       !Ctx.LangOpts.hasFeature(Feature::CDecl)) {
-    Ctx.Diags.diagnose(attr->getLocation(), diag::cdecl_feature_required);
+    diagnose(attr->getLocation(), diag::cdecl_feature_required);
   }
 }