20 #include "llvm/ADT/Optional.h" 21 #include "llvm/ADT/SmallVector.h" 22 #include "llvm/ADT/StringRef.h" 23 #include "llvm/Support/Allocator.h" 24 #include "llvm/Support/Errc.h" 25 #include "llvm/Support/MemoryBuffer.h" 26 #include "llvm/Support/StringSaver.h" 27 #include "llvm/Support/YAMLTraits.h" 28 #include "llvm/Support/raw_ostream.h" 36 std::pair<clang::clangd::SymbolID, std::vector<clang::clangd::Ref>>;
39 llvm::Optional<clang::clangd::Symbol> Symbol;
40 llvm::Optional<RefBundle> Refs;
61 using clang::index::SymbolLanguage;
67 llvm::raw_string_ostream OS(HexString);
72 auto ID = SymbolID::fromStr(HexString);
86 Flag =
static_cast<uint8_t
>(F);
99 Origin =
static_cast<uint8_t
>(O);
107 template <>
struct MappingTraits<YPosition> {
108 static void mapping(IO &IO, YPosition &Value) {
109 IO.mapRequired(
"Line", Value.Line);
110 IO.mapRequired(
"Column", Value.Column);
136 assert(IO.getContext() &&
137 "Expecting an UniqueStringSaver to allocate data");
138 return static_cast<llvm::UniqueStringSaver *
>(IO.getContext())
148 MappingNormalization<NormalizedFileURI, const char *> NFile(IO,
150 IO.mapRequired(
"FileURI", NFile->URI);
151 MappingNormalization<NormalizedPosition, SymbolLocation::Position> NStart(
153 IO.mapRequired(
"Start", NStart->P);
154 MappingNormalization<NormalizedPosition, SymbolLocation::Position> NEnd(
156 IO.mapRequired(
"End", NEnd->P);
163 io.mapRequired(
"Kind", SymInfo.Kind);
164 io.mapRequired(
"Lang", SymInfo.Lang);
169 struct MappingTraits<
clang::clangd::Symbol::IncludeHeaderWithReferences> {
177 template <>
struct MappingTraits<
Symbol> {
179 MappingNormalization<NormalizedSymbolID, SymbolID> NSymbolID(IO, Sym.
ID);
180 MappingNormalization<NormalizedSymbolFlag, Symbol::SymbolFlag> NSymbolFlag(
182 MappingNormalization<NormalizedSymbolOrigin, SymbolOrigin> NSymbolOrigin(
184 IO.mapRequired(
"ID", NSymbolID->HexString);
185 IO.mapRequired(
"Name", Sym.
Name);
186 IO.mapRequired(
"Scope", Sym.
Scope);
187 IO.mapRequired(
"SymInfo", Sym.
SymInfo);
191 IO.mapOptional(
"References", Sym.
References, 0u);
192 IO.mapOptional(
"Origin", NSymbolOrigin->Origin);
193 IO.mapOptional(
"Flags", NSymbolFlag->Flag);
194 IO.mapOptional(
"Signature", Sym.
Signature);
198 IO.mapOptional(
"Type", Sym.
Type);
203 template <>
struct ScalarEnumerationTraits<SymbolLanguage> {
205 IO.enumCase(Value,
"C", SymbolLanguage::C);
206 IO.enumCase(Value,
"Cpp", SymbolLanguage::CXX);
207 IO.enumCase(Value,
"ObjC", SymbolLanguage::ObjC);
208 IO.enumCase(Value,
"Swift", SymbolLanguage::Swift);
214 #define DEFINE_ENUM(name) IO.enumCase(Value, #name, SymbolKind::name) 249 template <>
struct MappingTraits<RefBundle> {
250 static void mapping(IO &IO, RefBundle &Refs) {
251 MappingNormalization<NormalizedSymbolID, SymbolID> NSymbolID(IO,
253 IO.mapRequired(
"ID", NSymbolID->HexString);
254 IO.mapRequired(
"References", Refs.second);
267 template <>
struct MappingTraits<
Ref> {
269 MappingNormalization<NormalizedRefKind, RefKind> NKind(IO, R.
Kind);
270 IO.mapRequired(
"Kind", NKind->Kind);
271 IO.mapRequired(
"Location", R.
Location);
275 template <>
struct MappingTraits<VariantEntry> {
276 static void mapping(IO &IO, VariantEntry &Variant) {
277 if (IO.mapTag(
"!Symbol", Variant.Symbol.hasValue())) {
278 if (!IO.outputting())
279 Variant.Symbol.emplace();
280 MappingTraits<Symbol>::mapping(IO, *Variant.Symbol);
281 }
else if (IO.mapTag(
"!Refs", Variant.Refs.hasValue())) {
282 if (!IO.outputting())
283 Variant.Refs.emplace();
284 MappingTraits<RefBundle>::mapping(IO, *Variant.Refs);
296 llvm::yaml::Output Yout(OS);
297 for (
const auto &Sym : *O.
Symbols) {
303 for (
auto &Sym : *O.
Refs) {
310 llvm::Expected<IndexFileIn>
readYAML(llvm::StringRef Data) {
313 llvm::BumpPtrAllocator
315 llvm::UniqueStringSaver
Strings(Arena);
316 llvm::yaml::Input Yin(Data, &Strings);
317 while (Yin.setCurrentDocument()) {
318 llvm::yaml::EmptyContext
Ctx;
319 VariantEntry Variant;
320 yamlize(Yin, Variant,
true, Ctx);
322 return llvm::errorCodeToError(Yin.error());
325 Symbols.
insert(*Variant.Symbol);
327 for (
const auto &
Ref : Variant.Refs->second)
333 Result.
Symbols.emplace(std::move(Symbols).build());
334 Result.
Refs.emplace(std::move(Refs).build());
335 return std::move(Result);
341 llvm::raw_string_ostream OS(Buf);
342 llvm::yaml::Output Yout(OS);
350 RefBundle Refs = {Data.first, Data.second};
353 llvm::raw_string_ostream OS(Buf);
354 llvm::yaml::Output Yout(OS);
llvm::Expected< IndexFileIn > readYAML(llvm::StringRef)
llvm::Optional< SymbolSlab > Symbols
Symbol::SymbolFlag denormalize(IO &)
Some operations such as code completion produce a set of candidates.
void setColumn(uint32_t Column)
static void mapping(IO &io, SymbolInfo &SymInfo)
This defines Dex - a symbol index implementation based on query iterators over symbol tokens...
void writeYAML(const IndexFileOut &, llvm::raw_ostream &)
clang::find_all_symbols::SymbolInfo::SymbolKind SymbolKind
void setLine(uint32_t Line)
NormalizedSymbolOrigin(IO &)
const char * denormalize(IO &IO)
void insert(const Symbol &S)
static llvm::StringRef toString(SpecialMemberFunctionsCheck::SpecialMemberFunctionKind K)
static void enumeration(IO &IO, SymbolKind &Value)
static void mapping(IO &IO, Ref &R)
const SymbolSlab * Symbols
static void mapping(IO &IO, Symbol &Sym)
index::SymbolInfo SymInfo
llvm::BumpPtrAllocator Arena
SymbolLocation Definition
clang::find_all_symbols::SymbolInfo SymbolInfo
NormalizedSymbolFlag(IO &, Symbol::SymbolFlag F)
llvm::SmallVector< IncludeHeaderWithReferences, 1 > IncludeHeaders
One Symbol can potentially be incuded via different headers.
llvm::StringRef Signature
A brief description of the symbol that can be appended in the completion candidate list...
static void enumeration(IO &IO, SymbolLanguage &Value)
llvm::StringRef Documentation
Documentation including comment for the symbol declaration.
SymbolLocation CanonicalDeclaration
llvm::Optional< llvm::Expected< tooling::AtomicChanges > > Result
std::string toYAML(const std::pair< SymbolID, llvm::ArrayRef< Ref >> &Data)
NormalizedSymbolFlag(IO &)
static void mapping(IO &IO, SymbolLocation &Value)
std::vector< llvm::StringRef > Strings
NormalizedPosition(IO &, const Position &Pos)
llvm::Optional< RefSlab > Refs
Position denormalize(IO &)
Position Start
The symbol range, using half-open range [Start, End).
===– Representation.cpp - ClangDoc Representation --------—*- C++ -*-===//
static void mapping(IO &IO, RefBundle &Refs)
RefKind denormalize(IO &)
NormalizedSymbolID(IO &, const SymbolID &ID)
NormalizedSymbolOrigin(IO &, SymbolOrigin O)
static void mapping(IO &IO, VariantEntry &Variant)
void insert(const SymbolID &ID, const Ref &S)
llvm::StringRef CompletionSnippetSuffix
What to insert when completing this symbol, after the symbol name.
#define DEFINE_ENUM(name)
static void mapping(IO &IO, YPosition &Value)
llvm::StringRef Type
Raw representation of the OpaqueType of the symbol, used for scoring purposes.
SymbolOrigin Origin
Where this symbol came from. Usually an index provides a constant value.
NormalizedFileURI(IO &, const char *FileURI)
llvm::StringRef ReturnType
Type when this symbol is used in an expression.
std::array< uint8_t, 20 > SymbolID
SymbolID denormalize(IO &I)
SymbolOrigin denormalize(IO &)
NormalizedRefKind(IO &, RefKind O)