Merge pull request #69207 from kateinoigakukun/yt/cdecl-without-body

Introduce `@extern(c)` to declare C function without Clang module

Author: kateinoigakukun

docs/ReferenceGuides/UnderscoredAttributes.md

@@ -437,18 +437,34 @@ the export name.
 
 It's the equivalent of clang's `__attribute__((export_name))`.
 
-## `@_extern(<language>)`
+## `@extern(<language>)`
 
 Indicates that a particular declaration should be imported
 from the external environment.
 
-### `@_extern(wasm, module: <"moduleName">, name: <"fieldName">)`
+### `@extern(wasm, module: <"moduleName">, name: <"fieldName">)`
 
 Indicates that a particular declaration should be imported
 through WebAssembly's import interface.
 
 It's the equivalent of clang's `__attribute__((import_module("module"), import_name("field")))`.
 
+### `@extern(c, [, <"cName">])`
+
+Indicates that a particular declaration should refer to a
+C declaration with the given name. If the optional "cName"
+string is not specified, the Swift function name is used
+without Swift name mangling. Platform-specific mangling
+rules (leading underscore on Darwin) are still applied.
+
+Similar to `@_cdecl`, but this attribute is used to reference
+C declarations from Swift, while `@_cdecl` is used to define
+Swift functions that can be referenced from C.
+
+Also similar to `@_silgen_name`, but a function declared with
+`@extern(c)` is assumed to use the C ABI, while `@_silgen_name`
+assumes the Swift ABI.
+
 ## `@_fixed_layout`
 
 Same as `@frozen` but also works for classes.

include/swift/AST/Attr.def

