[ObjC] Avoid the -Wunguarded-availability warnings for protocol requirements in protocol/class/category declarations

[arphaman]

Summary

The unguarded availability warnings in the protocol requirements of a protocol/class/category declaration can be avoided. This matches the behaviour of Swift's diagnostics.

[erik.pilkington]

lib/Sema/SemaExpr.cpp

142

Why are we doing this just for partials? Doesn't this also apply to unavailable/deprecated?

[arphaman]

lib/Sema/SemaExpr.cpp

142

We warned about the unavailable/deprecated protocols previously, so we should probably keep these warnings. The unguarded availability one is new, so we can drop it.

[erik.pilkington]

lib/Sema/SemaExpr.cpp

142

But this is strictly less diagnostics, dropping diagnostics for unavail/depr here won't break anything outside of clang tests. So if they don't make sense to emit, then there isn't any reason to keep them around.

[arphaman]

lib/Sema/SemaExpr.cpp

142

Swift emits warnings about deprecated/unavailable protocols even in the list of protocol requirements. I'd prefer it if we had the same behaviour.

[erik.pilkington]

LGTM, thanks!

lib/Sema/SemaExpr.cpp

132

AvoidPartialAvailabilityChecks?

142

OK, I agree that we should conform to what swift does here.

include/clang/Sema/Sema.h

public:
   /// \brief Issue any -Wunguarded-availability warnings in \c FD
   void DiagnoseUnguardedAvailabilityViolations(Decl *FD);
 
   //===--------------------------------------------------------------------===//
   // Expression Parsing Callbacks: SemaExpr.cpp.
 
   bool CanUseDecl(NamedDecl *D, bool TreatUnavailableAsInvalid);
   bool DiagnoseUseOfDecl(NamedDecl *D, SourceLocation Loc,
-                         const ObjCInterfaceDecl *UnknownObjCClass=nullptr,
-                         bool ObjCPropertyAccess=false);
+                         const ObjCInterfaceDecl *UnknownObjCClass = nullptr,
+                         bool ObjCPropertyAccess = false,
+                         bool AvoidAvailabilityChecks = false);
   void NoteDeletedFunction(FunctionDecl *FD);
   void NoteDeletedInheritingConstructor(CXXConstructorDecl *CD);
   std::string getDeletedOrUnavailableSuffix(const FunctionDecl *FD);
   bool DiagnosePropertyAccessorMismatch(ObjCPropertyDecl *PD,
                                         ObjCMethodDecl *Getter,
                                         SourceLocation Loc);
   void DiagnoseSentinelCalls(NamedDecl *D, SourceLocation Loc,
                              ArrayRef<Expr *> Args);

lib/Sema/SemaDeclObjC.cpp

