[SE-0497] Implement @export attribute syntax

Implement the @export(implementation) and @export(interface) attributes
to replace @_alwaysEmitIntoClient and @_neverEmitIntoClient. Provide a
warning + Fix-It to start staging out the very-new
@_neverEmitIntoClient. We'll hold off on pushing folks toward
@_alwaysEmitIntoClient for a little longer.

Author: DougGregor

include/swift/AST/ASTBridging.h

@@ -21,6 +21,7 @@
 #include "swift/AST/AttrKind.h"
 #include "swift/AST/DiagnosticKind.h"
 #include "swift/AST/DiagnosticList.h"
+#include "swift/AST/ExportKind.h"
 #include "swift/AST/GenericTypeParamKind.h"
 #include "swift/AST/Identifier.h"
 #include "swift/AST/LayoutConstraintKind.h"
@@ -956,6 +957,12 @@ BridgedImplementsAttr BridgedImplementsAttr_createParsed(
     swift::SourceRange range, BridgedTypeRepr cProtocolType,
     BridgedDeclNameRef cMemberName, BridgedDeclNameLoc cMemberNameLoc);
 
+SWIFT_NAME("BridgedExportAttr.createParsed(_:atLoc:range:kind:)")
+BridgedExportAttr BridgedExportAttr_createParsed(BridgedASTContext cContext,
+                                                 swift::SourceLoc atLoc,
+                                                 swift::SourceRange range,
+                                                 swift::ExportKind kind);
+
 SWIFT_NAME("BridgedInlineAttr.createParsed(_:atLoc:range:kind:)")
 BridgedInlineAttr BridgedInlineAttr_createParsed(BridgedASTContext cContext,
                                                  swift::SourceLoc atLoc,

include/swift/AST/Attr.h

@@ -23,6 +23,7 @@
 #include "swift/AST/AvailabilityRange.h"
 #include "swift/AST/ConcreteDeclRef.h"
 #include "swift/AST/DeclNameLoc.h"
+#include "swift/AST/ExportKind.h"
 #include "swift/AST/Identifier.h"
 #include "swift/AST/KnownProtocols.h"
 #include "swift/AST/LifetimeDependence.h"
@@ -2955,6 +2956,35 @@ enum class NonSendableKind : uint8_t {
   Assumed
 };
 
+/// Specify whether the declaration should be exported as an interface or
+/// an implementation.
+class ExportAttr : public DeclAttribute {
+public:
+  /// How this declaration is exported.
+  const ExportKind exportKind;
+
+  ExportAttr(SourceLoc atLoc, SourceRange range, ExportKind exportKind,
+             bool implicit = false)
+      : DeclAttribute(DeclAttrKind::Export, atLoc, range, implicit),
+        exportKind(exportKind) {}
+
+  ExportAttr(ExportKind exportKind, bool implicit = false)
+    : ExportAttr(SourceLoc(), SourceRange(), exportKind, implicit) { }
+
+  static bool classof(const DeclAttribute *DA) {
+    return DA->getKind() == DeclAttrKind::Export;
+  }
+
+  /// Create a copy of this attribute.
+  ExportAttr *clone(ASTContext &ctx) const {
+    return new (ctx) ExportAttr(AtLoc, Range, exportKind, isImplicit());
+  }
+
+  bool isEquivalent(const ExportAttr *other, Decl *attachedTo) const {
+    return exportKind == other->exportKind;
+  }
+};
+
 /// Marks a declaration as explicitly non-Sendable.
 class NonSendableAttr : public DeclAttribute {
 public:

include/swift/AST/Decl.h

@@ -1085,12 +1085,22 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl>, public Swi
   /// behaviors for it and, if it's an extension, its members.
   bool isObjCImplementation() const;
 
+  /// True if this declaration should always have its implementation made
+  /// available to the client, and not have an ABI symbol.
+  ///
+  /// This can be spelled with @export(implementation) or the historical
+  /// @_alwaysEmitIntoClient.
+  bool isAlwaysEmittedIntoClient() const;
+
   /// True if this declaration should never have its implementation made
   /// available to any client. This overrides cross-module optimization and
   /// optimizations that might use the implementation, such that the only
   /// implementation of this function is the one compiled into its owning
   /// module. Practically speaking, this prohibits serialization of the SIL
   /// for this definition.
+  ///
+  /// This can be spelled with @export(interface) or the historical
+  /// @_neverEmitIntoClient.
   bool isNeverEmittedIntoClient() const;
 
   using AuxiliaryDeclCallback = llvm::function_ref<void(Decl *)>;

include/swift/AST/DeclAttr.def

@@ -558,7 +558,10 @@ SIMPLE_DECL_ATTR(noDerivative, NoDerivative,
   ABIBreakingToAdd | ABIBreakingToRemove | APIBreakingToAdd | APIBreakingToRemove | ForbiddenInABIAttr,
   100)
 
-// Unused '101'
+DECL_ATTR(export, Export,
+    OnVar | OnSubscript | OnAbstractFunction,
+    ABIBreakingToAdd | ABIBreakingToRemove | APIStableToAdd | APIStableToRemove | ForbiddenInABIAttr,
+    101)
 
 CONTEXTUAL_SIMPLE_DECL_ATTR(actor, Actor,
   OnClass,

include/swift/AST/DiagnosticsSema.def

@@ -4170,6 +4170,10 @@ ERROR(final_not_allowed_here,none,
       "'final' may only be applied to classes, properties, methods, and "
       "subscripts", ())
 
+ERROR(attr_incompatible_with_attr,none,
+      "'%0' cannot be used with '%1'",
+      (DeclAttribute, DeclAttribute))
+
 ERROR(attr_incompatible_with_non_final,none,
       "'%0' cannot be applied to a non-final %kindonly1",
       (DeclAttribute, const ValueDecl *))
@@ -5369,7 +5373,7 @@ GROUPED_ERROR(opaque_type_unsupported_availability,OpaqueTypeInference,none,
   "a default argument value|" \
   "a property initializer in a '@frozen' type|" \
   "a '@backDeployed' function|" \
-  "an embedded function not marked '@_neverEmitIntoClient'}"
+  "an embedded function not marked '@export(interface)'}"
 
 ERROR(discard_wrong_context_decl,none,
       "'discard' statement cannot appear in %kindonly0",

include/swift/AST/KnownIdentifiers.def

@@ -332,6 +332,8 @@ IDENTIFIER(always)
 IDENTIFIER_(_always)
 IDENTIFIER_(assumed)
 IDENTIFIER(checked)
+IDENTIFIER(interface)
+IDENTIFIER(implementation)
 IDENTIFIER(never)
 IDENTIFIER(none)
 IDENTIFIER(safe)

include/swift/SIL/SILFunction.h

@@ -1421,7 +1421,7 @@ class SILFunction
       return false;
 
     auto *V = getLocation().getAsASTNode<ValueDecl>();
-    return V && V->getAttrs().hasAttribute<AlwaysEmitIntoClientAttr>();
+    return V && V->isAlwaysEmittedIntoClient();
   }
 
   /// Return whether this function has attribute @used on it

lib/APIDigester/ModuleAnalyzerNodes.cpp

@@ -1764,7 +1764,7 @@ SDKContext::shouldIgnore(Decl *D, const Decl* Parent) const {
     // Exclude decls with @_alwaysEmitIntoClient if we are checking ABI.
     // These decls are considered effectively public because they are usable
     // from inline, so we have to manually exclude them here.
-    if (D->getAttrs().hasAttribute<AlwaysEmitIntoClientAttr>())
+    if (D->isAlwaysEmittedIntoClient())
       return true;
   } else {
     if (D->isPrivateSystemDecl(false))

lib/AST/ASTDumper.cpp

@@ -590,6 +590,15 @@ static StringRef getDumpString(InlineKind kind) {
   }
   llvm_unreachable("unhandled InlineKind");
 }
+static StringRef getDumpString(ExportKind kind) {
+  switch (kind) {
+  case ExportKind::Interface:
+    return "interface";
+  case ExportKind::Implementation:
+    return "implementation";
+  }
+  llvm_unreachable("unhandled ExportKind");
+}
 static StringRef getDumpString(MacroRole role) {
   return getMacroRoleString(role);
 }
@@ -5306,6 +5315,11 @@ class PrintAttribute : public AttributeVisitor<PrintAttribute, void, Label>,
     printField(Attr->getKind(), Label::always("kind"));
     printFoot();
   }
+  void visitExportAttr(ExportAttr *Attr, Label label) {
+    printCommon(Attr, "export_attr", label);
+    printField(Attr->exportKind, Label::always("kind"));
+    printFoot();
+  }
   void visitLifetimeAttr(LifetimeAttr *Attr, Label label) {
     printCommon(Attr, "lifetime_attr", label);
     // FIXME: Improve, more detailed info.

lib/AST/Attr.cpp

@@ -1129,6 +1129,7 @@ bool DeclAttribute::printImpl(ASTPrinter &Printer, const PrintOptions &Options,
   case DeclAttrKind::AccessControl:
   case DeclAttrKind::ReferenceOwnership:
   case DeclAttrKind::Effects:
+  case DeclAttrKind::Export:
   case DeclAttrKind::Optimize:
   case DeclAttrKind::Exclusivity:
   case DeclAttrKind::NonSendable:
@@ -1932,6 +1933,15 @@ StringRef DeclAttribute::getAttrName() const {
       case EffectsKind::Custom:
         return "_effects";
     }
+  case DeclAttrKind::Export: {
+    switch (cast<ExportAttr>(this)->exportKind) {
+    case ExportKind::Interface:
+      return "export(interface)";
+    case ExportKind::Implementation:
+      return "export(implementation)";
+    }
+    llvm_unreachable("Invalid export kind");
+  }
   case DeclAttrKind::AccessControl:
   case DeclAttrKind::SetterAccess: {
     AccessLevel access = cast<AbstractAccessControlAttr>(this)->getAccess();