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

[compnerd]

Summary

This attribute allows declarations to be restricted to the framework
itself, enabling Swift to remove the declarations when importing
libraries. This is useful in the case that the functions can be
implemented in a more natural way for Swift.

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

2189

Similar concerns here with listing all of the subjects as with the other review? (I don't have strong opinions.)

clang/lib/Sema/SemaDecl.cpp

2613–2614 ↗

(On Diff #292014)

Hmm, I'm a bit confused. The attribute is an inheritable attribute, but when we try to merge attributes between declarations, we drop it?

clang/test/SemaObjC/attr-swift-private.m

1 ↗

(On Diff #292014)

No need for blocks support?

25 ↗

(On Diff #292014)

Should also have tests for the subjects you expect not to work.

[gribozavr2]

clang/include/clang/Basic/AttrDocs.td

3592

Please drop the "Objective-C" part.

3597

..., while hiding the non-idiomatic one.

[compnerd]

clang/include/clang/Basic/Attr.td

2189

Yes, I think that is a justified concern and it would be best to not have the subject list as per the swift_name case.

clang/test/SemaObjC/attr-swift-private.m

25 ↗

(On Diff #292014)

This no longer makes sense with the subject list removed.

[compnerd]

add more tests to cover the confusing case of attribute merge handling

[compnerd]

clang/lib/Sema/SemaDecl.cpp

2613–2614 ↗

(On Diff #292014)

Discussed offline - this is dead code. Removed and added a test case to demonstrate the beahviour.

[compnerd]

• address all feedback, add more test cases

[aaron.ballman]

LGTM!

clang/include/clang/Basic/Attr.td

def SwiftNewType : InheritableAttr {
   let Spellings = [GNU<"swift_newtype">, GNU<"swift_wrapper">];
   let Args = [EnumArgument<"NewtypeKind", "NewtypeKind",
                            ["struct", "enum"], ["NK_Struct", "NK_Enum"]>];
   let Subjects = SubjectList<[TypedefName], ErrorDiag>;
   let Documentation = [SwiftNewTypeDocs];
   let HasCustomParsing = 1;
 }
 
+def SwiftPrivate : InheritableAttr {
+  let Spellings = [GNU<"swift_private">];
+  let Documentation = [SwiftPrivateDocs];
+}
+
 def NoDeref : TypeAttr {
   let Spellings = [Clang<"noderef">];
   let Documentation = [NoDerefDocs];
 }
 
 def ReqdWorkGroupSize : InheritableAttr {
   // Does not have a [[]] spelling because it is an OpenCL-related attribute.
   let Spellings = [GNU<"reqd_work_group_size">];
   let Args = [UnsignedArgument<"XDim">, UnsignedArgument<"YDim">,
               UnsignedArgument<"ZDim">];
   let Subjects = SubjectList<[Function], ErrorDiag>;
   let Documentation = [Undocumented];
 }

clang/include/clang/Basic/AttrDocs.td

 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``).
 
   .. code-block:: objc
 
     @interface NSString;
     typedef NSString *AliasedString __attribute__((__swift_bridged_typedef__));
 
     extern void acceptsAliasedString(AliasedString _Nonnull parameter);
 
 In this case, the function ``acceptsAliasedString`` will be imported into Swift
.. code-block:: c
 
     // Import UIFontDescriptorFeatureKey as a structure type, with enumerated
     // values being members of the type structure.
     typedef NSString * UIFontDescriptorFeatureKey __attribute__((__swift_newtype__(struct)));
 
   }];
 }
 
+def SwiftPrivateDocs : Documentation {
+  let Category = SwiftDocs;
+  let Heading = "swift_private";
+  let Content = [{
+Declarations marked with the ``swift_private`` attribute are hidden from the
+framework client but are still made available for use within the framework or
+Swift SDK overlay.
+
+The purpose of this attribute is to permit a more idomatic implementation of
+declarations in Swift while hiding the non-idiomatic one.
+  }];
+}
+
 def OMPDeclareSimdDocs : Documentation {
   let Category = DocCatFunction;
   let Heading = "#pragma omp declare simd";
   let Content = [{
 The ``declare simd`` construct can be applied to a function to enable the creation
 of one or more versions that can process multiple arguments using SIMD
 instructions from a single invocation in a SIMD loop. The ``declare simd``
 directive is a declarative directive. There may be multiple ``declare simd``

clang/lib/Sema/SemaDeclAttr.cpp

case ParsedAttr::AT_SwiftName:
     handleSwiftName(S, D, AL);
     break;
   case ParsedAttr::AT_SwiftNewType:
     handleSwiftNewType(S, D, AL);
     break;
   case ParsedAttr::AT_SwiftObjCMembers:
     handleSimpleAttribute<SwiftObjCMembersAttr>(S, D, AL);
     break;
+  case ParsedAttr::AT_SwiftPrivate:
+    handleSimpleAttribute<SwiftPrivateAttr>(S, D, AL);
+    break;
 
   // XRay attributes.
   case ParsedAttr::AT_XRayLogArgs:
     handleXRayLogArgsAttr(S, D, AL);
     break;
 
   case ParsedAttr::AT_PatchableFunctionEntry:
     handlePatchableFunctionEntryAttr(S, D, AL);

clang/test/AST/attr-swift_private.m

+// RUN: %clang_cc1 -ast-dump %s | FileCheck %s
+
+@interface I
+- (void)method __attribute__((__swift_private__));
+@end
+
+// CHECK: ObjCInterfaceDecl {{.*}} I
+// CHECK: ObjCMethodDecl {{.*}} method 'void'
+// CHECK: SwiftPrivateAttr
+
+@interface J : I
+- (void)method;
+@end
+
+// CHECK: ObjCInterfaceDecl {{.*}} J
+// CHECK: ObjCMethodDecl {{.*}} method 'void'
+// CHECK: SwiftPrivateAttr {{.*}} Inherited
+
+void f(void) __attribute__((__swift_private__));
+// CHECK: FunctionDecl {{.*}} f 'void (void)'
+// CHECK: SwiftPrivateAttr
+
+void f(void) {
+}
+// CHECK: FunctionDecl {{.*}} f 'void (void)'
+// CHECK: SwiftPrivateAttr {{.*}} Inherited

clang/test/SemaObjC/attr-swift_private.m

+// RUN: %clang_cc1 -verify -fsyntax-only -fobjc-arc %s
+
+__attribute__((__swift_private__))
+@protocol P
+@end
+
+__attribute__((__swift_private__))
+@interface I
+@end
+
+@interface J
+@property id property __attribute__((__swift_private__));
+- (void)instanceMethod __attribute__((__swift_private__));
++ (void)classMethod __attribute__((__swift_private__));
+@end
+
+void f(void) __attribute__((__swift_private__));
+
+struct __attribute__((__swift_private__)) S {};
+
+enum __attribute__((__swift_private__)) E {
+  one,
+  two,
+};
+
+typedef struct { } T __attribute__((__swift_private__));
+
+void g(void) __attribute__((__swift_private__("private")));
+// expected-error@-1 {{'__swift_private__' attribute takes no arguments}}