[APINotes] Initial support for C++ namespaces

[egorzhdan]

Summary

This upstreams a part of the C++ namespaces support in Clang API Notes.

The complete patch was recently merged downstream in the Apple fork: https://github.com/apple/llvm-project/pull/7230.

This patch only adds the parts of the namespace support that can be cleanly applied on top of the API Notes infrastructure that was upstreamed previously.

clang/include/clang/APINotes/Types.h

 inline bool operator==(const TypedefInfo &LHS, const TypedefInfo &RHS) {
   return static_cast<const CommonTypeInfo &>(LHS) == RHS &&
          LHS.SwiftWrapper == RHS.SwiftWrapper;
 }
 
 inline bool operator!=(const TypedefInfo &LHS, const TypedefInfo &RHS) {
   return !(LHS == RHS);
 }
+
+/// Opaque context ID used to refer to an Objective-C class or protocol or a C++
+/// namespace.
+class ContextID {
+public:
+  unsigned Value;
+
+  explicit ContextID(unsigned value) : Value(value) {}
+};
+
+enum class ContextKind : uint8_t {
+  ObjCClass = 0,
+  ObjCProtocol = 1,
+  Namespace = 2,
+};
+
+struct Context {
+  ContextID id;
+  ContextKind kind;
+
+  Context(ContextID id, ContextKind kind) : id(id), kind(kind) {}
+};
 } // namespace api_notes
 } // namespace clang
 
 #endif

clang/lib/APINotes/APINotesFormat.h

 //===-- APINotesWriter.h - API Notes Writer ---------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_LIB_APINOTES_APINOTESFORMAT_H
 #define LLVM_CLANG_LIB_APINOTES_APINOTESFORMAT_H
 
