Debian Codegraph @

llvm-project/clang-tools-extra/clangd/unittests/TestIndex.cpp

raw
1 //===-- TestIndex.cpp -------------------------------------------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8
9 #include "TestIndex.h"
10 #include "clang/Index/IndexSymbol.h"
11 #include "llvm/Support/Regex.h"
12
13 namespace clang {
14 namespace clangd {
15
16 Symbol symbol(llvm::StringRef QName) {
17 Symbol Sym;
18 Sym.ID = SymbolID(QName.str());
19 size_t Pos = QName.rfind("::");
20 if (Pos == llvm::StringRef::npos) {
21 Sym.Name = QName;
22 Sym.Scope = "";
23 } else {
24 Sym.Name = QName.substr(Pos + 2);
25 Sym.Scope = QName.substr(0, Pos + 2);
26 }
27 return Sym;
28 }
29
30 static std::string replace(llvm::StringRef Haystack, llvm::StringRef Needle,
31 llvm::StringRef Repl) {
32 llvm::SmallVector<llvm::StringRef> Parts;
33 Haystack.split(Parts, Needle);
34 return llvm::join(Parts, Repl);
35 }
36
37 // Helpers to produce fake index symbols for memIndex() or completions().
38 // USRFormat is a regex replacement string for the unqualified part of the USR.
39 Symbol sym(llvm::StringRef QName, index::SymbolKind Kind,
40 llvm::StringRef USRFormat) {
41 Symbol Sym;
42 std::string USR = "c:"; // We synthesize a few simple cases of USRs by hand!
43 size_t Pos = QName.rfind("::");
44 if (Pos == llvm::StringRef::npos) {
45 Sym.Name = QName;
46 Sym.Scope = "";
47 } else {
48 Sym.Name = QName.substr(Pos + 2);
49 Sym.Scope = QName.substr(0, Pos + 2);
50 USR += "@N@" + replace(QName.substr(0, Pos), "::", "@N@"); // ns:: -> @N@ns
51 }
52 USR += llvm::Regex("^.*$").sub(USRFormat, Sym.Name); // e.g. func -> @F@func#
53 Sym.ID = SymbolID(USR);
54 Sym.SymInfo.Kind = Kind;
55 Sym.Flags |= Symbol::IndexedForCodeCompletion;
56 Sym.Origin = SymbolOrigin::Static;
57 return Sym;
58 }
59
60 Symbol func(llvm::StringRef Name) { // Assumes the function has no args.
61 return sym(Name, index::SymbolKind::Function, "@F@\\0#"); // no args
62 }
63
64 Symbol cls(llvm::StringRef Name) {
65 return sym(Name, index::SymbolKind::Class, "@S@\\0");
66 }
67
68 Symbol enm(llvm::StringRef Name) {
69 return sym(Name, index::SymbolKind::Enum, "@E@\\0");
70 }
71
72 Symbol enmConstant(llvm::StringRef Name) {
73 return sym(Name, index::SymbolKind::EnumConstant, "@\\0");
74 }
75
76 Symbol var(llvm::StringRef Name) {
77 return sym(Name, index::SymbolKind::Variable, "@\\0");
78 }
79
80 Symbol ns(llvm::StringRef Name) {
81 return sym(Name, index::SymbolKind::Namespace, "@N@\\0");
82 }
83
84 Symbol conceptSym(llvm::StringRef Name) {
85 return sym(Name, index::SymbolKind::Concept, "@CT@\\0");
86 }
87
88 Symbol objcSym(llvm::StringRef Name, index::SymbolKind Kind,
89 llvm::StringRef USRPrefix) {
90 Symbol Sym;
91 std::string USR = USRPrefix.str() + Name.str();
92 Sym.Name = Name;
93 Sym.Scope = "";
94 Sym.ID = SymbolID(USR);
95 Sym.SymInfo.Kind = Kind;
96 Sym.SymInfo.Lang = index::SymbolLanguage::ObjC;
97 Sym.Flags |= Symbol::IndexedForCodeCompletion;
98 Sym.Origin = SymbolOrigin::Static;
99 return Sym;
100 }
101
102 Symbol objcClass(llvm::StringRef Name) {
103 return objcSym(Name, index::SymbolKind::Class, "objc(cs)");
104 }
105
106 Symbol objcCategory(llvm::StringRef Name, llvm::StringRef CategoryName) {
107 std::string USRPrefix = ("objc(cy)" + Name + "@").str();
108 return objcSym(CategoryName, index::SymbolKind::Extension, USRPrefix);
109 }
110
111 Symbol objcProtocol(llvm::StringRef Name) {
112 return objcSym(Name, index::SymbolKind::Protocol, "objc(pl)");
113 }
114
115 SymbolSlab generateSymbols(std::vector<std::string> QualifiedNames) {
116 SymbolSlab::Builder Slab;
117 for (llvm::StringRef QName : QualifiedNames)
118 Slab.insert(symbol(QName));
119 return std::move(Slab).build();
120 }
121
122 SymbolSlab generateNumSymbols(int Begin, int End) {
123 std::vector<std::string> Names;
124 for (int I = Begin; I <= End; I++)
125 Names.push_back(std::to_string(I));
126 return generateSymbols(Names);
127 }
128
129 std::string getQualifiedName(const Symbol &Sym) {
130 return (Sym.Scope + Sym.Name + Sym.TemplateSpecializationArgs).str();
131 }
132
133 std::vector<std::string> match(const SymbolIndex &I,
134 const FuzzyFindRequest &Req, bool *Incomplete) {
135 std::vector<std::string> Matches;
136 bool IsIncomplete = I.fuzzyFind(Req, [&](const Symbol &Sym) {
137 Matches.push_back(clang::clangd::getQualifiedName(Sym));
138 });
139 if (Incomplete)
140 *Incomplete = IsIncomplete;
141 return Matches;
142 }
143
144 // Returns qualified names of symbols with any of IDs in the index.
145 std::vector<std::string> lookup(const SymbolIndex &I,
146 llvm::ArrayRef<SymbolID> IDs) {
147 LookupRequest Req;
148 Req.IDs.insert(IDs.begin(), IDs.end());
149 std::vector<std::string> Results;
150 I.lookup(Req, [&](const Symbol &Sym) {
151 Results.push_back(getQualifiedName(Sym));
152 });
153 return Results;
154 }
155
156 } // namespace clangd
157 } // namespace clang