[objc_direct] Small updates to help with adoption.

[MadCoder]

Summary

Add fixits for messaging self in MRR or using super, as the intent is
clear, and it turns out people do that a lot more than expected.

Allow for objc_direct_members on main interfaces, it's extremely useful
for internal only classes, and proves to be quite annoying for adoption.

Add some better warnings around properties direct/non-direct clashes (it
was done for methods but properties were a miss).

Add some errors when direct properties are marked @dynamic.

Radar-Id: rdar://problem/58355212

[MadCoder]

Add some errors when direct properties are marked @dynamic.

[erik.pilkington]

clang/include/clang/Basic/DiagnosticSemaKinds.td

1005–1007

This diagnostics reads a bit awkward when a property is conflicting with a property, since the the first half of the diagnostic is talking about the property declaration, but the second half is implicitly referring to the generated getter/setter.

1023

I think this might be more clear as: "direct property cannot be @dynamic"

clang/lib/Sema/SemaExprObjC.cpp

3032

I believe its UB to call a destructor twice. Please use a compound statement to control where the dtor will be called here.

3048

ditto

clang/lib/Sema/SemaObjCProperty.cpp

1630–1637

Would you mind adding a test for this diagnostic? It looks like err_objc_direct_dynamic_property doesn't take a parameter too, so there isn't any reason to do << PropertyId unless you add one.

2436

Just to be clear: so we need this check because the getter/setters of a property declared in a category aren't considered to override any getters/setters of the extended class, so the existing CheckObjCMethodOverrides checks below don't work?

clang/test/SemaObjC/method-direct.m

51

Can you leave this in so we have a test that has this attribute on an @interface?

[plotfi]

@MadCoder Could there be a way to mark objc_direct methods as something like attribute((visibility("default"))) or __declspec(dllexport) to denote that a given method should be directly callable but still retain the metadata to be called through an objc_msgSend from an external dylib? Could that help to boost adoption?

[MadCoder]

In D73755#1874962, @plotfi wrote:

@MadCoder Could there be a way to mark objc_direct methods as something like attribute((visibility("default"))) or __declspec(dllexport) to denote that a given method should be directly callable but still retain the metadata to be called through an objc_msgSend from an external dylib? Could that help to boost adoption?

I'm not sure how that is relevant to this review. secondly this kind of defeats the entire point of objc_direct which is to _not_ generate all that metadata.

[MadCoder]

@erik.pilkington review feedback

clang/lib/Sema/SemaObjCProperty.cpp

1630–1637

there were some, I forgot to add the test case to the commit ...

2436

not quite, it's because people do things like this:

@interface Foo (Cat)
@property int bar;
@end

But implement the property in the main @implementation (or the other way around) and this is not considered as overrides today, or even worse, many many times the Category doesn't even have a corresponding @implementation anywhere. Tthere's one direction of this that has a possible optional warning though today in the compiler.

But direct method resolution requires to not cross streams else the incorrect symbol is formed (because the category is an actual different namespace). With dynamism it actually doesn't matter which is why the compiler doesn't care today.

[erik.pilkington]

LGTM, thanks.

clang/lib/Sema/SemaObjCProperty.cpp

2436

Okay, thanks for clarifying.

clang/include/clang/Basic/Attr.td

def ObjCDirect : Attr {
   let Spellings = [Clang<"objc_direct">];
   let Subjects = SubjectList<[ObjCMethod], ErrorDiag>;
   let LangOpts = [ObjC];
   let Documentation = [ObjCDirectDocs];
 }
 
 def ObjCDirectMembers : Attr {
   let Spellings = [Clang<"objc_direct_members">];
-  let Subjects = SubjectList<[ObjCImpl, ObjCCategory], ErrorDiag>;
+  let Subjects = SubjectList<[ObjCImpl, ObjCInterface, ObjCCategory], ErrorDiag>;
   let LangOpts = [ObjC];
   let Documentation = [ObjCDirectMembersDocs];
 }
 
 def ObjCRuntimeName : Attr {
   let Spellings = [Clang<"objc_runtime_name">];
   let Subjects = SubjectList<[ObjCInterface, ObjCProtocol], ErrorDiag>;
   let Args = [StringArgument<"MetadataName">];

clang/include/clang/Basic/AttrDocs.td

 to simplify this, the ``objc_direct_members`` attribute is provided; see its
 documentation for more information.
   }];
 }
 
 def ObjCDirectMembersDocs : Documentation {
   let Category = DocCatDecl;
   let Content = [{
-The ``objc_direct_members`` attribute can be placed on an  Objective-C
+The ``objc_direct_members`` attribute can be placed on an Objective-C
 ``@interface`` or ``@implementation`` to mark that methods declared
 therein should be considered direct by default.  See the documentation
 for ``objc_direct`` for more information about direct methods.
 
 When ``objc_direct_members`` is placed on an ``@interface`` block, every
 method in the block is considered to be declared as direct.  This includes any
 implicit method declarations introduced by property declarations.  If the method
 redeclares a non-direct method, the declaration is ill-formed, exactly as if the
-method was annotated with the ``objc_direct`` attribute.  ``objc_direct_members``
-cannot be placed on the primary interface of a class, only on category or class
-extension interfaces.
+method was annotated with the ``objc_direct`` attribute.
 
 When ``objc_direct_members`` is placed on an ``@implementation`` block,
 methods defined in the block are considered to be declared as direct unless
 they have been previously declared as non-direct in any interface of the class.
 This includes the implicit method definitions introduced by synthesized
 properties, including auto-synthesized properties.
   }];
 }

