[ObjC] Follow-up r350768 and allow the use of unavailable methods that are declared in a parent class from within the @implementation context

[arphaman]

Summary

This patch extends r350768 and allows the use of methods marked as unavailable that are declared in a parent class/category from within the @implementation of the class where the method is marked as unavailable.
This allows users to call init that's marked as unavailable even if they don't define it.

[erik.pilkington]

lib/Sema/SemaDeclAttr.cpp

7373–7374

Why not just always accept a use of an unavailable method so long as its declared in the interface?

i.e., doesn't it make sense to accept something like the following? It seems like you're going out of your way to reject it though:

@interface Base 
-(void)doAThing;
-(void)doAThingImpl __attribute__((unavailable));
@end

@implemenation Base
-(void)doAThing { [self doAThingImpl]; }
@end

@interface Derived1 : Base @end
@interface Derived2 : Base @end

@implementation Derived1 
-(void)doAThingImpl { ... }
@end

@implementation Derived2
-(void)doAThingImpl { ... }
@end

[arphaman]

Follow Erik's suggestion and don't check for definition/declaration in parent class.

[smeenai]

My understanding is that rL349841 accidentally started producing some spurious warnings/errors, rL350768 fixed some instances, and this change fixes more instances. Given that the first two changes are already in the 8.0 branch, should this be cherry-picked to 8.0 as well once it lands?

[dexonsmith]

In D56816#1360824, @smeenai wrote:

My understanding is that rL349841 accidentally started producing some spurious warnings/errors, rL350768 fixed some instances, and this change fixes more instances. Given that the first two changes are already in the 8.0 branch, should this be cherry-picked to 8.0 as well once it lands?

Yes.

[erik.pilkington]

LGTM, thanks!

lib/Sema/SemaDeclAttr.cpp

if (K == AR_NotYetIntroduced) {
         return true;
     } else if (K == AR_Unavailable) {
       // It is perfectly fine to refer to an 'unavailable' Objective-C method
       // when it's actually defined and is referenced from within the
       // @implementation itself. In this context, we interpret unavailable as a
       // form of access control.
       if (const auto *MD = dyn_cast<ObjCMethodDecl>(OffendingDecl)) {
         if (const auto *Impl = dyn_cast<ObjCImplDecl>(C)) {
-          if (MD->getClassInterface() == Impl->getClassInterface() &&
-              MD->isDefined())
+          if (MD->getClassInterface() == Impl->getClassInterface())
             return true;
         }
       }
     }
 
     if (C->isUnavailable())
       return true;
     return false;
   };

test/SemaObjC/call-unavailable-init-in-self.m

 // RUN: %clang_cc1 -x objective-c -verify -fobjc-arc %s
 
 @interface NSObject
 
 + (instancetype)new;
 + (instancetype)alloc;
 
+- (void)declaredInSuper;
+
+@end
+
+@interface NSObject (Category)
+
+- (void)declaredInSuperCategory;
+
 @end
 
 @interface Sub: NSObject
 
 - (instancetype)init __attribute__((unavailable)); // expected-note 4 {{'init' has been explicitly marked unavailable here}}
 
-- (void)notImplemented __attribute__((unavailable)); // expected-note {{'notImplemented' has been explicitly marked unavailable here}}
+- (void)notImplemented __attribute__((unavailable));
+
+- (void)declaredInSuper __attribute__((unavailable));
+- (void)declaredInSuperCategory __attribute__((unavailable));
 
 @end
 
 @implementation Sub
 
 + (Sub *)create {
   return [[self alloc] init];
 }
 
 + (Sub *)create2 {
   return [self new];
 }
 
 + (Sub *)create3 {
   return [Sub new];
 }
 
 - (instancetype) init {
   return self;
 }
 
 - (void)reportUseOfUnimplemented {
-  [self notImplemented]; // expected-error {{'notImplemented' is unavailable}}
+  [self notImplemented];
+}
+
+- (void)allowSuperCallUsingSelf {
+  [self declaredInSuper];
+  [[Sub alloc] declaredInSuper];
+  [self declaredInSuperCategory];
+  [[Sub alloc] declaredInSuperCategory];
 }
 
 @end
 
 @interface SubClassContext: Sub
 @end
 
 @implementation SubClassContext