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

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

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

   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

   considered to have thrown if they return a zero result. The return type must be
   an integral type. If the return type would have been imported as ``Bool``, it
   is instead imported as ``Void``. This is the default error convention for
   Objective-C methods that return a type that would be imported as ``Bool``.
 
 * ``swift_error(nonzero_result)`` means that calls to the function should be
   considered to have thrown if they return a non-zero result. The return type must
   be an integral type. If the return type would have been imported as ``Bool``,
   it is instead imported as ``Void``.
 
 * ``swift_error(nonnull_error)`` means that calls to the function should be
   considered to have thrown if they leave a non-null error in the error parameter.
   The return type is left unmodified.
 
   }];
 }
 
 def SwiftNameDocs : Documentation {
   let Category = SwiftDocs;
   let Heading = "swift_name";
   let Content = [{
 The ``swift_name`` attribute provides the name of the declaration in Swift. If

 
     // 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/SemaDecl.cpp

     // CUDA target attributes are part of function signature for
     // overloading purposes and must not be merged.
     return false;
   } else if (const auto *MA = dyn_cast<MinSizeAttr>(Attr))
     NewAttr = S.mergeMinSizeAttr(D, *MA);
   else if (const auto *SNA = dyn_cast<SwiftNameAttr>(Attr))
     NewAttr = S.mergeSwiftNameAttr(D, *SNA, SNA->getName(),
                                    AMK == Sema::AMK_Override);
+  else if (isa<SwiftPrivateAttr>(Attr) && AMK == Sema::AMK_Override)
+    NewAttr = nullptr;
   else if (const auto *OA = dyn_cast<OptimizeNoneAttr>(Attr))
     NewAttr = S.mergeOptimizeNoneAttr(D, *OA);
   else if (const auto *InternalLinkageA = dyn_cast<InternalLinkageAttr>(Attr))
     NewAttr = S.mergeInternalLinkageAttr(D, *InternalLinkageA);
   else if (const auto *CommonA = dyn_cast<CommonAttr>(Attr))
     NewAttr = S.mergeCommonAttr(D, *CommonA);
   else if (isa<AlignedAttr>(Attr))
     // AlignedAttrs are handled separately, because we need to handle all
     // such attributes on a declaration at the same time.
     NewAttr = nullptr;
   else if ((isa<DeprecatedAttr>(Attr) || isa<UnavailableAttr>(Attr)) &&
            (AMK == Sema::AMK_Override ||
             AMK == Sema::AMK_ProtocolImplementation))
     NewAttr = nullptr;
   else if (const auto *UA = dyn_cast<UuidAttr>(Attr))
     NewAttr = S.mergeUuidAttr(D, *UA, UA->getGuid(), UA->getGuidDecl());
   else if (const auto *SLHA = dyn_cast<SpeculativeLoadHardeningAttr>(Attr))
     NewAttr = S.mergeSpeculativeLoadHardeningAttr(D, *SLHA);
   else if (const auto *SLHA = dyn_cast<NoSpeculativeLoadHardeningAttr>(Attr))
     NewAttr = S.mergeNoSpeculativeLoadHardeningAttr(D, *SLHA);
   else if (const auto *IMA = dyn_cast<WebAssemblyImportModuleAttr>(Attr))
     NewAttr = S.mergeImportModuleAttr(D, *IMA);
   else if (const auto *INA = dyn_cast<WebAssemblyImportNameAttr>(Attr))

clang/lib/Sema/SemaDeclAttr.cpp

     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

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}}