+#include "clang/APINotes/Types.h"
 #include "llvm/ADT/PointerEmbeddedInt.h"
 #include "llvm/Bitcode/BitcodeConvenience.h"
 
 namespace clang {
 namespace api_notes {
 /// Magic number for API notes files.
 const unsigned char API_NOTES_SIGNATURE[] = {0xE2, 0x9C, 0xA8, 0x01};
 
llvm::BCRecordLayout<ENUM_CONSTANT_DATA, // record ID
                          >;
 } // namespace enum_constant_block
 
 /// A stored Objective-C selector.
 struct StoredObjCSelector {
   unsigned NumPieces;
   llvm::SmallVector<IdentifierID, 2> Identifiers;
 };
+
+/// A stored Objective-C or C++ context, represented by the ID of its parent
+/// context, the kind of this context (Objective-C class / C++ namespace / etc),
+/// and the ID of this context.
+struct ContextTableKey {
+  uint32_t parentContextID;
+  uint8_t contextKind;
+  uint32_t contextID;
+
+  ContextTableKey() : parentContextID(-1), contextKind(-1), contextID(-1) {}
+
+  ContextTableKey(uint32_t parentContextID, uint8_t contextKind,
+                  uint32_t contextID)
+      : parentContextID(parentContextID), contextKind(contextKind),
+        contextID(contextID) {}
+
+  ContextTableKey(std::optional<Context> context, IdentifierID nameID)
+      : parentContextID(context ? context->id.Value : (uint32_t)-1),
+        contextKind(context ? (uint8_t)context->kind : (uint8_t)-1),
+        contextID(nameID) {}
+
+  llvm::hash_code hashValue() const {
+    return llvm::hash_value(
+        std::tuple{parentContextID, contextKind, contextID});
+  }
+};
+
+inline bool operator==(const ContextTableKey &lhs, const ContextTableKey &rhs) {
+  return lhs.parentContextID == rhs.parentContextID &&
+         lhs.contextKind == rhs.contextKind && lhs.contextID == rhs.contextID;
+}
+
 } // namespace api_notes
 } // namespace clang
 
 namespace llvm {
 template <> struct DenseMapInfo<clang::api_notes::StoredObjCSelector> {
   typedef DenseMapInfo<unsigned> UnsignedInfo;
 
   static inline clang::api_notes::StoredObjCSelector getEmptyKey() {
getHashValue(const clang::api_notes::StoredObjCSelector &Selector) {
     return hash;
   }
 
   static bool isEqual(const clang::api_notes::StoredObjCSelector &LHS,
                       const clang::api_notes::StoredObjCSelector &RHS) {
     return LHS.NumPieces == RHS.NumPieces && LHS.Identifiers == RHS.Identifiers;
   }
 };
+
+template <> struct DenseMapInfo<clang::api_notes::ContextTableKey> {
+  static inline clang::api_notes::ContextTableKey getEmptyKey() {
+    return clang::api_notes::ContextTableKey();
+  }
+
+  static inline clang::api_notes::ContextTableKey getTombstoneKey() {
+    return clang::api_notes::ContextTableKey{
+        DenseMapInfo<uint32_t>::getTombstoneKey(),
+        DenseMapInfo<uint8_t>::getTombstoneKey(),
+        DenseMapInfo<uint32_t>::getTombstoneKey()};
+  }
+
+  static unsigned getHashValue(const clang::api_notes::ContextTableKey &value) {
+    return value.hashValue();
+  }
+
+  static bool isEqual(const clang::api_notes::ContextTableKey &lhs,
+                      const clang::api_notes::ContextTableKey &rhs) {
+    return lhs == rhs;
+  }
+};
 } // namespace llvm
 
 #endif

clang/lib/APINotes/APINotesWriter.cpp

class APINotesWriter::Implementation {
   const FileEntry *SourceFile;
 
   /// Scratch space for bitstream writing.
   llvm::SmallVector<uint64_t, 64> Scratch;
 
   /// Mapping from strings to identifier IDs.
   llvm::StringMap<IdentifierID> IdentifierIDs;
 
-  /// Information about Objective-C contexts (classes or protocols).
+  /// Information about contexts (Objective-C classes or protocols or C++
+  /// namespaces).
   ///
-  /// Indexed by the identifier ID and a bit indication whether we're looking
-  /// for a class (0) or protocol (1) and provides both the context ID and
-  /// information describing the context within that module.
-  llvm::DenseMap<std::pair<unsigned, char>,
+  /// Indexed by the parent context ID, context kind and the identifier ID of
+  /// this context and provides both the context ID and information describing
+  /// the context within that module.
+  llvm::DenseMap<ContextTableKey,
                  std::pair<unsigned, VersionedSmallVector<ObjCContextInfo>>>
       ObjCContexts;
 
+  /// Information about parent contexts for each context.
+  ///
+  /// Indexed by context ID, provides the parent context ID.
+  llvm::DenseMap<uint32_t, uint32_t> ParentContexts;
+
   /// Information about Objective-C properties.
   ///
   /// Indexed by the context ID, property name, and whether this is an
   /// instance property.
   llvm::DenseMap<
       std::tuple<unsigned, unsigned, char>,
       llvm::SmallVector<std::pair<VersionTuple, ObjCPropertyInfo>, 1>>
       ObjCProperties;
 
   /// Information about Objective-C methods.
   ///
   /// Indexed by the context ID, selector ID, and Boolean (stored as a char)
   /// indicating whether this is a class or instance method.
   llvm::DenseMap<std::tuple<unsigned, unsigned, char>,
                  llvm::SmallVector<std::pair<VersionTuple, ObjCMethodInfo>, 1>>
       ObjCMethods;
 
   /// Mapping from selectors to selector ID.
   llvm::DenseMap<StoredObjCSelector, SelectorID> SelectorIDs;
 
   /// Information about global variables.
   ///
-  /// Indexed by the identifier ID.
-  llvm::DenseMap<unsigned, llvm::SmallVector<
-                               std::pair<VersionTuple, GlobalVariableInfo>, 1>>
+  /// Indexed by the context ID, contextKind, identifier ID.
+  llvm::DenseMap<
+      ContextTableKey,
+      llvm::SmallVector<std::pair<VersionTuple, GlobalVariableInfo>, 1>>
       GlobalVariables;
 
   /// Information about global functions.
   ///
-  /// Indexed by the identifier ID.
-  llvm::DenseMap<unsigned, llvm::SmallVector<
-                               std::pair<VersionTuple, GlobalFunctionInfo>, 1>>
+  /// Indexed by the context ID, contextKind, identifier ID.
+  llvm::DenseMap<
+      ContextTableKey,
+      llvm::SmallVector<std::pair<VersionTuple, GlobalFunctionInfo>, 1>>
       GlobalFunctions;
 
   /// Information about enumerators.
   ///
   /// Indexed by the identifier ID.
   llvm::DenseMap<
       unsigned, llvm::SmallVector<std::pair<VersionTuple, EnumConstantInfo>, 1>>
       EnumConstants;
 
   /// Information about tags.
   ///
-  /// Indexed by the identifier ID.
-  llvm::DenseMap<unsigned,
+  /// Indexed by the context ID, contextKind, identifier ID.
+  llvm::DenseMap<ContextTableKey,
                  llvm::SmallVector<std::pair<VersionTuple, TagInfo>, 1>>
       Tags;
 
   /// Information about typedefs.
   ///
-  /// Indexed by the identifier ID.
-  llvm::DenseMap<unsigned,
+  /// Indexed by the context ID, contextKind, identifier ID.
+  llvm::DenseMap<ContextTableKey,
                  llvm::SmallVector<std::pair<VersionTuple, TypedefInfo>, 1>>
       Typedefs;
 
   void writeBlockInfoBlock(llvm::BitstreamWriter &Stream);
   void writeControlBlock(llvm::BitstreamWriter &Stream);
   void writeIdentifierBlock(llvm::BitstreamWriter &Stream);
   void writeObjCContextBlock(llvm::BitstreamWriter &Stream);
   void writeObjCPropertyBlock(llvm::BitstreamWriter &Stream);
void APINotesWriter::Implementation::writeIdentifierBlock(
   identifier_block::IdentifierDataLayout IdentifierData(Stream);
   IdentifierData.emit(Scratch, Offset, HashTableBlob);
 }
 
 namespace {
 /// Used to serialize the on-disk Objective-C context table.
 class ObjCContextIDTableInfo {
 public:
-  using key_type = std::pair<unsigned, char>; // identifier ID, is-protocol
+  using key_type = ContextTableKey;
   using key_type_ref = key_type;
   using data_type = unsigned;
   using data_type_ref = const data_type &;
   using hash_value_type = size_t;
   using offset_type = unsigned;
 
   hash_value_type ComputeHash(key_type_ref Key) {
-    return static_cast<size_t>(llvm::hash_value(Key));
+    return static_cast<size_t>(Key.hashValue());
   }
 
   std::pair<unsigned, unsigned> EmitKeyDataLength(raw_ostream &OS, key_type_ref,
                                                   data_type_ref) {
-    uint32_t KeyLength = sizeof(uint32_t) + 1;
+    uint32_t KeyLength = sizeof(uint32_t) + sizeof(uint8_t) + sizeof(uint32_t);
     uint32_t DataLength = sizeof(uint32_t);
 
     llvm::support::endian::Writer writer(OS, llvm::support::little);
     writer.write<uint16_t>(KeyLength);
     writer.write<uint16_t>(DataLength);
     return {KeyLength, DataLength};
   }
 
   void EmitKey(raw_ostream &OS, key_type_ref Key, unsigned) {
     llvm::support::endian::Writer writer(OS, llvm::support::little);
-    writer.write<uint32_t>(Key.first);
-    writer.write<uint8_t>(Key.second);
+    writer.write<uint32_t>(Key.parentContextID);
+    writer.write<uint8_t>(Key.contextKind);
+    writer.write<uint32_t>(Key.contextID);
   }
 
   void EmitData(raw_ostream &OS, key_type_ref, data_type_ref Data, unsigned) {
     llvm::support::endian::Writer writer(OS, llvm::support::little);
     writer.write<uint32_t>(Data);
   }
 };
 

 public:
   unsigned getKeyLength(key_type_ref) { return sizeof(uint32_t); }
 
   void EmitKey(raw_ostream &OS, key_type_ref Key, unsigned) {
     llvm::support::endian::Writer writer(OS, llvm::support::little);
     writer.write<uint32_t>(Key);
   }
 
+  hash_value_type ComputeHash(key_type_ref Key) {
+    return static_cast<size_t>(llvm::hash_value(Key));
+  }
+
   unsigned getUnversionedInfoSize(const ObjCContextInfo &OCI) {
     return getCommonTypeInfoSize(OCI) + 1;
   }
 
   void emitUnversionedInfo(raw_ostream &OS, const ObjCContextInfo &OCI) {
     emitCommonTypeInfo(OS, OCI);
 
     uint8_t payload = 0;
public:
 
   void EmitKey(raw_ostream &OS, key_type_ref Key, unsigned) {
     llvm::support::endian::Writer writer(OS, llvm::support::little);
     writer.write<uint32_t>(std::get<0>(Key));
     writer.write<uint32_t>(std::get<1>(Key));
     writer.write<uint8_t>(std::get<2>(Key));
   }
 
+  hash_value_type ComputeHash(key_type_ref Key) {
+    return static_cast<size_t>(llvm::hash_value(Key));
+  }
+
   unsigned getUnversionedInfoSize(const ObjCPropertyInfo &OPI) {
     return getVariableInfoSize(OPI) + 1;
   }
 
   void emitUnversionedInfo(raw_ostream &OS, const ObjCPropertyInfo &OPI) {
     emitVariableInfo(OS, OPI);
 
     uint8_t flags = 0;
public:
 
   void EmitKey(raw_ostream &OS, key_type_ref Key, unsigned) {
     llvm::support::endian::Writer writer(OS, llvm::support::little);
     writer.write<uint32_t>(std::get<0>(Key));
     writer.write<uint32_t>(std::get<1>(Key));
     writer.write<uint8_t>(std::get<2>(Key));
   }
 
+  hash_value_type ComputeHash(key_type_ref key) {
+    return static_cast<size_t>(llvm::hash_value(key));
+  }
+
   unsigned getUnversionedInfoSize(const ObjCMethodInfo &OMI) {
     return getFunctionInfoSize(OMI) + 1;
   }
 
   void emitUnversionedInfo(raw_ostream &OS, const ObjCMethodInfo &OMI) {
     uint8_t flags = 0;
     llvm::support::endian::Writer writer(OS, llvm::support::little);
     flags = (flags << 1) | OMI.DesignatedInit;
if (SelectorIDs.empty())
     objc_selector_block::ObjCSelectorDataLayout ObjCSelectorData(Stream);
     ObjCSelectorData.emit(Scratch, Offset, HashTableBlob);
   }
 }
 
 namespace {
 /// Used to serialize the on-disk global variable table.
 class GlobalVariableTableInfo
-    : public VersionedTableInfo<GlobalVariableTableInfo, unsigned,
+    : public VersionedTableInfo<GlobalVariableTableInfo, ContextTableKey,
                                 GlobalVariableInfo> {
 public:
-  unsigned getKeyLength(key_type_ref) { return sizeof(uint32_t); }
+  unsigned getKeyLength(key_type_ref) {
+    return sizeof(uint32_t) + sizeof(uint8_t) + sizeof(uint32_t);
+  }
 
   void EmitKey(raw_ostream &OS, key_type_ref Key, unsigned) {
     llvm::support::endian::Writer writer(OS, llvm::support::little);
-    writer.write<uint32_t>(Key);
+    writer.write<uint32_t>(Key.parentContextID);
+    writer.write<uint8_t>(Key.contextKind);
+    writer.write<uint32_t>(Key.contextID);
+  }
+
+  hash_value_type ComputeHash(key_type_ref Key) {
+    return static_cast<size_t>(Key.hashValue());
   }
 
   unsigned getUnversionedInfoSize(const GlobalVariableInfo &GVI) {
     return getVariableInfoSize(GVI);
   }
 
   void emitUnversionedInfo(raw_ostream &OS, const GlobalVariableInfo &GVI) {
     emitVariableInfo(OS, GVI);
for (const auto &PI : FI.Params)
     emitParamInfo(OS, PI);
 
   writer.write<uint16_t>(FI.ResultType.size());
   writer.write(ArrayRef<char>{FI.ResultType.data(), FI.ResultType.size()});
 }
 
 /// Used to serialize the on-disk global function table.
 class GlobalFunctionTableInfo
-    : public VersionedTableInfo<GlobalFunctionTableInfo, unsigned,
+    : public VersionedTableInfo<GlobalFunctionTableInfo, ContextTableKey,
                                 GlobalFunctionInfo> {
 public:
-  unsigned getKeyLength(key_type_ref) { return sizeof(uint32_t); }
+  unsigned getKeyLength(key_type_ref) {
+    return sizeof(uint32_t) + sizeof(uint8_t) + sizeof(uint32_t);
+  }
 
   void EmitKey(raw_ostream &OS, key_type_ref Key, unsigned) {
     llvm::support::endian::Writer writer(OS, llvm::support::little);
-    writer.write<uint32_t>(Key);
+    writer.write<uint32_t>(Key.parentContextID);
+    writer.write<uint8_t>(Key.contextKind);
+    writer.write<uint32_t>(Key.contextID);
+  }
+
+  hash_value_type ComputeHash(key_type_ref Key) {
+    return static_cast<size_t>(Key.hashValue());
   }
 
   unsigned getUnversionedInfoSize(const GlobalFunctionInfo &GFI) {
     return getFunctionInfoSize(GFI);
   }
 
   void emitUnversionedInfo(raw_ostream &OS, const GlobalFunctionInfo &GFI) {
     emitFunctionInfo(OS, GFI);

 public:
   unsigned getKeyLength(key_type_ref) { return sizeof(uint32_t); }
 
   void EmitKey(raw_ostream &OS, key_type_ref Key, unsigned) {
     llvm::support::endian::Writer writer(OS, llvm::support::little);
     writer.write<uint32_t>(Key);
   }
 
+  hash_value_type ComputeHash(key_type_ref Key) {
+    return static_cast<size_t>(llvm::hash_value(Key));
+  }
+
   unsigned getUnversionedInfoSize(const EnumConstantInfo &ECI) {
     return getCommonEntityInfoSize(ECI);
   }
 
   void emitUnversionedInfo(raw_ostream &OS, const EnumConstantInfo &ECI) {
     emitCommonEntityInfo(OS, ECI);
   }
 };
if (EnumConstants.empty())
     enum_constant_block::EnumConstantDataLayout EnumConstantData(Stream);
     EnumConstantData.emit(Scratch, Offset, HashTableBlob);
   }
 }
 
 namespace {
 template <typename Derived, typename UnversionedDataType>
 class CommonTypeTableInfo
-    : public VersionedTableInfo<Derived, unsigned, UnversionedDataType> {
+    : public VersionedTableInfo<Derived, ContextTableKey, UnversionedDataType> {
 public:
   using key_type_ref = typename CommonTypeTableInfo::key_type_ref;
+  using hash_value_type = typename CommonTypeTableInfo::hash_value_type;
 
-  unsigned getKeyLength(key_type_ref) { return sizeof(IdentifierID); }
+  unsigned getKeyLength(key_type_ref) {
+    return sizeof(uint32_t) + sizeof(uint8_t) + sizeof(IdentifierID);
+  }
 
   void EmitKey(raw_ostream &OS, key_type_ref Key, unsigned) {
     llvm::support::endian::Writer writer(OS, llvm::support::little);
-    writer.write<IdentifierID>(Key);
+    writer.write<uint32_t>(Key.parentContextID);
+    writer.write<uint8_t>(Key.contextKind);
+    writer.write<IdentifierID>(Key.contextID);
+  }
+
+  hash_value_type ComputeHash(key_type_ref Key) {
+    return static_cast<size_t>(Key.hashValue());
   }
 
   unsigned getUnversionedInfoSize(const UnversionedDataType &UDT) {
     return getCommonTypeInfoSize(UDT);
   }
 
   void emitUnversionedInfo(raw_ostream &OS, const UnversionedDataType &UDT) {
     emitCommonTypeInfo(OS, UDT);

clang/lib/APINotes/APINotesYAMLCompiler.cpp

static void mapping(IO &IO, Typedef &T) {
     IO.mapOptional("NSErrorDomain", T.NSErrorDomain);
     IO.mapOptional("SwiftWrapper", T.SwiftType);
   }
 };
 } // namespace yaml
 } // namespace llvm
 
 namespace {
+struct Namespace;
+typedef std::vector<Namespace> NamespacesSeq;
+
 struct TopLevelItems {
   ClassesSeq Classes;
   ClassesSeq Protocols;
   FunctionsSeq Functions;
   GlobalVariablesSeq Globals;
   EnumConstantsSeq EnumConstants;
   TagsSeq Tags;
   TypedefsSeq Typedefs;
+  NamespacesSeq Namespaces;
 };
 } // namespace
 
 namespace llvm {
 namespace yaml {
 static void mapTopLevelItems(IO &IO, TopLevelItems &TLI) {
   IO.mapOptional("Classes", TLI.Classes);
   IO.mapOptional("Protocols", TLI.Protocols);
   IO.mapOptional("Functions", TLI.Functions);
   IO.mapOptional("Globals", TLI.Globals);
   IO.mapOptional("Enumerators", TLI.EnumConstants);
   IO.mapOptional("Tags", TLI.Tags);
   IO.mapOptional("Typedefs", TLI.Typedefs);
+  IO.mapOptional("Namespaces", TLI.Namespaces);
+}
+} // namespace yaml
+} // namespace llvm
+
+namespace {
+struct Namespace {
+  StringRef Name;
+  AvailabilityItem Availability;
+  StringRef SwiftName;
+  std::optional<bool> SwiftPrivate;
+  TopLevelItems Items;
+};
+} // namespace
+
+LLVM_YAML_IS_SEQUENCE_VECTOR(Namespace)
+
+namespace llvm {
+namespace yaml {
+template <> struct MappingTraits<Namespace> {
+  static void mapping(IO &IO, Namespace &T) {
+    IO.mapRequired("Name", T.Name);
+    IO.mapOptional("Availability", T.Availability.Mode,
+                   APIAvailability::Available);
+    IO.mapOptional("AvailabilityMsg", T.Availability.Msg, StringRef(""));
+    IO.mapOptional("SwiftPrivate", T.SwiftPrivate);
+    IO.mapOptional("SwiftName", T.SwiftName, StringRef(""));
+    mapTopLevelItems(IO, T.Items);
   }
+};
 } // namespace yaml
 } // namespace llvm
 
 namespace {
 struct Versioned {
   VersionTuple Version;
   TopLevelItems Items;
 };