clang/include/clang/Basic/DiagnosticSemaKinds.td

 def warn_objc_boxing_invalid_utf8_string : Warning<
   "string is ill-formed as UTF-8 and will become a null %0 when boxed">,
   InGroup<ObjCBoxing>;
 
 def err_objc_direct_on_protocol : Error<
   "'objc_direct' attribute cannot be applied to %select{methods|properties}0 "
   "declared in an Objective-C protocol">;
 def err_objc_direct_duplicate_decl : Error<
-  "%select{|direct }0method declaration conflicts "
-  "with previous %select{|direct }1declaration of method %2">;
+  "%select{|direct }0%select{method|property}1 declaration conflicts "
+  "with previous %select{|direct }2declaration of %select{method|property}1 %3">;
 def err_objc_direct_impl_decl_mismatch : Error<
   "direct method was declared in %select{the primary interface|an extension|a category}0 "
   "but is implemented in %select{the primary interface|a category|a different category}1">;
 def err_objc_direct_missing_on_decl : Error<
   "direct method implementation was previously declared not direct">;
 def err_objc_direct_on_override : Error<
   "methods that %select{override superclass methods|implement protocol requirements}0 cannot be direct">;
 def err_objc_override_direct_method : Error<
   "cannot override a method that is declared direct by a superclass">;
 def warn_objc_direct_ignored : Warning<
   "%0 attribute isn't implemented by this Objective-C runtime">,
   InGroup<IgnoredAttributes>;
 def warn_objc_direct_property_ignored : Warning<
   "direct attribute on property %0 ignored (not implemented by this Objective-C runtime)">,
   InGroup<IgnoredAttributes>;
+def err_objc_direct_dynamic_property : Error<
+  "direct property cannot be @dynamic">;
 
 def warn_conflicting_overriding_ret_types : Warning<
   "conflicting return type in "
   "declaration of %0%diff{: $ vs $|}1,2">,
   InGroup<OverridingMethodMismatch>, DefaultIgnore;
 
 def warn_conflicting_ret_types : Warning<
   "conflicting return type in "

clang/lib/Sema/SemaDeclObjC.cpp

if (!isa<ObjCProtocolDecl>(ClassDecl)) {
                                             /*followSuper=*/false)) {
           if (isa<ObjCProtocolDecl>(IMD->getDeclContext())) {
             // Do not emit a diagnostic for the Protocol case:
             // diag::err_objc_direct_on_protocol has already been emitted
             // during parsing for these with a nicer diagnostic.
           } else if (ObjCMethod->isDirectMethod() || IMD->isDirectMethod()) {
             Diag(ObjCMethod->getLocation(),
                  diag::err_objc_direct_duplicate_decl)
-                << ObjCMethod->isDirectMethod() << IMD->isDirectMethod()
-                << ObjCMethod->getDeclName();
+                << ObjCMethod->isDirectMethod() << /* method */ 0
+                << IMD->isDirectMethod() << ObjCMethod->getDeclName();
             Diag(IMD->getLocation(), diag::note_previous_declaration);
           }
         }
     }
 
     cast<DeclContext>(ClassDecl)->addDecl(ObjCMethod);
   }
 

clang/lib/Sema/SemaExprObjC.cpp

if (CheckMessageArgumentTypes(/*Receiver=*/nullptr, ReceiverType,
                                 RBracLoc, SourceRange(), ReturnType, VK))
     return ExprError();
 
   if (Method && !Method->getReturnType()->isVoidType() &&
       RequireCompleteType(LBracLoc, Method->getReturnType(),
                           diag::err_illegal_message_expr_incomplete_type))
     return ExprError();
 
