AST: Use an accessor to get the PlatformKind from an AvailableAttr.

tshortli · tshortli · commit 36230cd9c6f5 · 2024-11-21T09:10:36.000-08:00
diff --git a/include/swift/AST/Attr.h b/include/swift/AST/Attr.h
@@ -768,12 +768,14 @@ class AvailableAttr : public DeclAttribute {
   /// Indicates where the Obsoleted version was specified.
   const SourceRange ObsoletedRange;
 
+private:
   /// Indicates if the declaration has platform-agnostic availability.
   const PlatformAgnosticAvailabilityKind PlatformAgnostic;
 
-  /// The platform of the availability.
+  /// The platform that the attribute applies to (may be `none`).
   const PlatformKind Platform;
 
+public:
   /// Whether this is a language-version-specific entity.
   bool isLanguageVersionSpecific() const;
 
@@ -795,6 +797,9 @@ class AvailableAttr : public DeclAttribute {
   /// Whether this attribute was spelled `@_unavailableInEmbedded`.
   bool isForEmbedded() const { return Bits.AvailableAttr.IsForEmbedded; }
 
+  /// Returns the platform that the attribute applies to (may be `none`).
+  PlatformKind getPlatform() const { return Platform; }
+
   /// Returns the platform-agnostic availability.
   PlatformAgnosticAvailabilityKind getPlatformAgnosticAvailability() const {
     return PlatformAgnostic;
diff --git a/include/swift/Parse/Parser.h b/include/swift/Parse/Parser.h
@@ -2042,7 +2042,7 @@ class Parser {
   };
 
   /// Parse a comma-separated list of availability specifications. Try to
-  /// expand availability macros when /p Source is not a command line macro.
+  /// expand availability macros when \p Source is not a command line macro.
   ParserStatus
   parseAvailabilitySpecList(SmallVectorImpl<AvailabilitySpec *> &Specs,
                             AvailabilitySpecSource Source);
diff --git a/lib/APIDigester/ModuleAnalyzerNodes.cpp b/lib/APIDigester/ModuleAnalyzerNodes.cpp
@@ -1341,9 +1341,9 @@ static bool isABIPlaceHolder(Decl *D) {
   llvm::SmallSet<PlatformKind, 4> Platforms;
   for (auto *ATT: D->getAttrs()) {
     if (auto *AVA = dyn_cast<AvailableAttr>(ATT)) {
-      if (AVA->Platform != PlatformKind::none && AVA->Introduced &&
+      if (AVA->getPlatform() != PlatformKind::none && AVA->Introduced &&
           AVA->Introduced->getMajor() == 9999) {
-        Platforms.insert(AVA->Platform);
+        Platforms.insert(AVA->getPlatform());
       }
     }
   }
@@ -1363,7 +1363,7 @@ StringRef SDKContext::getPlatformIntroVersion(Decl *D, PlatformKind Kind) {
     return StringRef();
   for (auto *ATT: D->getAttrs()) {
     if (auto *AVA = dyn_cast<AvailableAttr>(ATT)) {
-      if (AVA->Platform == Kind && AVA->Introduced) {
+      if (AVA->getPlatform() == Kind && AVA->Introduced) {
         return buffer(AVA->Introduced->getAsString());
       }
     }
diff --git a/lib/AST/Attr.cpp b/lib/AST/Attr.cpp
@@ -413,13 +413,14 @@ DeclAttributes::findMostSpecificActivePlatform(const ASTContext &ctx,
     if (!avAttr->isActivePlatform(ctx))
       continue;
 
-    if (ignoreAppExtensions && isApplicationExtensionPlatform(avAttr->Platform))
+    if (ignoreAppExtensions &&
+        isApplicationExtensionPlatform(avAttr->getPlatform()))
       continue;
 
     // We have an attribute that is active for the platform, but
     // is it more specific than our current best?
-    if (!bestAttr || inheritsAvailabilityFromPlatform(avAttr->Platform,
-                                                      bestAttr->Platform)) {
+    if (!bestAttr || inheritsAvailabilityFromPlatform(
+                         avAttr->getPlatform(), bestAttr->getPlatform())) {
       bestAttr = avAttr;
     }
   }
@@ -452,7 +453,7 @@ DeclAttributes::getUnavailable(const ASTContext &ctx,
         continue;
 
       if (ignoreAppExtensions &&
-          isApplicationExtensionPlatform(AvAttr->Platform))
+          isApplicationExtensionPlatform(AvAttr->getPlatform()))
         continue;
 
       // Unconditional unavailable.
@@ -582,8 +583,8 @@ const AvailableAttr *DeclAttributes::getNoAsync(const ASTContext &ctx) const {
           bestAttr = avAttr;
         } else if (bestAttr && avAttr->hasPlatform() &&
                    bestAttr->hasPlatform() &&
-                   inheritsAvailabilityFromPlatform(avAttr->Platform,
-                                                    bestAttr->Platform)) {
+                   inheritsAvailabilityFromPlatform(avAttr->getPlatform(),
+                                                    bestAttr->getPlatform())) {
           // if they both have a viable platform, use the better one
           bestAttr = avAttr;
         } else if (avAttr->hasPlatform() && !bestAttr->hasPlatform()) {
@@ -655,7 +656,7 @@ static bool isShortAvailable(const DeclAttribute *DA) {
   if (!AvailAttr->Rename.empty())
     return false;
 
-  switch (AvailAttr->PlatformAgnostic) {
+  switch (AvailAttr->getPlatformAgnosticAvailability()) {
   case PlatformAgnosticAvailabilityKind::Deprecated:
   case PlatformAgnosticAvailabilityKind::Unavailable:
   case PlatformAgnosticAvailabilityKind::UnavailableInSwift:
@@ -682,10 +683,11 @@ static bool isShortFormAvailabilityImpliedByOther(const AvailableAttr *Attr,
 
   for (auto *DA : Others) {
     auto *Other = cast<AvailableAttr>(DA);
-    if (Attr->Platform == Other->Platform)
+    if (Attr->getPlatform() == Other->getPlatform())
       continue;
 
-    if (!inheritsAvailabilityFromPlatform(Attr->Platform, Other->Platform))
+    if (!inheritsAvailabilityFromPlatform(Attr->getPlatform(),
+                                          Other->getPlatform()))
       continue;
 
     if (Attr->Introduced == Other->Introduced)
@@ -730,7 +732,7 @@ static void printShortFormAvailable(ArrayRef<const DeclAttribute *> Attrs,
       if (!Options.IsForSwiftInterface &&
           isShortFormAvailabilityImpliedByOther(AvailAttr, Attrs))
         continue;
-      Printer << platformString(AvailAttr->Platform) << " "
+      Printer << platformString(AvailAttr->getPlatform()) << " "
               << AvailAttr->Introduced.value().getAsString() << ", ";
     }
     Printer << "*";
@@ -959,7 +961,7 @@ static std::optional<PlatformKind>
 referencedPlatform(const DeclAttribute *attr) {
   switch (attr->getKind()) {
   case DeclAttrKind::Available:
-    return static_cast<const AvailableAttr *>(attr)->Platform;
+    return static_cast<const AvailableAttr *>(attr)->getPlatform();
   case DeclAttrKind::BackDeployed:
     return static_cast<const BackDeployedAttr *>(attr)->Platform;
   case DeclAttrKind::OriginallyDefinedIn:
diff --git a/lib/AST/Availability.cpp b/lib/AST/Availability.cpp
@@ -66,7 +66,7 @@ AvailabilityRange AvailabilityRange::forRuntimeTarget(const ASTContext &Ctx) {
 }
 
 PlatformKind AvailabilityConstraint::getPlatform() const {
-  return attr->Platform;
+  return attr->getPlatform();
 }
 
 std::optional<AvailabilityRange>
@@ -94,10 +94,10 @@ bool AvailabilityConstraint::isConditionallySatisfiable() const {
 }
 
 bool AvailabilityConstraint::isActiveForRuntimeQueries(ASTContext &ctx) const {
-  if (attr->Platform == PlatformKind::none)
+  if (attr->getPlatform() == PlatformKind::none)
     return true;
 
-  return swift::isPlatformActive(attr->Platform, ctx.LangOpts,
+  return swift::isPlatformActive(attr->getPlatform(), ctx.LangOpts,
                                  /*forTargetVariant=*/false,
                                  /*forRuntimeQuery=*/true);
 }
@@ -220,14 +220,14 @@ void AvailabilityInference::applyInferredAvailableAttrs(
         // Skip an attribute from an outer declaration if it is for a platform
         // that was already handled implicitly by an attribute from an inner
         // declaration.
-        if (llvm::any_of(MergedAttrs,
-                         [&AvAttr](const AvailableAttr *MergedAttr) {
-                           return inheritsAvailabilityFromPlatform(
-                               AvAttr->Platform, MergedAttr->Platform);
-                         }))
+        if (llvm::any_of(
+                MergedAttrs, [&AvAttr](const AvailableAttr *MergedAttr) {
+                  return inheritsAvailabilityFromPlatform(
+                      AvAttr->getPlatform(), MergedAttr->getPlatform());
+                }))
           continue;
 
-        mergeWithInferredAvailability(AvAttr, Inferred[AvAttr->Platform]);
+        mergeWithInferredAvailability(AvAttr, Inferred[AvAttr->getPlatform()]);
         PendingAttrs.push_back(AvAttr);
 
         if (Message.empty() && !AvAttr->Message.empty())
@@ -302,12 +302,12 @@ static bool isBetterThan(const AvailableAttr *newAttr,
     return true;
 
   // If they belong to the same platform, the one that introduces later wins.
-  if (prevAttr->Platform == newAttr->Platform)
+  if (prevAttr->getPlatform() == newAttr->getPlatform())
     return prevAttr->Introduced.value() < newAttr->Introduced.value();
 
   // If the new attribute's platform inherits from the old one, it wins.
-  return inheritsAvailabilityFromPlatform(newAttr->Platform,
-                                          prevAttr->Platform);
+  return inheritsAvailabilityFromPlatform(newAttr->getPlatform(),
+                                          prevAttr->getPlatform());
 }
 
 static const clang::DarwinSDKInfo::RelatedTargetVersionMapping *
@@ -348,7 +348,8 @@ bool AvailabilityInference::updateIntroducedPlatformForFallback(
     const AvailableAttr *attr, const ASTContext &Ctx, llvm::StringRef &Platform,
     llvm::VersionTuple &PlatformVer) {
   std::optional<llvm::VersionTuple> IntroducedVersion = attr->Introduced;
-  if (attr->Platform == PlatformKind::iOS && IntroducedVersion.has_value() &&
+  if (attr->getPlatform() == PlatformKind::iOS &&
+      IntroducedVersion.has_value() &&
       isPlatformActive(PlatformKind::visionOS, Ctx.LangOpts)) {
     // We re-map the iOS introduced version to the corresponding visionOS version
     auto PotentiallyRemappedIntroducedVersion =
@@ -367,7 +368,8 @@ bool AvailabilityInference::updateDeprecatedPlatformForFallback(
     const AvailableAttr *attr, const ASTContext &Ctx, llvm::StringRef &Platform,
     llvm::VersionTuple &PlatformVer) {
   std::optional<llvm::VersionTuple> DeprecatedVersion = attr->Deprecated;
-  if (attr->Platform == PlatformKind::iOS && DeprecatedVersion.has_value() &&
+  if (attr->getPlatform() == PlatformKind::iOS &&
+      DeprecatedVersion.has_value() &&
       isPlatformActive(PlatformKind::visionOS, Ctx.LangOpts)) {
     // We re-map the iOS deprecated version to the corresponding visionOS version
     auto PotentiallyRemappedDeprecatedVersion =
@@ -386,7 +388,8 @@ bool AvailabilityInference::updateObsoletedPlatformForFallback(
     const AvailableAttr *attr, const ASTContext &Ctx, llvm::StringRef &Platform,
     llvm::VersionTuple &PlatformVer) {
   std::optional<llvm::VersionTuple> ObsoletedVersion = attr->Obsoleted;
-  if (attr->Platform == PlatformKind::iOS && ObsoletedVersion.has_value() &&
+  if (attr->getPlatform() == PlatformKind::iOS &&
+      ObsoletedVersion.has_value() &&
       isPlatformActive(PlatformKind::visionOS, Ctx.LangOpts)) {
     // We re-map the iOS obsoleted version to the corresponding visionOS version
     auto PotentiallyRemappedObsoletedVersion =
@@ -403,7 +406,7 @@ bool AvailabilityInference::updateObsoletedPlatformForFallback(
 
 void AvailabilityInference::updatePlatformStringForFallback(
     const AvailableAttr *attr, const ASTContext &Ctx, llvm::StringRef &Platform) {
-  if (attr->Platform == PlatformKind::iOS &&
+  if (attr->getPlatform() == PlatformKind::iOS &&
       isPlatformActive(PlatformKind::visionOS, Ctx.LangOpts)) {
     Platform = swift::prettyPlatformString(PlatformKind::visionOS);
   }
@@ -525,7 +528,7 @@ bool Decl::isUnreachableAtRuntime() const {
     return false;
 
   // Universally unavailable declarations are always unreachable.
-  if (unavailableAttr->Platform == PlatformKind::none)
+  if (unavailableAttr->getPlatform() == PlatformKind::none)
     return true;
 
   // FIXME: Support zippered frameworks (rdar://125371621)
diff --git a/lib/AST/AvailabilityContext.cpp b/lib/AST/AvailabilityContext.cpp
@@ -58,7 +58,7 @@ bool AvailabilityContext::PlatformInfo::constrainWith(const Decl *decl) {
     isConstrained |= constrainRange(Range, *range);
 
   if (auto *attr = decl->getAttrs().getUnavailable(ctx)) {
-    isConstrained |= constrainUnavailability(attr->Platform);
+    isConstrained |= constrainUnavailability(attr->getPlatform());
     isConstrained |=
         CONSTRAIN_BOOL(IsUnavailableInEmbedded, attr->isForEmbedded());
   }
diff --git a/lib/AST/AvailabilityScope.cpp b/lib/AST/AvailabilityScope.cpp
@@ -301,7 +301,7 @@ getAvailabilityConditionVersionSourceRange(const DeclAttributes &DeclAttrs,
   for (auto *Attr : DeclAttrs) {
     if (auto *AA = dyn_cast<AvailableAttr>(Attr)) {
       if (AA->Introduced.has_value() && AA->Introduced.value() == Version &&
-          AA->Platform == Platform) {
+          AA->getPlatform() == Platform) {
 
         // More than one: return invalid range.
         if (Range.isValid())
diff --git a/lib/AST/Decl.cpp b/lib/AST/Decl.cpp
@@ -557,7 +557,7 @@ std::optional<llvm::VersionTuple>
 Decl::getIntroducedOSVersion(PlatformKind Kind) const {
   for (auto *attr: getAttrs()) {
     if (auto *ava = dyn_cast<AvailableAttr>(attr)) {
-      if (ava->Platform == Kind && ava->Introduced) {
+      if (ava->getPlatform() == Kind && ava->Introduced) {
         return ava->Introduced;
       }
     }
@@ -9253,7 +9253,8 @@ AbstractFunctionDecl *AbstractFunctionDecl::getAsyncAlternative() const {
     // `getAttrs` is in reverse source order, so the last attribute is the
     // first in source
     if (!attr->Rename.empty() &&
-        (attr->Platform == PlatformKind::none || !avAttr) && !attr->isNoAsync()) {
+        (attr->getPlatform() == PlatformKind::none || !avAttr) &&
+        !attr->isNoAsync()) {
       avAttr = attr;
     }
   }
diff --git a/lib/Frontend/ModuleInterfaceSupport.cpp b/lib/Frontend/ModuleInterfaceSupport.cpp
@@ -456,8 +456,8 @@ class InheritedProtocolCollector {
         // attributes for the same platform; formally they'd need to be merged.
         bool alreadyHasMoreSpecificAttrForThisPlatform =
             llvm::any_of(*cache, [nextAttr](const AvailableAttr *existingAttr) {
-          return existingAttr->Platform == nextAttr->Platform;
-        });
+              return existingAttr->getPlatform() == nextAttr->getPlatform();
+            });
         if (alreadyHasMoreSpecificAttrForThisPlatform)
           continue;
         cache->push_back(nextAttr);
diff --git a/lib/IRGen/TBDGen.cpp b/lib/IRGen/TBDGen.cpp
@@ -773,11 +773,11 @@ class APIGenRecorder final : public APIRecorder {
     auto platform = targetPlatform(module->getASTContext().LangOpts);
     for (auto *attr : decl->getAttrs()) {
       if (auto *ava = dyn_cast<AvailableAttr>(attr)) {
-        if (ava->Platform == PlatformKind::none) {
+        if (ava->getPlatform() == PlatformKind::none) {
           hasFallbackUnavailability = ava->isUnconditionallyUnavailable();
           continue;
         }
-        if (ava->Platform != platform)
+        if (ava->getPlatform() != platform)
           continue;
         unavailable = ava->isUnconditionallyUnavailable();
         if (ava->Introduced)
diff --git a/lib/PrintAsClang/DeclAndTypePrinter.cpp b/lib/PrintAsClang/DeclAndTypePrinter.cpp
@@ -1686,8 +1686,8 @@ class DeclAndTypePrinter::Implementation
     };
 
     for (auto AvAttr : D->getAttrs().getAttributes<AvailableAttr>()) {
-      if (AvAttr->Platform == PlatformKind::none) {
-        if (AvAttr->PlatformAgnostic ==
+      if (AvAttr->getPlatform() == PlatformKind::none) {
+        if (AvAttr->getPlatformAgnosticAvailability() ==
             PlatformAgnosticAvailabilityKind::Unavailable) {
           // Availability for *
           if (!AvAttr->Rename.empty() && isa<ValueDecl>(D)) {
@@ -1741,7 +1741,7 @@ class DeclAndTypePrinter::Implementation
       }
 
       const char *plat;
-      switch (AvAttr->Platform) {
+      switch (AvAttr->getPlatform()) {
       case PlatformKind::macOS:
         plat = "macos";
         break;
diff --git a/lib/Sema/TypeCheckAttr.cpp b/lib/Sema/TypeCheckAttr.cpp
@@ -2164,14 +2164,14 @@ void AttributeChecker::visitAvailableAttr(AvailableAttr *attr) {
   // 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 &&
+  if (attr->getPlatform() == PlatformKind::iOS &&
       isPlatformActive(PlatformKind::macCatalyst, Ctx.LangOpts)) {
     if (attr != D->getAttrs().findMostSpecificActivePlatform(Ctx)) {
       return;
     }
   }
 
-  if (attr->Platform == PlatformKind::iOS &&
+  if (attr->getPlatform() == PlatformKind::iOS &&
       isPlatformActive(PlatformKind::visionOS, Ctx.LangOpts)) {
     if (attr != D->getAttrs().findMostSpecificActivePlatform(Ctx)) {
       return;
@@ -4798,7 +4798,7 @@ void AttributeChecker::checkBackDeployedAttrs(
     // Unavailable decls cannot be back deployed.
     if (auto unavailableAttrPair = VD->getSemanticUnavailableAttr()) {
       auto unavailableAttr = unavailableAttrPair.value().first;
-      if (!inheritsAvailabilityFromPlatform(unavailableAttr->Platform,
+      if (!inheritsAvailabilityFromPlatform(unavailableAttr->getPlatform(),
                                             Attr->Platform)) {
         auto platformString = prettyPlatformString(Attr->Platform);
         llvm::VersionTuple ignoredVersion;
diff --git a/lib/Sema/TypeCheckAvailability.cpp b/lib/Sema/TypeCheckAvailability.cpp
@@ -354,7 +354,7 @@ static bool isInsideCompatibleUnavailableDeclaration(
 
   // Refuse calling universally unavailable functions from unavailable code,
   // but allow the use of types.
-  PlatformKind platform = attr->Platform;
+  PlatformKind platform = attr->getPlatform();
   if (platform == PlatformKind::none && !attr->isForEmbedded() &&
       !isa<TypeDecl>(D) && !isa<ExtensionDecl>(D))
     return false;
@@ -3004,7 +3004,7 @@ getExplicitUnavailabilityDiagnosticInfo(const Decl *decl,
 
   case PlatformAgnosticAvailabilityKind::None:
   case PlatformAgnosticAvailabilityKind::Unavailable:
-    if (attr->Platform != PlatformKind::none) {
+    if (attr->getPlatform() != PlatformKind::none) {
       platform = attr->prettyPlatformString();
       versionedPlatform = platform;
     }
diff --git a/lib/Sema/TypeCheckConcurrency.cpp b/lib/Sema/TypeCheckConcurrency.cpp
@@ -6627,12 +6627,12 @@ static void addUnavailableAttrs(ExtensionDecl *ext, NominalTypeDecl *nominal) {
            : nullptr) {
     bool anyPlatformSpecificAttrs = false;
     for (auto available: enclosing->getAttrs().getAttributes<AvailableAttr>()) {
-      if (available->Platform == PlatformKind::none)
+      if (available->getPlatform() == PlatformKind::none)
         continue;
 
       auto attr = new (ctx) AvailableAttr(
           SourceLoc(), SourceRange(),
-          available->Platform,
+          available->getPlatform(),
           available->Message,
           "", nullptr,
           available->Introduced.value_or(noVersion), SourceRange(),
diff --git a/lib/Sema/TypeCheckDeclPrimary.cpp b/lib/Sema/TypeCheckDeclPrimary.cpp
@@ -916,8 +916,8 @@ CheckRedeclarationRequest::evaluate(Evaluator &eval, ValueDecl *current,
           static AvailabilityRange from(const ValueDecl *VD) {
             AvailabilityRange result;
             for (auto *attr : VD->getAttrs().getAttributes<AvailableAttr>()) {
-              if (attr->PlatformAgnostic ==
-                    PlatformAgnosticAvailabilityKind::SwiftVersionSpecific) {
+              if (attr->getPlatformAgnosticAvailability() ==
+                  PlatformAgnosticAvailabilityKind::SwiftVersionSpecific) {
                 if (attr->Introduced)
                   result.introduced = attr->Introduced;
                 if (attr->Obsoleted)
diff --git a/lib/Serialization/Serialization.cpp b/lib/Serialization/Serialization.cpp
diff --git a/lib/SymbolGraphGen/AvailabilityMixin.cpp b/lib/SymbolGraphGen/AvailabilityMixin.cpp
diff --git a/lib/SymbolGraphGen/SymbolGraphASTWalker.cpp b/lib/SymbolGraphGen/SymbolGraphASTWalker.cpp
diff --git a/tools/SourceKit/lib/SwiftLang/SwiftDocSupport.cpp b/tools/SourceKit/lib/SwiftLang/SwiftDocSupport.cpp

Original file line number	Diff line number	Diff line change
`@@ -1341,9 +1341,9 @@ static bool isABIPlaceHolder(Decl *D) {`
`1341`	`1341`	`llvm::SmallSet<PlatformKind, 4> Platforms;`
`1342`	`1342`	`for (auto *ATT: D->getAttrs()) {`
`1343`	`1343`	`if (auto *AVA = dyn_cast<AvailableAttr>(ATT)) {`
`1344`		`- if (AVA->Platform != PlatformKind::none && AVA->Introduced &&`
	`1344`	`+ if (AVA->getPlatform() != PlatformKind::none && AVA->Introduced &&`
`1345`	`1345`	`AVA->Introduced->getMajor() == 9999) {`
`1346`		`- Platforms.insert(AVA->Platform);`
	`1346`	`+ Platforms.insert(AVA->getPlatform());`
`1347`	`1347`	`}`
`1348`	`1348`	`}`
`1349`	`1349`	`}`
`@@ -1363,7 +1363,7 @@ StringRef SDKContext::getPlatformIntroVersion(Decl *D, PlatformKind Kind) {`
`1363`	`1363`	`return StringRef();`
`1364`	`1364`	`for (auto *ATT: D->getAttrs()) {`
`1365`	`1365`	`if (auto *AVA = dyn_cast<AvailableAttr>(ATT)) {`
`1366`		`- if (AVA->Platform == Kind && AVA->Introduced) {`
	`1366`	`+ if (AVA->getPlatform() == Kind && AVA->Introduced) {`
`1367`	`1367`	`return buffer(AVA->Introduced->getAsString());`
`1368`	`1368`	`}`
`1369`	`1369`	`}`
Original file line number	Diff line number	Diff line change
`@@ -58,7 +58,7 @@ bool AvailabilityContext::PlatformInfo::constrainWith(const Decl *decl) {`
`58`	`58`	`isConstrained \|= constrainRange(Range, *range);`
`59`	`59`
`60`	`60`	`if (auto *attr = decl->getAttrs().getUnavailable(ctx)) {`
`61`		`- isConstrained \|= constrainUnavailability(attr->Platform);`
	`61`	`+ isConstrained \|= constrainUnavailability(attr->getPlatform());`
`62`	`62`	`isConstrained \|=`
`63`	`63`	`CONSTRAIN_BOOL(IsUnavailableInEmbedded, attr->isForEmbedded());`
`64`	`64`	`}`
Original file line number	Diff line number	Diff line change
`@@ -557,7 +557,7 @@ std::optional<llvm::VersionTuple>`
`557`	`557`	`Decl::getIntroducedOSVersion(PlatformKind Kind) const {`
`558`	`558`	`for (auto *attr: getAttrs()) {`
`559`	`559`	`if (auto *ava = dyn_cast<AvailableAttr>(attr)) {`
`560`		`- if (ava->Platform == Kind && ava->Introduced) {`
	`560`	`+ if (ava->getPlatform() == Kind && ava->Introduced) {`
`561`	`561`	`return ava->Introduced;`
`562`	`562`	`}`
`563`	`563`	`}`
`@@ -9253,7 +9253,8 @@ AbstractFunctionDecl *AbstractFunctionDecl::getAsyncAlternative() const {`
`9253`	`9253`	// `getAttrs` is in reverse source order, so the last attribute is the
`9254`	`9254`	`// first in source`
`9255`	`9255`	`if (!attr->Rename.empty() &&`
`9256`		`- (attr->Platform == PlatformKind::none \|\| !avAttr) && !attr->isNoAsync()) {`
	`9256`	`+ (attr->getPlatform() == PlatformKind::none \|\| !avAttr) &&`
	`9257`	`+ !attr->isNoAsync()) {`
`9257`	`9258`	`avAttr = attr;`
`9258`	`9259`	`}`
`9259`	`9260`	`}`