[Sema] Make sure that -Wunguarded-availability emits notes at the right redeclaration

[erik.pilkington]

Summary

This is done by modifying ShouldDiagnoseAvailabilityOfDecl() so that the OffendingDecl is the one with the original availability attribute. Also, keep track of this availability attribute so we don't have to constantly recompute it via getAttrForPlatform().

Thanks for taking a look!
Erik

[erik.pilkington]

On second thought, I think it makes more sense to do this right before we emit a diagnostic so we have the most recent redecl with all the inherited availability attributes until then. I'll put a diff up for that tomorrow!

include/clang/AST/DeclBase.h

   /// the given declaration (e.g., preferring 'unavailable' to
   /// 'deprecated').
   ///
   /// \param Message If non-NULL and the result is not \c
   /// AR_Available, will be set to a (possibly empty) message
   /// describing why the declaration has not been introduced, is
   /// deprecated, or is unavailable.
   ///
-  /// \param EnclosingVersion The version to compare with. If empty, assume the
-  /// deployment target version.
-  AvailabilityResult
-  getAvailability(std::string *Message = nullptr,
-                  VersionTuple EnclosingVersion = VersionTuple()) const;
+  /// \param Attribute The attribute that lead to this result. One of
+  /// UnavailableAttr, DeprecatedAttr, AvailabilityAttr, or nullptr.
+  AvailabilityResult getAvailability(std::string *Message = nullptr,
+                                     const Attr **Attribute = nullptr) const;
 
   /// \brief Retrieve the version of the target platform in which this
   /// declaration was introduced.
   ///
   /// \returns An empty version tuple if this declaration has no 'introduced'
   /// availability attributes, or the version tuple that's specified in the
   /// attribute otherwise.
   VersionTuple getVersionIntroduced() const;

include/clang/Sema/DelayedDiagnostic.h

