Merge pull request #78037 from tshortli/introduce-availability-domain

tshortli · web-flow · commit 9503df969201 · 2024-12-09T07:38:44.000-08:00
diff --git a/include/swift/AST/AvailabilityDomain.h b/include/swift/AST/AvailabilityDomain.h
@@ -0,0 +1,101 @@
+//===--- AvailabilityDomain.h - Swift Availability Domains ------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2024 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the AvailabilityDomain class, which represents a domain
+// for which availability can be checked.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_AST_AVAILABILITY_DOMAIN_H
+#define SWIFT_AST_AVAILABILITY_DOMAIN_H
+
+#include "swift/AST/PlatformKind.h"
+#include "swift/Basic/LLVM.h"
+
+namespace swift {
+
+/// Represents a dimension of availability (e.g. macOS platform or Swift
+/// language mode).
+class AvailabilityDomain final {
+public:
+  enum class Kind : uint8_t {
+    /// The root availability domain. This is used for declarations that are
+    /// universally unavailable or deprecated, for example.
+    Universal,
+
+    /// Represents availability for a specific operating system platform.
+    Platform,
+
+    /// Represents availability with respect to Swift language mode.
+    SwiftLanguage,
+
+    /// Represents PackageDescription availability.
+    PackageDescription,
+  };
+
+private:
+  Kind kind;
+  PlatformKind platform;
+
+  AvailabilityDomain(Kind kind) : kind(kind), platform(PlatformKind::none) {
+    assert(kind != Kind::Platform);
+  };
+
+  AvailabilityDomain(PlatformKind platform)
+      : kind(Kind::Platform), platform(platform) {
+    assert(platform != PlatformKind::none);
+  };
+
+public:
+  static AvailabilityDomain forUniversal() {
+    return AvailabilityDomain(Kind::Universal);
+  }
+
+  static AvailabilityDomain forPlatform(PlatformKind platformKind) {
+    return AvailabilityDomain(platformKind);
+  }
+
+  static AvailabilityDomain forSwiftLanguage() {
+    return AvailabilityDomain(Kind::SwiftLanguage);
+  }
+
+  static AvailabilityDomain forPackageDescription() {
+    return AvailabilityDomain(Kind::PackageDescription);
+  }
+
+  Kind getKind() const { return kind; }
+
+  bool isUniversal() const { return kind == Kind::Universal; }
+
+  bool isPlatform() const { return kind == Kind::Platform; }
+
+  bool isSwiftLanguage() const { return kind == Kind::SwiftLanguage; }
+
+  bool isPackageDescription() const { return kind == Kind::PackageDescription; }
+
+  /// Returns the platform kind for this domain if applicable.
+  PlatformKind getPlatformKind() const {
+    assert(kind == Kind::Platform);
+    return platform;
+  }
+
+  /// Returns the string to use in diagnostics to identify the domain. May
+  /// return an empty string.
+  llvm::StringRef getNameForDiagnostics() const;
+
+  /// Returns the string to use when printing an `@available` attribute.
+  llvm::StringRef getNameForAttributePrinting() const;
+};
+
+} // end namespace swift
+
+#endif
diff --git a/include/swift/AST/Decl.h b/include/swift/AST/Decl.h
@@ -66,6 +66,7 @@ namespace swift {
   class AccessorDecl;
   class ApplyExpr;
   class AvailabilityRange;
+  class AvailabilityDomain;
   class GenericEnvironment;
   class ArchetypeType;
   class ASTContext;
@@ -1390,6 +1391,10 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl>, public Swi
   /// and its DeclContext does not.
   bool isOutermostPrivateOrFilePrivateScope() const;
 
+  /// Returns the availability domain associated with the given `AvailableAttr`
+  /// that is attached to this decl.
+  AvailabilityDomain getDomainForAvailableAttr(const AvailableAttr *attr) const;
+
   /// Returns the active platform-specific `@available` attribute for this decl.
   /// There may be multiple `@available` attributes that are relevant to the
   /// current platform, but the returned one has the highest priority.
diff --git a/lib/AST/Attr.cpp b/lib/AST/Attr.cpp
@@ -17,6 +17,7 @@
 #include "swift/AST/Attr.h"
 #include "swift/AST/ASTContext.h"
 #include "swift/AST/ASTPrinter.h"
+#include "swift/AST/AvailabilityDomain.h"
 #include "swift/AST/Decl.h"
 #include "swift/AST/Expr.h"
 #include "swift/AST/GenericEnvironment.h"
@@ -487,36 +488,32 @@ static bool isShortFormAvailabilityImpliedByOther(const AvailableAttr *Attr,
 ///   @available(iOS, introduced: 8.0)
 /// this will print:
 ///   @available(OSX 10.10, iOS 8.0, *)
-static void printShortFormAvailable(ArrayRef<const DeclAttribute *> Attrs,
+static void printShortFormAvailable(const Decl *D,
+                                    ArrayRef<const DeclAttribute *> Attrs,
                                     ASTPrinter &Printer,
                                     const PrintOptions &Options,
                                     bool forAtSpecialize = false) {
   assert(!Attrs.empty());
   if (!forAtSpecialize)
     Printer << "@available(";
   auto FirstAvail = cast<AvailableAttr>(Attrs.front());
-  if (Attrs.size() == 1 &&
-      FirstAvail->getPlatformAgnosticAvailability() !=
-      PlatformAgnosticAvailabilityKind::None) {
+  auto FirstAvailDomain = D->getDomainForAvailableAttr(FirstAvail);
+  if (Attrs.size() == 1 && !FirstAvailDomain.isPlatform()) {
     assert(FirstAvail->Introduced.has_value());
-    if (FirstAvail->isLanguageVersionSpecific()) {
-      Printer << "swift ";
-    } else {
-      assert(FirstAvail->isPackageDescriptionVersionSpecific());
-      Printer << "_PackageDescription ";
-    }
+    Printer << FirstAvailDomain.getNameForAttributePrinting() << " ";
     Printer << FirstAvail->Introduced.value().getAsString();
     if (!forAtSpecialize)
       Printer << ")";
   } else {
     for (auto *DA : Attrs) {
       auto *AvailAttr = cast<AvailableAttr>(DA);
+      auto AvailAttrDomain = D->getDomainForAvailableAttr(AvailAttr);
       assert(AvailAttr->Introduced.has_value());
       // Avoid omitting available attribute when we are printing module interface.
       if (!Options.IsForSwiftInterface &&
           isShortFormAvailabilityImpliedByOther(AvailAttr, Attrs))
         continue;
-      Printer << platformString(AvailAttr->getPlatform()) << " "
+      Printer << AvailAttrDomain.getNameForAttributePrinting() << " "
               << AvailAttr->Introduced.value().getAsString() << ", ";
     }
     Printer << "*";
@@ -848,11 +845,11 @@ void DeclAttributes::print(ASTPrinter &Printer, const PrintOptions &Options,
   }
 
   if (swiftVersionAvailableAttribute)
-    printShortFormAvailable(swiftVersionAvailableAttribute, Printer, Options);
+    printShortFormAvailable(D, swiftVersionAvailableAttribute, Printer, Options);
   if (packageDescriptionVersionAvailableAttribute)
-    printShortFormAvailable(packageDescriptionVersionAvailableAttribute, Printer, Options);
+    printShortFormAvailable(D, packageDescriptionVersionAvailableAttribute, Printer, Options);
   if (!shortAvailableAttributes.empty())
-    printShortFormAvailable(shortAvailableAttributes, Printer, Options);
+    printShortFormAvailable(D, shortAvailableAttributes, Printer, Options);
   if (!backDeployedAttributes.empty())
     printShortFormBackDeployed(backDeployedAttributes, Printer, Options);
 
@@ -901,12 +898,16 @@ ParsedDeclAttrFilter::operator()(const DeclAttribute *Attr) const {
 static void printAvailableAttr(const Decl *D, const AvailableAttr *Attr,
                                ASTPrinter &Printer,
                                const PrintOptions &Options) {
-  if (Attr->isLanguageVersionSpecific())
-    Printer << "swift";
-  else if (Attr->isPackageDescriptionVersionSpecific())
-    Printer << "_PackageDescription";
+  auto Domain = D->getDomainForAvailableAttr(Attr);
+
+  // The parser rejects `@available(swift, unavailable)`, so when printing
+  // attributes that are universally unavailable in Swift, we must print them
+  // as universally unavailable instead.
+  // FIXME: Reconsider this, it's a weird special case.
+  if (Domain.isSwiftLanguage() && Attr->isUnconditionallyUnavailable())
+    Printer << "*";
   else
-    Printer << Attr->platformString();
+    Printer << Domain.getNameForAttributePrinting();
 
   if (Attr->isUnconditionallyUnavailable())
     Printer << ", unavailable";
@@ -945,8 +946,7 @@ static void printAvailableAttr(const Decl *D, const AvailableAttr *Attr,
   if (!Attr->Message.empty()) {
     Printer << ", message: ";
     Printer.printEscapedStringLiteral(Attr->Message);
-  } else if (Attr->getPlatformAgnosticAvailability() ==
-             PlatformAgnosticAvailabilityKind::UnavailableInSwift)
+  } else if (Domain.isSwiftLanguage() && Attr->isUnconditionallyUnavailable())
     Printer << ", message: \"Not available in Swift\"";
 }
 
@@ -1257,7 +1257,7 @@ bool DeclAttribute::printImpl(ASTPrinter &Printer, const PrintOptions &Options,
       } else {
         SmallVector<const DeclAttribute *, 8> tmp(availAttrs.begin(),
                                                   availAttrs.end());
-        printShortFormAvailable(tmp, Printer, Options,
+        printShortFormAvailable(D, tmp, Printer, Options,
                                 true /*forAtSpecialize*/);
         Printer << "; ";
       }
diff --git a/lib/AST/AvailabilityDomain.cpp b/lib/AST/AvailabilityDomain.cpp
@@ -0,0 +1,63 @@
+//===--- AvailabilityDomain.cpp - Swift Availability Domains --------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+#include "swift/AST/AvailabilityDomain.h"
+#include "swift/AST/Decl.h"
+
+using namespace swift;
+
+AvailabilityDomain
+Decl::getDomainForAvailableAttr(const AvailableAttr *attr) const {
+  if (attr->hasPlatform())
+    return AvailabilityDomain::forPlatform(attr->getPlatform());
+
+  switch (attr->getPlatformAgnosticAvailability()) {
+  case PlatformAgnosticAvailabilityKind::Deprecated:
+  case PlatformAgnosticAvailabilityKind::Unavailable:
+  case PlatformAgnosticAvailabilityKind::NoAsync:
+  case PlatformAgnosticAvailabilityKind::None:
+    return AvailabilityDomain::forUniversal();
+
+  case PlatformAgnosticAvailabilityKind::UnavailableInSwift:
+  case PlatformAgnosticAvailabilityKind::SwiftVersionSpecific:
+    return AvailabilityDomain::forSwiftLanguage();
+
+  case PlatformAgnosticAvailabilityKind::PackageDescriptionVersionSpecific:
+    return AvailabilityDomain::forPackageDescription();
+  }
+}
+
+llvm::StringRef AvailabilityDomain::getNameForDiagnostics() const {
+  switch (kind) {
+  case Kind::Universal:
+    return "";
+  case Kind::Platform:
+    return swift::prettyPlatformString(getPlatformKind());
+  case Kind::SwiftLanguage:
+    return "Swift";
+  case Kind::PackageDescription:
+    return "PackageDescription";
+  }
+}
+
+llvm::StringRef AvailabilityDomain::getNameForAttributePrinting() const {
+  switch (kind) {
+  case Kind::Universal:
+    return "*";
+  case Kind::Platform:
+    return swift::platformString(getPlatformKind());
+  case Kind::SwiftLanguage:
+    return "swift";
+  case Kind::PackageDescription:
+    return "_PackageDescription";
+  }
+}
diff --git a/lib/AST/CMakeLists.txt b/lib/AST/CMakeLists.txt
@@ -28,6 +28,7 @@ add_swift_host_library(swiftAST STATIC
   AutoDiff.cpp
   Availability.cpp
   AvailabilityContext.cpp
+  AvailabilityDomain.cpp
   AvailabilityScope.cpp
   AvailabilitySpec.cpp
   Builtins.cpp
diff --git a/lib/Sema/TypeCheckAvailability.cpp b/lib/Sema/TypeCheckAvailability.cpp