@@ -421,8 +421,8 @@ DECL_ATTR(_section, Section,
 DECL_ATTR(_rawLayout, RawLayout,
   OnStruct | UserInaccessible | ABIBreakingToAdd | ABIBreakingToRemove | APIStableToAdd | APIStableToRemove,
   146)
-DECL_ATTR(_extern, Extern,
-  OnFunc | ABIStableToAdd | ABIBreakingToRemove | APIStableToAdd | APIStableToRemove,
+DECL_ATTR(extern, Extern,
+  OnFunc | AllowMultipleAttributes | ABIBreakingToAdd | ABIBreakingToRemove | APIStableToAdd | APIStableToRemove,
   147)
 SIMPLE_DECL_ATTR(_nonEscapable, NonEscapable,
   OnNominalType | UserInaccessible | ABIBreakingToAdd | ABIStableToRemove | APIBreakingToAdd | APIStableToRemove,

include/swift/AST/Attr.h

@@ -176,6 +176,10 @@ class DeclAttribute : public AttributeBase {
       kind : NumExposureKindBits
     );
 
+    SWIFT_INLINE_BITFIELD(ExternAttr, DeclAttribute, NumExternKindBits,
+      kind : NumExternKindBits
+    );
+
     SWIFT_INLINE_BITFIELD(SynthesizedProtocolAttr, DeclAttribute, 1,
       isUnchecked : 1
     );
@@ -2335,22 +2339,48 @@ class ExposeAttr : public DeclAttribute {
   }
 };
 
-/// Define the `@_extern` attribute, used to import external declarations in
+/// Define the `@extern` attribute, used to import external declarations in
 /// the specified way to interoperate with Swift.
 class ExternAttr : public DeclAttribute {
+  SourceLoc LParenLoc, RParenLoc;
+
 public:
-  ExternAttr(StringRef ModuleName, StringRef Name, SourceLoc AtLoc, SourceRange Range, bool Implicit)
-    : DeclAttribute(DAK_Extern, AtLoc, Range, Implicit),
-      ModuleName(ModuleName), Name(Name) {}
+  ExternAttr(llvm::Optional<StringRef> ModuleName,
+             llvm::Optional<StringRef> Name, SourceLoc AtLoc,
+             SourceLoc LParenLoc, SourceLoc RParenLoc, SourceRange Range,
+             ExternKind Kind, bool Implicit)
+      : DeclAttribute(DAK_Extern, AtLoc, Range, Implicit), LParenLoc(LParenLoc),
+        RParenLoc(RParenLoc), ModuleName(ModuleName), Name(Name) {
+    Bits.ExternAttr.kind = static_cast<unsigned>(Kind);
+  }
 
-  ExternAttr(StringRef ModuleName, StringRef Name, bool Implicit)
-    : ExternAttr(ModuleName, Name, SourceLoc(), SourceRange(), Implicit) {}
+  ExternAttr(llvm::Optional<StringRef> ModuleName,
+             llvm::Optional<StringRef> Name, ExternKind Kind, bool Implicit)
+      : ExternAttr(ModuleName, Name, SourceLoc(), SourceLoc(), SourceLoc(),
+                   SourceRange(), Kind, Implicit) {}
 
   /// The module name to import the named declaration in it
-  const StringRef ModuleName;
+  /// Used for Wasm import declaration.
+  const llvm::Optional<StringRef> ModuleName;
 
   /// The declaration name to import
-  const StringRef Name;
+  /// std::nullopt if the declaration name is not specified with @extern(c)
+  const llvm::Optional<StringRef> Name;
+
+  SourceLoc getLParenLoc() const { return LParenLoc; }
+  SourceLoc getRParenLoc() const { return RParenLoc; }
+
+  /// Returns the kind of extern.
+  ExternKind getExternKind() const {
+    return static_cast<ExternKind>(Bits.ExternAttr.kind);
+  }
+
+  /// Returns the C name of the given declaration.
+  /// \p forDecl is the func decl that the attribute belongs to.
+  StringRef getCName(const FuncDecl *forDecl) const;
+
+  /// Find an ExternAttr with the given kind in the given DeclAttributes.
+  static ExternAttr *find(DeclAttributes &attrs, ExternKind kind);
 
   static bool classof(const DeclAttribute *DA) {
     return DA->getKind() == DAK_Extern;

include/swift/AST/AttrKind.h

@@ -112,6 +112,24 @@ enum class ExposureKind: uint8_t {
 enum : unsigned { NumExposureKindBits =
   countBitsUsed(static_cast<unsigned>(ExposureKind::Last_ExposureKind)) };
 
+/// This enum represents the possible values of the @extern attribute.
+enum class ExternKind: uint8_t {
+  /// Reference an externally defined C function.
+  /// The imported function has C function pointer representation,
+  /// and is called using the C calling convention.
+  C,
+  /// Reference an externally defined function through WebAssembly's
+  /// import mechanism.
+  /// This does not specify the calling convention and can be used
+  /// with other extern kinds together.
+  /// Effectively, this is no-op on non-WebAssembly targets.
+  Wasm,
+  Last_ExternKind = Wasm
+};
+
+enum : unsigned { NumExternKindBits =
+  countBitsUsed(static_cast<unsigned>(ExternKind::Last_ExternKind)) };
+
 enum DeclAttrKind : unsigned {
 #define DECL_ATTR(_, NAME, ...) DAK_##NAME,
 #include "swift/AST/Attr.def"

include/swift/AST/DiagnosticsParse.def

@@ -1865,7 +1865,7 @@ ERROR(attr_rawlayout_expected_params,none,
       "expected %1 argument after %0 argument in @_rawLayout attribute", (StringRef, StringRef))
 
 ERROR(attr_extern_expected_label,none,
-      "expected %0 argument to @_extern attribute", (StringRef))
+      "expected %0 argument to @extern attribute", (StringRef))
 //------------------------------------------------------------------------------
 // MARK: Generics parsing diagnostics
 //------------------------------------------------------------------------------

include/swift/AST/DiagnosticsSema.def

@@ -1871,9 +1871,31 @@ ERROR(section_not_at_top_level,none,
 ERROR(section_empty_name,none,
       "@_section section name cannot be empty", ())
 
-// @_extern
+// @extern
+ERROR(attr_extern_experimental,none,
+      "@extern requires '-enable-experimental-feature Extern'", ())
 ERROR(extern_not_at_top_level_func,none,
-      "@_extern attribute can only be applied to global functions", ())
+      "@extern attribute can only be applied to global functions", ())
+ERROR(extern_empty_c_name,none,
+      "expected non-empty C name in @extern attribute", ())
+ERROR(extern_only_non_other_attr,none,
+      "@extern attribute cannot be applied to an '@%0' declaration", (StringRef))
+WARNING(extern_c_maybe_invalid_name, none,
+        "C name '%0' may be invalid; explicitly specify the name in @extern(c) to suppress this warning",
+        (StringRef))
+
+ERROR(c_func_variadic, none,
+      "cannot declare variadic argument %0 in %kind1",
+      (DeclName, const ValueDecl *))
+ERROR(c_func_unsupported_specifier, none,
+      "cannot declare '%0' argument %1 in %kind2",
+      (StringRef, DeclName, const ValueDecl *))
+ERROR(c_func_unsupported_type, none, "%0 cannot be represented in C",
+      (Type))
+ERROR(c_func_async,none,
+      "async functions cannot be represented in C", ())
+ERROR(c_func_throws,none,
+      "raising errors from C functions is not supported", ())
 
 ERROR(expose_wasm_not_at_top_level_func,none,
       "@_expose attribute with 'wasm' can only be applied to global functions", ())

include/swift/AST/TypeCheckRequests.h

@@ -205,6 +205,26 @@ class IsObjCRequest :
   void cacheResult(bool value) const;
 };
 
+/// Determine whether the given declaration has
+/// a C-compatible interface.
+class IsCCompatibleFuncDeclRequest :
+    public SimpleRequest<IsCCompatibleFuncDeclRequest,
+                         bool(FuncDecl *),
+                         RequestFlags::Cached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  // Evaluation.
+  bool evaluate(Evaluator &evaluator, FuncDecl *decl) const;
+
+public:
+  // Caching.
+  bool isCached() const { return true; }
+};
+
 void simple_display(llvm::raw_ostream &out, CtorInitializerKind initKind);
 
 /// Computes the kind of initializer for a given \c ConstructorDecl

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -520,3 +520,6 @@ SWIFT_REQUEST(TypeChecker, SerializeAttrGenericSignatureRequest,
 SWIFT_REQUEST(TypeChecker, IsFunctionBodySkippedRequest,
               bool(const AbstractFunctionDecl *),
               SeparatelyCached, NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, IsCCompatibleFuncDeclRequest,
+              bool(const FuncDecl *),
+              Cached, NoLocationInfo)

include/swift/Basic/Features.def

@@ -257,6 +257,9 @@ EXPERIMENTAL_FEATURE(StructLetDestructuring, true)
 /// lifetime-dependent results.
 EXPERIMENTAL_FEATURE(NonEscapableTypes, false)
 
+/// Enable the `@extern` attribute.
+EXPERIMENTAL_FEATURE(Extern, true)
+
 #undef EXPERIMENTAL_FEATURE_EXCLUDED_FROM_MODULE_INTERFACE
 #undef EXPERIMENTAL_FEATURE
 #undef UPCOMING_FEATURE

include/swift/Parse/Parser.h

@@ -1095,7 +1095,7 @@ class Parser {
   ParserResult<DifferentiableAttr> parseDifferentiableAttribute(SourceLoc AtLoc,
                                                                 SourceLoc Loc);
 
-  /// Parse the @_extern attribute.
+  /// Parse the @extern attribute.
   bool parseExternAttribute(DeclAttributes &Attributes, bool &DiscardAttribute,
                             StringRef AttrName, SourceLoc AtLoc, SourceLoc Loc);
 

include/swift/SIL/SILFunction.h

@@ -303,7 +303,7 @@ class SILFunction
   /// empty.
   StringRef WasmExportName;
 
-  /// Name of a Wasm import module and field if @_extern(wasm) attribute
+  /// Name of a Wasm import module and field if @extern(wasm) attribute
   llvm::Optional<std::pair<StringRef, StringRef>> WasmImportModuleAndField;
 
   /// Has value if there's a profile for this function
@@ -1297,14 +1297,14 @@ class SILFunction
   StringRef wasmExportName() const { return WasmExportName; }
   void setWasmExportName(StringRef value) { WasmExportName = value; }
 
-  /// Return Wasm import module name if @_extern(wasm) was used otherwise empty
+  /// Return Wasm import module name if @extern(wasm) was used otherwise empty
   StringRef wasmImportModuleName() const {
     if (WasmImportModuleAndField)
       return WasmImportModuleAndField->first;
     return StringRef();
   }
 
-  /// Return Wasm import field name if @_extern(wasm) was used otherwise empty
+  /// Return Wasm import field name if @extern(wasm) was used otherwise empty
   StringRef wasmImportFieldName() const {
     if (WasmImportModuleAndField)
       return WasmImportModuleAndField->second;

lib/AST/ASTPrinter.cpp

@@ -3612,6 +3612,10 @@ static bool usesFeatureTypedThrows(Decl *decl) {
   return false;
 }
 
+static bool usesFeatureExtern(Decl *decl) {
+  return decl->getAttrs().hasAttribute<ExternAttr>();
+}
+
 /// Suppress the printing of a particular feature.
 static void suppressingFeature(PrintOptions &options, Feature feature,
                                llvm::function_ref<void()> action) {

lib/AST/Attr.cpp

@@ -1141,9 +1141,22 @@ bool DeclAttribute::printImpl(ASTPrinter &Printer, const PrintOptions &Options,
 
   case DAK_Extern: {
     auto *Attr = cast<ExternAttr>(this);
-    Printer.printAttrName("@_extern");
-    // For now, it accepts only "wasm" as its kind.
-    Printer << "(wasm, module: \"" << Attr->ModuleName << "\", name: \"" << Attr->Name << "\")";
+    Printer.printAttrName("@extern");
+    Printer << "(";
+    switch (Attr->getExternKind()) {
+    case ExternKind::C:
+      Printer << "c";
+      // Symbol name can be omitted for C.
+      if (auto cName = Attr->Name)
+        Printer << ", \"" << *cName << "\"";
+      break;
+    case ExternKind::Wasm:
+      Printer << "wasm";
+      // @extern(wasm) always has names.
+      Printer << ", module: \"" << *Attr->ModuleName << "\"";
+      Printer << ", name: \"" << *Attr->Name << "\")";
+      break;
+    }
     break;
   }
 
@@ -1718,7 +1731,7 @@ StringRef DeclAttribute::getAttrName() const {
   case DAK_RawLayout:
     return "_rawLayout";
   case DAK_Extern:
-    return "_extern";
+    return "extern";
   }
   llvm_unreachable("bad DeclAttrKind");
 }
@@ -2638,6 +2651,24 @@ bool MacroRoleAttr::hasNameKind(MacroIntroducedDeclNameKind kind) const {
   }) != getNames().end();
 }
 
+StringRef ExternAttr::getCName(const FuncDecl *D) const {
+  if (auto cName = this->Name)
+    return cName.value();
+  // If no name was specified, fall back on the Swift base name without mangling.
+  // Base name is always available and non-empty for FuncDecl.
+  return D->getBaseIdentifier().str();
+}
+
+ExternAttr *ExternAttr::find(DeclAttributes &attrs, ExternKind kind) {
+  for (DeclAttribute *attr : attrs) {
+    if (auto *externAttr = dyn_cast<ExternAttr>(attr)) {
+      if (externAttr->getExternKind() == kind)
+        return externAttr;
+    }
+  }
+  return nullptr;
+}
+
 const DeclAttribute *
 DeclAttributes::getEffectiveSendableAttr() const {
   const NonSendableAttr *assumedAttr = nullptr;