static void diagnoseUseOfProtocols(Sema &TheSema,
                                    ObjCContainerDecl *CD,
                                    ObjCProtocolDecl *const *ProtoRefs,
                                    unsigned NumProtoRefs,
                                    const SourceLocation *ProtoLocs) {
   assert(ProtoRefs);
   // Diagnose availability in the context of the ObjC container.
   Sema::ContextRAII SavedContext(TheSema, CD);
   for (unsigned i = 0; i < NumProtoRefs; ++i) {
-    (void)TheSema.DiagnoseUseOfDecl(ProtoRefs[i], ProtoLocs[i]);
+    (void)TheSema.DiagnoseUseOfDecl(ProtoRefs[i], ProtoLocs[i],
+                                    /*UnknownObjCClass=*/nullptr,
+                                    /*ObjCPropertyAccess=*/false,
+                                    /*AvoidAvailabilityChecks=*/true);
   }
 }
 
 void Sema::
 ActOnSuperClassOfClassInterface(Scope *S,
                                 SourceLocation AtInterfaceLoc,
                                 ObjCInterfaceDecl *IDecl,
                                 IdentifierInfo *ClassName,

lib/Sema/SemaExpr.cpp

if (const auto *ECD = dyn_cast<EnumConstantDecl>(D))
     }
 
   return {Result, D};
 }
 
 static void
 DiagnoseAvailabilityOfDecl(Sema &S, NamedDecl *D, SourceLocation Loc,
                            const ObjCInterfaceDecl *UnknownObjCClass,
-                           bool ObjCPropertyAccess) {
+                           bool ObjCPropertyAccess,
+                           bool AvoidAvailabilityChecks = false) {
   std::string Message;
   AvailabilityResult Result;
   const NamedDecl* OffendingDecl;
   // See if this declaration is unavailable, deprecated, or partial.
   std::tie(Result, OffendingDecl) = S.ShouldDiagnoseAvailabilityOfDecl(D, &Message);
   if (Result == AR_Available)
     return;
 
   if (Result == AR_NotYetIntroduced) {
+    if (AvoidAvailabilityChecks)
+      return;
     if (S.getCurFunctionOrMethodDecl()) {
       S.getEnclosingFunction()->HasPotentialAvailabilityViolations = true;
       return;
     } else if (S.getCurBlock() || S.getCurLambda()) {
       S.getCurFunction()->HasPotentialAvailabilityViolations = true;
       return;
     }
   }

 /// used, or produce an error (and return true) if a C++0x deleted
 /// function is being used.
 ///
 /// \returns true if there was an error (this declaration cannot be
 /// referenced), false otherwise.
 ///
 bool Sema::DiagnoseUseOfDecl(NamedDecl *D, SourceLocation Loc,
                              const ObjCInterfaceDecl *UnknownObjCClass,
-                             bool ObjCPropertyAccess) {
+                             bool ObjCPropertyAccess,
+                             bool AvoidAvailabilityChecks) {
   if (getLangOpts().CPlusPlus && isa<FunctionDecl>(D)) {
     // If there were any diagnostics suppressed by template argument deduction,
     // emit them now.
     auto Pos = SuppressedDiagnostics.find(D->getCanonicalDecl());
     if (Pos != SuppressedDiagnostics.end()) {
       for (const PartialDiagnosticAt &Suppressed : Pos->second)
         Diag(Suppressed.first, Suppressed.second);
 
if (LangOpts.OpenMP && DRD && !CurContext->containsDecl(D) &&
       isa<VarDecl>(D)) {
     Diag(Loc, diag::err_omp_wrong_var_in_declare_reduction)
         << getCurFunction()->HasOMPDeclareReductionCombiner;
     Diag(D->getLocation(), diag::note_entity_declared_at) << D;
     return true;
   }
 
   DiagnoseAvailabilityOfDecl(*this, D, Loc, UnknownObjCClass,
-                             ObjCPropertyAccess);
+                             ObjCPropertyAccess, AvoidAvailabilityChecks);
 
   DiagnoseUnusedOfDecl(*this, D, Loc);
 
   diagnoseUseOfInternalDeclInInlineFunction(*this, D, Loc);
 
   return false;
 }
 

test/SemaObjC/unguarded-availability.m

 @property (class) new_int x; // expected-warning{{'new_int' is partial}}
 @end
 
 void with_local_struct() {
   struct local { // expected-note{{annotate 'local' with an availability attribute}}
     new_int x; // expected-warning{{'new_int' is partial}}
   };
 }
+
+// rdar://33156429:
+// Avoid the warning on protocol requirements.
+
+AVAILABLE_10_12
+@protocol NewProtocol // expected-note {{'NewProtocol' has been explicitly marked partial here}}
+@end
+
+@protocol ProtocolWithNewProtocolRequirement <NewProtocol> // expected-note {{annotate 'ProtocolWithNewProtocolRequirement' with an availability attribute to silence}}
+
+@property(copy) id<NewProtocol> prop; // expected-warning {{'NewProtocol' is partial: introduced in macOS 10.12}}
+
+@end
+
+@interface BaseClass
+@end
+
+@interface ClassWithNewProtocolRequirement : BaseClass <NewProtocol>
+
+@end
+
+@interface BaseClass (CategoryWithNewProtocolRequirement) <NewProtocol>
+
+@end