Sema: Basic type-checking of @cdecl on global functions

xymus · xymus · commit 498055c07281 · 2025-04-10T14:39:40.000-07:00
This implements basic checks on the validity of the @cdecl attribute and ensures the parameters and result types are representable in C. Many more diagnostics will need to be updated to verify full representability in C.
diff --git a/include/swift/AST/DiagnosticsSema.def b/include/swift/AST/DiagnosticsSema.def
@@ -2031,11 +2031,11 @@ WARNING(wrap_objc_implementation_will_become_error,none,
         (DiagnosticInfo *))
 
 ERROR(cdecl_not_at_top_level,none,
-      "@_cdecl can only be applied to global functions", ())
+      "%0 can only be applied to global functions", (DeclAttribute))
 ERROR(cdecl_empty_name,none,
-      "@_cdecl symbol name cannot be empty", ())
+      "%0 symbol name cannot be empty", (DeclAttribute))
 ERROR(cdecl_throws,none,
-      "raising errors from @_cdecl functions is not supported", ())
+      "raising errors from %0 functions is not supported", (DeclAttribute))
 ERROR(cdecl_feature_required,none,
       "@cdecl requires '-enable-experimental-feature CDecl'",
       ())
@@ -6489,7 +6489,10 @@ ERROR(objc_cannot_infer_name_raw_identifier,none,
       (const ValueDecl *))
 
 // If you change this, also change enum ObjCReason
-#define OBJC_ATTR_SELECT "select{marked @_cdecl|marked dynamic|marked @objc|marked @objcMembers|marked @IBOutlet|marked @IBAction|marked @IBSegueAction|marked @NSManaged|a member of an @objc protocol|implicitly @objc|an @objc override|an implementation of an @objc requirement|marked @IBInspectable|marked @GKInspectable|in an @objc extension of a class (without @nonobjc)|in an @objc @implementation extension of a class (without final or @nonobjc)|marked @objc by an access note}"
+#define OBJC_ATTR_SELECT "select{marked @cdecl|marked @_cdecl|marked dynamic|marked @objc|marked @objcMembers|marked @IBOutlet|marked @IBAction|marked @IBSegueAction|marked @NSManaged|a member of an @objc protocol|implicitly @objc|an @objc override|an implementation of an @objc requirement|marked @IBInspectable|marked @GKInspectable|in an @objc extension of a class (without @nonobjc)|in an @objc @implementation extension of a class (without final or @nonobjc)|marked @objc by an access note}"
+
+// Keep aligned with enum ForeignLanguage
+#define FOREIGN_LANG_SELECT "select{C|Objective-C}"
 
 ERROR(objc_invalid_on_var,none,
       "property cannot be %" OBJC_ATTR_SELECT "0 "
@@ -6569,17 +6572,21 @@ ERROR(objc_invalid_on_func_variadic,none,
       "method cannot be %" OBJC_ATTR_SELECT "0 because it has a variadic "
       "parameter", (unsigned))
 ERROR(objc_invalid_on_func_inout,none,
-      "method cannot be %" OBJC_ATTR_SELECT "0 because inout "
-      "parameters cannot be represented in Objective-C", (unsigned))
+      "%kindonly0 cannot be %" OBJC_ATTR_SELECT "1 because inout "
+      "parameters cannot be represented in %" FOREIGN_LANG_SELECT "2",
+      (const AbstractFunctionDecl*, unsigned, unsigned))
 ERROR(objc_invalid_on_func_param_type,none,
-      "method cannot be %" OBJC_ATTR_SELECT "1 because the type of the "
-      "parameter %0 cannot be represented in Objective-C", (unsigned, unsigned))
+      "%kindonly0 cannot be %" OBJC_ATTR_SELECT "2 because the type of the "
+      "parameter %1 cannot be represented in %" FOREIGN_LANG_SELECT "3",
+      (const AbstractFunctionDecl*, unsigned, unsigned, unsigned))
 ERROR(objc_invalid_on_func_single_param_type,none,
-      "method cannot be %" OBJC_ATTR_SELECT "0 because the type of the "
-      "parameter cannot be represented in Objective-C", (unsigned))
+      "%kindonly0 cannot be %" OBJC_ATTR_SELECT "1 because the type of the "
+      "parameter cannot be represented in %" FOREIGN_LANG_SELECT "2",
+      (const AbstractFunctionDecl*, unsigned, unsigned))
 ERROR(objc_invalid_on_func_result_type,none,
-      "method cannot be %" OBJC_ATTR_SELECT "0 because its result type "
-      "cannot be represented in Objective-C", (unsigned))
+      "%kindonly0 cannot be %" OBJC_ATTR_SELECT "1 because its result type "
+      "cannot be represented in %" FOREIGN_LANG_SELECT "2",
+      (const AbstractFunctionDecl*, unsigned, unsigned))
 ERROR(objc_invalid_on_foreign_class,none,
       "method cannot be %" OBJC_ATTR_SELECT "0 because Core Foundation "
       "types are not classes in Objective-C", (unsigned))
