Support for attributes on @class declarations

[erik.pilkington]

Summary

This is useful to make availability checking work with forward declarations, but there also seem to be other attributes that make sense here.

rdar://43118198

[aaron.ballman]

I don't think I know enough about ObjC semantics to say much about the language design aspects of this patch.

clang/include/clang/Parse/Parser.h

1496

Slight preference for using ParsedAttributesWithRange instead when making new interfaces -- we often need the range when trying to prohibit attributes in places, or for other diagnostic purposes.

However, this may not be feasible depending on where you're getting the attributes from (some parts of the parser are still unfortunately deficient in this regard).

clang/lib/Parse/ParseObjc.cpp

124

Comment seems out of date now.

clang/test/CodeGenObjC/objc-asm-attribute-test.m

78

Can probably drop this spurious newline.

clang/test/SemaObjC/attr-forward-class.m

11–12

Do you have plans to fix this? If so, I'm fine with a FIXME for now, but I think the note is essentially a bug as it stands.

27

What is a "postfix attribute"? I would have assumed this was attempting to add a type attribute rather than a declaration attribute (based on the usual C and C++ semantics), so this diagnostic is a bit unhelpful.

[rjmccall]

Have you looked through the attributes that can be written on @interfaces and verified that they're all sensible to write on a @class? It's not hard to imagine that *some* of them should be diagnosed when added to a non-definition.

clang/include/clang/Parse/Parser.h

   // EndLoc, if non-NULL, is filled with the location of the last token of
   // the simple-asm.
   ExprResult ParseSimpleAsm(SourceLocation *EndLoc = nullptr);
   ExprResult ParseAsmStringLiteral();
 
   // Objective-C External Declarations
   void MaybeSkipAttributes(tok::ObjCKeywordKind Kind);
   DeclGroupPtrTy ParseObjCAtDirectives(ParsedAttributesWithRange &Attrs);
-  DeclGroupPtrTy ParseObjCAtClassDeclaration(SourceLocation atLoc);
+  DeclGroupPtrTy ParseObjCAtClassDeclaration(SourceLocation atLoc,
+                                             ParsedAttributes &Attrs);
   Decl *ParseObjCAtInterfaceDeclaration(SourceLocation AtLoc,
                                         ParsedAttributes &prefixAttrs);
   class ObjCTypeParamListScope;
   ObjCTypeParamList *parseObjCTypeParamList();
   ObjCTypeParamList *parseObjCTypeParamListOrProtocolRefs(
       ObjCTypeParamListScope &Scope, SourceLocation &lAngleLoc,
       SmallVectorImpl<IdentifierLocPair> &protocolIdents,
       SourceLocation &rAngleLoc, bool mayBeProtocolList = true);

clang/include/clang/Sema/Sema.h

                                          SourceLocation ClassLoc,
                                          IdentifierInfo *CatName,
                                          SourceLocation CatLoc,
                                          const ParsedAttributesView &AttrList);
 
   DeclGroupPtrTy ActOnFinishObjCImplementation(Decl *ObjCImpDecl,
                                                ArrayRef<Decl *> Decls);
 
