[clang] 46e376c - [APINotes] Serialize function-like Where.Parameters (#204147)
via cfe-commits
cfe-commits at lists.llvm.org
Tue Jun 30 01:19:35 PDT 2026
Author: StoeckOverflow
Date: 2026-06-30T09:19:30+01:00
New Revision: 46e376c6025f155ab4ec7a09a96e18c744b709f7
URL: https://github.com/llvm/llvm-project/commit/46e376c6025f155ab4ec7a09a96e18c744b709f7
DIFF: https://github.com/llvm/llvm-project/commit/46e376c6025f155ab4ec7a09a96e18c744b709f7.diff
LOG: [APINotes] Serialize function-like Where.Parameters (#204147)
This PR builds on #203227 by serializing function-like
`Where.Parameters` selectors into binary API notes.
The selector remains declaration-selection data, separate from
annotation payloads. Existing Sema paths still use name-only lookup and
keep legacy broad matching. Exact overload matching is left to the
follow-up Sema PR.
## Format
This bumps the API notes minor version because the global-function and
C++ method table key layout changes.
Function-like entries now use a shared binary key containing:
- parent context ID
- declaration name ID
- selector flags
- parameter count
- zero or more parameter type string IDs
The parameter type strings are stored through the existing identifier
table.
The selector flag records whether `Where.Parameters` was present. This
is needed because an absent selector and an explicitly empty selector
would otherwise both have parameter count `0`:
```yaml
- Name: currentWidget
```
versus:
```yaml
- Name: currentWidget
Where:
Parameters: []
```
The first entry is the legacy broad/name-only key. The second entry is
an exact zero-explicit-parameter selector.
## Implementation Details
This introduces a shared `FunctionTableKey` for global functions and C++
methods, so same-name entries can be distinguished by optional exact
parameter selectors.
Existing name-only reader/writer APIs are preserved as compatibility
wrappers. New selector-aware overloads accept optional parameter
strings:
- `std::nullopt` means broad/name-only key
- empty parameter list means exact zero-parameter selector
- non-empty parameter list means exact ordered parameter selector
The selector remains outside
`FunctionInfo`/`GlobalFunctionInfo`/`CXXMethodInfo`, because it
identifies which declaration an entry applies to rather than changing
the imported declaration effect.
Malformed empty `Where: {}` entries are rejected during conversion so
they do not silently fall back to broad name-only storage.
## Testing caveat
This PR keeps testing in the ordinary `clang/test/APINotes` FileCheck
path and does not add an APINotes binary lookup helper. As a result, the
tests cover YAML conversion and malformed selector diagnostics, but they
do not directly prove binary reader round-trip lookup for
same-name/different-parameter entries.
The binary reader/writer support is implemented here. Direct end-to-end
lookup coverage will come with the follow-up Sema matching PR.
Reviewers: @Xazax-hun @egorzhdan @j-hui
Added:
clang/test/APINotes/Inputs/WhereParametersEmptyWhereDiag/APINotes.apinotes
clang/test/APINotes/Inputs/WhereParametersEmptyWhereDiag/WhereParametersConvertDiag.h
Modified:
clang/include/clang/APINotes/APINotesReader.h
clang/include/clang/APINotes/APINotesWriter.h
clang/lib/APINotes/APINotesFormat.h
clang/lib/APINotes/APINotesReader.cpp
clang/lib/APINotes/APINotesWriter.cpp
clang/lib/APINotes/APINotesYAMLCompiler.cpp
clang/test/APINotes/Inputs/WhereParametersConvertDiag/APINotes.apinotes
clang/test/APINotes/Inputs/WhereParametersConvertDiag/WhereParametersConvertDiag.h
clang/test/APINotes/where-parameters-convert-diags.cpp
Removed:
################################################################################
diff --git a/clang/include/clang/APINotes/APINotesReader.h b/clang/include/clang/APINotes/APINotesReader.h
index 875c314b284c1..8e748b5803189 100644
--- a/clang/include/clang/APINotes/APINotesReader.h
+++ b/clang/include/clang/APINotes/APINotesReader.h
@@ -16,10 +16,12 @@
#define LLVM_CLANG_APINOTES_READER_H
#include "clang/APINotes/Types.h"
+#include "llvm/ADT/ArrayRef.h"
#include "llvm/Support/Error.h"
#include "llvm/Support/MemoryBuffer.h"
#include "llvm/Support/VersionTuple.h"
#include <memory>
+#include <optional>
namespace clang {
namespace api_notes {
@@ -159,6 +161,13 @@ class APINotesReader {
VersionedInfo<CXXMethodInfo> lookupCXXMethod(ContextID CtxID,
llvm::StringRef Name);
+ /// Look for information regarding the given C++ method with an exact
+ /// parameter selector. An empty parameter list uses an exact zero-parameter
+ /// key, and a non-empty list uses an exact ordered parameter key.
+ VersionedInfo<CXXMethodInfo>
+ lookupCXXMethod(ContextID CtxID, llvm::StringRef Name,
+ llvm::ArrayRef<llvm::StringRef> Parameters);
+
/// Look for information regarding the given global variable.
///
/// \param Name The name of the global variable.
@@ -177,6 +186,14 @@ class APINotesReader {
lookupGlobalFunction(llvm::StringRef Name,
std::optional<Context> Ctx = std::nullopt);
+ /// Look for information regarding the given global function with an exact
+ /// parameter selector. An empty parameter list uses an exact zero-parameter
+ /// key, and a non-empty list uses an exact ordered parameter key.
+ VersionedInfo<GlobalFunctionInfo>
+ lookupGlobalFunction(llvm::StringRef Name,
+ llvm::ArrayRef<llvm::StringRef> Parameters,
+ std::optional<Context> Ctx = std::nullopt);
+
/// Look for information regarding the given enumerator.
///
/// \param Name The name of the enumerator.
@@ -221,6 +238,20 @@ class APINotesReader {
std::optional<ContextID>
lookupNamespaceID(llvm::StringRef Name,
std::optional<ContextID> ParentNamespaceID = std::nullopt);
+
+private:
+ VersionedInfo<CXXMethodInfo> lookupCXXMethodImpl(ContextID CtxID,
+ llvm::StringRef Name);
+ VersionedInfo<CXXMethodInfo>
+ lookupCXXMethodImpl(ContextID CtxID, llvm::StringRef Name,
+ llvm::ArrayRef<llvm::StringRef> Parameters);
+
+ VersionedInfo<GlobalFunctionInfo>
+ lookupGlobalFunctionImpl(llvm::StringRef Name, std::optional<Context> Ctx);
+ VersionedInfo<GlobalFunctionInfo>
+ lookupGlobalFunctionImpl(llvm::StringRef Name,
+ llvm::ArrayRef<llvm::StringRef> Parameters,
+ std::optional<Context> Ctx);
};
} // end namespace api_notes
diff --git a/clang/include/clang/APINotes/APINotesWriter.h b/clang/include/clang/APINotes/APINotesWriter.h
index 3cc16c3d959fa..5ed6686e1bb85 100644
--- a/clang/include/clang/APINotes/APINotesWriter.h
+++ b/clang/include/clang/APINotes/APINotesWriter.h
@@ -16,11 +16,13 @@
#define LLVM_CLANG_APINOTES_WRITER_H
#include "clang/APINotes/Types.h"
+#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/VersionTuple.h"
#include "llvm/Support/raw_ostream.h"
#include <memory>
+#include <optional>
namespace clang {
class FileEntry;
@@ -86,6 +88,13 @@ class APINotesWriter {
void addCXXMethod(ContextID CtxID, llvm::StringRef Name,
const CXXMethodInfo &Info, llvm::VersionTuple SwiftVersion);
+ /// Add information about a C++ method with an exact parameter selector. An
+ /// empty parameter list uses an exact zero-parameter key, and a non-empty
+ /// list uses an exact ordered parameter key.
+ void addCXXMethod(ContextID CtxID, llvm::StringRef Name,
+ llvm::ArrayRef<llvm::StringRef> Parameters,
+ const CXXMethodInfo &Info, llvm::VersionTuple SwiftVersion);
+
/// Add information about a specific C record field.
///
/// \param CtxID The context in which this field resides, i.e. a C/C++ tag.
@@ -110,6 +119,14 @@ class APINotesWriter {
const GlobalFunctionInfo &Info,
llvm::VersionTuple SwiftVersion);
+ /// Add information about a global function with an exact parameter selector.
+ /// An empty parameter list uses an exact zero-parameter key, and a non-empty
+ /// list uses an exact ordered parameter key.
+ void addGlobalFunction(std::optional<Context> Ctx, llvm::StringRef Name,
+ llvm::ArrayRef<llvm::StringRef> Parameters,
+ const GlobalFunctionInfo &Info,
+ llvm::VersionTuple SwiftVersion);
+
/// Add information about an enumerator.
///
/// \param Name The name of this enumerator.
diff --git a/clang/lib/APINotes/APINotesFormat.h b/clang/lib/APINotes/APINotesFormat.h
index 5679ae39e9900..df67da0845baf 100644
--- a/clang/lib/APINotes/APINotesFormat.h
+++ b/clang/lib/APINotes/APINotesFormat.h
@@ -10,9 +10,13 @@
#define LLVM_CLANG_LIB_APINOTES_APINOTESFORMAT_H
#include "clang/APINotes/Types.h"
+#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/PointerEmbeddedInt.h"
+#include "llvm/ADT/SmallVector.h"
#include "llvm/Bitcode/BitcodeConvenience.h"
+#include <optional>
+
namespace clang {
namespace api_notes {
/// Magic number for API notes files.
@@ -24,8 +28,9 @@ const uint16_t VERSION_MAJOR = 0;
/// API notes file minor version number.
///
/// When the format changes IN ANY WAY, this number should be incremented.
-const uint16_t VERSION_MINOR = 40; // 39 for BoundsSafety;
+const uint16_t VERSION_MINOR = 41; // 39 for BoundsSafety;
// 40 for UnsafeBufferUsageAttr
+ // 41 for FunctionTableKey parameters
const uint8_t kSwiftConforms = 1;
const uint8_t kSwiftDoesNotConform = 2;
@@ -354,6 +359,91 @@ inline bool operator==(const SingleDeclTableKey &lhs,
return lhs.parentContextID == rhs.parentContextID && lhs.nameID == rhs.nameID;
}
+/// A stored C or C++ function declaration, represented by the ID of its parent
+/// context, the name of the declaration, and optional exact parameter types.
+constexpr uint8_t FunctionKeyHasParameterSelector = 0x01;
+constexpr unsigned FunctionTableKeyBaseLength =
+ sizeof(uint32_t) + sizeof(uint32_t) + sizeof(uint8_t) + sizeof(uint16_t);
+
+struct FunctionTableKey {
+ uint32_t parentContextID;
+ uint32_t nameID;
+ std::optional<llvm::SmallVector<IdentifierID, 2>> parameterTypeIDs;
+
+ FunctionTableKey() : parentContextID(-1), nameID(-1) {}
+
+ FunctionTableKey(uint32_t ParentContextID, uint32_t NameID)
+ : parentContextID(ParentContextID), nameID(NameID) {}
+
+ FunctionTableKey(uint32_t ParentContextID, uint32_t NameID,
+ const llvm::SmallVectorImpl<IdentifierID> &ParameterTypeIDs)
+ : parentContextID(ParentContextID), nameID(NameID) {
+ parameterTypeIDs.emplace(ParameterTypeIDs.begin(), ParameterTypeIDs.end());
+ }
+
+ FunctionTableKey(std::optional<Context> ParentCtx, IdentifierID NameID)
+ : parentContextID(ParentCtx ? ParentCtx->id.Value
+ : static_cast<uint32_t>(-1)),
+ nameID(NameID) {}
+
+ FunctionTableKey(std::optional<Context> ParentCtx, IdentifierID NameID,
+ const llvm::SmallVectorImpl<IdentifierID> &ParameterTypeIDs)
+ : parentContextID(ParentCtx ? ParentCtx->id.Value
+ : static_cast<uint32_t>(-1)),
+ nameID(NameID) {
+ parameterTypeIDs.emplace(ParameterTypeIDs.begin(), ParameterTypeIDs.end());
+ }
+
+ llvm::hash_code hashValue() const {
+ auto Hash = llvm::hash_combine(parentContextID, nameID,
+ static_cast<bool>(parameterTypeIDs));
+ if (parameterTypeIDs) {
+ Hash = llvm::hash_combine(Hash, parameterTypeIDs->size());
+ for (IdentifierID TypeID : *parameterTypeIDs)
+ Hash = llvm::hash_combine(Hash, static_cast<unsigned>(TypeID));
+ }
+ return Hash;
+ }
+};
+
+template <typename GetIdentifierFn>
+std::optional<FunctionTableKey>
+getFunctionKeyImpl(uint32_t ParentContextID, llvm::StringRef Name,
+ GetIdentifierFn GetIdentifier) {
+ std::optional<IdentifierID> NameID = GetIdentifier(Name);
+ if (!NameID)
+ return std::nullopt;
+
+ return FunctionTableKey(ParentContextID, *NameID);
+}
+
+template <typename GetIdentifierFn>
+std::optional<FunctionTableKey>
+getFunctionKeyImpl(uint32_t ParentContextID, llvm::StringRef Name,
+ llvm::ArrayRef<llvm::StringRef> Parameters,
+ GetIdentifierFn GetIdentifier) {
+ std::optional<IdentifierID> NameID = GetIdentifier(Name);
+ if (!NameID)
+ return std::nullopt;
+
+ llvm::SmallVector<IdentifierID, 2> ParameterTypeIDs;
+ ParameterTypeIDs.reserve(Parameters.size());
+ for (llvm::StringRef Parameter : Parameters) {
+ std::optional<IdentifierID> ParameterID = GetIdentifier(Parameter);
+ if (!ParameterID)
+ return std::nullopt;
+ ParameterTypeIDs.push_back(*ParameterID);
+ }
+ return FunctionTableKey(ParentContextID, *NameID, ParameterTypeIDs);
+}
+
+inline bool operator==(const FunctionTableKey &lhs,
+ const FunctionTableKey &rhs) {
+ return lhs.parentContextID == rhs.parentContextID &&
+ lhs.nameID == rhs.nameID &&
+ lhs.parameterTypeIDs == rhs.parameterTypeIDs;
+}
+
} // namespace api_notes
} // namespace clang
@@ -401,6 +491,18 @@ template <> struct DenseMapInfo<clang::api_notes::SingleDeclTableKey> {
}
};
+template <> struct DenseMapInfo<clang::api_notes::FunctionTableKey> {
+ static unsigned
+ getHashValue(const clang::api_notes::FunctionTableKey &value) {
+ return value.hashValue();
+ }
+
+ static bool isEqual(const clang::api_notes::FunctionTableKey &lhs,
+ const clang::api_notes::FunctionTableKey &rhs) {
+ return lhs == rhs;
+ }
+};
+
} // namespace llvm
#endif
diff --git a/clang/lib/APINotes/APINotesReader.cpp b/clang/lib/APINotes/APINotesReader.cpp
index 7713e47cba3a9..9305a5f10b4e8 100644
--- a/clang/lib/APINotes/APINotesReader.cpp
+++ b/clang/lib/APINotes/APINotesReader.cpp
@@ -46,6 +46,38 @@ llvm::VersionTuple ReadVersionTuple(const uint8_t *&Data) {
return llvm::VersionTuple(Major, Minor, Subminor, Build);
}
+static FunctionTableKey readFunctionTableKey(const uint8_t *Data,
+ unsigned Length) {
+ assert(Length >= FunctionTableKeyBaseLength &&
+ "Unexpected function table key length");
+
+ auto CtxID = endian::readNext<uint32_t, llvm::endianness::little>(Data);
+ auto NameID = endian::readNext<uint32_t, llvm::endianness::little>(Data);
+ uint8_t FunctionKeyFlags =
+ endian::readNext<uint8_t, llvm::endianness::little>(Data);
+ auto ParameterCount =
+ endian::readNext<uint16_t, llvm::endianness::little>(Data);
+
+ assert(Length ==
+ FunctionTableKeyBaseLength + ParameterCount * sizeof(uint32_t) &&
+ "Unexpected function table key length");
+
+ llvm::SmallVector<IdentifierID, 2> ParameterTypeIDs;
+ ParameterTypeIDs.reserve(ParameterCount);
+ for (unsigned I = 0; I != ParameterCount; ++I)
+ ParameterTypeIDs.push_back(
+ endian::readNext<uint32_t, llvm::endianness::little>(Data));
+
+ assert((FunctionKeyFlags & ~FunctionKeyHasParameterSelector) == 0 &&
+ "Unexpected function table key flags");
+ if (FunctionKeyFlags & FunctionKeyHasParameterSelector)
+ return {CtxID, NameID, ParameterTypeIDs};
+
+ assert(ParameterTypeIDs.empty() &&
+ "Broad function table key should not store parameters");
+ return {CtxID, NameID};
+}
+
/// An on-disk hash table whose data is versioned based on the Swift version.
template <typename Derived, typename KeyType, typename UnversionedDataType>
class VersionedTableInfo {
@@ -527,13 +559,11 @@ class GlobalVariableTableInfo
/// Used to deserialize the on-disk global function table.
class GlobalFunctionTableInfo
- : public VersionedTableInfo<GlobalFunctionTableInfo, SingleDeclTableKey,
+ : public VersionedTableInfo<GlobalFunctionTableInfo, FunctionTableKey,
GlobalFunctionInfo> {
public:
static internal_key_type ReadKey(const uint8_t *Data, unsigned Length) {
- auto CtxID = endian::readNext<uint32_t, llvm::endianness::little>(Data);
- auto NameID = endian::readNext<uint32_t, llvm::endianness::little>(Data);
- return {CtxID, NameID};
+ return readFunctionTableKey(Data, Length);
}
hash_value_type ComputeHash(internal_key_type Key) {
@@ -550,13 +580,11 @@ class GlobalFunctionTableInfo
/// Used to deserialize the on-disk C++ method table.
class CXXMethodTableInfo
- : public VersionedTableInfo<CXXMethodTableInfo, SingleDeclTableKey,
+ : public VersionedTableInfo<CXXMethodTableInfo, FunctionTableKey,
CXXMethodInfo> {
public:
static internal_key_type ReadKey(const uint8_t *Data, unsigned Length) {
- auto CtxID = endian::readNext<uint32_t, llvm::endianness::little>(Data);
- auto NameID = endian::readNext<uint32_t, llvm::endianness::little>(Data);
- return {CtxID, NameID};
+ return readFunctionTableKey(Data, Length);
}
hash_value_type ComputeHash(internal_key_type Key) {
@@ -827,6 +855,17 @@ class APINotesReader::Implementation {
llvm::SmallVectorImpl<uint64_t> &Scratch);
llvm::Error readGlobalVariableBlock(llvm::BitstreamCursor &Cursor,
llvm::SmallVectorImpl<uint64_t> &Scratch);
+ std::optional<FunctionTableKey> getFunctionKey(uint32_t ParentContextID,
+ llvm::StringRef Name);
+ std::optional<FunctionTableKey>
+ getFunctionKey(uint32_t ParentContextID, llvm::StringRef Name,
+ llvm::ArrayRef<llvm::StringRef> Parameters);
+ std::optional<FunctionTableKey>
+ getFunctionKey(std::optional<Context> ParentContext, llvm::StringRef Name);
+ std::optional<FunctionTableKey>
+ getFunctionKey(std::optional<Context> ParentContext, llvm::StringRef Name,
+ llvm::ArrayRef<llvm::StringRef> Parameters);
+
llvm::Error readGlobalFunctionBlock(llvm::BitstreamCursor &Cursor,
llvm::SmallVectorImpl<uint64_t> &Scratch);
llvm::Error readEnumConstantBlock(llvm::BitstreamCursor &Cursor,
@@ -852,6 +891,37 @@ APINotesReader::Implementation::getIdentifier(llvm::StringRef Str) {
return *Known;
}
+std::optional<FunctionTableKey>
+APINotesReader::Implementation::getFunctionKey(uint32_t ParentContextID,
+ llvm::StringRef Name) {
+ return getFunctionKeyImpl(ParentContextID, Name, [this](llvm::StringRef S) {
+ return getIdentifier(S);
+ });
+}
+
+std::optional<FunctionTableKey> APINotesReader::Implementation::getFunctionKey(
+ uint32_t ParentContextID, llvm::StringRef Name,
+ llvm::ArrayRef<llvm::StringRef> Parameters) {
+ return getFunctionKeyImpl(
+ ParentContextID, Name, Parameters,
+ [this](llvm::StringRef S) { return getIdentifier(S); });
+}
+
+std::optional<FunctionTableKey> APINotesReader::Implementation::getFunctionKey(
+ std::optional<Context> ParentContext, llvm::StringRef Name) {
+ uint32_t ParentContextID =
+ ParentContext ? ParentContext->id.Value : static_cast<uint32_t>(-1);
+ return getFunctionKey(ParentContextID, Name);
+}
+
+std::optional<FunctionTableKey> APINotesReader::Implementation::getFunctionKey(
+ std::optional<Context> ParentContext, llvm::StringRef Name,
+ llvm::ArrayRef<llvm::StringRef> Parameters) {
+ uint32_t ParentContextID =
+ ParentContext ? ParentContext->id.Value : static_cast<uint32_t>(-1);
+ return getFunctionKey(ParentContextID, Name, Parameters);
+}
+
std::optional<SelectorID>
APINotesReader::Implementation::getSelector(ObjCSelectorRef Selector) {
if (!ObjCSelectorTable || !IdentifierTable)
@@ -2268,15 +2338,45 @@ auto APINotesReader::lookupField(ContextID CtxID, llvm::StringRef Name)
auto APINotesReader::lookupCXXMethod(ContextID CtxID, llvm::StringRef Name)
-> VersionedInfo<CXXMethodInfo> {
+ return lookupCXXMethodImpl(CtxID, Name);
+}
+
+auto APINotesReader::lookupCXXMethod(ContextID CtxID, llvm::StringRef Name,
+ llvm::ArrayRef<llvm::StringRef> Parameters)
+ -> VersionedInfo<CXXMethodInfo> {
+ return lookupCXXMethodImpl(CtxID, Name, Parameters);
+}
+
+auto APINotesReader::lookupCXXMethodImpl(ContextID CtxID, llvm::StringRef Name)
+ -> VersionedInfo<CXXMethodInfo> {
if (!Implementation->CXXMethodTable)
return std::nullopt;
- std::optional<IdentifierID> NameID = Implementation->getIdentifier(Name);
- if (!NameID)
+ std::optional<FunctionTableKey> Key =
+ Implementation->getFunctionKey(CtxID.Value, Name);
+ if (!Key)
return std::nullopt;
- auto Known = Implementation->CXXMethodTable->find(
- SingleDeclTableKey(CtxID.Value, *NameID));
+ auto Known = Implementation->CXXMethodTable->find(*Key);
+ if (Known == Implementation->CXXMethodTable->end())
+ return std::nullopt;
+
+ return {Implementation->SwiftVersion, *Known};
+}
+
+auto APINotesReader::lookupCXXMethodImpl(
+ ContextID CtxID, llvm::StringRef Name,
+ llvm::ArrayRef<llvm::StringRef> Parameters)
+ -> VersionedInfo<CXXMethodInfo> {
+ if (!Implementation->CXXMethodTable)
+ return std::nullopt;
+
+ std::optional<FunctionTableKey> Key =
+ Implementation->getFunctionKey(CtxID.Value, Name, Parameters);
+ if (!Key)
+ return std::nullopt;
+
+ auto Known = Implementation->CXXMethodTable->find(*Key);
if (Known == Implementation->CXXMethodTable->end())
return std::nullopt;
@@ -2305,16 +2405,45 @@ auto APINotesReader::lookupGlobalVariable(llvm::StringRef Name,
auto APINotesReader::lookupGlobalFunction(llvm::StringRef Name,
std::optional<Context> Ctx)
-> VersionedInfo<GlobalFunctionInfo> {
+ return lookupGlobalFunctionImpl(Name, Ctx);
+}
+
+auto APINotesReader::lookupGlobalFunction(
+ llvm::StringRef Name, llvm::ArrayRef<llvm::StringRef> Parameters,
+ std::optional<Context> Ctx) -> VersionedInfo<GlobalFunctionInfo> {
+ return lookupGlobalFunctionImpl(Name, Parameters, Ctx);
+}
+
+auto APINotesReader::lookupGlobalFunctionImpl(llvm::StringRef Name,
+ std::optional<Context> Ctx)
+ -> VersionedInfo<GlobalFunctionInfo> {
if (!Implementation->GlobalFunctionTable)
return std::nullopt;
- std::optional<IdentifierID> NameID = Implementation->getIdentifier(Name);
- if (!NameID)
+ std::optional<FunctionTableKey> Key =
+ Implementation->getFunctionKey(Ctx, Name);
+ if (!Key)
return std::nullopt;
- SingleDeclTableKey Key(Ctx, *NameID);
+ auto Known = Implementation->GlobalFunctionTable->find(*Key);
+ if (Known == Implementation->GlobalFunctionTable->end())
+ return std::nullopt;
+
+ return {Implementation->SwiftVersion, *Known};
+}
+
+auto APINotesReader::lookupGlobalFunctionImpl(
+ llvm::StringRef Name, llvm::ArrayRef<llvm::StringRef> Parameters,
+ std::optional<Context> Ctx) -> VersionedInfo<GlobalFunctionInfo> {
+ if (!Implementation->GlobalFunctionTable)
+ return std::nullopt;
+
+ std::optional<FunctionTableKey> Key =
+ Implementation->getFunctionKey(Ctx, Name, Parameters);
+ if (!Key)
+ return std::nullopt;
- auto Known = Implementation->GlobalFunctionTable->find(Key);
+ auto Known = Implementation->GlobalFunctionTable->find(*Key);
if (Known == Implementation->GlobalFunctionTable->end())
return std::nullopt;
diff --git a/clang/lib/APINotes/APINotesWriter.cpp b/clang/lib/APINotes/APINotesWriter.cpp
index 61150669d8329..86fee93ec4765 100644
--- a/clang/lib/APINotes/APINotesWriter.cpp
+++ b/clang/lib/APINotes/APINotesWriter.cpp
@@ -82,8 +82,8 @@ class APINotesWriter::Implementation {
/// Information about C++ methods.
///
- /// Indexed by the context ID and name ID.
- llvm::DenseMap<SingleDeclTableKey,
+ /// Indexed by the context ID, name ID, and optional parameter selector.
+ llvm::DenseMap<FunctionTableKey,
llvm::SmallVector<std::pair<VersionTuple, CXXMethodInfo>, 1>>
CXXMethods;
@@ -100,9 +100,9 @@ class APINotesWriter::Implementation {
/// Information about global functions.
///
- /// Indexed by the context ID, identifier ID.
+ /// Indexed by the context ID, identifier ID, and optional parameter selector.
llvm::DenseMap<
- SingleDeclTableKey,
+ FunctionTableKey,
llvm::SmallVector<std::pair<VersionTuple, GlobalFunctionInfo>, 1>>
GlobalFunctions;
@@ -137,6 +137,42 @@ class APINotesWriter::Implementation {
.first->second;
}
+ FunctionTableKey getFunctionKey(uint32_t ParentContextID, StringRef Name) {
+ std::optional<FunctionTableKey> Key =
+ getFunctionKeyImpl(ParentContextID, Name,
+ [this](StringRef S) -> std::optional<IdentifierID> {
+ return getIdentifier(S);
+ });
+ assert(Key && "Writer identifier lookup should not fail");
+ return *Key;
+ }
+
+ FunctionTableKey getFunctionKey(uint32_t ParentContextID, StringRef Name,
+ ArrayRef<StringRef> Parameters) {
+ std::optional<FunctionTableKey> Key =
+ getFunctionKeyImpl(ParentContextID, Name, Parameters,
+ [this](StringRef S) -> std::optional<IdentifierID> {
+ return getIdentifier(S);
+ });
+ assert(Key && "Writer identifier lookup should not fail");
+ return *Key;
+ }
+
+ FunctionTableKey getFunctionKey(std::optional<Context> ParentContext,
+ StringRef Name) {
+ uint32_t ParentContextID =
+ ParentContext ? ParentContext->id.Value : static_cast<uint32_t>(-1);
+ return getFunctionKey(ParentContextID, Name);
+ }
+
+ FunctionTableKey getFunctionKey(std::optional<Context> ParentContext,
+ StringRef Name,
+ ArrayRef<StringRef> Parameters) {
+ uint32_t ParentContextID =
+ ParentContext ? ParentContext->id.Value : static_cast<uint32_t>(-1);
+ return getFunctionKey(ParentContextID, Name, Parameters);
+ }
+
/// Retrieve the ID for the given selector.
SelectorID getSelector(ObjCSelectorRef SelectorRef) {
// Translate the selector reference into a stored selector.
@@ -465,6 +501,25 @@ void emitVersionedInfo(
}
}
+static unsigned getFunctionTableKeyLength(const FunctionTableKey &Key) {
+ return FunctionTableKeyBaseLength +
+ (Key.parameterTypeIDs ? Key.parameterTypeIDs->size() * sizeof(uint32_t)
+ : 0);
+}
+
+static void emitFunctionTableKey(raw_ostream &OS, const FunctionTableKey &Key) {
+ llvm::support::endian::Writer writer(OS, llvm::endianness::little);
+ writer.write<uint32_t>(Key.parentContextID);
+ writer.write<uint32_t>(Key.nameID);
+ writer.write<uint8_t>(Key.parameterTypeIDs ? FunctionKeyHasParameterSelector
+ : 0);
+ writer.write<uint16_t>(Key.parameterTypeIDs ? Key.parameterTypeIDs->size()
+ : 0);
+ if (Key.parameterTypeIDs)
+ for (IdentifierID TypeID : *Key.parameterTypeIDs)
+ writer.write<uint32_t>(TypeID);
+}
+
/// On-disk hash table info key base for handling versioned data.
template <typename Derived, typename KeyType, typename UnversionedDataType>
class VersionedTableInfo {
@@ -801,17 +856,15 @@ class ObjCMethodTableInfo
/// Used to serialize the on-disk C++ method table.
class CXXMethodTableInfo
- : public VersionedTableInfo<CXXMethodTableInfo, SingleDeclTableKey,
+ : public VersionedTableInfo<CXXMethodTableInfo, FunctionTableKey,
CXXMethodInfo> {
public:
- unsigned getKeyLength(key_type_ref) {
- return sizeof(uint32_t) + sizeof(uint32_t);
+ unsigned getKeyLength(key_type_ref Key) {
+ return getFunctionTableKeyLength(Key);
}
void EmitKey(raw_ostream &OS, key_type_ref Key, unsigned) {
- llvm::support::endian::Writer writer(OS, llvm::endianness::little);
- writer.write<uint32_t>(Key.parentContextID);
- writer.write<uint32_t>(Key.nameID);
+ emitFunctionTableKey(OS, Key);
}
hash_value_type ComputeHash(key_type_ref key) {
@@ -1176,17 +1229,15 @@ void emitFunctionInfo(raw_ostream &OS, const FunctionInfo &FI) {
/// Used to serialize the on-disk global function table.
class GlobalFunctionTableInfo
- : public VersionedTableInfo<GlobalFunctionTableInfo, SingleDeclTableKey,
+ : public VersionedTableInfo<GlobalFunctionTableInfo, FunctionTableKey,
GlobalFunctionInfo> {
public:
- unsigned getKeyLength(key_type_ref) {
- return sizeof(uint32_t) + sizeof(uint32_t);
+ unsigned getKeyLength(key_type_ref Key) {
+ return getFunctionTableKeyLength(Key);
}
void EmitKey(raw_ostream &OS, key_type_ref Key, unsigned) {
- llvm::support::endian::Writer writer(OS, llvm::endianness::little);
- writer.write<uint32_t>(Key.parentContextID);
- writer.write<uint32_t>(Key.nameID);
+ emitFunctionTableKey(OS, Key);
}
hash_value_type ComputeHash(key_type_ref Key) {
@@ -1567,8 +1618,16 @@ void APINotesWriter::addObjCMethod(ContextID CtxID, ObjCSelectorRef Selector,
void APINotesWriter::addCXXMethod(ContextID CtxID, llvm::StringRef Name,
const CXXMethodInfo &Info,
VersionTuple SwiftVersion) {
- IdentifierID NameID = Implementation->getIdentifier(Name);
- SingleDeclTableKey Key(CtxID.Value, NameID);
+ FunctionTableKey Key = Implementation->getFunctionKey(CtxID.Value, Name);
+ Implementation->CXXMethods[Key].push_back({SwiftVersion, Info});
+}
+
+void APINotesWriter::addCXXMethod(ContextID CtxID, llvm::StringRef Name,
+ llvm::ArrayRef<llvm::StringRef> Parameters,
+ const CXXMethodInfo &Info,
+ VersionTuple SwiftVersion) {
+ FunctionTableKey Key =
+ Implementation->getFunctionKey(CtxID.Value, Name, Parameters);
Implementation->CXXMethods[Key].push_back({SwiftVersion, Info});
}
@@ -1593,8 +1652,15 @@ void APINotesWriter::addGlobalFunction(std::optional<Context> Ctx,
llvm::StringRef Name,
const GlobalFunctionInfo &Info,
VersionTuple SwiftVersion) {
- IdentifierID NameID = Implementation->getIdentifier(Name);
- SingleDeclTableKey Key(Ctx, NameID);
+ FunctionTableKey Key = Implementation->getFunctionKey(Ctx, Name);
+ Implementation->GlobalFunctions[Key].push_back({SwiftVersion, Info});
+}
+
+void APINotesWriter::addGlobalFunction(
+ std::optional<Context> Ctx, llvm::StringRef Name,
+ llvm::ArrayRef<llvm::StringRef> Parameters, const GlobalFunctionInfo &Info,
+ VersionTuple SwiftVersion) {
+ FunctionTableKey Key = Implementation->getFunctionKey(Ctx, Name, Parameters);
Implementation->GlobalFunctions[Key].push_back({SwiftVersion, Info});
}
diff --git a/clang/lib/APINotes/APINotesYAMLCompiler.cpp b/clang/lib/APINotes/APINotesYAMLCompiler.cpp
index e17549f33d219..1c3a59873db25 100644
--- a/clang/lib/APINotes/APINotesYAMLCompiler.cpp
+++ b/clang/lib/APINotes/APINotesYAMLCompiler.cpp
@@ -1043,6 +1043,18 @@ class YAMLConverter {
TheNamespace.Items, SwiftVersion);
}
+ std::pair<bool, std::optional<llvm::ArrayRef<llvm::StringRef>>>
+ getWhereParameters(const Function &Function) {
+ if (!Function.Where)
+ return {true, std::nullopt};
+
+ if (!Function.Where->Parameters) {
+ emitError("'Where' requires 'Parameters'");
+ return {false, std::nullopt};
+ }
+ return {true, llvm::ArrayRef<llvm::StringRef>(*Function.Where->Parameters)};
+ }
+
template <typename FuncOrMethodInfo>
void convertFunction(const Function &Function, FuncOrMethodInfo &FI) {
convertAvailability(Function.Availability, FI, Function.Name);
@@ -1151,14 +1163,17 @@ class YAMLConverter {
}
for (const auto &CXXMethod : T.Methods) {
- if (CXXMethod.Where) {
- emitError("'Where' is not supported by binary API notes yet");
+ auto WhereParameters = getWhereParameters(CXXMethod);
+ if (!WhereParameters.first)
continue;
- }
CXXMethodInfo MI;
convertFunction(CXXMethod, MI);
- Writer.addCXXMethod(TagCtxID, CXXMethod.Name, MI, SwiftVersion);
+ if (WhereParameters.second)
+ Writer.addCXXMethod(TagCtxID, CXXMethod.Name, *WhereParameters.second,
+ MI, SwiftVersion);
+ else
+ Writer.addCXXMethod(TagCtxID, CXXMethod.Name, MI, SwiftVersion);
}
// Convert nested tags.
@@ -1227,15 +1242,16 @@ class YAMLConverter {
}
// Write all global functions.
- llvm::StringSet<> KnownFunctions;
+ llvm::StringSet<> KnownNameOnlyFunctions;
for (const auto &Function : TLItems.Functions) {
- if (Function.Where) {
- emitError("'Where' is not supported by binary API notes yet");
+ auto WhereParameters = getWhereParameters(Function);
+ if (!WhereParameters.first)
continue;
- }
- // Check for duplicate global functions.
- if (!KnownFunctions.insert(Function.Name).second) {
+ // Check for duplicate name-only global functions. Selector-aware
+ // duplicate diagnostics are handled by a later overload-matching PR.
+ if (!WhereParameters.second &&
+ !KnownNameOnlyFunctions.insert(Function.Name).second) {
emitError(llvm::Twine("multiple definitions of global function '") +
Function.Name + "'");
continue;
@@ -1243,7 +1259,11 @@ class YAMLConverter {
GlobalFunctionInfo GFI;
convertFunction(Function, GFI);
- Writer.addGlobalFunction(Ctx, Function.Name, GFI, SwiftVersion);
+ if (WhereParameters.second)
+ Writer.addGlobalFunction(Ctx, Function.Name, *WhereParameters.second,
+ GFI, SwiftVersion);
+ else
+ Writer.addGlobalFunction(Ctx, Function.Name, GFI, SwiftVersion);
}
// Write all enumerators.
diff --git a/clang/test/APINotes/Inputs/WhereParametersConvertDiag/APINotes.apinotes b/clang/test/APINotes/Inputs/WhereParametersConvertDiag/APINotes.apinotes
index c1eca20d96e89..f6451eab24544 100644
--- a/clang/test/APINotes/Inputs/WhereParametersConvertDiag/APINotes.apinotes
+++ b/clang/test/APINotes/Inputs/WhereParametersConvertDiag/APINotes.apinotes
@@ -1,8 +1,15 @@
---
Name: WhereParametersConvertDiag
+Functions:
+- Name: makeWidget
+ Where:
+ Parameters:
+ - int
+ SwiftName: makeWidget(_:)
Tags:
- Name: Widget
Methods:
- Name: reset
- Where: {}
+ Where:
+ Parameters: []
SwiftName: reset()
diff --git a/clang/test/APINotes/Inputs/WhereParametersConvertDiag/WhereParametersConvertDiag.h b/clang/test/APINotes/Inputs/WhereParametersConvertDiag/WhereParametersConvertDiag.h
index 32dc081bfc036..6807ce279f99a 100644
--- a/clang/test/APINotes/Inputs/WhereParametersConvertDiag/WhereParametersConvertDiag.h
+++ b/clang/test/APINotes/Inputs/WhereParametersConvertDiag/WhereParametersConvertDiag.h
@@ -1,6 +1,8 @@
#ifndef WHERE_PARAMETERS_CONVERT_DIAG_H
#define WHERE_PARAMETERS_CONVERT_DIAG_H
+void makeWidget(int);
+
struct Widget {
void reset();
};
diff --git a/clang/test/APINotes/Inputs/WhereParametersEmptyWhereDiag/APINotes.apinotes b/clang/test/APINotes/Inputs/WhereParametersEmptyWhereDiag/APINotes.apinotes
new file mode 100644
index 0000000000000..5017c5737e13a
--- /dev/null
+++ b/clang/test/APINotes/Inputs/WhereParametersEmptyWhereDiag/APINotes.apinotes
@@ -0,0 +1,12 @@
+---
+Name: WhereParametersConvertDiag
+Functions:
+- Name: makeWidget
+ Where: {}
+ SwiftName: makeWidget(_:)
+Tags:
+- Name: Widget
+ Methods:
+ - Name: reset
+ Where: {}
+ SwiftName: reset()
diff --git a/clang/test/APINotes/Inputs/WhereParametersEmptyWhereDiag/WhereParametersConvertDiag.h b/clang/test/APINotes/Inputs/WhereParametersEmptyWhereDiag/WhereParametersConvertDiag.h
new file mode 100644
index 0000000000000..6807ce279f99a
--- /dev/null
+++ b/clang/test/APINotes/Inputs/WhereParametersEmptyWhereDiag/WhereParametersConvertDiag.h
@@ -0,0 +1,10 @@
+#ifndef WHERE_PARAMETERS_CONVERT_DIAG_H
+#define WHERE_PARAMETERS_CONVERT_DIAG_H
+
+void makeWidget(int);
+
+struct Widget {
+ void reset();
+};
+
+#endif // WHERE_PARAMETERS_CONVERT_DIAG_H
diff --git a/clang/test/APINotes/where-parameters-convert-diags.cpp b/clang/test/APINotes/where-parameters-convert-diags.cpp
index ee40efeaa865b..ed0b804a5385e 100644
--- a/clang/test/APINotes/where-parameters-convert-diags.cpp
+++ b/clang/test/APINotes/where-parameters-convert-diags.cpp
@@ -1,5 +1,6 @@
-// RUN: not %clang_cc1 -fsyntax-only -fapinotes %s -I %S/Inputs/WhereParametersConvertDiag 2>&1 | FileCheck %s
+// RUN: %clang_cc1 -fsyntax-only -fapinotes %s -I %S/Inputs/WhereParametersConvertDiag
+// RUN: not %clang_cc1 -fsyntax-only -fapinotes %s -I %S/Inputs/WhereParametersEmptyWhereDiag 2>&1 | FileCheck %s --check-prefix=EMPTY-WHERE
#include "WhereParametersConvertDiag.h"
-// CHECK: error: 'Where' is not supported by binary API notes yet
+// EMPTY-WHERE-COUNT-2: error: 'Where' requires 'Parameters'
More information about the cfe-commits
mailing list