Sema: add support for `__attribute__((__swift_bridge__))`

[compnerd]

Summary

This extends semantic analysis of attributes for Swift interoperability
by introducing the swift_bridge attribute. This attribute enables
bridging Objective-C types to Swift specific types.

This is based on the work of the original changes in
https://github.com/llvm/llvm-project-staging/commit/8afaf3aad2af43cfedca7a24cd817848c4e95c0c

[aaron.ballman]

clang/include/clang/Basic/Attr.td

2133

Is this a type or a declaration attribute? It looks like a declaration attribute based on the declaration and the list of subjects, but it looks like a type based on the ExpectedType diagnostic and the documentation. Or is this one of those unholy GNU attributes that's confused about what it appertains to?

Should this be inherited by redeclarations? Might be worth adding a test:

struct __attribute__((swift_bridge)) S;

struct S { // Should still have the attribute
  int i;
};

clang/include/clang/Basic/AttrDocs.td

3483

If this is a type attribute, should it be listed as a TypeAttr above?

clang/lib/Sema/SemaDeclAttr.cpp

5535

Can a type bridge across multiple types? e.g., could you say this bridges to "foo" and "bar"?

5536

Can drop the getAttrName() and just pass in AL directly.

clang/test/SemaObjC/attr-swift_bridged_typedef.m

11 ↗

(On Diff #291272)

I'd appreciate a test that shows it diagnosing when given the wrong subject.

[aaron.ballman]

clang/include/clang/Basic/Attr.td

2137

Are you sure the ExpectedType is needed?

[compnerd]

clang/lib/Sema/SemaDeclAttr.cpp

5535

No, I believe that you can not bridge to two different types.

[compnerd]

Address some feedback from @aaron.ballman

[compnerd]

clang/include/clang/Basic/Attr.td

2133

It is a declaration attribute, and yes, it should be inheritable.

[aaron.ballman]

clang/include/clang/Basic/Attr.td

2133

Okay, you should mark the attribute as an InheritableAttr above and a test.

2134

Is it intentional that this is swift_bridge but we just added swift_bridged_typedef (bridge vs bridged)? That seems like a bit of a spelling gotcha, if it can be corrected.

clang/include/clang/Basic/AttrDocs.td

3483

The documentation should probably also say that it is bridging the declarations rather than the types, just to be clear. Maybe something like: The swift_bridge attribute indicates that the declaration to which the attribute is applied is bridged to the named Swift type. ?

If not that formulation, you should at least change swift_bridged to be swift_bridge.

Adding a code example of how to use this properly would also be appreciated.

[compnerd]

clang/include/clang/Basic/Attr.td

2134

Yes, that is intentional. This has already shipped, so Im afraid that changing the spelling isn't really reasonable at this point. I agree that it is is a spelling gotcha, but fortunately, most of the uses of these are done through macros (e.g. CF_REFINED_FOR_SWIFT).

[compnerd]

Address feedback

[aaron.ballman]

LGTM!

clang/include/clang/Basic/Attr.td

2134

Okie dokie, that's what I figured.

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 SwiftBridge : InheritableAttr {
+  let Spellings = [GNU<"swift_bridge">];
+  let Args = [StringArgument<"SwiftType">];
+  let Subjects = SubjectList<[Tag, TypedefName, ObjCInterface, ObjCProtocol],
+                             ErrorDiag>;
+  let Documentation = [SwiftBridgeDocs];
+}
+
 def SwiftBridgedTypedef : InheritableAttr {
   let Spellings = [GNU<"swift_bridged_typedef">];
   let Subjects = SubjectList<[TypedefName], ErrorDiag>;
   let Documentation = [SwiftBridgedTypedefDocs];
 }
 
 def SwiftObjCMembers : Attr {
   let Spellings = [GNU<"swift_objc_members">];

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 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:: c
+
+    __attribute__((__objc_root__))
+    @interface Base
+    - (instancetype)init;
+    @end
+
+    __attribute__((__swift_bridge__("BridgedI")))
+    @interface I : Base
+    @end
+
+In this example, the Objective-C interface ``I`` will be made available to Swift
+with the name ``BridgedI``.  It would be possible for the compiler to refer to
+``I`` still in order to bridge the type back to Objective-C.
+  }];
+}
+
 def SwiftBridgedTypedefDocs : Documentation {
   let Category = SwiftDocs;
   let Heading = "swift_bridged";
   let Content = [{
 The ``swift_bridged_typedef`` attribute indicates that when the typedef to which
 the attribute appertains is imported into Swift, it should refer to the bridged
 Swift type (e.g. Swift's ``String``) rather than the Objective-C type as written
 (e.g. ``NSString``).

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 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.
+  if (D->hasAttr<SwiftBridgeAttr>()) {
+    S.Diag(AL.getLoc(), diag::warn_duplicate_attribute) << AL;
+    return;
+  }
+
+  D->addAttr(::new (S.Context) SwiftBridgeAttr(S.Context, AL, BT));
+}
+
 static bool isErrorParameter(Sema &S, QualType QT) {
   const auto *PT = QT->getAs<PointerType>();
   if (!PT)
     return false;
 
   QualType Pointee = PT->getPointeeType();
 
   // Check for NSError**.
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_SwiftBridge:
+    handleSwiftBridge(S, D, AL);
+    break;
   case ParsedAttr::AT_SwiftBridgedTypedef:
     handleSimpleAttribute<SwiftBridgedTypedefAttr>(S, D, AL);
     break;
   case ParsedAttr::AT_SwiftError:
     handleSwiftError(S, D, AL);
     break;
   case ParsedAttr::AT_SwiftObjCMembers:
     handleSimpleAttribute<SwiftObjCMembersAttr>(S, D, AL);

clang/test/AST/attr-swift_bridge.m

+// RUN: %clang_cc1 -fsyntax-only -ast-dump %s | FileCheck %s
+
+struct __attribute__((__swift_bridge__("BridgedS"))) S;
+// CHECK: RecordDecl {{.*}} struct S
+// CHECK: SwiftBridgeAttr {{.*}} "BridgedS"
+
+struct S {
+};
+
+// CHECK: RecordDecl {{.*}} struct S definition
+// CHECK: SwiftBridgeAttr {{.*}} Inherited "BridgedS"

clang/test/SemaObjC/attr-swift_bridge.m

+// RUN: %clang_cc1 -verify -fsyntax-only %s
+
+// expected-error@+1 {{'__swift_bridge__' attribute takes one argument}}
+__attribute__((__swift_bridge__))
+@interface I
+@end
+
+// expected-error@+1 {{'__swift_bridge__' attribute requires a string}}
+__attribute__((__swift_bridge__(1)))
+@interface J
+@end
+
+// expected-error@+1 {{'__swift_bridge__' attribute takes one argument}}
+__attribute__((__swift_bridge__("K", 1)))
+@interface K
+@end
+
+@interface L
+// expected-error@+1 {{'__swift_bridge__' attribute only applies to tag types, typedefs, Objective-C interfaces, and Objective-C protocols}}
+- (void)method __attribute__((__swift_bridge__("method")));
+@end
+
+__attribute__((__swift_bridge__("Array")))
+@interface NSArray
+@end
+
+__attribute__((__swift_bridge__("ProtocolP")))
+@protocol P
+@end
+
+typedef NSArray *NSArrayAlias __attribute__((__swift_bridge__("ArrayAlias")));
+
+struct __attribute__((__swift_bridge__("StructT"))) T {};