Sending a message to `self` when it is const and within a class method
is safe because we know that `self` is the Class itself.
We can only relax this warning in ARC.
Signed-off-by: Pierre Habouzit <phabouzit@apple.com>
Radar-Id: rdar://problem/
58581965
Differential Revision: https://reviews.llvm.org/D72747
<< Method->getDeclName();
}
- if (ReceiverType->isObjCClassType() && !isImplicit) {
+ // Under ARC, self can't be assigned, and doing a direct call to `self`
+ // when it's a Class is hence safe. For other cases, we can't trust `self`
+ // is what we think it is, so we reject it.
+ if (ReceiverType->isObjCClassType() && !isImplicit &&
+ !(Receiver->isObjCSelfExpr() && getLangOpts().ObjCAutoRefCount)) {
Diag(Receiver->getExprLoc(),
diag::err_messaging_class_with_direct_method);
Diag(Method->getLocation(), diag::note_direct_method_declared_at)
--- /dev/null
+// RUN: %clang_cc1 -fobjc-arc -fsyntax-only -verify -Wselector-type-mismatch %s
+
+extern Class object_getClass(id);
+
+__attribute__((objc_root_class))
+@interface Root
+- (Class)class;
++ (void)directMethod __attribute__((objc_direct)); // expected-note {{direct method 'directMethod' declared here}}
++ (void)anotherDirectMethod __attribute__((objc_direct));
+@end
+
+@implementation Root
+- (Class)class
+{
+ return object_getClass(self);
+}
++ (void)directMethod {
+}
++ (void)anotherDirectMethod {
+ [self directMethod]; // this should not warn
+}
++ (void)regularMethod {
+ [self directMethod]; // this should not warn
+ [self anotherDirectMethod]; // this should not warn
+}
+- (void)regularInstanceMethod {
+ [[self class] directMethod]; // expected-error {{messaging a Class with a method that is possibly direct}}
+}
+@end
+
+@interface Sub : Root
+@end
+
+@implementation Sub
++ (void)foo {
+ [self directMethod]; // this should not warn
+}
+@end
+
+__attribute__((objc_root_class))
+@interface Other
+@end
+
+@implementation Other
++ (void)bar {
+ [self directMethod]; // expected-error {{no known class method for selector 'directMethod'}}
+}
+@end
}
- (void)otherRootDirect {
}
++ (void)someRootDirectMethod { // expected-note {{direct method 'someRootDirectMethod' declared here}}
+}
+ (void)otherClassRootDirect {
+ [self someRootDirectMethod]; // expected-error {{messaging a Class with a method that is possibly direct}}
}
- (void)rootExtensionDirect {
}