[clang] add a new `swift_attr` attribute

[arphaman]

Summary

The swift_attr attribute is a generic annotation attribute that's not used by clang, but is used by the Swift compiler. The Swift compiler can use these annotations to provide various syntactic and semantic sugars for the imported Objective-C API declarations.

[erik.pilkington]

Do we need to add APINotes support for this?

clang/include/clang/Basic/Attr.td

2155

Should we limit this to appear on certain subjects? Presumably the swift importer is only going to look for this in certain places, so I think it makes sense to call out places where it'll be ignored in clang. WDYT?

[aaron.ballman]

clang/include/clang/Basic/Attr.td

2153

The other swift attributes use a GNU spelling and don't expose any C++ spelling. Should this follow suit (or should the other attributes be updated)?

clang/include/clang/Basic/AttrDocs.td

3635

What declarations does this attribute appertain to?

3637

clang -> Clang

[arphaman]

Updated for review comments

[arphaman]

Thanks for taking a look.

In D92354#2428604, @erik.pilkington wrote:

Do we need to add APINotes support for this?

Not at the moment, maybe in the future

clang/include/clang/Basic/Attr.td

2153

You're right, that was my mistake. Changed it to GNU.

2155

I think we want to leave it as a flexible attribute that can be applied to any declaration for now, and let the Swift importer decide on which declarations it wants to support them.

clang/include/clang/Basic/AttrDocs.td

3635

Mentioned that it can be applied to any declaration.

[aaron.ballman]

LGTM!

clang/include/clang/Basic/Attr.td

 def Regparm : TypeAttr {
   let Spellings = [GCC<"regparm">];
   let Args = [UnsignedArgument<"NumParams">];
   let Documentation = [RegparmDocs];
   // Represented as part of the enclosing function type.
   let ASTNode = 0;
 }
 
+def SwiftAttr : InheritableAttr {
+  let Spellings = [GNU<"swift_attr">];
+  let Args = [StringArgument<"Attribute">];
+  let Documentation = [SwiftAttrDocs];
+}
+
 def SwiftBridge : InheritableAttr {
   let Spellings = [GNU<"swift_bridge">];
   let Args = [StringArgument<"SwiftType">];
   let Subjects = SubjectList<[Tag, TypedefName, ObjCInterface, ObjCProtocol],
                              ErrorDiag>;
   let Documentation = [SwiftBridgeDocs];
 }
 

clang/include/clang/Basic/AttrDocs.td

 
 def SwiftDocs : DocumentationCategory<"Customizing Swift Import"> {
   let Content = [{
 Clang supports additional attributes for customizing how APIs are imported into
 Swift.
   }];
 }
 
+def SwiftAttrDocs : Documentation {
+  let Category = SwiftDocs;
+  let Heading = "swift_attr";
+  let Content = [{
+The ``swift_attr`` provides a Swift-specific annotation for the declaration
+to which the attribute appertains to. It can be used on any declaration
+in Clang. This kind of annotation is ignored by Clang as it doesn't have any
+semantic meaning in languages supported by Clang. The Swift compiler can
+interpret these annotations according to its own rules when importing C or
+Objective-C declarations.
+}];
+}
+
 def SwiftBridgeDocs : Documentation {
   let Category = SwiftDocs;
   let Heading = "swift_bridge";
   let Content = [{
 The ``swift_bridge`` attribute indicates that the declaration to which the
 attribute appertains is bridged to the named Swift type.
 
   .. code-block:: objc

clang/lib/Sema/SemaDeclAttr.cpp

case Qualifiers::OCL_Autoreleasing:
     S.Diag(AL.getLoc(), diag::warn_objc_precise_lifetime_meaningless)
         << (Lifetime == Qualifiers::OCL_Autoreleasing);
     break;
   }
 
   D->addAttr(::new (S.Context) ObjCPreciseLifetimeAttr(S.Context, AL));
 }
 
+static void handleSwiftAttrAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
+  // Make sure that there is a string literal as the annotation's single
+  // argument.
+  StringRef Str;
+  if (!S.checkStringLiteralArgumentAttr(AL, 0, Str))
+    return;
+
+  D->addAttr(::new (S.Context) SwiftAttrAttr(S.Context, AL, Str));
+}
+
 static void handleSwiftBridge(Sema &S, Decl *D, const ParsedAttr &AL) {
   // Make sure that there is a string literal as the annotation's single
   // argument.
   StringRef BT;
   if (!S.checkStringLiteralArgumentAttr(AL, 0, BT))
     return;
 
   // Don't duplicate annotations that are already set.
static void ProcessDeclAttribute(Sema &S, Scope *scope, Decl *D,
   case ParsedAttr::AT_ArgumentWithTypeTag:
     handleArgumentWithTypeTagAttr(S, D, AL);
     break;
   case ParsedAttr::AT_TypeTagForDatatype:
     handleTypeTagForDatatypeAttr(S, D, AL);
     break;
 
   // Swift attributes.
+  case ParsedAttr::AT_SwiftAttr:
+    handleSwiftAttrAttr(S, D, AL);
+    break;
   case ParsedAttr::AT_SwiftBridge:
     handleSwiftBridge(S, D, AL);
     break;
   case ParsedAttr::AT_SwiftBridgedTypedef:
     handleSimpleAttribute<SwiftBridgedTypedefAttr>(S, D, AL);
     break;
   case ParsedAttr::AT_SwiftError:
     handleSwiftError(S, D, AL);

clang/test/AST/attr-swift_attr.m

+// RUN: %clang_cc1 -fsyntax-only -ast-dump %s | FileCheck %s
+
+__attribute__((swift_attr("@actor")))
+@interface View
+@end
+
+// CHECK: InterfaceDecl {{.*}} View
+// CHECK-NEXT: SwiftAttrAttr {{.*}} "@actor"

clang/test/SemaObjC/validate-attr-swift_attr.m

+// RUN: %clang_cc1 -verify -fsyntax-only %s
+
+// expected-error@+1 {{'swift_attr' attribute takes one argument}}
+__attribute__((swift_attr))
+@interface I
+@end
+
+// expected-error@+1 {{'swift_attr' attribute requires a string}}
+__attribute__((swift_attr(1)))
+@interface J
+@end