Sema: Type-check @cdecl enums

@cdecl enums are Swift enums representable in C. These enums must have
an integer raw type. They can be referenced from @cdecl functions and
@objc methods. @objc enums are still rejected from @cdecl functions.

Author: xymus

include/swift/AST/DiagnosticsSema.def

@@ -3758,9 +3758,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,
@@ -6615,6 +6615,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

@@ -4853,9 +4853,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> {
@@ -4872,6 +4872,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

@@ -550,8 +550,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,

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

@@ -3082,6 +3082,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:
@@ -3120,6 +3126,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/Sema/TypeCheckDeclObjC.cpp

@@ -223,9 +223,17 @@ static void diagnoseTypeNotRepresentableInObjC(const DeclContext *DC,
 
   // Special diagnostic for enums.
   if (T->is<EnumType>()) {
-    diags.diagnose(TypeRange.Start, diag::not_objc_swift_enum)
-        .highlight(TypeRange)
-        .limitBehavior(behavior);
+    if (DC->getASTContext().LangOpts.hasFeature(Feature::CDecl)) {
+      // New dialog mentioning @cdecl.
+      diags.diagnose(TypeRange.Start, diag::not_cdecl_or_objc_swift_enum,
+                     language)
+          .highlight(TypeRange)
+          .limitBehavior(behavior);
+    } else {
+      diags.diagnose(TypeRange.Start, diag::not_objc_swift_enum)
+          .highlight(TypeRange)
+          .limitBehavior(behavior);
+    }
     return;
   }
 
@@ -1766,19 +1774,18 @@ static bool isCIntegerType(Type type) {
 }
 
 /// Determine whether the given enum should be @objc.
-static bool isEnumObjC(EnumDecl *enumDecl) {
+static bool isEnumObjC(EnumDecl *enumDecl, DeclAttribute *attr) {
   // FIXME: Use shouldMarkAsObjC once it loses it's TypeChecker argument.
 
-  // If there is no @objc attribute, it's not @objc.
-  auto attr = enumDecl->getAttrs().getAttribute<ObjCAttr>();
+  // If there is no @objc or @cdecl attribute, skip it.
   if (!attr)
     return false;
 
   Type rawType = enumDecl->getRawType();
 
-  // @objc enums must have a raw type.
+  // @objc/@cdecl enums must have a raw type.
   if (!rawType) {
-    enumDecl->diagnose(diag::objc_enum_no_raw_type);
+    enumDecl->diagnose(diag::objc_enum_no_raw_type, attr);
     return false;
   }
 
@@ -1791,7 +1798,7 @@ static bool isEnumObjC(EnumDecl *enumDecl) {
     SourceRange errorRange;
     if (!enumDecl->getInherited().empty())
       errorRange = enumDecl->getInherited().getEntry(0).getSourceRange();
-    enumDecl->diagnose(diag::objc_enum_raw_type_not_integer, rawType)
+    enumDecl->diagnose(diag::objc_enum_raw_type_not_integer, attr, rawType)
       .highlight(errorRange);
     return false;
   }
@@ -1801,7 +1808,8 @@ static bool isEnumObjC(EnumDecl *enumDecl) {
     enumDecl->diagnose(diag::empty_enum_raw_type);
   }
 
-  checkObjCNameValidity(enumDecl, attr);
+  if (auto objcAttr = dyn_cast<ObjCAttr>(attr))
+    checkObjCNameValidity(enumDecl, objcAttr);
   return true;
 }
 
@@ -1842,9 +1850,9 @@ bool IsObjCRequest::evaluate(Evaluator &evaluator, ValueDecl *VD) const {
   } else if (auto enumDecl = dyn_cast<EnumDecl>(VD)) {
     // Enums can be @objc so long as they have a raw type that is representable
     // as an arithmetic type in C.
-    if (isEnumObjC(enumDecl))
-      isObjC = objCReasonForObjCAttr(
-                                 enumDecl->getAttrs().getAttribute<ObjCAttr>());
+    auto attr = enumDecl->getAttrs().getAttribute<ObjCAttr>();
+    if (attr && isEnumObjC(enumDecl, attr))
+      isObjC = objCReasonForObjCAttr(attr);
   } else if (auto enumElement = dyn_cast<EnumElementDecl>(VD)) {
     // Enum elements can be @objc so long as the containing enum is @objc.
     if (enumElement->getParentEnum()->isObjC()) {
@@ -4209,9 +4217,9 @@ evaluate(Evaluator &evaluator, Decl *D) const {
 }
 
 evaluator::SideEffect
-TypeCheckCDeclAttributeRequest::evaluate(Evaluator &evaluator,
-                                         FuncDecl *FD,
-                                         CDeclAttr *attr) const {
+TypeCheckCDeclFunctionRequest::evaluate(Evaluator &evaluator,
+                                        FuncDecl *FD,
+                                        CDeclAttr *attr) const {
   auto &ctx = FD->getASTContext();
 
   auto lang = FD->getCDeclKind();
@@ -4236,6 +4244,14 @@ TypeCheckCDeclAttributeRequest::evaluate(Evaluator &evaluator,
   } else {
     reason.setAttrInvalid();
   }
+  return {};
+}
 
+evaluator::SideEffect
+TypeCheckCDeclEnumRequest::evaluate(Evaluator &evaluator,
+                                    EnumDecl *ED,
+                                    CDeclAttr *attr) const {
+  // Apply @objc's logic.
+  isEnumObjC(ED, attr);
   return {};
 }

lib/Sema/TypeCheckDeclPrimary.cpp

@@ -3280,6 +3280,13 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
       }
     }
 
+    // If the enum is exported to C, it must be representable in C.
+    if (auto CDeclAttr = ED->getAttrs().getAttribute<swift::CDeclAttr>()) {
+      evaluateOrDefault(Ctx.evaluator,
+                        TypeCheckCDeclEnumRequest{ED, CDeclAttr},
+                        {});
+    }
+
     // -----
     // NonCopyableChecks
     //
@@ -3813,7 +3820,7 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
     // If the function is exported to C, it must be representable in (Obj-)C.
     if (auto CDeclAttr = FD->getAttrs().getAttribute<swift::CDeclAttr>()) {
       evaluateOrDefault(Ctx.evaluator,
-                        TypeCheckCDeclAttributeRequest{FD, CDeclAttr},
+                        TypeCheckCDeclFunctionRequest{FD, CDeclAttr},
                         {});
     }
 

test/attr/attr_cdecl.swift

@@ -25,7 +25,7 @@ enum SwiftEnum { case A, B }
 #endif
 
 @_cdecl("enum") // expected-error {{@_cdecl may only be used on 'func' declarations}}
-enum UnderscoreCDeclEnum: Int { case A, B }
+enum UnderscoreCDeclEnum: CInt { case A, B }
 
 @_cdecl("swiftStruct")
 func swiftStruct(x: SwiftStruct) {} // expected-error{{cannot be represented}} expected-note{{Swift struct}}

test/attr/attr_cdecl_official.swift

@@ -27,26 +27,35 @@ func noBody(x: inout Int) { } // expected-error{{global function cannot be marke
 
 struct SwiftStruct { var x, y: Int }
 enum SwiftEnum { case A, B }
+
 #if os(Windows) && (arch(x86_64) || arch(arm64))
-@objc enum CEnum: Int32 { case A, B }
+@cdecl("CEnum") enum CEnum: Int32 { case A, B }
 #else
-@objc enum CEnum: Int { case A, B }
+@cdecl("CEnum") enum CEnum: Int { case A, B }
 #endif
 
+@cdecl("CEnumNoRawType") enum CEnumNoRawType { case A, B }
+// expected-error @-1 {{'@cdecl' enum must declare an integer raw type}}
+
+@cdecl("CEnumStringRawType") enum CEnumStringRawType: String { case A, B }
+// expected-error @-1 {{'@cdecl' enum raw type 'String' is not an integer type}}
+
 @cdecl("swiftStruct")
 func swiftStruct(x: SwiftStruct) {}
 // expected-error @-1 {{global function cannot be marked '@cdecl' because the type of the parameter cannot be represented in C}}
 // expected-note @-2 {{Swift structs cannot be represented in C}}
 
 @cdecl("swiftEnum")
-func swiftEnum(x: SwiftEnum) {} // expected-error{{cannot be represented}} expected-note{{non-'@objc' enum}}
+func swiftEnum(x: SwiftEnum) {}
+// expected-error @-1 {{global function cannot be marked '@cdecl' because the type of the parameter cannot be represented in C}}
+// expected-note @-2 {{Swift enums not marked '@cdecl' cannot be represented in C}}
 
 @cdecl("cEnum")
 func cEnum(x: CEnum) {}
 
 @cdecl("CDeclAndObjC") // expected-error {{cannot apply both '@cdecl' and '@objc' to enum}}
 @objc
-enum CDeclAndObjC: Int { case A, B }
+enum CDeclAndObjC: CInt { case A, B }
 
 @cdecl("TwoCDecls") // expected-note {{attribute already specified here}}
 @_cdecl("TwoCDecls") // expected-error {{duplicate attribute}}

test/attr/attr_cdecl_official_with_objc.swift

@@ -24,3 +24,19 @@ protocol ObjCProtocol {}
 @cdecl("objcProtocol") func objcProtocol(a: ObjCProtocol) { }
 // expected-error @-1 {{global function cannot be marked '@cdecl' because the type of the parameter cannot be represented in C}}
 // expected-note @-2 {{protocols cannot be represented in C}}
+
+@objc
+enum ObjCEnum: Int { case A, B }
+@cdecl("objcEnumUseInCDecl") func objcEnumUseInCDecl(a: ObjCEnum) { }
+// expected-error @-1 {{global function cannot be marked '@cdecl' because the type of the parameter cannot be represented in C}}
+// expected-note @-2 {{Swift enums not marked '@cdecl' cannot be represented in C}}
+
+/// Objective-C accepts @cdecl enums.
+@cdecl("CEnum")
+enum CEnum: Int { case A, B }
+@_cdecl("cdeclEnumUseInObjc") func cdeclEnumUseInObjc(a: CEnum) { }
+
+enum SwiftEnum { case A, B }
+@_cdecl("swiftEnumUseInObjc") func swiftEnumUseInObjc(a: SwiftEnum) { }
+// expected-error @-1 {{global function cannot be marked '@_cdecl' because the type of the parameter cannot be represented in Objective-C}}
+// expected-note @-2 {{Swift enums not marked '@cdecl' or '@objc' cannot be represented in Objective-C}}