[AST/Sema] Add availability attributes for macCatalyst

Add a platform kind and availability attributes for macCatalyst. macCatalyst
uses iOS version numbers and inherits availability from iOS attributes unless
a macCatalyst attribute is explicitly provided.

Author: devincoughlin

include/swift/AST/Attr.h

@@ -1997,6 +1997,11 @@ class DeclAttributes {
   bool
   isUnavailableInSwiftVersion(const version::Version &effectiveVersion) const;
 
+  /// Finds the most-specific platform-specific attribute that is
+  /// active for the current platform.
+  const AvailableAttr *
+  findMostSpecificActivePlatform(const ASTContext &ctx) const;
+
   /// Returns the first @available attribute that indicates
   /// a declaration is unavailable, or the first one that indicates it's
   /// potentially unavailable, or null otherwise.

include/swift/AST/PlatformKind.h

@@ -51,11 +51,20 @@ StringRef prettyPlatformString(PlatformKind platform);
 /// restrictions are enabled, but OSXApplicationExtension is not considered
 /// active when the target platform is OS X and app extension restrictions are
 /// disabled. PlatformKind::none is always considered active.
-bool isPlatformActive(PlatformKind Platform, LangOptions &LangOpts);
-  
+/// If ForTargetVariant is true then for zippered builds the target-variant
+/// triple will be used rather than the target to determine whether the
+/// platform is active.
+bool isPlatformActive(PlatformKind Platform, LangOptions &LangOpts,
+                      bool ForTargetVariant = false);
+
 /// Returns the target platform for the given language options.
 PlatformKind targetPlatform(LangOptions &LangOpts);
-  
+
+/// Returns true when availability attributes from the "parent" platform
+/// should also apply to the "child" platform for declarations without
+/// an explicit attribute for the child.
+bool inheritsAvailabilityFromPlatform(PlatformKind Child, PlatformKind Parent);
+
 } // end namespace swift
 
 #endif

include/swift/AST/PlatformKinds.def

@@ -30,5 +30,7 @@ AVAILABILITY_PLATFORM(iOSApplicationExtension, "application extensions for iOS")
 AVAILABILITY_PLATFORM(tvOSApplicationExtension, "application extensions for tvOS")
 AVAILABILITY_PLATFORM(watchOSApplicationExtension, "application extensions for watchOS")
 AVAILABILITY_PLATFORM(OSXApplicationExtension, "application extensions for macOS")
+AVAILABILITY_PLATFORM(macCatalyst, "Mac Catalyst")
+AVAILABILITY_PLATFORM(macCatalystApplicationExtension, "application extensions for Mac Catalyst")
 
 #undef AVAILABILITY_PLATFORM

include/swift/AST/Stmt.h

@@ -329,11 +329,20 @@ class alignas(8) PoundAvailableInfo final :
   /// The version range when this query will return true. This value is
   /// filled in by Sema.
   VersionRange AvailableRange;
-  
+
+  /// For zippered builds, this is the version range for the target variant
+  /// that must hold for the query to return true. For example, when
+  /// compiling with target x86_64-macosx10.15 and target-variant
+  /// x86_64-ios13.0 a query of #available(macOS 10.22, iOS 20.0, *) will
+  /// have a variant range of [20.0, +inf).
+  /// This is filled in by Sema.
+  VersionRange VariantAvailableRange;
+
   PoundAvailableInfo(SourceLoc PoundLoc, ArrayRef<AvailabilitySpec *> queries,
                      SourceLoc RParenLoc)
    : PoundLoc(PoundLoc), RParenLoc(RParenLoc), NumQueries(queries.size()),