@@ -6705,6 +6712,7 @@ ERROR(nonobjc_not_allowed,none,
 #undef OBJC_DIAG_SELECT_2
 #undef OBJC_DIAG_SELECT
 #undef OBJC_ATTR_SELECT
+#undef FOREIGN_LANG_SELECT
 
 //------------------------------------------------------------------------------
 // MARK: @exclusivity
diff --git a/lib/Sema/CodeSynthesis.cpp b/lib/Sema/CodeSynthesis.cpp
@@ -637,8 +637,9 @@ configureInheritedDesignatedInitAttributes(ClassDecl *classDecl,
   std::optional<ForeignAsyncConvention> asyncConvention;
   std::optional<ForeignErrorConvention> errorConvention;
   if (superclassCtor->isObjC() &&
-      !isRepresentableInObjC(ctor, ObjCReason::MemberOfObjCSubclass,
-                             asyncConvention, errorConvention))
+      !isRepresentableInLanguage(ctor, ObjCReason::MemberOfObjCSubclass,
+                                 asyncConvention, errorConvention,
+                                 ForeignLanguage::ObjectiveC))
     ctor->getAttrs().add(new (ctx) NonObjCAttr(/*isImplicit=*/true));
 }
 
diff --git a/lib/Sema/TypeCheckAttr.cpp b/lib/Sema/TypeCheckAttr.cpp
@@ -2356,11 +2356,13 @@ static bool canDeclareSymbolName(StringRef symbol, ModuleDecl *fromModule) {
 void AttributeChecker::visitCDeclAttr(CDeclAttr *attr) {
   // Only top-level func decls are currently supported.
   if (D->getDeclContext()->isTypeContext())
-    diagnose(attr->getLocation(), diag::cdecl_not_at_top_level);
+    diagnose(attr->getLocation(), diag::cdecl_not_at_top_level,
+             attr);
 
   // The name must not be empty.
   if (attr->Name.empty())
-    diagnose(attr->getLocation(), diag::cdecl_empty_name);
+    diagnose(attr->getLocation(), diag::cdecl_empty_name,
+             attr);
 
   // The standard library can use @_cdecl to implement runtime functions.
   if (!canDeclareSymbolName(attr->Name, D->getModuleContext())) {
diff --git a/lib/Sema/TypeCheckCaptures.cpp b/lib/Sema/TypeCheckCaptures.cpp
@@ -789,8 +789,10 @@ CaptureInfo CaptureInfoRequest::evaluate(Evaluator &evaluator,
         std::optional<ForeignAsyncConvention> asyncConvention;
         std::optional<ForeignErrorConvention> errorConvention;
         if (!AFD->isObjC() &&
-            isRepresentableInObjC(AFD, ObjCReason::MemberOfObjCMembersClass,
-                                  asyncConvention, errorConvention)) {
+            isRepresentableInLanguage(AFD,
+                                      ObjCReason::MemberOfObjCMembersClass,
+                                      asyncConvention, errorConvention,
+                                      ForeignLanguage::ObjectiveC)) {
           AFD->diagnose(
                    diag::objc_generic_extension_using_type_parameter_try_objc)
             .fixItInsert(AFD->getAttributeInsertionLoc(false), "@objc ");
diff --git a/lib/Sema/TypeCheckDeclObjC.cpp b/lib/Sema/TypeCheckDeclObjC.cpp
@@ -48,6 +48,7 @@ swift::behaviorLimitForObjCReason(ObjCReason reason, ASTContext &ctx) {
     LLVM_FALLTHROUGH;
 
   case ObjCReason::ExplicitlyCDecl:
+  case ObjCReason::ExplicitlyUnderscoreCDecl:
   case ObjCReason::ExplicitlyDynamic:
   case ObjCReason::ExplicitlyObjC:
   case ObjCReason::ExplicitlyObjCMembers:
@@ -81,6 +82,7 @@ swift::behaviorLimitForObjCReason(ObjCReason reason, ASTContext &ctx) {
 unsigned swift::getObjCDiagnosticAttrKind(ObjCReason reason) {
   switch (reason) {
   case ObjCReason::ExplicitlyCDecl:
+  case ObjCReason::ExplicitlyUnderscoreCDecl:
   case ObjCReason::ExplicitlyDynamic:
   case ObjCReason::ExplicitlyObjC:
   case ObjCReason::ExplicitlyObjCMembers:
@@ -132,6 +134,7 @@ void ObjCReason::describe(const Decl *D) const {
 
   case ObjCReason::ExplicitlyObjCByAccessNote:
   case ObjCReason::ExplicitlyCDecl:
+  case ObjCReason::ExplicitlyUnderscoreCDecl:
   case ObjCReason::ExplicitlyDynamic:
   case ObjCReason::ExplicitlyObjC:
   case ObjCReason::ExplicitlyObjCMembers:
@@ -293,18 +296,21 @@ static void diagnoseTypeNotRepresentableInObjC(const DeclContext *DC,
 
 static void diagnoseFunctionParamNotRepresentable(
     const AbstractFunctionDecl *AFD, unsigned NumParams,
-    unsigned ParamIndex, const ParamDecl *P, ObjCReason Reason) {
+    unsigned ParamIndex, const ParamDecl *P, ObjCReason Reason,
+    ForeignLanguage Language) {
   auto behavior = behaviorLimitForObjCReason(Reason, AFD->getASTContext());
 
   if (NumParams == 1) {
     softenIfAccessNote(AFD, Reason.getAttr(),
       AFD->diagnose(diag::objc_invalid_on_func_single_param_type,
-                    getObjCDiagnosticAttrKind(Reason))
+                    AFD, getObjCDiagnosticAttrKind(Reason),
+                    (unsigned)Language)
           .limitBehavior(behavior));
   } else {
     softenIfAccessNote(AFD, Reason.getAttr(),
       AFD->diagnose(diag::objc_invalid_on_func_param_type,
-                    ParamIndex + 1, getObjCDiagnosticAttrKind(Reason))
+                    AFD, ParamIndex + 1, getObjCDiagnosticAttrKind(Reason),
+                    (unsigned)Language)
           .limitBehavior(behavior));
   }
   SourceRange SR;
@@ -321,9 +327,10 @@ static void diagnoseFunctionParamNotRepresentable(
   Reason.describe(AFD);
 }
 
-static bool isParamListRepresentableInObjC(const AbstractFunctionDecl *AFD,
-                                           const ParameterList *PL,
-                                           ObjCReason Reason) {
+static bool isParamListRepresentableInLanguage(const AbstractFunctionDecl *AFD,
+                                               const ParameterList *PL,
+                                               ObjCReason Reason,
+                                               ForeignLanguage Language) {
   // If you change this function, you must add or modify a test in PrintAsClang.
   ASTContext &ctx = AFD->getASTContext();
   auto &diags = ctx.Diags;
@@ -349,7 +356,7 @@ static bool isParamListRepresentableInObjC(const AbstractFunctionDecl *AFD,
     if (param->isInOut()) {
       softenIfAccessNote(AFD, Reason.getAttr(),
         diags.diagnose(param->getStartLoc(), diag::objc_invalid_on_func_inout,
-                       getObjCDiagnosticAttrKind(Reason))
+                       AFD, getObjCDiagnosticAttrKind(Reason), (unsigned)Language)
           .highlight(param->getSourceRange())
           .limitBehavior(behavior));
       Reason.describe(AFD);
@@ -362,11 +369,11 @@ static bool isParamListRepresentableInObjC(const AbstractFunctionDecl *AFD,
 
     if (param->hasAttachedPropertyWrapper()) {
       if (param->getPropertyWrapperBackingPropertyType()->isRepresentableIn(
-          ForeignLanguage::ObjectiveC,
+          Language,
           const_cast<AbstractFunctionDecl *>(AFD)))
         continue;
     } else if (param->getTypeInContext()->isRepresentableIn(
-          ForeignLanguage::ObjectiveC,
+          Language,
           const_cast<AbstractFunctionDecl *>(AFD))) {
       continue;
     }
@@ -387,7 +394,7 @@ static bool isParamListRepresentableInObjC(const AbstractFunctionDecl *AFD,
 
     IsObjC = false;
     diagnoseFunctionParamNotRepresentable(AFD, NumParams, ParamIndex,
-                                          param, Reason);
+                                          param, Reason, Language);
   }
   return IsObjC;
 }
@@ -645,14 +652,16 @@ static bool isValidObjectiveCErrorResultType(DeclContext *dc, Type type) {
   llvm_unreachable("Unhandled ForeignRepresentableKind in switch.");
 }
 
-bool swift::isRepresentableInObjC(
+bool swift::isRepresentableInLanguage(
     const AbstractFunctionDecl *AFD, ObjCReason Reason,
     std::optional<ForeignAsyncConvention> &asyncConvention,
-    std::optional<ForeignErrorConvention> &errorConvention) {
+    std::optional<ForeignErrorConvention> &errorConvention,
+    ForeignLanguage Language) {
   auto abiRole = ABIRoleInfo(AFD);
   if (!abiRole.providesAPI() && abiRole.getCounterpart())
-    return isRepresentableInObjC(abiRole.getCounterpart(), Reason,
-                                 asyncConvention, errorConvention);
+    return isRepresentableInLanguage(abiRole.getCounterpart(), Reason,
+                                     asyncConvention, errorConvention,
+                                     Language);
 
   // Clear out the async and error conventions. They will be added later if
   // needed.
@@ -688,6 +697,7 @@ bool swift::isRepresentableInObjC(
     auto storage = accessor->getStorage();
     bool storageIsObjC = storage->isObjC()
         || Reason == ObjCReason::ExplicitlyCDecl
+        || Reason == ObjCReason::ExplicitlyUnderscoreCDecl
         || Reason == ObjCReason::WitnessToObjC
         || Reason == ObjCReason::MemberOfObjCProtocol;
 
@@ -773,9 +783,10 @@ bool swift::isRepresentableInObjC(
     isSpecialInit = init->isObjCZeroParameterWithLongSelector();
 
   if (!isSpecialInit &&
-      !isParamListRepresentableInObjC(AFD,
-                                      AFD->getParameters(),
-                                      Reason)) {
+      !isParamListRepresentableInLanguage(AFD,
+                                          AFD->getParameters(),
+                                          Reason,
+                                          Language)) {
     return false;
   }
 
@@ -785,11 +796,12 @@ bool swift::isRepresentableInObjC(
         !ResultType->hasError() &&
         !ResultType->isVoid() &&
         !ResultType->isUninhabited() &&
-        !ResultType->isRepresentableIn(ForeignLanguage::ObjectiveC,
+        !ResultType->isRepresentableIn(Language,
                                        const_cast<FuncDecl *>(FD))) {
       softenIfAccessNote(AFD, Reason.getAttr(),
        AFD->diagnose(diag::objc_invalid_on_func_result_type,
-                      getObjCDiagnosticAttrKind(Reason))
+                     FD, getObjCDiagnosticAttrKind(Reason),
+                     (unsigned)Language)
             .limitBehavior(behavior));
       diagnoseTypeNotRepresentableInObjC(FD, ResultType,
                                          FD->getResultTypeSourceRange(),
@@ -842,11 +854,11 @@ bool swift::isRepresentableInObjC(
       completionHandlerParams.push_back(AnyFunctionType::Param(type));
 
       // Make sure that the parameter type is representable in Objective-C.
-      if (!type->isRepresentableIn(
-              ForeignLanguage::ObjectiveC, const_cast<FuncDecl *>(FD))) {
+      if (!type->isRepresentableIn(Language, const_cast<FuncDecl *>(FD))) {
         softenIfAccessNote(AFD, Reason.getAttr(),
           AFD->diagnose(diag::objc_invalid_on_func_result_type,
-                        getObjCDiagnosticAttrKind(Reason))
+                        FD, getObjCDiagnosticAttrKind(Reason),
+                        (unsigned)Language)
               .limitBehavior(behavior));
         diagnoseTypeNotRepresentableInObjC(FD, type,
                                            FD->getResultTypeSourceRange(),
@@ -1260,8 +1272,10 @@ bool swift::canBeRepresentedInObjC(const ValueDecl *decl) {
   if (auto func = dyn_cast<AbstractFunctionDecl>(decl)) {
     std::optional<ForeignAsyncConvention> asyncConvention;
     std::optional<ForeignErrorConvention> errorConvention;
-    return isRepresentableInObjC(func, ObjCReason::MemberOfObjCMembersClass,
-                                 asyncConvention, errorConvention);
+    return isRepresentableInLanguage(func,
+                                     ObjCReason::MemberOfObjCMembersClass,
+                                     asyncConvention, errorConvention,
+                                     ForeignLanguage::ObjectiveC);
   }
 
   if (auto var = dyn_cast<VarDecl>(decl))
@@ -1865,8 +1879,9 @@ bool IsObjCRequest::evaluate(Evaluator &evaluator, ValueDecl *VD) const {
   } else if (isa<DestructorDecl>(VD)) {
     // Destructors need no additional checking.
   } else if (auto func = dyn_cast<AbstractFunctionDecl>(VD)) {
-    if (!isRepresentableInObjC(
-            func, *isObjC, asyncConvention, errorConvention)) {
+    if (!isRepresentableInLanguage(
+            func, *isObjC, asyncConvention, errorConvention,
+            ForeignLanguage::ObjectiveC)) {
       isObjC->setAttrInvalid();
       return false;
     }
@@ -4150,17 +4165,25 @@ TypeCheckCDeclAttributeRequest::evaluate(Evaluator &evaluator,
                                          CDeclAttr *attr) const {
   auto &ctx = FD->getASTContext();
 
+  auto lang = FD->getCDeclKind();
+  assert(lang && "missing @cdecl?");
+  auto kind = lang == ForeignLanguage::ObjectiveC
+                      ? ObjCReason::ExplicitlyUnderscoreCDecl
+                      : ObjCReason::ExplicitlyCDecl;
+  ObjCReason reason(kind, attr);
+
   std::optional<ForeignAsyncConvention> asyncConvention;
   std::optional<ForeignErrorConvention> errorConvention;
-  ObjCReason reason(ObjCReason::ExplicitlyCDecl, attr);
-  if (isRepresentableInObjC(FD, reason, asyncConvention, errorConvention)) {
+  if (isRepresentableInLanguage(FD, reason, asyncConvention, errorConvention,
+                                *lang)) {
     if (FD->hasAsync()) {
       FD->setForeignAsyncConvention(*asyncConvention);
       ctx.Diags.diagnose(attr->getLocation(), diag::attr_decl_async,
                          attr, FD);
     } else if (FD->hasThrows()) {
       FD->setForeignErrorConvention(*errorConvention);
-      ctx.Diags.diagnose(attr->getLocation(), diag::cdecl_throws);
+      ctx.Diags.diagnose(attr->getLocation(), diag::cdecl_throws,
+                         attr);
     }
   } else {
     reason.setAttrInvalid();
diff --git a/lib/Sema/TypeCheckObjC.h b/lib/Sema/TypeCheckObjC.h
@@ -43,6 +43,8 @@ class ObjCReason {
   enum Kind {
     /// Has the '@cdecl' attribute.
     ExplicitlyCDecl,
+    /// Has the '@_cdecl' attribute.
+    ExplicitlyUnderscoreCDecl,
     /// Has the 'dynamic' modifier.
     ExplicitlyDynamic,
     /// Has an explicit '@objc' attribute.
@@ -101,6 +103,7 @@ class ObjCReason {
   static bool requiresAttr(Kind kind) {
     switch (kind) {
     case ExplicitlyCDecl:
+    case ExplicitlyUnderscoreCDecl:
     case ExplicitlyDynamic:
     case ExplicitlyObjC:
     case ExplicitlyObjCMembers:
@@ -183,10 +186,11 @@ unsigned getObjCDiagnosticAttrKind(ObjCReason reason);
 
 /// Determine whether the given function can be represented in Objective-C,
 /// and figure out its foreign error convention (if any).
-bool isRepresentableInObjC(
+bool isRepresentableInLanguage(
     const AbstractFunctionDecl *AFD, ObjCReason Reason,
     std::optional<ForeignAsyncConvention> &asyncConvention,
-    std::optional<ForeignErrorConvention> &errorConvention);
+    std::optional<ForeignErrorConvention> &errorConvention,
+    ForeignLanguage lang);
 
 /// Determine whether the given variable can be represented in Objective-C.
 bool isRepresentableInObjC(const VarDecl *VD, ObjCReason Reason);
diff --git a/test/attr/attr_cdecl_official.swift b/test/attr/attr_cdecl_official.swift
diff --git a/test/attr/attr_cdecl_official_async.swift b/test/attr/attr_cdecl_official_async.swift
diff --git a/test/attr/attr_cdecl_official_with_objc.swift b/test/attr/attr_cdecl_official_with_objc.swift
