[apinotes][cxx-interop] Add support for ImportAs, Retain, and Release.

Author: zoecarver

clang/include/clang/APINotes/Types.h

@@ -509,6 +509,8 @@ class FunctionInfo : public CommonEntityInfo {
   /// The function parameters.
   std::vector<ParamInfo> Params;
 
+  llvm::Optional<std::string> ImportAs;
+
   FunctionInfo()
       : NullabilityAudited(false), NumAdjustedNullable(0),
         RawRetainCountConvention() {}
@@ -659,7 +661,11 @@ class TagInfo : public CommonTypeInfo {
 public:
   llvm::Optional<EnumExtensibilityKind> EnumExtensibility;
 
-  TagInfo() : HasFlagEnum(0), IsFlagEnum(0) {}
+  llvm::Optional<std::string> ImportAs;
+  llvm::Optional<std::string> RetainOp;
+  llvm::Optional<std::string> ReleaseOp;
+
+  TagInfo() : CommonTypeInfo(), HasFlagEnum(0), IsFlagEnum(0) {}
 
   llvm::Optional<bool> isFlagEnum() const {
     if (HasFlagEnum)
@@ -671,6 +677,27 @@ class TagInfo : public CommonTypeInfo {
     IsFlagEnum = Value.value_or(false);
   }
 
+  void setImportAs(llvm::Optional<std::string> Value) {
+    ImportAs = Value;
+  }
+  llvm::Optional<std::string> getImportAs() const {
+    return ImportAs;
+  }
+
+  void setRetainOp(llvm::Optional<std::string> Value) {
+    RetainOp = Value;
+  }
+  llvm::Optional<std::string> getRetainOp() const {
+    return RetainOp;
+  }
+
+  void setReleaseOp(llvm::Optional<std::string> Value) {
+    ReleaseOp = Value;
+  }
+  llvm::Optional<std::string> getReleaseOp() const {
+    return ReleaseOp;
+  }
+
   TagInfo &operator|=(const TagInfo &RHS) {
     static_cast<CommonTypeInfo &>(*this) |= RHS;
 
@@ -680,6 +707,13 @@ class TagInfo : public CommonTypeInfo {
     if (!EnumExtensibility)
       EnumExtensibility = RHS.EnumExtensibility;
 
+    if (!getImportAs())
+      setImportAs(RHS.getImportAs());
+    if (!getRetainOp())
+      setImportAs(RHS.getRetainOp());
+    if (!getReleaseOp())
+      setImportAs(RHS.getReleaseOp());
+
     return *this;
   }
 
@@ -691,7 +725,10 @@ class TagInfo : public CommonTypeInfo {
 inline bool operator==(const TagInfo &LHS, const TagInfo &RHS) {
   return static_cast<const CommonTypeInfo &>(LHS) == RHS &&
          LHS.isFlagEnum() == RHS.isFlagEnum() &&
-         LHS.EnumExtensibility == RHS.EnumExtensibility;
+         LHS.EnumExtensibility == RHS.EnumExtensibility &&
+         LHS.getImportAs() == RHS.getImportAs() &&
+         LHS.getRetainOp() == RHS.getRetainOp() &&
+         LHS.getReleaseOp() == RHS.getReleaseOp();
 }
 
 inline bool operator!=(const TagInfo &LHS, const TagInfo &RHS) {

clang/lib/APINotes/APINotesReader.cpp

@@ -351,6 +351,14 @@ namespace {
       = endian::readNext<uint16_t, little, unaligned>(data);
     info.ResultType = std::string(data, data + resultTypeLen);
     data += resultTypeLen;
+
+    unsigned importAsLength =
+        endian::readNext<uint16_t, little, unaligned>(data);
+    if (importAsLength > 0) {
+      info.ImportAs =
+          std::string(reinterpret_cast<const char *>(data), importAsLength-1);
+      data += importAsLength-1;
+    }
   }
 
   /// Used to deserialize the on-disk Objective-C method table.
@@ -524,6 +532,28 @@ namespace {
             static_cast<EnumExtensibilityKind>((payload & 0x3) - 1);
       }
 
+      unsigned importAsLength =
+          endian::readNext<uint16_t, little, unaligned>(data);
+      if (importAsLength > 0) {
+        info.setImportAs(
+            std::string(reinterpret_cast<const char *>(data), importAsLength-1));
+        data += importAsLength-1;
+      }
+      unsigned retainOpLength =
+          endian::readNext<uint16_t, little, unaligned>(data);
+      if (retainOpLength > 0) {
+        info.setRetainOp(
+            std::string(reinterpret_cast<const char *>(data), retainOpLength-1));
+        data += retainOpLength-1;
+      }
+      unsigned releaseOpLength =
+          endian::readNext<uint16_t, little, unaligned>(data);
+      if (releaseOpLength > 0) {
+        info.setReleaseOp(
+            std::string(reinterpret_cast<const char *>(data), releaseOpLength-1));
+        data += releaseOpLength-1;
+      }
+
       readCommonTypeInfo(data, info);
       return info;
     }

clang/lib/APINotes/APINotesWriter.cpp

@@ -739,7 +739,8 @@ namespace {
   /// Retrieve the serialized size of the given FunctionInfo, for use in
   /// on-disk hash tables.
   static unsigned getFunctionInfoSize(const FunctionInfo &info) {
-    unsigned size = 2 + sizeof(uint64_t) + getCommonEntityInfoSize(info) + 2;
+    unsigned size = 2 + sizeof(uint64_t) + getCommonEntityInfoSize(info) + 2 +
+                    2 + (info.ImportAs ? info.ImportAs->size() : 0);
 
     for (const auto &param : info.Params)
       size += getParamInfoSize(param);
@@ -773,6 +774,13 @@ namespace {
     // Result type.
     writer.write<uint16_t>(info.ResultType.size());
     out.write(info.ResultType.data(), info.ResultType.size());
+
+    if (auto importAs = info.ImportAs) {
+      writer.write<uint16_t>(importAs->size() + 1);
+      out.write(importAs->c_str(), importAs->size());
+    } else {
+      writer.write<uint16_t>(0);
+    }
   }
 
   /// Used to serialize the on-disk Objective-C method table.
@@ -1132,7 +1140,10 @@ namespace {
   class TagTableInfo : public CommonTypeTableInfo<TagTableInfo, TagInfo> {
   public:
     unsigned getUnversionedInfoSize(const TagInfo &info) {
-      return 1 + getCommonTypeInfoSize(info);
+      return 2 + (info.getImportAs() ? info.getImportAs()->size() : 0) +
+             2 + (info.getRetainOp() ? info.getRetainOp()->size() : 0) +
+             2 + (info.getReleaseOp() ? info.getReleaseOp()->size() : 0) +
+          1 + getCommonTypeInfoSize(info);
     }
 
     void emitUnversionedInfo(raw_ostream &out, const TagInfo &info) {
@@ -1152,6 +1163,27 @@ namespace {
 
       writer.write<uint8_t>(payload);
 
+      if (auto importAs = info.getImportAs()) {
+        writer.write<uint16_t>(importAs->size() + 1);
+        out.write(importAs->c_str(), importAs->size());
+      } else {
+        writer.write<uint16_t>(0);
+      }
+
+      if (auto retainOp = info.getRetainOp()) {
+        writer.write<uint16_t>(retainOp->size() + 1);
+        out.write(retainOp->c_str(), retainOp->size());
+      } else {
+        writer.write<uint16_t>(0);
+      }
+
+      if (auto releaseOp = info.getReleaseOp()) {
+        writer.write<uint16_t>(releaseOp->size() + 1);
+        out.write(releaseOp->c_str(), releaseOp->size());
+      } else {
+        writer.write<uint16_t>(0);
+      }
+
       emitCommonTypeInfo(out, info);
     }
   };

clang/lib/APINotes/APINotesYAMLCompiler.cpp

@@ -402,6 +402,7 @@ struct Function {
   StringRef SwiftName;
   StringRef Type;
   StringRef ResultType;
+  Optional<StringRef> ImportAs;
 };
 
 typedef std::vector<Function> FunctionsSeq;
@@ -424,6 +425,7 @@ template <> struct MappingTraits<Function> {
     IO.mapOptional("SwiftPrivate", F.SwiftPrivate);
     IO.mapOptional("SwiftName", F.SwiftName, StringRef(""));
     IO.mapOptional("ResultType", F.ResultType, StringRef(""));
+    IO.mapOptional("ImportAs", F.ImportAs);
   }
 };
 } // namespace yaml
@@ -530,6 +532,9 @@ struct Tag {
   Optional<EnumExtensibilityKind> EnumExtensibility;
   Optional<bool> FlagEnum;
   Optional<EnumConvenienceAliasKind> EnumConvenienceKind;
+  Optional<StringRef> ImportAs;
+  Optional<StringRef> RetainOp;
+  Optional<StringRef> ReleaseOp;
   FunctionsSeq MemberFuncs;
 };
 
@@ -561,6 +566,9 @@ template <> struct MappingTraits<Tag> {
     IO.mapOptional("EnumExtensibility", T.EnumExtensibility);
     IO.mapOptional("FlagEnum", T.FlagEnum);
     IO.mapOptional("EnumKind", T.EnumConvenienceKind);
+    IO.mapOptional("ImportAs", T.ImportAs);
+    IO.mapOptional("Retain", T.RetainOp);
+    IO.mapOptional("Release", T.ReleaseOp);
     IO.mapOptional("Methods", T.MemberFuncs);
   }
 };
@@ -1032,6 +1040,9 @@ namespace {
                            info, function.Name);
         info.ResultType = std::string(function.ResultType);
         info.setRetainCountConvention(function.RetainCountConvention);
+        if (function.ImportAs)
+          info.ImportAs = function.ImportAs->str();
+
         Writer->addGlobalFunction(function.Name, info, swiftVersion);
       }
 
@@ -1100,6 +1111,13 @@ namespace {
           tagInfo.setFlagEnum(t.FlagEnum);          
         }
 
+        if (t.ImportAs)
+          tagInfo.setImportAs(t.ImportAs->str());
+        if (t.RetainOp)
+          tagInfo.setRetainOp(t.RetainOp->str());
+        if (t.ReleaseOp)
+          tagInfo.setReleaseOp(t.ReleaseOp->str());
+
         Writer->addTag(t.Name, tagInfo, swiftVersion);
 
         for (auto Member : t.MemberFuncs) {
@@ -1115,6 +1133,8 @@ namespace {
                              info, MemberName);
           info.ResultType = std::string(Member.ResultType);
           info.setRetainCountConvention(Member.RetainCountConvention);
+          if (Member.ImportAs)
+            info.ImportAs = Member.ImportAs->str();
 
           Writer->addMemberFunction(MemberName, info, swiftVersion);
         }

clang/lib/Sema/SemaAPINotes.cpp

@@ -583,6 +583,12 @@ static void ProcessAPINotes(Sema &S, FunctionOrMethod AnyFunc,
     }
   }
 
+  if (auto importAs = info.ImportAs) {
+    auto str = "import_" + importAs.getValue();
+    auto attr = SwiftAttrAttr::CreateImplicit(S.Context, str);
+    D->addAttr(attr);
+  }
+
   // Retain count convention
   handleAPINotedRetainCountConvention(S, D, metadata,
                                       info.getRetainCountConvention());
@@ -667,6 +673,22 @@ static void ProcessAPINotes(Sema &S, TagDecl *D,
     });
   }
 
+  if (auto importAs = info.getImportAs()) {
+    auto str = "import_" + importAs.getValue();
+    auto attr = SwiftAttrAttr::CreateImplicit(S.Context, str);
+    D->addAttr(attr);
+  }
+  if (auto retainOp = info.getRetainOp()) {
+    auto str = "retain:" + retainOp.getValue();
+    auto attr = SwiftAttrAttr::CreateImplicit(S.Context, str);
+    D->addAttr(attr);
+  }
+  if (auto releaseOp = info.getReleaseOp()) {
+    auto str = "release:" + releaseOp.getValue();
+    auto attr = SwiftAttrAttr::CreateImplicit(S.Context, str);
+    D->addAttr(attr);
+  }
+
   // Handle common type information.
   ProcessAPINotes(S, D, static_cast<const api_notes::CommonTypeInfo &>(info),
                   metadata);

clang/test/APINotes/Inputs/Frameworks/CXXInteropKit.framework/Headers/CXXInteropKit.apinotes

@@ -17,10 +17,16 @@ Tags:
   Methods:
   - Name: 'method'
     SwiftName: globalMethod()
+    ImportAs: unsafe
 - Name: ParentNS.ChildNS.ParentStruct.ChildStruct
   Methods:
     - Name: 'method'
       SwiftName: nestedMethod()
+- Name: ImportAsReference
+  ImportAs: reference
+  Retain: IARetain
+  Release: IARelease
 Functions:
 - Name: ParentNS.ChildNS.gloablFnInNS
-  SwiftName: childFnInNS()
+  SwiftName: childFnInNS()
+  ImportAs: unsafe

clang/test/APINotes/Inputs/Frameworks/CXXInteropKit.framework/Headers/CXXInteropKit.h

@@ -42,3 +42,5 @@ struct ParentStruct {
 
 }
 }
+
+struct ImportAsReference { int x; };

clang/test/APINotes/objcxx-swift-name.m

@@ -3,6 +3,7 @@
 // RUN: %clang_cc1 -fmodules -fblocks -fimplicit-module-maps -fmodules-cache-path=%t/ModulesCache/CxxInterop -fdisable-module-hash -fapinotes-modules -fsyntax-only -I %S/Inputs/Headers -F %S/Inputs/Frameworks %s -ast-dump -ast-dump-filter SomeClass -x objective-c++ | FileCheck %s
 // RUN: %clang_cc1 -fmodules -fblocks -fimplicit-module-maps -fmodules-cache-path=%t/ModulesCache/CxxInterop -fdisable-module-hash -fapinotes-modules -fsyntax-only -I %S/Inputs/Headers -F %S/Inputs/Frameworks %s -ast-dump -ast-dump-filter method -x objective-c++ | FileCheck -check-prefix=CHECK-METHOD %s
 // RUN: %clang_cc1 -fmodules -fblocks -fimplicit-module-maps -fmodules-cache-path=%t/ModulesCache/CxxInterop -fdisable-module-hash -fapinotes-modules -fsyntax-only -I %S/Inputs/Headers -F %S/Inputs/Frameworks %s -ast-dump -ast-dump-filter gloablFnInNS -x objective-c++ | FileCheck -check-prefix=CHECK-FN %s
+// RUN: %clang_cc1 -fmodules -fblocks -fimplicit-module-maps -fmodules-cache-path=%t/ModulesCache/CxxInterop -fdisable-module-hash -fapinotes-modules -fsyntax-only -I %S/Inputs/Headers -F %S/Inputs/Frameworks %s -ast-dump -ast-dump-filter ImportAsReference -x objective-c++ | FileCheck -check-prefix=CHECK-REF %s
 // RUN: %clang_cc1 -fmodules -fblocks -fimplicit-module-maps -fmodules-cache-path=%t/ModulesCache/CxxInterop -fdisable-module-hash -fapinotes-modules -fsyntax-only -I %S/Inputs/Headers -F %S/Inputs/Frameworks %s -ast-dump -ast-dump-filter "(anonymous)" -x objective-c++ | FileCheck -check-prefix=CHECK-ANONYMOUS-ENUM %s
 
 #import <CXXInteropKit/CXXInteropKit.h>
@@ -20,14 +21,21 @@
 // CHECK: SwiftNameAttr {{.+}} <<invalid sloc>> "red"
 
 // CHECK-METHOD: Dumping GlobalStruct::method:
+// CHECK-METHOD: SwiftAttrAttr {{.+}} <<invalid sloc>> Implicit "import_unsafe"
 // CHECK-METHOD: SwiftNameAttr {{.+}} <<invalid sloc>> "globalMethod()"
 
 // CHECK-METHOD: Dumping ParentNS::ChildNS::ParentStruct::ChildStruct::method:
 // CHECK-METHOD: SwiftNameAttr {{.+}} <<invalid sloc>> "nestedMethod()"
 
 // CHECK-FN: Dumping ParentNS::ChildNS::gloablFnInNS:
+// CHECK-FN: SwiftAttrAttr {{.+}} <<invalid sloc>> Implicit "import_unsafe"
 // CHECK-FN: SwiftNameAttr {{.+}} <<invalid sloc>> "childFnInNS()"
 
+// CHECK-REF: Dumping ImportAsReference:
+// CHECK-REF: SwiftAttrAttr {{.+}} <<invalid sloc>> Implicit "import_reference"
+// CHECK-REF: SwiftAttrAttr {{.+}} <<invalid sloc>> Implicit "retain:IARetain"
+// CHECK-REF: SwiftAttrAttr {{.+}} <<invalid sloc>> Implicit "release:IARelease"
+
 // CHECK-ANONYMOUS-ENUM: Dumping (anonymous):
 // CHECK-ANONYMOUS-ENUM-NEXT: EnumDecl {{.+}} imported in CXXInteropKit <undeserialized declarations> 'NSSomeEnumOptions':'unsigned long'
 // CHECK-ANONYMOUS-ENUM-NEXT: SwiftNameAttr {{.+}} <<invalid sloc>> "SomeEnum.Options"