-     AvailableRange(VersionRange::empty()) {
+     AvailableRange(VersionRange::empty()),
+     VariantAvailableRange(VersionRange::empty()) {
     std::uninitialized_copy(queries.begin(), queries.end(),
                             getTrailingObjects<AvailabilitySpec *>());
   }
@@ -356,6 +365,13 @@ class alignas(8) PoundAvailableInfo final :
 
   const VersionRange &getAvailableRange() const { return AvailableRange; }
   void setAvailableRange(const VersionRange &Range) { AvailableRange = Range; }
+
+  const VersionRange &getVariantAvailableRange() const {
+    return VariantAvailableRange;
+  }
+  void setVariantAvailableRange(const VersionRange &Range) {
+    VariantAvailableRange = Range;
+  }
 };
 
 

lib/AST/Attr.cpp

@@ -172,6 +172,35 @@ DeclAttributes::isUnavailableInSwiftVersion(
   return false;
 }
 
+const AvailableAttr *
+DeclAttributes::findMostSpecificActivePlatform(const ASTContext &ctx) const{
+  const AvailableAttr *bestAttr = nullptr;
+
+  for (auto attr : *this) {
+    auto *avAttr = dyn_cast<AvailableAttr>(attr);
+    if (!avAttr)
+      continue;
+
+    if (avAttr->isInvalid())
+      continue;
+
+    if (!avAttr->hasPlatform())
+      continue;
+
+    if (!avAttr->isActivePlatform(ctx))
+      continue;
+
+    // We have an attribute that is active for the platform, but
+    // is it more specific than our curent best?
+    if (!bestAttr || inheritsAvailabilityFromPlatform(avAttr->Platform,
+                                                      bestAttr->Platform)) {
+      bestAttr = avAttr;
+    }
+  }
+
+  return bestAttr;
+}
+
 const AvailableAttr *
 DeclAttributes::getPotentiallyUnavailable(const ASTContext &ctx) const {
   const AvailableAttr *potential = nullptr;
@@ -217,12 +246,19 @@ DeclAttributes::getPotentiallyUnavailable(const ASTContext &ctx) const {
 const AvailableAttr *DeclAttributes::getUnavailable(
                           const ASTContext &ctx) const {
   const AvailableAttr *conditional = nullptr;
+  const AvailableAttr *bestActive = findMostSpecificActivePlatform(ctx);
 
   for (auto Attr : *this)
     if (auto AvAttr = dyn_cast<AvailableAttr>(Attr)) {
       if (AvAttr->isInvalid())
         continue;
 
+      // If this is a platform-specific attribute and it isn't the most
+      // specific attribute for the current platform, we're done.
+      if (AvAttr->hasPlatform() &&
+          (!bestActive || AvAttr != bestActive))
+        continue;
+
       // If this attribute doesn't apply to the active platform, we're done.
       if (!AvAttr->isActivePlatform(ctx) &&
           !AvAttr->isLanguageVersionSpecific() &&
@@ -250,11 +286,16 @@ const AvailableAttr *DeclAttributes::getUnavailable(
 const AvailableAttr *
 DeclAttributes::getDeprecated(const ASTContext &ctx) const {
   const AvailableAttr *conditional = nullptr;
+  const AvailableAttr *bestActive = findMostSpecificActivePlatform(ctx);
   for (auto Attr : *this) {
     if (auto AvAttr = dyn_cast<AvailableAttr>(Attr)) {
       if (AvAttr->isInvalid())
         continue;
 
+      if (AvAttr->hasPlatform() &&
+          (!bestActive || AvAttr != bestActive))
+        continue;
+
       if (!AvAttr->isActivePlatform(ctx) &&
           !AvAttr->isLanguageVersionSpecific() &&
           !AvAttr->isPackageDescriptionVersionSpecific())
@@ -329,6 +370,30 @@ static bool isShortAvailable(const DeclAttribute *DA) {
   return true;
 }
 
+/// Return true when another availability attribute implies the same availability as this
+/// attribute and so printing the attribute can be skipped to de-clutter the declaration
+/// when printing the short form.
+/// For example, iOS availability implies macCatalyst availability so if attributes for
+/// both are present and they have the same 'introduced' version, we can skip printing an
+/// explicit availability for macCatalyst.
+static bool isShortFormAvailabilityImpliedByOther(const AvailableAttr *Attr,
+    ArrayRef<const DeclAttribute *> Others) {
+  assert(isShortAvailable(Attr));
+
+  for (auto *DA : Others) {
+    auto *Other = cast<AvailableAttr>(DA);
+    if (Attr->Platform == Other->Platform)
+      continue;
+
+    if (!inheritsAvailabilityFromPlatform(Attr->Platform, Other->Platform))
+      continue;
+
+    if (Attr->Introduced == Other->Introduced)
+      return true;
+  }
+  return false;
+}
+
 /// Print the short-form @available() attribute for an array of long-form
 /// AvailableAttrs that can be represented in the short form.
 /// For example, for:
@@ -359,6 +424,8 @@ static void printShortFormAvailable(ArrayRef<const DeclAttribute *> Attrs,
     for (auto *DA : Attrs) {
       auto *AvailAttr = cast<AvailableAttr>(DA);
       assert(AvailAttr->Introduced.hasValue());
+      if (isShortFormAvailabilityImpliedByOther(AvailAttr, Attrs))
+        continue;
       Printer << platformString(AvailAttr->Platform) << " "
               << AvailAttr->Introduced.getValue().getAsString() << ", ";
     }

lib/AST/PlatformKind.cpp

@@ -16,6 +16,7 @@
 
 #include "swift/AST/PlatformKind.h"
 #include "swift/Basic/LangOptions.h"
+#include "swift/Basic/Platform.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Support/ErrorHandling.h"
 
@@ -63,7 +64,8 @@ static bool isPlatformActiveForTarget(PlatformKind Platform,
     return true;
 
   if (Platform == PlatformKind::OSXApplicationExtension ||
-      Platform == PlatformKind::iOSApplicationExtension)
+      Platform == PlatformKind::iOSApplicationExtension ||
+      Platform == PlatformKind::macCatalystApplicationExtension)
     if (!EnableAppExtensionRestrictions)
       return false;
 
@@ -75,6 +77,9 @@ static bool isPlatformActiveForTarget(PlatformKind Platform,
     case PlatformKind::iOS:
     case PlatformKind::iOSApplicationExtension:
       return Target.isiOS() && !Target.isTvOS();
+    case PlatformKind::macCatalyst:
+    case PlatformKind::macCatalystApplicationExtension:
+      return tripleIsMacCatalystEnvironment(Target);
     case PlatformKind::tvOS:
     case PlatformKind::tvOSApplicationExtension:
       return Target.isTvOS();
@@ -87,8 +92,15 @@ static bool isPlatformActiveForTarget(PlatformKind Platform,
   llvm_unreachable("bad PlatformKind");
 }
 
-bool swift::isPlatformActive(PlatformKind Platform, LangOptions &LangOpts) {
+bool swift::isPlatformActive(PlatformKind Platform, LangOptions &LangOpts,
+                             bool ForTargetVariant) {
   llvm::Triple TT = LangOpts.Target;
+
+  if (ForTargetVariant) {
+    assert(LangOpts.TargetVariant && "Must have target variant triple");
+    TT = *LangOpts.TargetVariant;
+  }
+
   return isPlatformActiveForTarget(Platform, TT,
                                    LangOpts.EnableAppExtensionRestrictions);
 }
@@ -113,10 +125,33 @@ PlatformKind swift::targetPlatform(LangOptions &LangOpts) {
   }
 
   if (LangOpts.Target.isiOS()) {
+    if (tripleIsMacCatalystEnvironment(LangOpts.Target))
+      return (LangOpts.EnableAppExtensionRestrictions
+                  ? PlatformKind::macCatalystApplicationExtension
+                  : PlatformKind::macCatalyst);
     return (LangOpts.EnableAppExtensionRestrictions
                 ? PlatformKind::iOSApplicationExtension
                 : PlatformKind::iOS);
   }
 
   return PlatformKind::none;
 }
+
+bool swift::inheritsAvailabilityFromPlatform(PlatformKind Child,
+                                             PlatformKind Parent) {
+  if (Child == PlatformKind::macCatalyst && Parent == PlatformKind::iOS)
+    return true;
+
+  if (Child == PlatformKind::macCatalystApplicationExtension) {
+    if (Parent == PlatformKind::iOS ||
+        Parent == PlatformKind::iOSApplicationExtension ||
+        Parent == PlatformKind::macCatalyst) {
+      return true;
+    }
+  }
+
+  // Ideally we would have all ApplicationExtension platforms
+  // inherit from their non-extension platform.
+
+  return false;
+}

lib/ClangImporter/ClangImporter.cpp

@@ -1859,6 +1859,8 @@ PlatformAvailability::PlatformAvailability(LangOptions &langOpts)
   switch (platformKind) {
   case PlatformKind::iOS:
   case PlatformKind::iOSApplicationExtension:
+  case PlatformKind::macCatalyst:
+  case PlatformKind::macCatalystApplicationExtension:
   case PlatformKind::tvOS:
   case PlatformKind::tvOSApplicationExtension:
     deprecatedAsUnavailableMessage =
@@ -1893,6 +1895,11 @@ bool PlatformAvailability::isPlatformRelevant(StringRef name) const {
   case PlatformKind::iOSApplicationExtension:
     return name == "ios" || name == "ios_app_extension";
 
+  case PlatformKind::macCatalyst:
+  case PlatformKind::macCatalystApplicationExtension:
+    // ClangImporter does not yet support macCatalyst.
+    return false;
+
   case PlatformKind::tvOS:
     return name == "tvos";
   case PlatformKind::tvOSApplicationExtension:
@@ -1933,6 +1940,11 @@ bool PlatformAvailability::treatDeprecatedAsUnavailable(
     // Anything deprecated in iOS 7.x and earlier is unavailable in Swift.
     return major <= 7;
 
+  case PlatformKind::macCatalyst:
+  case PlatformKind::macCatalystApplicationExtension:
+    // ClangImporter does not yet support macCatalyst.
+    return false;
+
   case PlatformKind::watchOS:
   case PlatformKind::watchOSApplicationExtension:
     // No deprecation filter on watchOS

lib/PrintAsObjC/DeclAndTypePrinter.cpp

@@ -827,6 +827,9 @@ class DeclAndTypePrinter::Implementation
       case PlatformKind::iOS:
         plat = "ios";
         break;
+      case PlatformKind::macCatalyst:
+        plat = "maccatalyst";
+        break;
       case PlatformKind::tvOS:
         plat = "tvos";
         break;
@@ -839,6 +842,9 @@ class DeclAndTypePrinter::Implementation
       case PlatformKind::iOSApplicationExtension:
         plat = "ios_app_extension";
         break;
+      case PlatformKind::macCatalystApplicationExtension:
+        plat = "maccatalyst_app_extension";
+        break;
       case PlatformKind::tvOSApplicationExtension:
         plat = "tvos_app_extension";
         break;

lib/Sema/TypeCheckAttr.cpp

@@ -1351,6 +1351,16 @@ void AttributeChecker::visitAvailableAttr(AvailableAttr *attr) {
     return;
   }
 
+  // Make sure there isn't a more specific attribute we should be using instead.
+  // findMostSpecificActivePlatform() is O(N), so only do this if we're checking
+  // an iOS attribute while building for macCatalyst.
+  if (attr->Platform == PlatformKind::iOS &&
+      isPlatformActive(PlatformKind::macCatalyst, Ctx.LangOpts)) {
+    if (attr != D->getAttrs().findMostSpecificActivePlatform(Ctx)) {
+      return;
+    }
+  }
+
   SourceLoc attrLoc = attr->getLocation();
 
   Optional<Diag<>> MaybeNotAllowed =