AvailabilityAttrs: Delay partial availability diagnostics

[erik.pilkington]

Summary

Note: this patch depends on: https://reviews.llvm.org/D25283

This patch delays handling of AR_NotYetIntroduced diagnostics, so that the following compiles with no warnings:

typedef int new_int __attribute__((availability(macos, introduced=100)));

new_int f() __attribute__((availability(macos, introduced=100)));

This is done by treating AR_NotYetIntroduced diagnostics as delayed, just like AR_Unavailable and AR_Deprecated. This means that we emit the diagnostic once we finished parsing f(), at which point we have the context to determine if we should diagnose new_int.

Thanks!

[manmanren]

Nice cleanup! Thanks for working on this,

Manman

include/clang/Sema/DelayedDiagnostic.h

232

Can you update this comment now we have generalized this to handle all delayed availability checks?

[erik.pilkington]

This new patch renames DelayedDiagnostic::DeprecationData to DelayedDiagnostic::AvailabilityData, because now that it can hold information about deprecated, unavailable, and partial diagnostics.
Thanks,
Erik

[manmanren]

This is better than what I asked for :]

Manman

include/clang/Sema/DelayedDiagnostic.h

private:
   QualType BaseObjectType;
   PartialDiagnostic Diag;
 };
 
 /// A diagnostic message which has been conditionally emitted pending
 /// the complete parsing of the current declaration.
 class DelayedDiagnostic {
 public:
-  enum DDKind { Deprecation, Unavailable, Access, ForbiddenType };
+  enum DDKind : unsigned char { Availability, Access, ForbiddenType };
 
-  unsigned char Kind; // actually a DDKind
+  DDKind Kind;
   bool Triggered;
 
   SourceLocation Loc;
 
   void Destroy();
 
   static DelayedDiagnostic makeAvailability(AvailabilityResult AR,
                                             SourceLocation Loc,
AccessedEntity &getAccessData() {
     return *reinterpret_cast<AccessedEntity*>(AccessData);
   }
   const AccessedEntity &getAccessData() const {
     assert(Kind == Access && "Not an access diagnostic.");
     return *reinterpret_cast<const AccessedEntity*>(AccessData);
   }
 
   const NamedDecl *getDeprecationDecl() const {
-    assert((Kind == Deprecation || Kind == Unavailable) &&
-           "Not a deprecation diagnostic.");
+    assert(Kind == Availability && "Not an availability diagnostic.");
     return DeprecationData.Decl;
   }
 
   StringRef getDeprecationMessage() const {
-    assert((Kind == Deprecation || Kind == Unavailable) &&
-           "Not a deprecation diagnostic.");
-    return StringRef(DeprecationData.Message,
-                           DeprecationData.MessageLen);
+    assert(Kind == Availability && "Not an availability diagnostic.");
+    return StringRef(DeprecationData.Message, DeprecationData.MessageLen);
+  }
+
+  AvailabilityResult getAvailabilityResult() const {
+    assert(Kind == Availability && "Not an availability diagnostic.");
+    return DeprecationData.AR;
   }
 
   /// The diagnostic ID to emit.  Used like so:
   ///   Diag(diag.Loc, diag.getForbiddenTypeDiagnostic())
   ///     << diag.getForbiddenTypeOperand()
   ///     << diag.getForbiddenTypeArgument();
   unsigned getForbiddenTypeDiagnostic() const {
     assert(Kind == ForbiddenType && "not a forbidden-type diagnostic");

 private:
 
   struct DD {
     const NamedDecl *Decl;
     const ObjCInterfaceDecl *UnknownObjCClass;
     const ObjCPropertyDecl  *ObjCProperty;
     const char *Message;
     size_t MessageLen;
+    AvailabilityResult AR;
     bool ObjCPropertyAccess;
   };
 
   struct FTD {
     unsigned Diagnostic;
     unsigned Argument;
     void *OperandType;
   };
 
   union {
     /// Deprecation
     struct DD DeprecationData;
     struct FTD ForbiddenTypeData;
 
     /// Access control.
     char AccessData[sizeof(AccessedEntity)];
   };
 };
 

lib/Sema/DelayedDiagnostic.cpp

 //
 //===----------------------------------------------------------------------===//
 #include "clang/Sema/DelayedDiagnostic.h"
 #include <string.h>
 using namespace clang;
 using namespace sema;
 
 DelayedDiagnostic
-DelayedDiagnostic::makeAvailability(AvailabilityResult AD,
+DelayedDiagnostic::makeAvailability(AvailabilityResult AR,
                                     SourceLocation Loc,
                                     const NamedDecl *D,
                                     const ObjCInterfaceDecl *UnknownObjCClass,
                                     const ObjCPropertyDecl  *ObjCProperty,
                                     StringRef Msg,
                                     bool ObjCPropertyAccess) {
   DelayedDiagnostic DD;
-  switch (AD) {
-  case AR_Deprecated:
-    DD.Kind = Deprecation;
-    break;
-  case AR_Unavailable:
-    DD.Kind = Unavailable;
-    break;
-  default:
-    llvm_unreachable("partial diags should not be delayed");
-  }
+  DD.Kind = Availability;
   DD.Triggered = false;
   DD.Loc = Loc;
   DD.DeprecationData.Decl = D;
   DD.DeprecationData.UnknownObjCClass = UnknownObjCClass;
   DD.DeprecationData.ObjCProperty = ObjCProperty;
   char *MessageData = nullptr;
   if (Msg.size()) {
     MessageData = new char [Msg.size()];
     memcpy(MessageData, Msg.data(), Msg.size());
   }
 
   DD.DeprecationData.Message = MessageData;
   DD.DeprecationData.MessageLen = Msg.size();
+  DD.DeprecationData.AR = AR;
   DD.DeprecationData.ObjCPropertyAccess = ObjCPropertyAccess;
   return DD;
 }
 
 void DelayedDiagnostic::Destroy() {
-  switch (static_cast<DDKind>(Kind)) {
+  switch (Kind) {
   case Access: 
     getAccessData().~AccessedEntity(); 
     break;
 
-  case Deprecation:
-  case Unavailable:
+  case Availability:
     delete [] DeprecationData.Message;
     break;
 
   case ForbiddenType:
     break;
   }
 }

lib/Sema/SemaDeclAttr.cpp

           diag_available_here = diag::note_arc_field_with_ownership;
           break;
         }
       }
     }
     break;
 
   case AR_NotYetIntroduced:
-    assert(!S.getCurFunctionOrMethodDecl() &&
-           "Function-level partial availablity should not be diagnosed here!");
-
     diag = diag::warn_partial_availability;
     diag_message = diag::warn_partial_message;
     diag_fwdclass_message = diag::warn_partial_fwdclass_message;
     property_note_select = /* partial */ 2;
     available_here_select_kind = /* partial */ 3;
     break;
 
   case AR_Available:

         << D << available_here_select_kind;
 
   if (K == AR_NotYetIntroduced)
     S.Diag(Loc, diag::note_partial_availability_silence) << D;
 }
 
 static void handleDelayedAvailabilityCheck(Sema &S, DelayedDiagnostic &DD,
                                            Decl *Ctx) {
-  assert(DD.Kind == DelayedDiagnostic::Deprecation ||
-         DD.Kind == DelayedDiagnostic::Unavailable);
-  AvailabilityResult AR = DD.Kind == DelayedDiagnostic::Deprecation
-                              ? AR_Deprecated
-                              : AR_Unavailable;
+  assert(DD.Kind == DelayedDiagnostic::Availability &&
+         "Expected an availability diagnostic here");
+
   DD.Triggered = true;
-  DoEmitAvailabilityWarning(
-      S, AR, Ctx, DD.getDeprecationDecl(), DD.getDeprecationMessage(), DD.Loc,
-      DD.getUnknownObjCClass(), DD.getObjCProperty(), false);
+  DoEmitAvailabilityWarning(S, DD.getAvailabilityResult(), Ctx,
+                            DD.getDeprecationDecl(), DD.getDeprecationMessage(),
+                            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

     for (DelayedDiagnosticPool::pool_iterator
            i = pool->pool_begin(), e = pool->pool_end(); i != e; ++i) {
       // This const_cast is a bit lame.  Really, Triggered should be mutable.
       DelayedDiagnostic &diag = const_cast<DelayedDiagnostic&>(*i);
       if (diag.Triggered)
         continue;
 
       switch (diag.Kind) {
-      case DelayedDiagnostic::Deprecation:
-      case DelayedDiagnostic::Unavailable:
+      case DelayedDiagnostic::Availability:
         // Don't bother giving deprecation/unavailable diagnostics if
         // the decl is invalid.
         if (!decl->isInvalidDecl())
           handleDelayedAvailabilityCheck(*this, diag, decl);
         break;
 
       case DelayedDiagnostic::Access:
         HandleDelayedAccessCheck(diag, decl);

 
 void Sema::EmitAvailabilityWarning(AvailabilityResult AR,
                                    NamedDecl *D, StringRef Message,
                                    SourceLocation Loc,
                                    const ObjCInterfaceDecl *UnknownObjCClass,
                                    const ObjCPropertyDecl  *ObjCProperty,
                                    bool ObjCPropertyAccess) {
   // Delay if we're currently parsing a declaration.
-  if (DelayedDiagnostics.shouldDelayDiagnostics() &&
-      AR != AR_NotYetIntroduced) {
+  if (DelayedDiagnostics.shouldDelayDiagnostics()) {
     DelayedDiagnostics.add(DelayedDiagnostic::makeAvailability(
         AR, Loc, D, UnknownObjCClass, ObjCProperty, Message,
         ObjCPropertyAccess));
     return;
   }
 
   Decl *Ctx = cast<Decl>(getCurLexicalContext());
   DoEmitAvailabilityWarning(*this, AR, Ctx, D, Message, Loc, UnknownObjCClass,

test/SemaObjC/unguarded-availability.m

if (@available(macos 10.11, *)) {
     }
   }
 }
 
 typedef int int_10_11 AVAILABLE_10_11; // expected-note {{'int_10_11' has been explicitly marked partial here}}
 #ifdef OBJCPP
 // expected-note@+2 {{marked partial here}}
 #endif
-typedef int int_10_12 AVAILABLE_10_12; // expected-note 3 {{'int_10_12' has been explicitly marked partial here}}
+typedef int int_10_12 AVAILABLE_10_12; // expected-note 2 {{'int_10_12' has been explicitly marked partial here}}
 
 void use_typedef() {
   int_10_11 x; // expected-warning{{'int_10_11' is only available on macOS 10.11 or newer}} expected-note{{enclose 'int_10_11' in an @available check to silence this warning}}
 }
 
 __attribute__((objc_root_class))
 AVAILABLE_10_11 @interface Class_10_11 {
   int_10_11 foo;

 void test_blocks() {
   (void) ^{
     func_10_12(); // expected-warning{{'func_10_12' is only available on macOS 10.12 or newer}} expected-note{{@available}}
   };
 }
 
 void test_params(int_10_12 x); // expected-warning {{'int_10_12' is partial: introduced in macOS 10.12}} expected-note{{redeclare}}
 
-// FIXME: This should be fine!
-void test_params2(int_10_12 x) AVAILABLE_10_12; // expected-warning {{'int_10_12' is partial: introduced in macOS 10.12}} expected-note{{redeclare}}
+void test_params2(int_10_12 x) AVAILABLE_10_12; // no warn
 
 #ifdef OBJCPP
 
 int f(char) AVAILABLE_10_12;
 int f(int);
 
 template <class T> int use_f() {
   // FIXME: We should warn here!