+  if (Method && Method->isDirectMethod() && SuperLoc.isValid()) {
+    Diag(SuperLoc, diag::err_messaging_super_with_direct_method)
+        << FixItHint::CreateReplacement(
+               SuperLoc, getLangOpts().ObjCAutoRefCount
+                             ? "self"
+                             : Method->getClassInterface()->getName());
+    Diag(Method->getLocation(), diag::note_direct_method_declared_at)
+        << Method->getDeclName();
+  }
+
   // Warn about explicit call of +initialize on its own class. But not on 'super'.
   if (Method && Method->getMethodFamily() == OMF_initialize) {
     if (!SuperLoc.isValid()) {
       const ObjCInterfaceDecl *ID =
         dyn_cast<ObjCInterfaceDecl>(Method->getDeclContext());
       if (ID == Class) {
         Diag(Loc, diag::warn_direct_initialize_call);
         Diag(Method->getLocation(), diag::note_method_declared_at)
if (Receiver) {
     if (ReceiverType->isObjCRetainableType()) {
       // do nothing
     } else if (!getLangOpts().ObjCAutoRefCount &&
                !Context.getObjCIdType().isNull() &&
                (ReceiverType->isPointerType() ||
                 ReceiverType->isIntegerType())) {
       // Implicitly convert integers and pointers to 'id' but emit a warning.
       // But not in ARC.
-      Diag(Loc, diag::warn_bad_receiver_type)
-        << ReceiverType
-        << Receiver->getSourceRange();
+      Diag(Loc, diag::warn_bad_receiver_type) << ReceiverType << RecRange;
       if (ReceiverType->isPointerType()) {
         Receiver = ImpCastExprToType(Receiver, Context.getObjCIdType(),
                                      CK_CPointerToObjCPointerCast).get();
       } else {
         // TODO: specialized warning on null receivers?
         bool IsNull = Receiver->isNullPointerConstant(Context,
                                               Expr::NPC_ValueDependentIsNull);
         CastKind Kind = IsNull ? CK_NullToPointer : CK_IntegralToPointer;
if (receiverIsIdLike || ReceiverType->isBlockPointerType() ||
         ClassDecl = OCIType->getInterfaceDecl();
 
         // Try to complete the type. Under ARC, this is a hard error from which
         // we don't try to recover.
         // FIXME: In the non-ARC case, this will still be a hard error if the
         // definition is found in a module that's not visible.
         const ObjCInterfaceDecl *forwardClass = nullptr;
         if (RequireCompleteType(Loc, OCIType->getPointeeType(),
                                 getLangOpts().ObjCAutoRefCount
                                     ? diag::err_arc_receiver_forward_instance
                                     : diag::warn_receiver_forward_instance,
-                                Receiver? Receiver->getSourceRange()
-                                        : SourceRange(SuperLoc))) {
+                                RecRange)) {
           if (getLangOpts().ObjCAutoRefCount)
             return ExprError();
 
           forwardClass = OCIType->getInterfaceDecl();
           Diag(Receiver ? Receiver->getBeginLoc() : SuperLoc,
                diag::note_receiver_is_id);
           Method = nullptr;
         } else {
if (receiverIsIdLike || ReceiverType->isBlockPointerType() ||
                   << Sel << RecRange;
             }
           }
         }
         if (Method && DiagnoseUseOfDecl(Method, SelectorSlotLocs, forwardClass))
           return ExprError();
       } else {
         // Reject other random receiver types (e.g. structs).
-        Diag(Loc, diag::err_bad_receiver_type)
-          << ReceiverType << Receiver->getSourceRange();
+        Diag(Loc, diag::err_bad_receiver_type) << ReceiverType << RecRange;
         return ExprError();
       }
     }
   }
 
   FunctionScopeInfo *DIFunctionScopeInfo =
     (Method && Method->getMethodFamily() == OMF_init)
       ? getEnclosingFunction() : nullptr;
 
   if (Method && Method->isDirectMethod()) {
     if (ReceiverType->isObjCIdType() && !isImplicit) {
       Diag(Receiver->getExprLoc(),
            diag::err_messaging_unqualified_id_with_direct_method);
       Diag(Method->getLocation(), diag::note_direct_method_declared_at)
           << Method->getDeclName();
     }
 
     // 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)) {
+      {
+        DiagnosticBuilder Builder =
             Diag(Receiver->getExprLoc(),
                  diag::err_messaging_class_with_direct_method);
+        if (Receiver->isObjCSelfExpr()) {
+          Builder.AddFixItHint(FixItHint::CreateReplacement(
+              RecRange, Method->getClassInterface()->getName()));
+        }
+      }
       Diag(Method->getLocation(), diag::note_direct_method_declared_at)
           << Method->getDeclName();
     }
 
     if (SuperLoc.isValid()) {
+      {
+        DiagnosticBuilder Builder =
             Diag(SuperLoc, diag::err_messaging_super_with_direct_method);
+        if (ReceiverType->isObjCClassType()) {
+          Builder.AddFixItHint(FixItHint::CreateReplacement(
+              SuperLoc, Method->getClassInterface()->getName()));
+        } else {
+          Builder.AddFixItHint(FixItHint::CreateReplacement(SuperLoc, "self"));
+        }
+      }
       Diag(Method->getLocation(), diag::note_direct_method_declared_at)
           << Method->getDeclName();
     }
   } else if (ReceiverType->isObjCIdType() && !isImplicit) {
     Diag(Receiver->getExprLoc(), diag::warn_messaging_unqualified_id);
   }
 
   if (DIFunctionScopeInfo &&

clang/lib/Sema/SemaObjCProperty.cpp

if (ObjCPropertyImplDecl *PPIDecl =
         CatImplClass->FindPropertyImplDecl(PropertyId, QueryKind)) {
       Diag(PropertyDiagLoc, diag::err_property_implemented) << PropertyId;
       Diag(PPIDecl->getLocation(), diag::note_previous_declaration);
       return nullptr;
     }
     CatImplClass->addPropertyImplementation(PIDecl);
   }
 
+  if (PIDecl->getPropertyImplementation() == ObjCPropertyImplDecl::Dynamic &&
+      PIDecl->getPropertyDecl() &&
+      PIDecl->getPropertyDecl()->isDirectProperty()) {
+    Diag(PropertyLoc, diag::err_objc_direct_dynamic_property);
+    Diag(PIDecl->getPropertyDecl()->getLocation(),
+         diag::note_previous_declaration);
+    return nullptr;
+  }
+
   return PIDecl;
 }
 
 //===----------------------------------------------------------------------===//
 // Helper methods.
 //===----------------------------------------------------------------------===//
 
 /// DiagnosePropertyMismatch - Compares two properties for their