public:
   SourceLocation Loc;
 
   void Destroy();
 
   static DelayedDiagnostic makeAvailability(AvailabilityResult AR,
                                             SourceLocation Loc,
                                             const NamedDecl *ReferringDecl,
                                             const NamedDecl *OffendingDecl,
+                                            const Attr *OffendingAttr,
                                             const ObjCInterfaceDecl *UnknownObjCClass,
                                             const ObjCPropertyDecl  *ObjCProperty,
                                             StringRef Msg,
                                             bool ObjCPropertyAccess);
 
 
   static DelayedDiagnostic makeAccess(SourceLocation Loc,
                                       const AccessedEntity &Entity) {
public:
   const ObjCPropertyDecl *getObjCProperty() const {
     return AvailabilityData.ObjCProperty;
   }
 
   bool getObjCPropertyAccess() const {
     return AvailabilityData.ObjCPropertyAccess;
   }
 
+  const Attr *getAvailabilityAttr() const {
+    return AvailabilityData.OffendingAttr;
+  }
+
 private:
 
   struct AD {
     const NamedDecl *ReferringDecl;
     const NamedDecl *OffendingDecl;
+    const Attr *OffendingAttr;
     const ObjCInterfaceDecl *UnknownObjCClass;
     const ObjCPropertyDecl  *ObjCProperty;
     const char *Message;
     size_t MessageLen;
     AvailabilityResult AR;
     bool ObjCPropertyAccess;
   };
 

lib/AST/DeclBase.cpp

 /// When it returns an availability result other than \c AR_Available,
 /// if the \p Message parameter is non-NULL, it will be set to a
 /// string describing why the entity is unavailable.
 ///
 /// FIXME: Make these strings localizable, since they end up in
 /// diagnostics.
 static AvailabilityResult CheckAvailability(ASTContext &Context,
                                             const AvailabilityAttr *A,
-                                            std::string *Message,
-                                            VersionTuple EnclosingVersion) {
-  if (EnclosingVersion.empty())
-    EnclosingVersion = Context.getTargetInfo().getPlatformMinVersion();
-
+                                            std::string *Message) {
+  VersionTuple EnclosingVersion =
+    Context.getTargetInfo().getPlatformMinVersion();
   if (EnclosingVersion.empty())
     return AR_Available;
 
   StringRef ActualPlatform = A->getPlatform()->getName();
   StringRef TargetPlatform = Context.getTargetInfo().getPlatformName();
 
   // Match the platform name.
   if (getRealizedPlatform(A, Context) != TargetPlatform)
if (!A->getDeprecated().empty() && EnclosingVersion >= A->getDeprecated()) {
     
     return AR_Deprecated;
   }
 
   return AR_Available;
 }
 
 AvailabilityResult Decl::getAvailability(std::string *Message,
-                                         VersionTuple EnclosingVersion) const {
+                                         const Attr **Attribute) const {
   if (auto *FTD = dyn_cast<FunctionTemplateDecl>(this))
-    return FTD->getTemplatedDecl()->getAvailability(Message, EnclosingVersion);
+    return FTD->getTemplatedDecl()->getAvailability(Message, Attribute);
 
   AvailabilityResult Result = AR_Available;
+  const Attr *CorrispondingAttr = nullptr;
   std::string ResultMessage;
 
   for (const auto *A : attrs()) {
     if (const auto *Deprecated = dyn_cast<DeprecatedAttr>(A)) {
       if (Result >= AR_Deprecated)
         continue;
 
       if (Message)
         ResultMessage = Deprecated->getMessage();
-
+      CorrispondingAttr = Deprecated;
       Result = AR_Deprecated;
       continue;
     }
 
     if (const auto *Unavailable = dyn_cast<UnavailableAttr>(A)) {
       if (Message)
         *Message = Unavailable->getMessage();
+      if (Attribute)
+        *Attribute = Unavailable;
       return AR_Unavailable;
     }
 
     if (const auto *Availability = dyn_cast<AvailabilityAttr>(A)) {
-      AvailabilityResult AR = CheckAvailability(getASTContext(), Availability,
-                                                Message, EnclosingVersion);
+      AvailabilityResult AR =
+          CheckAvailability(getASTContext(), Availability, Message);
 
-      if (AR == AR_Unavailable)
+      if (AR == AR_Unavailable) {
+        if (Attribute)
+          *Attribute = Availability;
         return AR_Unavailable;
+      }
 
       if (AR > Result) {
         Result = AR;
+        CorrispondingAttr = Availability;
         if (Message)
           ResultMessage.swap(*Message);
       }
       continue;
     }
   }
 
   if (Message)
     Message->swap(ResultMessage);
+  if (Attribute)
+    *Attribute = CorrispondingAttr;
   return Result;
 }
 
 VersionTuple Decl::getVersionIntroduced() const {
   const ASTContext &Context = getASTContext();
   StringRef TargetPlatform = Context.getTargetInfo().getPlatformName();
   for (const auto *A : attrs()) {
     if (const auto *Availability = dyn_cast<AvailabilityAttr>(A)) {
bool Decl::isWeakImported() const {
   if (!canBeWeakImported(IsDefinition))
     return false;
 
   for (const auto *A : attrs()) {
     if (isa<WeakImportAttr>(A))
       return true;
 
     if (const auto *Availability = dyn_cast<AvailabilityAttr>(A)) {
-      if (CheckAvailability(getASTContext(), Availability, nullptr,
-                            VersionTuple()) == AR_NotYetIntroduced)
+      if (CheckAvailability(getASTContext(), Availability, nullptr) ==
+          AR_NotYetIntroduced)
         return true;
     }
   }
 
   return false;
 }
 
 unsigned Decl::getIdentifierNamespaceForKind(Kind DeclKind) {

lib/Sema/DelayedDiagnostic.cpp

 using namespace clang;
 using namespace sema;
 
 DelayedDiagnostic
 DelayedDiagnostic::makeAvailability(AvailabilityResult AR,
                                     SourceLocation Loc,
                                     const NamedDecl *ReferringDecl,
                                     const NamedDecl *OffendingDecl,
+                                    const Attr *OffendingAttr,
                                     const ObjCInterfaceDecl *UnknownObjCClass,
                                     const ObjCPropertyDecl  *ObjCProperty,
                                     StringRef Msg,
                                     bool ObjCPropertyAccess) {
   DelayedDiagnostic DD;
   DD.Kind = Availability;
   DD.Triggered = false;
   DD.Loc = Loc;
   DD.AvailabilityData.ReferringDecl = ReferringDecl;
   DD.AvailabilityData.OffendingDecl = OffendingDecl;
+  DD.AvailabilityData.OffendingAttr = OffendingAttr;
   DD.AvailabilityData.UnknownObjCClass = UnknownObjCClass;
   DD.AvailabilityData.ObjCProperty = ObjCProperty;
   char *MessageData = nullptr;
   if (Msg.size()) {
     MessageData = new char [Msg.size()];
     memcpy(MessageData, Msg.data(), Msg.size());
   }
 

lib/Sema/SemaDeclAttr.cpp

       }
     }
 
   S.Diag(diag.Loc, diag.getForbiddenTypeDiagnostic())
     << diag.getForbiddenTypeOperand() << diag.getForbiddenTypeArgument();
   diag.Triggered = true;
 }
 
-static const AvailabilityAttr *getAttrForPlatform(ASTContext &Context,
-                                                  const Decl *D) {
-  // Check each AvailabilityAttr to find the one for this platform.
-  for (const auto *A : D->attrs()) {
-    if (const auto *Avail = dyn_cast<AvailabilityAttr>(A)) {
-      // FIXME: this is copied from CheckAvailability. We should try to
-      // de-duplicate.
-
-      // Check if this is an App Extension "platform", and if so chop off
-      // the suffix for matching with the actual platform.
-      StringRef ActualPlatform = Avail->getPlatform()->getName();
-      StringRef RealizedPlatform = ActualPlatform;
-      if (Context.getLangOpts().AppExt) {
-        size_t suffix = RealizedPlatform.rfind("_app_extension");
-        if (suffix != StringRef::npos)
-          RealizedPlatform = RealizedPlatform.slice(0, suffix);
-      }
-
-      StringRef TargetPlatform = Context.getTargetInfo().getPlatformName();
-
-      // Match the platform name.
-      if (RealizedPlatform == TargetPlatform)
-        return Avail;
-    }
-  }
-  return nullptr;
-}
-
 /// The diagnostic we should emit for \c D, and the declaration that
 /// originated it, or \c AR_Available.
 ///
 /// \param D The declaration to check.
 /// \param Message If non-null, this will be populated with the message from
 /// the availability attribute that is selected.
-static std::pair<AvailabilityResult, const NamedDecl *>
+static std::tuple<AvailabilityResult, const NamedDecl *, const Attr *>
 ShouldDiagnoseAvailabilityOfDecl(const NamedDecl *D, std::string *Message) {
-  AvailabilityResult Result = D->getAvailability(Message);
+  const Attr *Attribute = nullptr;
+  AvailabilityResult Result = D->getAvailability(Message, &Attribute);
 
   // For typedefs, if the typedef declaration appears available look
   // to the underlying type to see if it is more restrictive.
   while (const TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D)) {
     if (Result == AR_Available) {
       if (const TagType *TT = TD->getUnderlyingType()->getAs<TagType>()) {
         D = TT->getDecl();
-        Result = D->getAvailability(Message);
+        Result = D->getAvailability(Message, &Attribute);
         continue;
       }
     }
     break;
   }
 
   // Forward class declarations get their attributes from their definition.
   if (const ObjCInterfaceDecl *IDecl = dyn_cast<ObjCInterfaceDecl>(D)) {
     if (IDecl->getDefinition()) {
       D = IDecl->getDefinition();
-      Result = D->getAvailability(Message);
+      Result = D->getAvailability(Message, &Attribute);
     }
   }
 
   if (const auto *ECD = dyn_cast<EnumConstantDecl>(D))
     if (Result == AR_Available) {
       const DeclContext *DC = ECD->getDeclContext();
       if (const auto *TheEnumDecl = dyn_cast<EnumDecl>(DC)) {
-        Result = TheEnumDecl->getAvailability(Message);
+        Result = TheEnumDecl->getAvailability(Message, &Attribute);
         D = TheEnumDecl;
       }
     }
 
-  return {Result, D};
+  // This decl could only have an inherited attribute, prefer pointing at the
+  // decl with the original availability attribute.
+  if (Attribute && Attribute->isInherited()) {
+    for (const NamedDecl *Redecl = D->getMostRecentDecl(); Redecl;
+         Redecl = cast_or_null<NamedDecl>(Redecl->getPreviousDecl())) {
+      for (const auto *RedeclAttr : Redecl->attrs()) {
+        if (RedeclAttr->isInherited())
+          continue;
+
+        if (isa<UnavailableAttr>(Attribute) && isa<UnavailableAttr>(RedeclAttr))
+          return {AR_Unavailable, Redecl, cast<UnavailableAttr>(RedeclAttr)};
+
+        if (isa<DeprecatedAttr>(Attribute) && isa<DeprecatedAttr>(RedeclAttr))
+          return {AR_Deprecated, Redecl, cast<DeprecatedAttr>(RedeclAttr)};
+
+        const AvailabilityAttr *RedeclAA =
+            dyn_cast<AvailabilityAttr>(RedeclAttr);
+        const AvailabilityAttr *OrigAA = dyn_cast<AvailabilityAttr>(Attribute);
+        if (!RedeclAA || !OrigAA)
+          continue;
+
+        // Check if this is an App Extension "platform", and if so chop off
+        // the suffix for matching with the actual platform.
+        StringRef ActualPlatform = RedeclAA->getPlatform()->getName();
+        StringRef RealizedPlatform = ActualPlatform;
+        if (Redecl->getASTContext().getLangOpts().AppExt) {
+          size_t suffix = RealizedPlatform.rfind("_app_extension");
+          if (suffix != StringRef::npos)
+            RealizedPlatform = RealizedPlatform.slice(0, suffix);
+        }
+
+        StringRef TargetPlatform =
+            Redecl->getASTContext().getTargetInfo().getPlatformName();
+
+        // Match the platform name.
+        if (RealizedPlatform != TargetPlatform)
+          continue;
+
+        bool EqualAttr;
+        switch (Result) {
+        case AR_NotYetIntroduced:
+          EqualAttr = RedeclAA->getIntroduced() == OrigAA->getIntroduced();
+          break;
+        case AR_Deprecated:
+          EqualAttr = RedeclAA->getDeprecated() == OrigAA->getDeprecated();
+          break;
+        case AR_Unavailable:
+          EqualAttr = RedeclAA->getObsoleted() == OrigAA->getObsoleted();
+          break;
+        default:
+          EqualAttr = false;
+        }
+        if (EqualAttr)
+          return {Result, Redecl, RedeclAA};
+      }
+    }
+  }
+
+  return {Result, D, Attribute};
 }
 
 
 /// \brief whether we should emit a diagnostic for \c K and \c DeclVersion in
 /// the context of \c Ctx. For example, we should emit an unavailable diagnostic
 /// in a deprecated context, but not the other way around.
 static bool ShouldDiagnoseAvailabilityInContext(Sema &S, AvailabilityResult K,
                                                 VersionTuple DeclVersion,
                                                 Decl *Ctx) {
   assert(K != AR_Available && "Expected an unavailable declaration here!");
 
   // Checks if we should emit the availability diagnostic in the context of C.
   auto CheckContext = [&](const Decl *C) {
     if (K == AR_NotYetIntroduced) {
-      if (const AvailabilityAttr *AA = getAttrForPlatform(S.Context, C))
-        if (AA->getIntroduced() >= DeclVersion)
-          return true;
+      if (C->getVersionIntroduced() >= DeclVersion)
+        return true;
     } else if (K == AR_Deprecated)
       if (C->isDeprecated())
         return true;
 
     if (C->isUnavailable())
       return true;
     return false;
   };

 /// \param OffendingDecl A related decl to \c ReferringDecl that has an
 /// availability attribute corrisponding to \c K attached to it. Note that this
 /// may not be the same as ReferringDecl, i.e. if an EnumDecl is annotated and
 /// we refer to a member EnumConstantDecl, ReferringDecl is the EnumConstantDecl
 /// and OffendingDecl is the EnumDecl.
 static void DoEmitAvailabilityWarning(Sema &S, AvailabilityResult K,
                                       Decl *Ctx, const NamedDecl *ReferringDecl,
                                       const NamedDecl *OffendingDecl,
+                                      const Attr *OffendingAttr,
                                       StringRef Message, SourceLocation Loc,
                                       const ObjCInterfaceDecl *UnknownObjCClass,
                                       const ObjCPropertyDecl *ObjCProperty,
                                       bool ObjCPropertyAccess) {
   // Diagnostics for deprecated or unavailable.
   unsigned diag, diag_message, diag_fwdclass_message;
   unsigned diag_available_here = diag::note_availability_specified_here;
   SourceLocation NoteLocation = OffendingDecl->getLocation();
 
   // Matches 'diag::note_property_attribute' options.
   unsigned property_note_select;
 
   // Matches diag::note_availability_specified_here.
   unsigned available_here_select_kind;
 
   VersionTuple DeclVersion;
-  if (const AvailabilityAttr *AA = getAttrForPlatform(S.Context, OffendingDecl))
+  if (const AvailabilityAttr *AA = dyn_cast<AvailabilityAttr>(OffendingAttr))
     DeclVersion = AA->getIntroduced();
 
   if (!ShouldDiagnoseAvailabilityInContext(S, K, DeclVersion, Ctx))
     return;
 
   switch (K) {
   case AR_Deprecated:
     diag = !ObjCPropertyAccess ? diag::warn_deprecated

   case AR_Unavailable:
     diag = !ObjCPropertyAccess ? diag::err_unavailable
                                : diag::err_property_method_unavailable;
     diag_message = diag::err_unavailable_message;
     diag_fwdclass_message = diag::warn_unavailable_fwdclass_message;
     property_note_select = /* unavailable */ 1;
     available_here_select_kind = /* unavailable */ 0;
 
-    if (auto attr = OffendingDecl->getAttr<UnavailableAttr>()) {
+    if (auto attr = dyn_cast<UnavailableAttr>(OffendingAttr)) {
       if (attr->isImplicit() && attr->getImplicitReason()) {
         // Most of these failures are due to extra restrictions in ARC;
         // reflect that in the primary diagnostic when applicable.
         auto flagARCError = [&] {
           if (S.getLangOpts().ObjCAutoRefCount &&
               S.getSourceManager().isInSystemHeader(
                   OffendingDecl->getLocation()))
             diag = diag::err_unavailable_in_arc;

     }
     break;
 
   case AR_NotYetIntroduced: {
     // We would like to emit the diagnostic even if -Wunguarded-availability is
     // not specified for deployment targets >= to iOS 11 or equivalent or
     // for declarations that were introduced in iOS 11 (macOS 10.13, ...) or
     // later.
-    const AvailabilityAttr *AA =
-        getAttrForPlatform(S.getASTContext(), OffendingDecl);
+    const AvailabilityAttr *AA = cast<AvailabilityAttr>(OffendingAttr);
     VersionTuple Introduced = AA->getIntroduced();
     bool NewWarning = shouldDiagnoseAvailabilityByDefault(
         S.Context, S.Context.getTargetInfo().getPlatformMinVersion(),
         Introduced);
     diag = NewWarning ? diag::warn_partial_availability_new
                       : diag::warn_partial_availability;
     diag_message = NewWarning ? diag::warn_partial_message_new
                               : diag::warn_partial_message;
     diag_fwdclass_message = NewWarning ? diag::warn_partial_fwdclass_message_new
                                        : diag::warn_partial_fwdclass_message;
     property_note_select = /* partial */ 2;
     available_here_select_kind = /* partial */ 3;
     break;
   }
 
   case AR_Available:
     llvm_unreachable("Warning for availability of available declaration?");
   }
 
   CharSourceRange UseRange;
   StringRef Replacement;
   if (K == AR_Deprecated) {
-    if (auto attr = OffendingDecl->getAttr<DeprecatedAttr>())
+    if (auto attr = dyn_cast<DeprecatedAttr>(OffendingAttr))
       Replacement = attr->getReplacement();
-    if (auto attr = getAttrForPlatform(S.Context, OffendingDecl))
+    if (auto attr = dyn_cast<AvailabilityAttr>(OffendingAttr))
       Replacement = attr->getReplacement();
 
     if (!Replacement.empty())
       UseRange =
           CharSourceRange::getCharRange(Loc, S.getLocForEndOfToken(Loc));
   }
 
   if (!Message.empty()) {

           << ObjCProperty->getDeclName() << property_note_select;
   } else {
     S.Diag(Loc, diag_fwdclass_message) << ReferringDecl
       << (UseRange.isValid() ?
           FixItHint::CreateReplacement(UseRange, Replacement) : FixItHint());
     S.Diag(UnknownObjCClass->getLocation(), diag::note_forward_class);
   }
 
-  // The declaration can have multiple availability attributes, we are looking
-  // at one of them.
-  const AvailabilityAttr *A = getAttrForPlatform(S.Context, OffendingDecl);
-  if (A && A->isInherited()) {
-    for (const Decl *Redecl = OffendingDecl->getMostRecentDecl(); Redecl;
-         Redecl = Redecl->getPreviousDecl()) {
-      const AvailabilityAttr *AForRedecl = getAttrForPlatform(S.Context,
-                                                              Redecl);
-      if (AForRedecl && !AForRedecl->isInherited()) {
-        // If D is a declaration with inherited attributes, the note should
-        // point to the declaration with actual attributes.
-        S.Diag(Redecl->getLocation(), diag_available_here) << OffendingDecl
-            << available_here_select_kind;
-        break;
-      }
-    }
-  }
-  else
-    S.Diag(NoteLocation, diag_available_here)
-        << OffendingDecl << available_here_select_kind;
+  S.Diag(NoteLocation, diag_available_here)
+    << OffendingDecl << available_here_select_kind;
 
   if (K == AR_NotYetIntroduced)
     if (const auto *Enclosing = findEnclosingDeclToAnnotate(Ctx)) {
       if (auto *TD = dyn_cast<TagDecl>(Enclosing))
         if (TD->getDeclName().isEmpty()) {
           S.Diag(TD->getLocation(), diag::note_partial_availability_silence)
               << /*Anonymous*/1 << TD->getKindName();
           return;
         }
       S.Diag(Enclosing->getLocation(), diag::note_partial_availability_silence)
           << /*Named*/0 << Enclosing;
     }
 }
 
 static void handleDelayedAvailabilityCheck(Sema &S, DelayedDiagnostic &DD,
                                            Decl *Ctx) {
   assert(DD.Kind == DelayedDiagnostic::Availability &&
          "Expected an availability diagnostic here");
 
   DD.Triggered = true;
   DoEmitAvailabilityWarning(
       S, DD.getAvailabilityResult(), Ctx, DD.getAvailabilityReferringDecl(),
-      DD.getAvailabilityOffendingDecl(), DD.getAvailabilityMessage(), DD.Loc,
-      DD.getUnknownObjCClass(), DD.getObjCProperty(), false);
+      DD.getAvailabilityOffendingDecl(), DD.getAvailabilityAttr(),
+      DD.getAvailabilityMessage(), DD.Loc, DD.getUnknownObjCClass(),
+      DD.getObjCProperty(), false);
 }
 
 void Sema::PopParsingDeclaration(ParsingDeclState state, Decl *decl) {
   assert(DelayedDiagnostics.getCurrentPool());
   DelayedDiagnosticPool &poppedPool = *DelayedDiagnostics.getCurrentPool();
   DelayedDiagnostics.popWithoutEmitting(state);
 
   // When delaying diagnostics to run in the context of a parsed

   DelayedDiagnosticPool *curPool = DelayedDiagnostics.getCurrentPool();
   assert(curPool && "re-emitting in undelayed context not supported");
   curPool->steal(pool);
 }
 
 static void EmitAvailabilityWarning(Sema &S, AvailabilityResult AR,
                                     const NamedDecl *ReferringDecl,
                                     const NamedDecl *OffendingDecl,
+                                    const Attr *OffendingAttr,
                                     StringRef Message, SourceLocation Loc,
                                     const ObjCInterfaceDecl *UnknownObjCClass,
                                     const ObjCPropertyDecl *ObjCProperty,
                                     bool ObjCPropertyAccess) {
   // Delay if we're currently parsing a declaration.
   if (S.DelayedDiagnostics.shouldDelayDiagnostics()) {
-    S.DelayedDiagnostics.add(
-        DelayedDiagnostic::makeAvailability(
-            AR, Loc, ReferringDecl, OffendingDecl, UnknownObjCClass,
-            ObjCProperty, Message, ObjCPropertyAccess));
+    S.DelayedDiagnostics.add(DelayedDiagnostic::makeAvailability(
+        AR, Loc, ReferringDecl, OffendingDecl, OffendingAttr, UnknownObjCClass,
+        ObjCProperty, Message, ObjCPropertyAccess));
     return;
   }
 
   Decl *Ctx = cast<Decl>(S.getCurLexicalContext());
   DoEmitAvailabilityWarning(S, AR, Ctx, ReferringDecl, OffendingDecl,
-                            Message, Loc, UnknownObjCClass, ObjCProperty,
-                            ObjCPropertyAccess);
+                            OffendingAttr, Message, Loc, UnknownObjCClass,
+                            ObjCProperty, ObjCPropertyAccess);
 }
 
 namespace {
 
 /// Returns true if the given statement can be a body-like child of \p Parent.
 bool isBodyLikeChildStmt(const Stmt *S, const Stmt *Parent) {
   switch (Parent->getStmtClass()) {
   case Stmt::IfStmtClass:

 
   bool VisitTypeLoc(TypeLoc Ty);
 };
 
 void DiagnoseUnguardedAvailability::DiagnoseDeclAvailability(
     NamedDecl *D, SourceRange Range) {
   AvailabilityResult Result;
   const NamedDecl *OffendingDecl;
-  std::tie(Result, OffendingDecl) =
-    ShouldDiagnoseAvailabilityOfDecl(D, nullptr);
+  const Attr *Attribute;
+  std::tie(Result, OffendingDecl, Attribute) =
+      ShouldDiagnoseAvailabilityOfDecl(D, nullptr);
   if (Result != AR_Available) {
     // All other diagnostic kinds have already been handled in
     // DiagnoseAvailabilityOfDecl.
     if (Result != AR_NotYetIntroduced)
       return;
 
-    const AvailabilityAttr *AA =
-      getAttrForPlatform(SemaRef.getASTContext(), OffendingDecl);
-    VersionTuple Introduced = AA->getIntroduced();
+    VersionTuple Introduced =
+        cast<AvailabilityAttr>(Attribute)->getIntroduced();
 
     if (AvailabilityStack.back() >= Introduced)
       return;
 
     // If the context of this function is less available than D, we should not
     // emit a diagnostic.
     if (!ShouldDiagnoseAvailabilityInContext(SemaRef, Result, Introduced, Ctx))
       return;

 
 void Sema::DiagnoseAvailabilityOfDecl(NamedDecl *D, SourceLocation Loc,
                                       const ObjCInterfaceDecl *UnknownObjCClass,
                                       bool ObjCPropertyAccess,
                                       bool AvoidPartialAvailabilityChecks) {
   std::string Message;
   AvailabilityResult Result;
   const NamedDecl* OffendingDecl;
+  const Attr *Attribute;
   // See if this declaration is unavailable, deprecated, or partial.
-  std::tie(Result, OffendingDecl) = ShouldDiagnoseAvailabilityOfDecl(D, &Message);
+  std::tie(Result, OffendingDecl, Attribute) =
+    ShouldDiagnoseAvailabilityOfDecl(D, &Message);
   if (Result == AR_Available)
     return;
 
   if (Result == AR_NotYetIntroduced) {
     if (AvoidPartialAvailabilityChecks)
       return;
 
     // We need to know the @available context in the current function to
     // diagnose this use, let DiagnoseUnguardedAvailabilityViolations do that
     // when we're done parsing the current function.
     if (getCurFunctionOrMethodDecl()) {
       getEnclosingFunction()->HasPotentialAvailabilityViolations = true;
       return;
     } else if (getCurBlock() || getCurLambda()) {
       getCurFunction()->HasPotentialAvailabilityViolations = true;
       return;
     }
   }
 
   const ObjCPropertyDecl *ObjCPDecl = nullptr;
   if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) {
     if (const ObjCPropertyDecl *PD = MD->findPropertyDecl()) {
-      AvailabilityResult PDeclResult = PD->getAvailability(nullptr);
+      AvailabilityResult PDeclResult = PD->getAvailability();
       if (PDeclResult == Result)
         ObjCPDecl = PD;
     }
   }
 
-  EmitAvailabilityWarning(*this, Result, D, OffendingDecl, Message, Loc,
-                          UnknownObjCClass, ObjCPDecl, ObjCPropertyAccess);
+  EmitAvailabilityWarning(*this, Result, D, OffendingDecl, Attribute, Message,
+                          Loc, UnknownObjCClass, ObjCPDecl, ObjCPropertyAccess);
 }

test/Sema/attr-availability-ios.c

 // RUN: %clang_cc1 "-triple" "x86_64-apple-ios3.0" -fsyntax-only -verify %s
 
 void f0(int) __attribute__((availability(ios,introduced=2.0,deprecated=2.1))); // expected-note {{'f0' has been explicitly marked deprecated here}}
 void f1(int) __attribute__((availability(ios,introduced=2.1)));
 void f2(int) __attribute__((availability(ios,introduced=2.0,deprecated=3.0))); // expected-note {{'f2' has been explicitly marked deprecated here}}
 void f3(int) __attribute__((availability(ios,introduced=3.0)));
 void f4(int) __attribute__((availability(macosx,introduced=10.1,deprecated=10.3,obsoleted=10.5), availability(ios,introduced=2.0,deprecated=2.1,obsoleted=3.0))); // expected-note{{explicitly marked unavailable}}
 
 void f5(int) __attribute__((availability(ios,introduced=2.0))) __attribute__((availability(ios,deprecated=3.0))); // expected-note {{'f5' has been explicitly marked deprecated here}}
-void f6(int) __attribute__((availability(ios,deprecated=3.0)));
-void f6(int) __attribute__((availability(ios,introduced=2.0))); // expected-note {{'f6' has been explicitly marked deprecated here}}
+void f6(int) __attribute__((availability(ios,deprecated=3.0))); // expected-note {{'f6' has been explicitly marked deprecated here}}
+void f6(int) __attribute__((availability(ios,introduced=2.0)));
 
 void test() {
   f0(0); // expected-warning{{'f0' is deprecated: first deprecated in iOS 2.1}}
   f1(0);
   f2(0); // expected-warning{{'f2' is deprecated: first deprecated in iOS 3.0}}
   f3(0);
   f4(0); // expected-error{{f4' is unavailable: obsoleted in iOS 3.0}}
   f5(0); // expected-warning{{'f5' is deprecated: first deprecated in iOS 3.0}}
   f6(0); // expected-warning{{'f6' is deprecated: first deprecated in iOS 3.0}}
 }

test/Sema/attr-availability-tvos.c

 // RUN: %clang_cc1 "-triple" "x86_64-apple-tvos3.0" -fsyntax-only -verify %s
 
 void f0(int) __attribute__((availability(tvos,introduced=2.0,deprecated=2.1))); // expected-note {{'f0' has been explicitly marked deprecated here}}
 void f1(int) __attribute__((availability(tvos,introduced=2.1)));
 void f2(int) __attribute__((availability(tvos,introduced=2.0,deprecated=3.0))); // expected-note {{'f2' has been explicitly marked deprecated here}}
 void f3(int) __attribute__((availability(tvos,introduced=3.0)));
 void f4(int) __attribute__((availability(macosx,introduced=10.1,deprecated=10.3,obsoleted=10.5), availability(tvos,introduced=2.0,deprecated=2.1,obsoleted=3.0))); // expected-note{{explicitly marked unavailable}}
 
 void f5(int) __attribute__((availability(tvos,introduced=2.0))) __attribute__((availability(tvos,deprecated=3.0))); // expected-note {{'f5' has been explicitly marked deprecated here}}
-void f6(int) __attribute__((availability(tvos,deprecated=3.0)));
-void f6(int) __attribute__((availability(tvos,introduced=2.0))); // expected-note {{'f6' has been explicitly marked deprecated here}}
+void f6(int) __attribute__((availability(tvos,deprecated=3.0))); // expected-note {{'f6' has been explicitly marked deprecated here}}
+void f6(int) __attribute__((availability(tvos,introduced=2.0)));
 
 void test() {
   f0(0); // expected-warning{{'f0' is deprecated: first deprecated in tvOS 2.1}}
   f1(0);
   f2(0); // expected-warning{{'f2' is deprecated: first deprecated in tvOS 3.0}}
   f3(0);
   f4(0); // expected-error{{f4' is unavailable: obsoleted in tvOS 3.0}}
   f5(0); // expected-warning{{'f5' is deprecated: first deprecated in tvOS 3.0}}

 void f1_tvos(int) __attribute__((availability(tvos,introduced=2.1)));
 void f2_tvos(int) __attribute__((availability(tvos,introduced=2.0,deprecated=3.0))); // expected-note {{'f2_tvos' has been explicitly marked deprecated here}}
 void f3_tvos(int) __attribute__((availability(tvos,introduced=3.0)));
 void f4_tvos(int) __attribute__((availability(macosx,introduced=10.1,deprecated=10.3,obsoleted=10.5), availability(tvos,introduced=2.0,deprecated=2.1,obsoleted=3.0))); // expected-note{{explicitly marked unavailable}}
 void f5_tvos(int) __attribute__((availability(tvos,introduced=2.0))) __attribute__((availability(ios,deprecated=3.0)));
 void f5_attr_reversed_tvos(int) __attribute__((availability(ios, deprecated=3.0))) __attribute__((availability(tvos,introduced=2.0)));
 void f5b_tvos(int) __attribute__((availability(tvos,introduced=2.0))) __attribute__((availability(tvos,deprecated=3.0))); // expected-note {{'f5b_tvos' has been explicitly marked deprecated here}}
 void f5c_tvos(int) __attribute__((availability(ios,introduced=2.0))) __attribute__((availability(ios,deprecated=3.0))); // expected-note {{'f5c_tvos' has been explicitly marked deprecated here}}
-void f6_tvos(int) __attribute__((availability(tvos,deprecated=3.0)));
-void f6_tvos(int) __attribute__((availability(tvos,introduced=2.0))); // expected-note {{'f6_tvos' has been explicitly marked deprecated here}}
+void f6_tvos(int) __attribute__((availability(tvos,deprecated=3.0))); // expected-note {{'f6_tvos' has been explicitly marked deprecated here}}
+void f6_tvos(int) __attribute__((availability(tvos,introduced=2.0)));
 
 void test_tvos() {
   f0_tvos(0); // expected-warning{{'f0_tvos' is deprecated: first deprecated in tvOS 2.1}}
   f1_tvos(0);
   f2_tvos(0); // expected-warning{{'f2_tvos' is deprecated: first deprecated in tvOS 3.0}}
   f3_tvos(0);
   f4_tvos(0); // expected-error{{'f4_tvos' is unavailable: obsoleted in tvOS 3.0}}
   // We get no warning here because any explicit 'tvos' availability causes

test/Sema/attr-availability-watchos.c

 void f1_watchos(int) __attribute__((availability(watchos,introduced=2.1)));
 void f2_watchos(int) __attribute__((availability(watchos,introduced=2.0,deprecated=3.0))); // expected-note {{'f2_watchos' has been explicitly marked deprecated here}}
 void f3_watchos(int) __attribute__((availability(watchos,introduced=3.0)));
 void f4_watchos(int) __attribute__((availability(macosx,introduced=10.1,deprecated=10.3,obsoleted=10.5), availability(watchos,introduced=2.0,deprecated=2.1,obsoleted=3.0))); // expected-note{{explicitly marked unavailable}}
 void f5_watchos(int) __attribute__((availability(watchos,introduced=2.0))) __attribute__((availability(ios,deprecated=3.0)));
 void f5_attr_reversed_watchos(int) __attribute__((availability(ios, deprecated=3.0))) __attribute__((availability(watchos,introduced=2.0)));
 void f5b_watchos(int) __attribute__((availability(watchos,introduced=2.0))) __attribute__((availability(watchos,deprecated=3.0))); // expected-note {{'f5b_watchos' has been explicitly marked deprecated here}}
 void f5c_watchos(int) __attribute__((availability(ios,introduced=2.0))) __attribute__((availability(ios,deprecated=3.0))); // expected-note {{'f5c_watchos' has been explicitly marked deprecated here}}
-void f6_watchos(int) __attribute__((availability(watchos,deprecated=3.0)));
-void f6_watchos(int) __attribute__((availability(watchos,introduced=2.0))); // expected-note {{'f6_watchos' has been explicitly marked deprecated here}}
+void f6_watchos(int) __attribute__((availability(watchos,deprecated=3.0))); // expected-note {{'f6_watchos' has been explicitly marked deprecated here}}
+void f6_watchos(int) __attribute__((availability(watchos,introduced=2.0)));
 
 void test_watchos() {
   f0_watchos(0); // expected-warning{{'f0_watchos' is deprecated: first deprecated in watchOS 2.1}}
   f1_watchos(0);
   f2_watchos(0); // expected-warning{{'f2_watchos' is deprecated: first deprecated in watchOS 3.0}}
   f3_watchos(0);
   f4_watchos(0); // expected-error{{'f4_watchos' is unavailable: obsoleted in watchOS 3.0}}
   // We get no warning here because any explicit 'watchos' availability causes

test/Sema/attr-availability.c

 // rdar://10095131
 extern void 
 ATSFontGetName(const char *oName) __attribute__((availability(macosx,introduced=8.0,deprecated=9.0, message="use CTFontCopyFullName"))); // expected-note {{'ATSFontGetName' has been explicitly marked deprecated here}}
 
 extern void
 ATSFontGetPostScriptName(int flags) __attribute__((availability(macosx,introduced=8.0,obsoleted=9.0, message="use ATSFontGetFullPostScriptName"))); // expected-note {{'ATSFontGetPostScriptName' has been explicitly marked unavailable here}}
 
 #if defined(WARN_PARTIAL)
-// expected-note@+3 {{has been explicitly marked partial here}}
+// expected-note@+3 2 {{has been explicitly marked partial here}}
 #endif
 extern void
 PartiallyAvailable() __attribute__((availability(macosx,introduced=10.8)));
 
 #ifdef WARN_PARTIAL
 // expected-note@+2 2 {{marked partial here}}
 #endif
 enum __attribute__((availability(macosx,introduced=10.8))) PartialEnum {
   kPartialEnumConstant,
 };
 
 void test_10095131() {
   ATSFontGetName("Hello"); // expected-warning {{'ATSFontGetName' is deprecated: first deprecated in macOS 9.0 - use CTFontCopyFullName}}
   ATSFontGetPostScriptName(100); // expected-error {{'ATSFontGetPostScriptName' is unavailable: obsoleted in macOS 9.0 - use ATSFontGetFullPostScriptName}}
 
 #if defined(WARN_PARTIAL)
   // expected-warning@+2 {{is only available on macOS 10.8 or newer}} expected-note@+2 {{enclose 'PartiallyAvailable' in a __builtin_available check to silence this warning}}
 #endif
   PartiallyAvailable();
 }
 
-#ifdef WARN_PARTIAL
-// FIXME: This note should point to the declaration with the availability
-// attribute.
-// expected-note@+2 {{marked partial here}}
-#endif
 extern void PartiallyAvailable() ;
 void with_redeclaration() {
 #ifdef WARN_PARTIAL
   // expected-warning@+4 {{'PartiallyAvailable' is only available on macOS 10.8 or newer}} expected-note@+4 {{__builtin_available}}
   // expected-warning@+4 {{'PartialEnum' is only available on macOS 10.8 or newer}} expected-note@+4 {{__builtin_available}}
   // expected-warning@+3 {{'kPartialEnumConstant' is only available on macOS 10.8 or newer}} expected-note@+3 {{__builtin_available}}
 #endif
   PartiallyAvailable();

test/SemaObjC/protocol-attribute.m

 // RUN: %clang_cc1 -fsyntax-only -verify %s
 
 __attribute ((unavailable))
-@protocol FwProto; // expected-note{{marked unavailable}}
+@protocol FwProto; // expected-note 2 {{marked unavailable}}
 
 Class <FwProto> cFw = 0;  // expected-error {{'FwProto' is unavailable}}
 
 
 __attribute ((deprecated)) @protocol MyProto1 // expected-note 7 {{'MyProto1' has been explicitly marked deprecated here}}
 @end
 
 @protocol Proto2  <MyProto1>  // expected-warning {{'MyProto1' is deprecated}}

 
 @interface MyClass1 (Category) <MyProto1, Proto2>  // expected-warning {{'MyProto1' is deprecated}}
 @end
 
 
 
 Class <MyProto1> clsP1 = 0;  // expected-warning {{'MyProto1' is deprecated}}
 
-@protocol FwProto @end // expected-note{{marked unavailable}}
+@protocol FwProto @end
 
 @interface MyClass2 <FwProto> // expected-error {{'FwProto' is unavailable}}
 @end
 
 __attribute ((unavailable)) __attribute ((deprecated)) @protocol XProto; // expected-note{{marked unavailable}}
 
 id <XProto> idX = 0; // expected-error {{'XProto' is unavailable}}
 
 int main ()
 {
   MyClass1 <MyProto1> *p1;  // expected-warning {{'MyProto1' is deprecated}}
 }