-  DeclGroupPtrTy ActOnForwardClassDeclaration(SourceLocation Loc,
-                   IdentifierInfo **IdentList,
-                   SourceLocation *IdentLocs,
-                   ArrayRef<ObjCTypeParamList *> TypeParamLists,
-                   unsigned NumElts);
+  DeclGroupPtrTy ActOnForwardClassDeclaration(
+      SourceLocation Loc, IdentifierInfo **IdentList, SourceLocation *IdentLocs,
+      ArrayRef<ObjCTypeParamList *> TypeParamLists, unsigned NumElts,
+      const ParsedAttributesView &AttrList);
 
   DeclGroupPtrTy
   ActOnForwardProtocolDeclaration(SourceLocation AtProtoclLoc,
                                   ArrayRef<IdentifierLocPair> IdentList,
                                   const ParsedAttributesView &attrList);
 
   void FindProtocolDeclaration(bool WarnOnDeclarations, bool ForObjCContainer,
                                ArrayRef<IdentifierLocPair> ProtocolId,

clang/lib/Parse/ParseObjc.cpp

if (Tok.is(tok::code_completion)) {
     Actions.CodeCompleteObjCAtDirective(getCurScope());
     cutOffParsing();
     return nullptr;
   }
 
   Decl *SingleDecl = nullptr;
   switch (Tok.getObjCKeywordID()) {
   case tok::objc_class:
-    return ParseObjCAtClassDeclaration(AtLoc);
+    return ParseObjCAtClassDeclaration(AtLoc, Attrs);
   case tok::objc_interface:
     SingleDecl = ParseObjCAtInterfaceDeclaration(AtLoc, Attrs);
     break;
   case tok::objc_protocol:
     return ParseObjCAtProtocolDeclaration(AtLoc, Attrs);
   case tok::objc_implementation:
     return ParseObjCAtImplementationDeclaration(AtLoc, Attrs);
   case tok::objc_end:
void leave() {
     if (Params)
       Actions.popObjCTypeParamList(S, Params);
     Params = nullptr;
   }
 };
 
 ///
 /// objc-class-declaration:
 ///    '@' 'class' objc-class-forward-decl (',' objc-class-forward-decl)* ';'
 ///
 /// objc-class-forward-decl:
 ///   identifier objc-type-parameter-list[opt]
 ///
 Parser::DeclGroupPtrTy
-Parser::ParseObjCAtClassDeclaration(SourceLocation atLoc) {
+Parser::ParseObjCAtClassDeclaration(SourceLocation atLoc,
+                                    ParsedAttributes &Attrs) {
   ConsumeToken(); // the identifier "class"
   SmallVector<IdentifierInfo *, 8> ClassNames;
   SmallVector<SourceLocation, 8> ClassLocs;
   SmallVector<ObjCTypeParamList *, 8> ClassTypeParams;
 
   while (1) {
     MaybeSkipAttributes(tok::objc_class);
     if (expectIdentifier()) {
Parser::ParseObjCAtClassDeclaration(SourceLocation atLoc,
 
   // Consume the ';'.
   if (ExpectAndConsume(tok::semi, diag::err_expected_after, "@class"))
     return Actions.ConvertDeclToDeclGroup(nullptr);
 
   return Actions.ActOnForwardClassDeclaration(atLoc, ClassNames.data(),
                                               ClassLocs.data(),
                                               ClassTypeParams,
-                                              ClassNames.size());
+                                              ClassNames.size(),
+                                              Attrs);
 }
 
 void Parser::CheckNestedObjCContexts(SourceLocation AtLoc)
 {
   Sema::ObjCContainerKind ock = Actions.getObjCContainerKind();
   if (ock == Sema::OCK_None)
     return;
 

clang/lib/Parse/Parser.cpp

 
   // ObjC2 allows prefix attributes on class interfaces and protocols.
   // FIXME: This still needs better diagnostics. We should only accept
   // attributes here, no types, etc.
   if (getLangOpts().ObjC && Tok.is(tok::at)) {
     SourceLocation AtLoc = ConsumeToken(); // the "@"
     if (!Tok.isObjCAtKeyword(tok::objc_interface) &&
         !Tok.isObjCAtKeyword(tok::objc_protocol) &&
-        !Tok.isObjCAtKeyword(tok::objc_implementation)) {
+        !Tok.isObjCAtKeyword(tok::objc_implementation) &&
+        !Tok.isObjCAtKeyword(tok::objc_class)) {
       Diag(Tok, diag::err_objc_unexpected_attr);
       SkipUntil(tok::semi);
       return nullptr;
     }
 
     DS.abort();
 
     const char *PrevSpec = nullptr;
     unsigned DiagID;
     if (DS.SetTypeSpecType(DeclSpec::TST_unspecified, AtLoc, PrevSpec, DiagID,
                            Actions.getASTContext().getPrintingPolicy()))
       Diag(AtLoc, DiagID) << PrevSpec;
 
     if (Tok.isObjCAtKeyword(tok::objc_protocol))
       return ParseObjCAtProtocolDeclaration(AtLoc, DS.getAttributes());
 
     if (Tok.isObjCAtKeyword(tok::objc_implementation))
       return ParseObjCAtImplementationDeclaration(AtLoc, DS.getAttributes());
 
+    if (Tok.isObjCAtKeyword(tok::objc_class))
+      return ParseObjCAtClassDeclaration(AtLoc, DS.getAttributes());
+
     return Actions.ConvertDeclToDeclGroup(
             ParseObjCAtInterfaceDeclaration(AtLoc, DS.getAttributes()));
   }
 
   // If the declspec consisted only of 'extern' and we have a string
   // literal following it, this must be a C++ linkage specifier like
   // 'extern "C"'.
   if (getLangOpts().CPlusPlus && isTokenStringLiteral() &&

clang/lib/Sema/SemaDeclObjC.cpp

         << PrevIDecl->getDeclName();
       Diag(Def->getLocation(), diag::note_previous_definition);
       IDecl->setInvalidDecl();
     }
   }
 
   ProcessDeclAttributeList(TUScope, IDecl, AttrList);
   AddPragmaAttributes(TUScope, IDecl);
+  if (PrevIDecl)
+    mergeDeclAttributes(IDecl, PrevIDecl);
+
   PushOnScopeChains(IDecl, TUScope);
 
   // Start the definition of this class. If we're in a redefinition case, there
   // may already be a definition, so we'll end up adding to it.
   if (!IDecl->hasDefinition())
     IDecl->startDefinition();
 
   if (SuperName) {

                                 ExplicitImplProtocols);
       DiagnoseUnimplementedProperties(S, IMPDecl, CDecl,
                                       /*SynthesizeProperties=*/false);
     }
   } else
     llvm_unreachable("invalid ObjCContainerDecl type.");
 }
 
-Sema::DeclGroupPtrTy
-Sema::ActOnForwardClassDeclaration(SourceLocation AtClassLoc,
-                                   IdentifierInfo **IdentList,
-                                   SourceLocation *IdentLocs,
-                                   ArrayRef<ObjCTypeParamList *> TypeParamLists,
-                                   unsigned NumElts) {
+Sema::DeclGroupPtrTy Sema::ActOnForwardClassDeclaration(
+    SourceLocation AtClassLoc, IdentifierInfo **IdentList,
+    SourceLocation *IdentLocs, ArrayRef<ObjCTypeParamList *> TypeParamLists,
+    unsigned NumElts, const ParsedAttributesView &AttrList) {
   SmallVector<Decl *, 8> DeclsInGroup;
   for (unsigned i = 0; i != NumElts; ++i) {
     // Check for another declaration kind with the same name.
     NamedDecl *PrevDecl
       = LookupSingleName(TUScope, IdentList[i], IdentLocs[i],
                          LookupOrdinaryName, forRedeclarationInCurContext());
     if (PrevDecl && !isa<ObjCInterfaceDecl>(PrevDecl)) {
       // GCC apparently allows the following idiom:

     }
 
     ObjCInterfaceDecl *IDecl
       = ObjCInterfaceDecl::Create(Context, CurContext, AtClassLoc,
                                   ClassName, TypeParams, PrevIDecl,
                                   IdentLocs[i]);
     IDecl->setAtEndRange(IdentLocs[i]);
 
+    ProcessDeclAttributeList(TUScope, IDecl, AttrList);
+    AddPragmaAttributes(TUScope, IDecl);
+    if (PrevIDecl)
+      mergeDeclAttributes(IDecl, PrevIDecl);
+
     PushOnScopeChains(IDecl, TUScope);
     CheckObjCDeclScope(IDecl);
     DeclsInGroup.push_back(IDecl);
   }
 
   return BuildDeclaratorGroup(DeclsInGroup);
 }
 

clang/test/CodeGenObjC/objc-asm-attribute-test.m

 - (instancetype)init;
 + (instancetype)alloc;
 @end
 
 id Test16877359() {
     return [SLREarth alloc];
 }
 
+__attribute__((objc_runtime_name("MySecretNamespace.ForwardClass")))
+@class ForwardClass;
+
+void testForwardClass() {
+  [ForwardClass alloc];
+}
+
 // CHECK: @"OBJC_IVAR_$_MySecretNamespace.Message.MyIVAR" = global i64 0
 // CHECK: @"OBJC_CLASS_$_MySecretNamespace.Message" = global %struct._class_t
 // CHECK: @"OBJC_METACLASS_$_MySecretNamespace.Message" = global %struct._class_t
-
 // CHECK: private unnamed_addr constant [42 x i8] c"T@\22MySecretNamespace.Message\22,&,V_msgProp\00"
 // CHECK: private unnamed_addr constant [76 x i8] c"T@\22MySecretNamespace.Message<MySecretNamespace.Protocol3>\22,&,V_msgProtoProp\00"
 // CHECK: private unnamed_addr constant [50 x i8] c"T@\22<MySecretNamespace.Protocol3>\22,&,V_idProtoProp\00"
 
 // CHECK: @"OBJC_CLASS_$_foo" = external global %struct._class_t
+
+// CHECK: @"OBJC_CLASS_$_MySecretNamespace.ForwardClass" = external global %struct._class_t
+
 // CHECK: define internal i8* @"\01-[Message MyMethod]"
 // CHECK: [[IVAR:%.*]] = load i64, i64* @"OBJC_IVAR_$_MySecretNamespace.Message.MyIVAR"
+

clang/test/Misc/pragma-attribute-objc.m

 
 @implementation testInterface1(testCat)
 // CHECK-LABEL: ObjCCategoryImplDecl{{.*}}testCat
 // CHECK-NOT: AnnotateAttr
 // CHECK-NOT: ObjCSubclassingRestrictedAttr
 
 @end
 
-// @class/@compatibility_alias declarations can't receive explicit attributes,
-// so don't add pragma attributes to them.
 @class testClass;
 // CHECK-LABEL: ObjCInterfaceDecl{{.*}}testClass
-// CHECK-NOT: AnnotateAttr
-// CHECK-NOT: ObjCSubclassingRestrictedAttr
+// CHECK-NEXT: AnnotateAttr
+// CHECK-NEXT: ObjCSubclassingRestrictedAttr
 
+// @compatibility_alias declarations can't receive explicit attributes, so don't
+// add pragma attributes to them.
 @compatibility_alias testCompat testInterface1;
 // CHECK-LABEL: ObjCCompatibleAliasDecl{{.*}}testCompat
 // CHECK-NOT: AnnotateAttr
 // CHECK-NOT: ObjCSubclassingRestrictedAttr
 
 #pragma clang attribute pop // objc_subclassing_restricted
 
 @interface testInterface3

clang/test/Parser/attributes.mm

 // RUN: %clang_cc1 -verify -fsyntax-only -Wno-objc-root-class %s
 
-// FIXME: Why isn't this supported? Seems useful for availability attributes at
-// the very least.
-__attribute__((deprecated)) @class B; // expected-error {{prefix attribute must be followed by an interface, protocol, or implementation}}
+__attribute__((deprecated)) @class B;
 
 __attribute__((deprecated)) @interface A @end
 __attribute__((deprecated)) @protocol P0;
 __attribute__((deprecated)) @protocol P1
 @end
 
 #define EXP __attribute__((visibility("default")))
 class EXP C {};
 EXP class C2 {}; // expected-warning {{attribute 'visibility' is ignored, place it after "class" to apply attribute to type declaration}}
 
 @interface EXP I @end // expected-error {{postfix attributes are not allowed on Objective-C directives, place them in front of '@interface'}}
 EXP @interface I2 @end
 
 @implementation EXP I @end // expected-error-re {{postfix attributes are not allowed on Objective-C directives{{$}}}}
 EXP @implementation I2 @end
 
 @class EXP OC; // expected-error-re {{postfix attributes are not allowed on Objective-C directives{{$}}}}
-EXP @class OC2; // expected-error {{prefix attribute must be followed by an interface, protocol, or implementation}}
+EXP @class OC2;
 
 @protocol EXP P @end // expected-error {{postfix attributes are not allowed on Objective-C directives, place them in front of '@protocol'}}
 EXP @protocol P2 @end

clang/test/SemaObjC/attr-forward-class.m

+// RUN: %clang_cc1 -verify %s -triple x86_64-apple-macos10.14
+
+__attribute__((availability(macos, introduced=1000)))
+@class JustForward; // expected-note{{introduced in macOS 1000 here}}
+
+JustForward *makeIt(); // expected-warning{{'JustForward' is only available on macOS 1000 or newer}} expected-note{{annotate 'makeIt' with an availability attribute to silence this warning}}
+
+__attribute__((availability(macos, introduced=1000)))
+@class FwdDefined;
+
+// FIXME: it'd be nice to point to the declaration with the attribute if its
+// inherited.
+@interface FwdDefined // expected-note{{introduced in macOS 1000 here}}
+@end
+
+FwdDefined *makeIt2(); // expected-warning{{'FwdDefined' is only available on macOS 1000 or newer}} expected-note{{annotate 'makeIt2' with an availability attribute to silence this warning}}
+
+@class FwdDefined2;
+
+__attribute__((availability(macos, introduced=1000)))
+@interface FwdDefined2 // expected-note{{introduced in macOS 1000 here}}
+@end
+
+FwdDefined2 *makeIt3(); // expected-warning{{'FwdDefined2' is only available on macOS 1000 or newer}} expected-note {{annotate}}
+
+
+// expected-error@+1{{postfix attributes are not allowed on Objective-C directives}}
+@class __attribute__((availability(macos, introduced=1000))) InTheMiddle;
+
+#pragma clang attribute push (__attribute__((availability(macos,introduced=1000))), apply_to=objc_interface)
+
+@class PragmaAttribute; // expected-note{{'PragmaAttribute' has been marked as being introduced in macOS 1000 here, but the deployment target is macOS 10.14.0}}
+
+#pragma clang attribute pop
+
+PragmaAttribute *makeIt4();  // expected-warning{{PragmaAttribute' is only available on macOS 1000 or newer}} expected-note {{annotate}}

clang/test/SemaObjC/objc-asm-attribute-neg-test.m

 
 - (int) getMyProperty __attribute__((objc_runtime_name("MySecretNamespace.Message"))); // expected-error {{'objc_runtime_name' attribute only applies to}}
 
 - (void) setMyProperty : (int) arg __attribute__((objc_runtime_name("MySecretNamespace.Message"))); // expected-error {{'objc_runtime_name' attribute only applies to}}
 
 @end
 
 __attribute__((objc_runtime_name("MySecretNamespace.ForwardClass")))
-@class ForwardClass; // expected-error {{prefix attribute must be followed by an interface, protocol, or implementation}}
+@class ForwardClass;
 
 __attribute__((objc_runtime_name("MySecretNamespace.ForwardProtocol")))
 @protocol ForwardProtocol;
 
 @implementation Message
 // expected-error@+1 {{'objc_runtime_name' attribute only applies to Objective-C interfaces and Objective-C protocols}}
 - (id) MyMethod __attribute__((objc_runtime_name("MySecretNamespace.Message"))) {
   return MyIVAR;