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

[compnerd]

Summary

Add the swift_newtype attribute which allows a type definition to be
imported into Swift as a new type. The imported type must be either an
enumerated type (enum) or an object type (struct).

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

2179

We don't ever document swift_wrapper, is that intentional?

(Do you have code elsewhere that's looking at the spelling of the AST attribute object? Should you add an AdditionalMembers to this declaration to make that easier to distinguish?)

2183

You should also set: let HasCustomParsing = 1; since this uses a custom parser.

Is the custom parser actually needed though? Or is it only needed because the enum names selected are keywords? If it's only because of the keyword nature, should the parser be improved in Parser::ParseAttributeArgsCommon() instead?

clang/include/clang/Basic/AttrDocs.td

3585

Code examples of how to use this properly would be appreciated.

clang/include/clang/Basic/DiagnosticSemaKinds.td

4038 ↗

(On Diff #291725)

Hrm, we already have existing diagnostics to cover this (warn_attribute_wrong_decl_type_str) but it's in the IgnoredAttributes group. Do you need a new warning group specific to this? Is there a reason that group is not a subset of IgnoredAttributes?

clang/lib/Sema/SemaDeclAttr.cpp

5894

Btw, if you fix up the parser, then you can skip setting HasCustomParsing and then can remove some of this manual error checking as well.

5895

No need to do this (I'm surprised it even compiles given that AL is a const reference), here or elsewhere.

5905

There should be a helper method to do this dance for you. SwiftNewTypeAttr::ConvertStrToNewtypeKind() should be roughly what it's called (it's generated for you by the attr emitter).

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

2 ↗

(On Diff #291725)

Can you split the AST bits out into their own test in the AST directory?

[compnerd]

clang/include/clang/Basic/Attr.td

2179

Yes, that was intentional. I believe that swift_wrapper predates swift_newtype and is only kept for compatibility. People should gravitate towards swift_newtype.

I don't understand the need for AdditionalMembers.

2183

It's for the keyword handling. I'll take a look and see if I can convert this to the ParseAttributeArgsCommon path.

clang/include/clang/Basic/DiagnosticSemaKinds.td

4038 ↗

(On Diff #291725)

Hmm, Im okay with changing the group, but I do wonder if Apple is going to worry about diagnostic compatibility. @doug.gregor, @rjmccall, or @dexonsmith would be better suited to answer the question about command line compatibility.

[aaron.ballman]

clang/include/clang/Basic/Attr.td

2179

Ah, thank you for the explanation. I think we should document swift_wrapper as explicitly being deprecated then so it's clear to people (esp Future Aaron) what the intent is. It sounds like there's no need for AdditionalMembers (that's only useful if you need to distinguish between the spellings that share a semantic attribute).

2183

If you can easily modify ParseAttributeArgsCommon, then awesome! If that turns out to be a slog, I don't insist on the change being made.

clang/include/clang/Basic/DiagnosticSemaKinds.td

4038 ↗

(On Diff #291725)

If you need specific control over the swift attribute diagnostics for ignored attributes, you could make the group be a part of IgnoredAttributes (so by default, swift ignored attributes are controlled by IgnoredAttributes but can be selectively enabled/disabled).

[compnerd]

Update for feedback from @aaron.ballman
The ParseAttrCommonArgs refactoring still needs to be looked at, but this should address the feedback, and doesn't need to be predicated on the refactoring.

[aaron.ballman]

clang/include/clang/Basic/Attr.td

2172

Should we make these docs part of the public docs in AttrDocs.td? That's sort of what I had in mind with my comment (so that if someone runs into the attribute in the wild and wonders what it is, they have a hint).

clang/lib/Sema/SemaDeclAttr.cpp

5968

Rather than adding a new enumeration to warn_attribute_wrong_decl_type, I would use warn_attribute_wrong_decl_type_str and pass in the string as part of the diagnostic.

[compnerd]

clang/include/clang/Basic/Attr.td

2172

Ah, okay, that seems reasonable enough.

[aaron.ballman]

The changes LGTM aside from a small wording nit with the documentation. The parser changes I asked about can be done in a follow-up to this patch.

clang/include/clang/Basic/AttrDocs.td

3604–3606

For the new blurb about the deprecated name, how about:

Previously, the attribute was spelled swift_wrapper. While the behavior of the attribute is identical with either spelling, swift_wrapper is deprecated, only exists for compatibility purposes, and should not be used in new code.

clang/include/clang/Basic/Attr.td

 }
 
 def SwiftName : InheritableAttr {
   let Spellings = [GNU<"swift_name">];
   let Args = [StringArgument<"Name">];
   let Documentation = [SwiftNameDocs];
 }
 
+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 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

 * ``swift_error(null_result)`` means that calls to the function should be
   considered to have thrown if they return a null value. The return type must be
   a pointer type, and it will be imported into Swift with a non-optional type.
   This is the default error convention for Objective-C methods that return
   pointers.
 
 * ``swift_error(zero_result)`` means that calls to the function should be
   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
 this attribute is absent, the name is transformed according to the algorithm
 built into the Swift compiler.
 
 The argument is a string literal that contains the Swift name of the function,
 variable, or type. When renaming a function, the name may be a compound Swift
 name.  For a type, enum constant, property, or variable declaration, the name
 must be a simple or qualified identifier.
 
   .. code-block:: objc
 
     @interface URL
     - (void) initWithString:(NSString *)s __attribute__((__swift_name__("URL.init(_:)")))
     @end
 
     void __attribute__((__swift_name__("squareRoot()"))) sqrt(double v) {
     }
   }];
 }
 
+def SwiftNewTypeDocs : Documentation {
+  let Category = SwiftDocs;
+  let Heading = "swift_newtype";
+  let Content = [{
+The ``swift_newtype`` attribute indicates that the typedef to which the
+attribute appertains is imported as a new Swift type of the typedef's name.
+Previously, the attribute was spelt ``swift_wrapper``.  While the behaviour of
+the attribute is identical with either spelling, ``swift_wrapper`` is
+deprecated, only exists for compatibility purposes, and should not be used in
+new code.
+
+* ``swift_newtype(struct)`` means that a Swift struct will be created for this
+typedef.
+
+* ``swift_newtype(enum)`` means that a Swift enum will be created for this
+ypedef.
+
+  .. code-block:: c
+
+    // Import UIFontTextStyle as an enum type, with enumerated values being
+    // constants.
+    typedef NSString * UIFontTextStyle __attribute__((__swift_newtype__(enum)));
+
+    // Import UIFontDescriptorFeatureKey as a structure type, with enumerated
+    // values being members of the type structure.
+    typedef NSString * UIFontDescriptorFeatureKey __attribute__((__swift_newtype__(struct)));
+
+  }];
+}
+
 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/include/clang/Parse/Parser.h

private:
   void ParseObjCBridgeRelatedAttribute(IdentifierInfo &ObjCBridgeRelated,
                                        SourceLocation ObjCBridgeRelatedLoc,
                                        ParsedAttributes &attrs,
                                        SourceLocation *endLoc,
                                        IdentifierInfo *ScopeName,
                                        SourceLocation ScopeLoc,
                                        ParsedAttr::Syntax Syntax);
 
+  void ParseSwiftNewTypeAttribute(IdentifierInfo &AttrName,
+                                  SourceLocation AttrNameLoc,
+                                  ParsedAttributes &Attrs,
+                                  SourceLocation *EndLoc,
+                                  IdentifierInfo *ScopeName,
+                                  SourceLocation ScopeLoc,
+                                  ParsedAttr::Syntax Syntax);
+
   void ParseTypeTagForDatatypeAttribute(IdentifierInfo &AttrName,
                                         SourceLocation AttrNameLoc,
                                         ParsedAttributes &Attrs,
                                         SourceLocation *EndLoc,
                                         IdentifierInfo *ScopeName,
                                         SourceLocation ScopeLoc,
                                         ParsedAttr::Syntax Syntax);
 

clang/lib/Parse/ParseDecl.cpp

 #include "clang/Basic/AddressSpaces.h"
 #include "clang/Basic/Attributes.h"
 #include "clang/Basic/CharInfo.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Parse/ParseDiagnostic.h"
 #include "clang/Sema/Lookup.h"
 #include "clang/Sema/ParsedTemplate.h"
 #include "clang/Sema/Scope.h"
+#include "clang/Sema/SemaDiagnostic.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringSwitch.h"
 
 using namespace clang;
 
 //===----------------------------------------------------------------------===//
void Parser::ParseGNUAttributeArgs(IdentifierInfo *AttrName,
   } else if (AttrKind == ParsedAttr::AT_ExternalSourceSymbol) {
     ParseExternalSourceSymbolAttribute(*AttrName, AttrNameLoc, Attrs, EndLoc,
                                        ScopeName, ScopeLoc, Syntax);
     return;
   } else if (AttrKind == ParsedAttr::AT_ObjCBridgeRelated) {
     ParseObjCBridgeRelatedAttribute(*AttrName, AttrNameLoc, Attrs, EndLoc,
                                     ScopeName, ScopeLoc, Syntax);
     return;
+  } else if (AttrKind == ParsedAttr::AT_SwiftNewType) {
+    ParseSwiftNewTypeAttribute(*AttrName, AttrNameLoc, Attrs, EndLoc, ScopeName,
+                               ScopeLoc, Syntax);
+    return;
   } else if (AttrKind == ParsedAttr::AT_TypeTagForDatatype) {
     ParseTypeTagForDatatypeAttribute(*AttrName, AttrNameLoc, Attrs, EndLoc,
                                      ScopeName, ScopeLoc, Syntax);
     return;
   } else if (attributeIsTypeArgAttr(*AttrName)) {
     ParseAttributeWithTypeArg(*AttrName, AttrNameLoc, Attrs, EndLoc, ScopeName,
                               ScopeLoc, Syntax);
     return;
unsigned Parser::ParseClangAttributeArgs(
   case ParsedAttr::AT_Availability:
     ParseAvailabilityAttribute(*AttrName, AttrNameLoc, Attrs, EndLoc, ScopeName,
                                ScopeLoc, Syntax);
     break;
   case ParsedAttr::AT_ObjCBridgeRelated:
     ParseObjCBridgeRelatedAttribute(*AttrName, AttrNameLoc, Attrs, EndLoc,
                                     ScopeName, ScopeLoc, Syntax);
     break;
+  case ParsedAttr::AT_SwiftNewType:
+    ParseSwiftNewTypeAttribute(*AttrName, AttrNameLoc, Attrs, EndLoc, ScopeName,
+                               ScopeLoc, Syntax);
+    break;
   case ParsedAttr::AT_TypeTagForDatatype:
     ParseTypeTagForDatatypeAttribute(*AttrName, AttrNameLoc, Attrs, EndLoc,
                                      ScopeName, ScopeLoc, Syntax);
     break;
   }
   return !Attrs.empty() ? Attrs.begin()->getNumArgs() : 0;
 }
 
attrs.addNew(&ObjCBridgeRelated,
                SourceRange(ObjCBridgeRelatedLoc, T.getCloseLocation()),
                ScopeName, ScopeLoc,
                RelatedClass,
                ClassMethod,
                InstanceMethod,
                Syntax);
 }
 
+
+void Parser::ParseSwiftNewTypeAttribute(
+    IdentifierInfo &AttrName, SourceLocation AttrNameLoc,
+    ParsedAttributes &Attrs, SourceLocation *EndLoc, IdentifierInfo *ScopeName,
+    SourceLocation ScopeLoc, ParsedAttr::Syntax Syntax) {
+  BalancedDelimiterTracker T(*this, tok::l_paren);
+
+  // Opening '('
+  if (T.consumeOpen()) {
+    Diag(Tok, diag::err_expected) << tok::l_paren;
+    return;
+  }
+
+  if (Tok.is(tok::r_paren)) {
+    Diag(Tok.getLocation(), diag::err_argument_required_after_attribute);
+    T.consumeClose();
+    return;
+  }
+  if (Tok.isNot(tok::kw_struct) && Tok.isNot(tok::kw_enum)) {
+    Diag(Tok, diag::warn_attribute_type_not_supported)
+        << &AttrName << Tok.getIdentifierInfo();
+    if (!isTokenSpecial())
+      ConsumeToken();
+    T.consumeClose();
+    return;
+  }
+
+  auto *SwiftType = IdentifierLoc::create(Actions.Context, Tok.getLocation(),
+                                          Tok.getIdentifierInfo());
+  ConsumeToken();
+
+  // Closing ')'
+  if (T.consumeClose())
+    return;
+  if (EndLoc)
+    *EndLoc = T.getCloseLocation();
+
+  ArgsUnion Args[] = {SwiftType};
+  Attrs.addNew(&AttrName, SourceRange(AttrNameLoc, T.getCloseLocation()),
+               ScopeName, ScopeLoc, Args, llvm::array_lengthof(Args), Syntax);
+}
+
+
 void Parser::ParseTypeTagForDatatypeAttribute(IdentifierInfo &AttrName,
                                               SourceLocation AttrNameLoc,
                                               ParsedAttributes &Attrs,
                                               SourceLocation *EndLoc,
                                               IdentifierInfo *ScopeName,
                                               SourceLocation ScopeLoc,
                                               ParsedAttr::Syntax Syntax) {
   assert(Tok.is(tok::l_paren) && "Attribute arg list not starting with '('");

clang/lib/Sema/SemaDeclAttr.cpp

if (SwiftParamCount == ParamCount) {
       ParamCountValid = IsSingleParamInit && ParamCount == 0;
     } else {
       // We have fewer Swift parameters than Objective-C parameters, but that
       // might be because we've transformed some of them. Check for potential
       // "out" parameters and err on the side of not warning.
       unsigned MaybeOutParamCount =
           std::count_if(Params.begin(), Params.end(),
                         [](const ParmVarDecl *Param) -> bool {
         QualType ParamTy = Param->getType();
         if (ParamTy->isReferenceType() || ParamTy->isPointerType())
           return !ParamTy->getPointeeType().isConstQualified();
         return false;
       });
 
       ParamCountValid = SwiftParamCount + MaybeOutParamCount >= ParamCount;
     }
 
     if (!ParamCountValid) {
       Diag(Loc, diag::warn_attr_swift_name_num_params)
           << (SwiftParamCount > ParamCount) << AL << ParamCount
           << SwiftParamCount;
       return false;
     }
   } else if (isa<EnumConstantDecl>(D) || isa<ObjCProtocolDecl>(D) ||
              isa<ObjCInterfaceDecl>(D) || isa<ObjCPropertyDecl>(D) ||
              isa<VarDecl>(D) || isa<TypedefNameDecl>(D) || isa<TagDecl>(D) ||
              isa<IndirectFieldDecl>(D) || isa<FieldDecl>(D)) {
     StringRef ContextName, BaseName;
if (!S.checkStringLiteralArgumentAttr(AL, 0, Name, &Loc))
     return;
 
   if (!S.DiagnoseSwiftName(D, Name, Loc, AL))
     return;
 
   D->addAttr(::new (S.Context) SwiftNameAttr(S.Context, AL, Name));
 }
 
+static void handleSwiftNewType(Sema &S, Decl *D, const ParsedAttr &AL) {
+  // Make sure that there is an identifier as the annotation's single argument.
+  if (!checkAttributeNumArgs(S, AL, 1))
+    return;
+
+  if (!AL.isArgIdent(0)) {
+    S.Diag(AL.getLoc(), diag::err_attribute_argument_type)
+        << AL << AANT_ArgumentIdentifier;
+    return;
+  }
+
+  SwiftNewTypeAttr::NewtypeKind Kind;
+  IdentifierInfo *II = AL.getArgAsIdent(0)->Ident;
+  if (!SwiftNewTypeAttr::ConvertStrToNewtypeKind(II->getName(), Kind)) {
+    S.Diag(AL.getLoc(), diag::warn_attribute_type_not_supported) << AL << II;
+    return;
+  }
+
+  if (!isa<TypedefNameDecl>(D)) {
+    S.Diag(AL.getLoc(), diag::warn_attribute_wrong_decl_type_str)
+        << AL << "typedefs";
+    return;
+  }
+
+  D->addAttr(::new (S.Context) SwiftNewTypeAttr(S.Context, AL, Kind));
+}
+
 //===----------------------------------------------------------------------===//
 // Microsoft specific attribute handlers.
 //===----------------------------------------------------------------------===//
 
 UuidAttr *Sema::mergeUuidAttr(Decl *D, const AttributeCommonInfo &CI,
                               StringRef UuidAsWritten, MSGuidDecl *GuidDecl) {
   if (const auto *UA = D->getAttr<UuidAttr>()) {
     if (declaresSameEntity(UA->getGuidDecl(), GuidDecl))
case ParsedAttr::AT_SwiftBridgedTypedef:
     handleSimpleAttribute<SwiftBridgedTypedefAttr>(S, D, AL);
     break;
   case ParsedAttr::AT_SwiftError:
     handleSwiftError(S, D, AL);
     break;
   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;
 
   // XRay attributes.
   case ParsedAttr::AT_XRayLogArgs:
     handleXRayLogArgsAttr(S, D, AL);
     break;

clang/test/AST/attr-swift_newtype.m

+// RUN: %clang_cc1 -ast-dump %s | FileCheck %s
+
+typedef int T1 __attribute__((__swift_newtype__(struct)));
+typedef int T2 __attribute__((__swift_newtype__(enum)));
+
+typedef int T3 __attribute__((__swift_wrapper__(struct)));
+typedef int T4 __attribute__((__swift_wrapper__(enum)));
+
+typedef int T5;
+typedef int T5 __attribute__((__swift_wrapper__(struct)));
+typedef int T5;
+// CHECK-LABEL: TypedefDecl {{.+}} T5 'int'
+// CHECK-NEXT: BuiltinType {{.+}} 'int'
+// CHECK-NEXT: TypedefDecl {{.+}} T5 'int'
+// CHECK-NEXT: BuiltinType {{.+}} 'int'
+// CHECK-NEXT: SwiftNewTypeAttr {{.+}} NK_Struct
+// CHECK-NEXT: TypedefDecl {{.+}} T5 'int'
+// CHECK-NEXT: BuiltinType {{.+}} 'int'
+// CHECK-NEXT: SwiftNewTypeAttr {{.+}} NK_Struct

clang/test/Misc/pragma-attribute-supported-attributes-list.test

 // CHECK-NEXT: Section (SubjectMatchRule_function, SubjectMatchRule_variable_is_global, SubjectMatchRule_objc_method, SubjectMatchRule_objc_property)
 // CHECK-NEXT: SetTypestate (SubjectMatchRule_function_is_member)
 // CHECK-NEXT: SpeculativeLoadHardening (SubjectMatchRule_function, SubjectMatchRule_objc_method)
 // CHECK-NEXT: SwiftBridgedTypedef (SubjectMatchRule_type_alias)
 // CHECK-NEXT: SwiftContext (SubjectMatchRule_variable_is_parameter)
 // CHECK-NEXT: SwiftError (SubjectMatchRule_function, SubjectMatchRule_objc_method)
 // CHECK-NEXT: SwiftErrorResult (SubjectMatchRule_variable_is_parameter)
 // CHECK-NEXT: SwiftIndirectResult (SubjectMatchRule_variable_is_parameter)
+// CHECK-NEXT: SwiftNewType (SubjectMatchRule_type_alias)
 // CHECK-NEXT: SwiftObjCMembers (SubjectMatchRule_objc_interface)
 // CHECK-NEXT: TLSModel (SubjectMatchRule_variable_is_thread_local)
 // CHECK-NEXT: Target (SubjectMatchRule_function)
 // CHECK-NEXT: TestTypestate (SubjectMatchRule_function_is_member)
 // CHECK-NEXT: TrivialABI (SubjectMatchRule_record)
 // CHECK-NEXT: Uninitialized (SubjectMatchRule_variable_is_local)
 // CHECK-NEXT: UseHandle (SubjectMatchRule_variable_is_parameter)
 // CHECK-NEXT: VecReturn (SubjectMatchRule_record)

clang/test/SemaObjC/attr-swift_newtype.m

+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+typedef int Bad1 __attribute__((swift_newtype(invalid)));
+// expected-warning@-1 {{'swift_newtype' attribute argument not supported: 'invalid'}}
+typedef int Bad2 __attribute__((swift_newtype()));
+// expected-error@-1 {{argument required after attribute}}
+typedef int Bad3 __attribute__((swift_newtype(invalid, ignored)));
+// expected-error@-1 {{expected ')'}}
+// expected-note@-2 {{to match this '('}}
+// expected-warning@-3 {{'swift_newtype' attribute argument not supported: 'invalid'}}
+
+struct __attribute__((__swift_newtype__(struct))) Bad4 {};
+// expected-error@-1 {{'__swift_newtype__' attribute only applies to typedefs}}