if (const ObjCCategoryDecl *CatDecl = dyn_cast<ObjCCategoryDecl>(CD))
       if (CatDecl->IsClassExtension())
         SetterMethod = IsClassProperty ? CatDecl->getClassInterface()->
                           getClassMethod(property->getSetterName()) :
                        CatDecl->getClassInterface()->
                           getInstanceMethod(property->getSetterName());
   DiagnosePropertyAccessorMismatch(property, GetterMethod,
                                    property->getLocation());
 
+  // synthesizing accessors must not result in a direct method that is not
+  // monomorphic
+  if (!GetterMethod) {
+    if (const ObjCCategoryDecl *CatDecl = dyn_cast<ObjCCategoryDecl>(CD)) {
+      auto *ExistingGetter = CatDecl->getClassInterface()->lookupMethod(
+          property->getGetterName(), !IsClassProperty, true, false, CatDecl);
+      if (ExistingGetter) {
+        if (ExistingGetter->isDirectMethod() || property->isDirectProperty()) {
+          Diag(property->getLocation(), diag::err_objc_direct_duplicate_decl)
+              << property->isDirectProperty() << 1 /* property */
+              << ExistingGetter->isDirectMethod()
+              << ExistingGetter->getDeclName();
+          Diag(ExistingGetter->getLocation(), diag::note_previous_declaration);
+        }
+      }
+    }
+  }
+
+  if (!property->isReadOnly() && !SetterMethod) {
+    if (const ObjCCategoryDecl *CatDecl = dyn_cast<ObjCCategoryDecl>(CD)) {
+      auto *ExistingSetter = CatDecl->getClassInterface()->lookupMethod(
+          property->getSetterName(), !IsClassProperty, true, false, CatDecl);
+      if (ExistingSetter) {
+        if (ExistingSetter->isDirectMethod() || property->isDirectProperty()) {
+          Diag(property->getLocation(), diag::err_objc_direct_duplicate_decl)
+              << property->isDirectProperty() << 1 /* property */
+              << ExistingSetter->isDirectMethod()
+              << ExistingSetter->getDeclName();
+          Diag(ExistingSetter->getLocation(), diag::note_previous_declaration);
+        }
+      }
+    }
+  }
+
   if (!property->isReadOnly() && SetterMethod) {
     if (Context.getCanonicalType(SetterMethod->getReturnType()) !=
         Context.VoidTy)
       Diag(SetterMethod->getLocation(), diag::err_setter_type_void);
     if (SetterMethod->param_size() != 1 ||
         !Context.hasSameUnqualifiedType(
           (*SetterMethod->param_begin())->getType().getNonReferenceType(),
           property->getType().getNonReferenceType())) {

clang/test/FixIt/fixit-objc-direct.m

+// Objective-C recovery
+// RUN: not %clang_cc1 -triple x86_64-apple-darwin10 -fdiagnostics-parseable-fixits -x objective-c %s 2>&1 | FileCheck -check-prefix=CHECK-MRR %s
+// RUN: not %clang_cc1 -triple x86_64-apple-darwin10 -fobjc-arc -fdiagnostics-parseable-fixits -x objective-c %s 2>&1 | FileCheck -check-prefix=CHECK-ARC %s
+
+__attribute__((objc_root_class))
+@interface Root
++ (void)classDirectMethod __attribute__((objc_direct));
++ (void)classDirectMethod2 __attribute__((objc_direct));
+- (void)instanceDirectMethod __attribute__((objc_direct));
+@end
+
+@interface A : Root
+@end
+
+@implementation A
++ (void)classMethod {
+  // CHECK-MRR: {18:4-18:8}:"Root"
+  [self classDirectMethod];
+}
++ (void)classMethod2 {
+  // CHECK-MRR: {23:4-23:9}:"Root"
+  // CHECK-ARC: {23:4-23:9}:"self"
+  [super classDirectMethod2];
+}
+- (void)instanceMethod {
+  // CHECK-MRR: {28:4-28:9}:"self"
+  // CHECK-ARC: {28:4-28:9}:"self"
+  [super instanceDirectMethod];
+}
+@end

clang/test/Misc/pragma-attribute-supported-attributes-list.test

 // CHECK-NEXT: OSReturnsRetainedOnZero (SubjectMatchRule_variable_is_parameter)
 // CHECK-NEXT: ObjCBoxable (SubjectMatchRule_record)
 // CHECK-NEXT: ObjCBridge (SubjectMatchRule_record, SubjectMatchRule_type_alias)
 // CHECK-NEXT: ObjCBridgeMutable (SubjectMatchRule_record)
 // CHECK-NEXT: ObjCBridgeRelated (SubjectMatchRule_record)
 // CHECK-NEXT: ObjCClassStub (SubjectMatchRule_objc_interface)
 // CHECK-NEXT: ObjCDesignatedInitializer (SubjectMatchRule_objc_method)
 // CHECK-NEXT: ObjCDirect (SubjectMatchRule_objc_method)
-// CHECK-NEXT: ObjCDirectMembers (SubjectMatchRule_objc_implementation, SubjectMatchRule_objc_category)
+// CHECK-NEXT: ObjCDirectMembers (SubjectMatchRule_objc_implementation, SubjectMatchRule_objc_interface, SubjectMatchRule_objc_category)
 // CHECK-NEXT: ObjCException (SubjectMatchRule_objc_interface)
 // CHECK-NEXT: ObjCExplicitProtocolImpl (SubjectMatchRule_objc_protocol)
 // CHECK-NEXT: ObjCExternallyRetained (SubjectMatchRule_variable_not_is_parameter, SubjectMatchRule_function, SubjectMatchRule_block, SubjectMatchRule_objc_method)
 // CHECK-NEXT: ObjCMethodFamily (SubjectMatchRule_objc_method)
 // CHECK-NEXT: ObjCNonLazyClass (SubjectMatchRule_objc_interface, SubjectMatchRule_objc_implementation)
 // CHECK-NEXT: ObjCPreciseLifetime (SubjectMatchRule_variable)
 // CHECK-NEXT: ObjCRequiresPropertyDefs (SubjectMatchRule_objc_interface)
 // CHECK-NEXT: ObjCRequiresSuper (SubjectMatchRule_objc_method)

clang/test/SemaObjC/category-direct-properties.m

+// RUN: %clang_cc1 -fsyntax-only -verify -Wselector-type-mismatch %s
+
+__attribute__((objc_root_class))
+@interface Inteface_Implementation
+@property(nonatomic, readonly) int normal_normal;
+@property(nonatomic, readonly, direct) int direct_normal;
+@property(nonatomic, readonly) int normal_direct; // expected-note {{previous declaration is here}}
+@property(nonatomic, readonly, direct) int direct_direct;
+@end
+
+@implementation Inteface_Implementation
+- (int)normal_normal {
+  return 42;
+}
+- (int)direct_normal {
+  return 42;
+}
+- (int)normal_direct __attribute__((objc_direct)) { // expected-error {{direct method implementation was previously declared not direct}}
+  return 42;
+}
+- (int)direct_direct __attribute__((objc_direct)) {
+  return 42;
+}
+@end
+
+__attribute__((objc_root_class))
+@interface Inteface_Extension
+@property(nonatomic, readonly) int normal_normal;
+@property(nonatomic, readonly, direct) int direct_normal;
+@property(nonatomic, readonly) int normal_direct;
+@property(nonatomic, readonly, direct) int direct_direct;
+@end
+
+@interface Inteface_Extension ()
+@property(nonatomic, readwrite) int normal_normal;
+@property(nonatomic, readwrite) int direct_normal;
+@property(nonatomic, readwrite, direct) int normal_direct;
+@property(nonatomic, readwrite, direct) int direct_direct;
+@end
+
+@implementation Inteface_Extension
+@end
+
+__attribute__((objc_root_class))
+@interface Extension_Implementation
+@end
+
+@interface Extension_Implementation ()
+@property(nonatomic, readwrite) int normal_normal;
+@property(nonatomic, readwrite, direct) int direct_normal;
+@property(nonatomic, readwrite) int normal_direct; // expected-note {{previous declaration is here}}
+@property(nonatomic, readwrite, direct) int direct_direct;
+@end
+
+@implementation Extension_Implementation
+- (int)normal_normal {
+  return 42;
+}
+- (int)direct_normal {
+  return 42;
+}
+- (int)normal_direct __attribute__((objc_direct)) { // expected-error {{direct method implementation was previously declared not direct}}
+  return 42;
+}
+- (int)direct_direct __attribute__((objc_direct)) {
+  return 42;
+}
+@end
+
+__attribute__((objc_root_class))
+@interface Inteface_Category
+@property(nonatomic, readonly) int normal_normal;
+@property(nonatomic, readonly, direct) int direct_normal; // expected-note {{previous declaration is here}}
+@property(nonatomic, readonly) int normal_direct;         // expected-note {{previous declaration is here}}
+@property(nonatomic, readonly, direct) int direct_direct; // expected-note {{previous declaration is here}}
+@end
+
+@interface Inteface_Category (SomeCategory)
+@property(nonatomic, readonly) int normal_normal;
+@property(nonatomic, readonly) int direct_normal;         // expected-error {{property declaration conflicts with previous direct declaration of property 'direct_normal'}}
+@property(nonatomic, readonly, direct) int normal_direct; // expected-error {{direct property declaration conflicts with previous declaration of property 'normal_direct'}}
+@property(nonatomic, readonly, direct) int direct_direct; // expected-error {{direct property declaration conflicts with previous direct declaration of property 'direct_direct'}}
+@end
+
+@implementation Inteface_Category
+@end
+
+__attribute__((objc_root_class))
+@interface Extension_Category
+@end
+
+@interface Extension_Category ()
+@property(nonatomic, readonly) int normal_normal;
+@property(nonatomic, readonly, direct) int direct_normal; // expected-note {{previous declaration is here}}
+@property(nonatomic, readonly) int normal_direct;         // expected-note {{previous declaration is here}}
+@property(nonatomic, readonly, direct) int direct_direct; // expected-note {{previous declaration is here}}
+@end
+
+@interface Extension_Category (SomeCategory)
+@property(nonatomic, readonly) int normal_normal;
+@property(nonatomic, readonly) int direct_normal;         // expected-error {{property declaration conflicts with previous direct declaration of property 'direct_normal'}}
+@property(nonatomic, readonly, direct) int normal_direct; // expected-error {{direct property declaration conflicts with previous declaration of property 'normal_direct'}}
+@property(nonatomic, readonly, direct) int direct_direct; // expected-error {{direct property declaration conflicts with previous direct declaration of property 'direct_direct'}}
+@end
+
+@implementation Extension_Category
+@end
+
+__attribute__((objc_root_class))
+@interface Implementation_Category
+@end
+
+@interface Implementation_Category (SomeCategory)
+@property(nonatomic, readonly) int normal_normal;
+@property(nonatomic, readonly, direct) int direct_normal; // expected-note {{previous declaration is here}}
+@property(nonatomic, readonly) int normal_direct;         // expected-note {{previous declaration is here}}
+@property(nonatomic, readonly, direct) int direct_direct; // expected-note {{previous declaration is here}}
+@end
+
+@implementation Implementation_Category
+- (int)normal_normal {
+  return 42;
+}
+- (int)direct_normal { // expected-error {{direct method was declared in a category but is implemented in the primary interface}}
+  return 42;
+}
+- (int)normal_direct __attribute__((objc_direct)) { // expected-error {{direct method was declared in a category but is implemented in the primary interface}}
+  return 42;
+}
+- (int)direct_direct __attribute__((objc_direct)) { // expected-error {{direct method was declared in a category but is implemented in the primary interface}}
+  return 42;
+}
+@end
+
+__attribute__((objc_root_class))
+@interface Category_Category
+@end
+
+@interface Category_Category (SomeCategory)
+@property(nonatomic, readonly) int normal_normal;
+@property(nonatomic, readonly, direct) int direct_normal; // expected-note {{previous declaration is here}}
+@property(nonatomic, readonly) int normal_direct;         // expected-note {{previous declaration is here}}
+@property(nonatomic, readonly, direct) int direct_direct; // expected-note {{previous declaration is here}}
+@end
+
+@interface Category_Category (SomeOtherCategory)
+@property(nonatomic, readonly) int normal_normal;
+@property(nonatomic, readonly) int direct_normal;         // expected-error {{property declaration conflicts with previous direct declaration of property 'direct_normal'}}
+@property(nonatomic, readonly, direct) int normal_direct; // expected-error {{direct property declaration conflicts with previous declaration of property 'normal_direct'}}
+@property(nonatomic, readonly, direct) int direct_direct; // expected-error {{direct property declaration conflicts with previous direct declaration of property 'direct_direct'}}
+@end
+
+@implementation Category_Category
+@end
+
+__attribute__((objc_root_class))
+@interface Category_CategoryImplementation
+@end
+
+@interface Category_CategoryImplementation (SomeCategory)
+@property(nonatomic, readonly) int normal_normal;
+@property(nonatomic, readonly, direct) int direct_normal;
+@property(nonatomic, readonly) int normal_direct; // expected-note {{previous declaration is here}}
+@property(nonatomic, readonly, direct) int direct_direct;
+@end
+
+@implementation Category_CategoryImplementation (SomeCategory)
+- (int)normal_normal {
+  return 42;
+}
+- (int)direct_normal {
+  return 42;
+}
+- (int)normal_direct __attribute__((objc_direct)) { // expected-error {{direct method implementation was previously declared not direct}}
+  return 42;
+}
+- (int)direct_direct __attribute__((objc_direct)) {
+  return 42;
+}
+@end
+
+@implementation Category_CategoryImplementation
+@end
+
+__attribute__((objc_root_class))
+@interface Interface_CategoryImplementation
+@property(nonatomic, readonly) int normal_normal;
+@property(nonatomic, readonly, direct) int direct_normal; // expected-note {{previous declaration is here}}
+@property(nonatomic, readonly) int normal_direct;         // expected-note {{previous declaration is here}}
+@property(nonatomic, readonly, direct) int direct_direct; // expected-note {{previous declaration is here}}
+@end
+
+@interface Interface_CategoryImplementation (SomeCategory)
+@end
+
+@implementation Interface_CategoryImplementation (SomeCategory)
+- (int)normal_normal {
+  return 42;
+}
+- (int)direct_normal { // expected-error {{direct method was declared in the primary interface but is implemented in a category}}
+  return 42;
+}
+- (int)normal_direct __attribute__((objc_direct)) { // expected-error {{direct method was declared in the primary interface but is implemented in a category}}
+  return 42;
+}
+- (int)direct_direct __attribute__((objc_direct)) { // expected-error {{direct method was declared in the primary interface but is implemented in a category}}
+  return 42;
+}
+@end
+
+@implementation Interface_CategoryImplementation
+@end
+
+__attribute__((objc_root_class))
+@interface Extension_CategoryImplementation
+@end
+
+@interface Extension_CategoryImplementation ()
+@property(nonatomic, readonly) int normal_normal;
+@property(nonatomic, readonly, direct) int direct_normal; // expected-note {{previous declaration is here}}
+@property(nonatomic, readonly) int normal_direct;         // expected-note {{previous declaration is here}}
+@property(nonatomic, readonly, direct) int direct_direct; // expected-note {{previous declaration is here}}
+@end
+
+@interface Extension_CategoryImplementation (SomeCategory)
+@end
+
+@implementation Extension_CategoryImplementation (SomeCategory)
+- (int)normal_normal {
+  return 42;
+}
+- (int)direct_normal { // expected-error {{direct method was declared in an extension but is implemented in a different category}}
+  return 42;
+}
+- (int)normal_direct __attribute__((objc_direct)) { // expected-error {{direct method was declared in an extension but is implemented in a different category}}
+  return 42;
+}
+- (int)direct_direct __attribute__((objc_direct)) { // expected-error {{direct method was declared in an extension but is implemented in a different category}}
+  return 42;
+}
+@end
+
+__attribute__((objc_root_class))
+@interface OtherCategory_CategoryImplementation
+@end
+
+@interface OtherCategory_CategoryImplementation (SomeCategory)
+@end
+
+@interface OtherCategory_CategoryImplementation (SomeOtherCategory)
+@property(nonatomic, readonly) int normal_normal;
+@property(nonatomic, readonly, direct) int direct_normal; // expected-note {{previous declaration is here}}
+@property(nonatomic, readonly) int normal_direct;         // expected-note {{previous declaration is here}}
+@property(nonatomic, readonly, direct) int direct_direct; // expected-note {{previous declaration is here}}
+@end
+
+@implementation OtherCategory_CategoryImplementation (SomeCategory)
+- (int)normal_normal {
+  return 42;
+}
+- (int)direct_normal { // expected-error {{direct method was declared in a category but is implemented in a different category}}
+  return 42;
+}
+- (int)normal_direct __attribute__((objc_direct)) { // expected-error {{direct method was declared in a category but is implemented in a different category}}
+  return 42;
+}
+- (int)direct_direct __attribute__((objc_direct)) { // expected-error {{direct method was declared in a category but is implemented in a different category}}
+  return 42;
+}
+@end
+
+@implementation OtherCategory_CategoryImplementation
+@end

clang/test/SemaObjC/dynamic-direct-properties.m

+// RUN: %clang_cc1 -fsyntax-only -verify -Wselector-type-mismatch %s
+
+__attribute__((objc_root_class))
+@interface Foo
+@property() int dynamic_property;
+@property(direct) int direct_property; // expected-note {{previous declaration is here}}
+@end
+
+@implementation Foo
+@dynamic dynamic_property;
+@dynamic direct_property; // expected-error {{direct property cannot be @dynamic}}
+@end
+
+@interface Foo (Bar)
+@property() int dynamic_category_property;
+@property(direct) int direct_category_property; // expected-note {{previous declaration is here}}
+@end
+
+@implementation Foo (Bar)
+@dynamic dynamic_category_property;
+@dynamic direct_category_property; // expected-error {{direct property cannot be @dynamic}}
+@end

clang/test/SemaObjC/method-direct.m

 __attribute__((objc_root_class))
 @interface Root
 - (void)rootRegular;                                  // expected-note {{previous declaration is here}}
 + (void)classRootRegular;                             // expected-note {{previous declaration is here}}
 - (void)rootDirect __attribute__((objc_direct));      // expected-note {{previous declaration is here}};
 + (void)classRootDirect __attribute__((objc_direct)); // expected-note {{previous declaration is here}};
 - (void)otherRootDirect __attribute__((objc_direct)); // expected-note {{direct method 'otherRootDirect' declared here}}
 + (void)otherClassRootDirect __attribute__((objc_direct)); // expected-note {{direct method 'otherClassRootDirect' declared here}}
++ (void)otherOtherClassRootDirect __attribute__((objc_direct)); // expected-note {{direct method 'otherOtherClassRootDirect' declared here}}
 - (void)notDirectInIface;                             // expected-note {{previous declaration is here}}
 + (void)classNotDirectInIface;                        // expected-note {{previous declaration is here}}
 @end
 
 __attribute__((objc_direct_members))
 @interface Root ()
 - (void)rootExtensionDirect;      // expected-note {{previous declaration is here}}
 + (void)classRootExtensionDirect; // expected-note {{previous declaration is here}}

 
 @interface Root (Direct2)
 - (void)rootCategoryRegular;                                   // expected-note {{previous declaration is here}}
 + (void)classRootCategoryRegular;                              // expected-note {{previous declaration is here}}
 - (void)rootCategoryDirect2 __attribute__((objc_direct));      // expected-note {{previous declaration is here}}
 + (void)classRootCategoryDirect2 __attribute__((objc_direct)); // expected-note {{previous declaration is here}}
 @end
 
-__attribute__((objc_root_class, objc_direct_members)) // expected-error {{'objc_direct_members' attribute only applies to Objective-C implementation declarations and Objective-C containers}}
-@interface SubDirectFail : Root
+__attribute__((objc_direct_members))
+@interface SubDirectMembers : Root
+@property int foo; // expected-note {{previous declaration is here}}
 - (instancetype)init;
 @end
 
 @interface Sub : Root <Proto>
 /* invalid overrides with directs */
 - (void)rootRegular __attribute__((objc_direct));               // expected-error {{methods that override superclass methods cannot be direct}}
 + (void)classRootRegular __attribute__((objc_direct));          // expected-error {{methods that override superclass methods cannot be direct}}
 - (void)protoMethod __attribute__((objc_direct));               // expected-error {{methods that implement protocol requirements cannot be direct}}

 }
 - (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)otherOtherClassRootDirect {
+}
 - (void)rootExtensionDirect {
 }
 + (void)classRootExtensionDirect {
 }
 - (void)rootExtensionRegular {
 }
 + (void)classRootExtensionRegular {
 }

 
 @interface ValidSub : Root
 @end
 
 @implementation ValidSub
 - (void)someValidSubMethod {
   [super otherRootDirect]; // expected-error {{messaging super with a direct method}}
 }
++ (void)someValidSubMethod {
+  [super otherOtherClassRootDirect]; // expected-error {{messaging super with a direct method}}
+}
+@end
+
+@implementation SubDirectMembers
+@dynamic foo; // expected-error {{direct property cannot be @dynamic}}
+- (instancetype)init {
+  return self;
+}
 @end
 
 extern void callMethod(id obj, Class cls);
 extern void useSel(SEL sel);
 
 void callMethod(id obj, Class cls) {
   [Root otherClassRootDirect];
   [cls otherClassRootDirect]; // expected-error {{messaging a Class with a method that is possibly direct}}
   [obj direct1];              // expected-error {{messaging unqualified id with a method that is possibly direct}}
   [(Root *)obj direct1];
   [obj directMismatch1];              // expected-warning {{multiple methods named 'directMismatch1' found}}
   useSel(@selector(direct2));         // expected-error {{@selector expression formed with direct selector 'direct2'}}
   useSel(@selector(directMismatch2)); // expected-warning {{several methods with selector 'directMismatch2' of mismatched types are found for the @selector expression}}
 }