annotate clang-tools-extra/clangd/Protocol.cpp @ 221:79ff65ed7e25

LLVM12 Original
author Shinji KONO <kono@ie.u-ryukyu.ac.jp>
date Tue, 15 Jun 2021 19:15:29 +0900
parents 0572611fdcc8
children c4bab56944e8
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
150
anatofuz
parents:
diff changeset
1 //===--- Protocol.cpp - Language Server Protocol Implementation -----------===//
anatofuz
parents:
diff changeset
2 //
anatofuz
parents:
diff changeset
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
anatofuz
parents:
diff changeset
4 // See https://llvm.org/LICENSE.txt for license information.
anatofuz
parents:
diff changeset
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
anatofuz
parents:
diff changeset
6 //
anatofuz
parents:
diff changeset
7 //===----------------------------------------------------------------------===//
anatofuz
parents:
diff changeset
8 //
anatofuz
parents:
diff changeset
9 // This file contains the serialization code for the LSP structs.
anatofuz
parents:
diff changeset
10 //
anatofuz
parents:
diff changeset
11 //===----------------------------------------------------------------------===//
anatofuz
parents:
diff changeset
12
anatofuz
parents:
diff changeset
13 #include "Protocol.h"
anatofuz
parents:
diff changeset
14 #include "URI.h"
173
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
15 #include "support/Logger.h"
150
anatofuz
parents:
diff changeset
16 #include "clang/Basic/LLVM.h"
173
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
17 #include "clang/Index/IndexSymbol.h"
150
anatofuz
parents:
diff changeset
18 #include "llvm/ADT/Hashing.h"
anatofuz
parents:
diff changeset
19 #include "llvm/ADT/SmallString.h"
anatofuz
parents:
diff changeset
20 #include "llvm/ADT/StringSwitch.h"
anatofuz
parents:
diff changeset
21 #include "llvm/Support/ErrorHandling.h"
anatofuz
parents:
diff changeset
22 #include "llvm/Support/Format.h"
anatofuz
parents:
diff changeset
23 #include "llvm/Support/FormatVariadic.h"
anatofuz
parents:
diff changeset
24 #include "llvm/Support/JSON.h"
anatofuz
parents:
diff changeset
25 #include "llvm/Support/Path.h"
anatofuz
parents:
diff changeset
26 #include "llvm/Support/raw_ostream.h"
anatofuz
parents:
diff changeset
27
anatofuz
parents:
diff changeset
28 namespace clang {
anatofuz
parents:
diff changeset
29 namespace clangd {
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
30 namespace {
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
31
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
32 // Helper that doesn't treat `null` and absent fields as failures.
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
33 template <typename T>
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
34 bool mapOptOrNull(const llvm::json::Value &Params, llvm::StringLiteral Prop,
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
35 T &Out, llvm::json::Path P) {
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
36 auto *O = Params.getAsObject();
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
37 assert(O);
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
38 auto *V = O->get(Prop);
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
39 // Field is missing or null.
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
40 if (!V || V->getAsNull().hasValue())
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
41 return true;
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
42 return fromJSON(*V, Out, P.field(Prop));
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
43 }
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
44 } // namespace
150
anatofuz
parents:
diff changeset
45
anatofuz
parents:
diff changeset
46 char LSPError::ID;
anatofuz
parents:
diff changeset
47
anatofuz
parents:
diff changeset
48 URIForFile URIForFile::canonicalize(llvm::StringRef AbsPath,
anatofuz
parents:
diff changeset
49 llvm::StringRef TUPath) {
anatofuz
parents:
diff changeset
50 assert(llvm::sys::path::is_absolute(AbsPath) && "the path is relative");
anatofuz
parents:
diff changeset
51 auto Resolved = URI::resolvePath(AbsPath, TUPath);
anatofuz
parents:
diff changeset
52 if (!Resolved) {
anatofuz
parents:
diff changeset
53 elog("URIForFile: failed to resolve path {0} with TU path {1}: "
anatofuz
parents:
diff changeset
54 "{2}.\nUsing unresolved path.",
anatofuz
parents:
diff changeset
55 AbsPath, TUPath, Resolved.takeError());
anatofuz
parents:
diff changeset
56 return URIForFile(std::string(AbsPath));
anatofuz
parents:
diff changeset
57 }
anatofuz
parents:
diff changeset
58 return URIForFile(std::move(*Resolved));
anatofuz
parents:
diff changeset
59 }
anatofuz
parents:
diff changeset
60
anatofuz
parents:
diff changeset
61 llvm::Expected<URIForFile> URIForFile::fromURI(const URI &U,
anatofuz
parents:
diff changeset
62 llvm::StringRef HintPath) {
anatofuz
parents:
diff changeset
63 auto Resolved = URI::resolve(U, HintPath);
anatofuz
parents:
diff changeset
64 if (!Resolved)
anatofuz
parents:
diff changeset
65 return Resolved.takeError();
anatofuz
parents:
diff changeset
66 return URIForFile(std::move(*Resolved));
anatofuz
parents:
diff changeset
67 }
anatofuz
parents:
diff changeset
68
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
69 bool fromJSON(const llvm::json::Value &E, URIForFile &R, llvm::json::Path P) {
150
anatofuz
parents:
diff changeset
70 if (auto S = E.getAsString()) {
anatofuz
parents:
diff changeset
71 auto Parsed = URI::parse(*S);
anatofuz
parents:
diff changeset
72 if (!Parsed) {
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
73 consumeError(Parsed.takeError());
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
74 P.report("failed to parse URI");
150
anatofuz
parents:
diff changeset
75 return false;
anatofuz
parents:
diff changeset
76 }
anatofuz
parents:
diff changeset
77 if (Parsed->scheme() != "file" && Parsed->scheme() != "test") {
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
78 P.report("clangd only supports 'file' URI scheme for workspace files");
150
anatofuz
parents:
diff changeset
79 return false;
anatofuz
parents:
diff changeset
80 }
anatofuz
parents:
diff changeset
81 // "file" and "test" schemes do not require hint path.
anatofuz
parents:
diff changeset
82 auto U = URIForFile::fromURI(*Parsed, /*HintPath=*/"");
anatofuz
parents:
diff changeset
83 if (!U) {
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
84 P.report("unresolvable URI");
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
85 consumeError(U.takeError());
150
anatofuz
parents:
diff changeset
86 return false;
anatofuz
parents:
diff changeset
87 }
anatofuz
parents:
diff changeset
88 R = std::move(*U);
anatofuz
parents:
diff changeset
89 return true;
anatofuz
parents:
diff changeset
90 }
anatofuz
parents:
diff changeset
91 return false;
anatofuz
parents:
diff changeset
92 }
anatofuz
parents:
diff changeset
93
anatofuz
parents:
diff changeset
94 llvm::json::Value toJSON(const URIForFile &U) { return U.uri(); }
anatofuz
parents:
diff changeset
95
anatofuz
parents:
diff changeset
96 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const URIForFile &U) {
anatofuz
parents:
diff changeset
97 return OS << U.uri();
anatofuz
parents:
diff changeset
98 }
anatofuz
parents:
diff changeset
99
anatofuz
parents:
diff changeset
100 llvm::json::Value toJSON(const TextDocumentIdentifier &R) {
anatofuz
parents:
diff changeset
101 return llvm::json::Object{{"uri", R.uri}};
anatofuz
parents:
diff changeset
102 }
anatofuz
parents:
diff changeset
103
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
104 bool fromJSON(const llvm::json::Value &Params, TextDocumentIdentifier &R,
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
105 llvm::json::Path P) {
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
106 llvm::json::ObjectMapper O(Params, P);
150
anatofuz
parents:
diff changeset
107 return O && O.map("uri", R.uri);
anatofuz
parents:
diff changeset
108 }
anatofuz
parents:
diff changeset
109
173
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
110 llvm::json::Value toJSON(const VersionedTextDocumentIdentifier &R) {
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
111 auto Result = toJSON(static_cast<const TextDocumentIdentifier &>(R));
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
112 Result.getAsObject()->try_emplace("version", R.version);
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
113 return Result;
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
114 }
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
115
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
116 bool fromJSON(const llvm::json::Value &Params,
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
117 VersionedTextDocumentIdentifier &R, llvm::json::Path P) {
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
118 llvm::json::ObjectMapper O(Params, P);
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
119 return fromJSON(Params, static_cast<TextDocumentIdentifier &>(R), P) && O &&
173
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
120 O.map("version", R.version);
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
121 }
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
122
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
123 bool fromJSON(const llvm::json::Value &Params, Position &R,
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
124 llvm::json::Path P) {
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
125 llvm::json::ObjectMapper O(Params, P);
150
anatofuz
parents:
diff changeset
126 return O && O.map("line", R.line) && O.map("character", R.character);
anatofuz
parents:
diff changeset
127 }
anatofuz
parents:
diff changeset
128
anatofuz
parents:
diff changeset
129 llvm::json::Value toJSON(const Position &P) {
anatofuz
parents:
diff changeset
130 return llvm::json::Object{
anatofuz
parents:
diff changeset
131 {"line", P.line},
anatofuz
parents:
diff changeset
132 {"character", P.character},
anatofuz
parents:
diff changeset
133 };
anatofuz
parents:
diff changeset
134 }
anatofuz
parents:
diff changeset
135
anatofuz
parents:
diff changeset
136 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const Position &P) {
anatofuz
parents:
diff changeset
137 return OS << P.line << ':' << P.character;
anatofuz
parents:
diff changeset
138 }
anatofuz
parents:
diff changeset
139
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
140 bool fromJSON(const llvm::json::Value &Params, Range &R, llvm::json::Path P) {
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
141 llvm::json::ObjectMapper O(Params, P);
150
anatofuz
parents:
diff changeset
142 return O && O.map("start", R.start) && O.map("end", R.end);
anatofuz
parents:
diff changeset
143 }
anatofuz
parents:
diff changeset
144
anatofuz
parents:
diff changeset
145 llvm::json::Value toJSON(const Range &P) {
anatofuz
parents:
diff changeset
146 return llvm::json::Object{
anatofuz
parents:
diff changeset
147 {"start", P.start},
anatofuz
parents:
diff changeset
148 {"end", P.end},
anatofuz
parents:
diff changeset
149 };
anatofuz
parents:
diff changeset
150 }
anatofuz
parents:
diff changeset
151
anatofuz
parents:
diff changeset
152 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const Range &R) {
anatofuz
parents:
diff changeset
153 return OS << R.start << '-' << R.end;
anatofuz
parents:
diff changeset
154 }
anatofuz
parents:
diff changeset
155
anatofuz
parents:
diff changeset
156 llvm::json::Value toJSON(const Location &P) {
anatofuz
parents:
diff changeset
157 return llvm::json::Object{
anatofuz
parents:
diff changeset
158 {"uri", P.uri},
anatofuz
parents:
diff changeset
159 {"range", P.range},
anatofuz
parents:
diff changeset
160 };
anatofuz
parents:
diff changeset
161 }
anatofuz
parents:
diff changeset
162
anatofuz
parents:
diff changeset
163 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const Location &L) {
anatofuz
parents:
diff changeset
164 return OS << L.range << '@' << L.uri;
anatofuz
parents:
diff changeset
165 }
anatofuz
parents:
diff changeset
166
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
167 bool fromJSON(const llvm::json::Value &Params, TextDocumentItem &R,
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
168 llvm::json::Path P) {
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
169 llvm::json::ObjectMapper O(Params, P);
150
anatofuz
parents:
diff changeset
170 return O && O.map("uri", R.uri) && O.map("languageId", R.languageId) &&
anatofuz
parents:
diff changeset
171 O.map("version", R.version) && O.map("text", R.text);
anatofuz
parents:
diff changeset
172 }
anatofuz
parents:
diff changeset
173
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
174 bool fromJSON(const llvm::json::Value &Params, TextEdit &R,
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
175 llvm::json::Path P) {
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
176 llvm::json::ObjectMapper O(Params, P);
150
anatofuz
parents:
diff changeset
177 return O && O.map("range", R.range) && O.map("newText", R.newText);
anatofuz
parents:
diff changeset
178 }
anatofuz
parents:
diff changeset
179
anatofuz
parents:
diff changeset
180 llvm::json::Value toJSON(const TextEdit &P) {
anatofuz
parents:
diff changeset
181 return llvm::json::Object{
anatofuz
parents:
diff changeset
182 {"range", P.range},
anatofuz
parents:
diff changeset
183 {"newText", P.newText},
anatofuz
parents:
diff changeset
184 };
anatofuz
parents:
diff changeset
185 }
anatofuz
parents:
diff changeset
186
anatofuz
parents:
diff changeset
187 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const TextEdit &TE) {
anatofuz
parents:
diff changeset
188 OS << TE.range << " => \"";
anatofuz
parents:
diff changeset
189 llvm::printEscapedString(TE.newText, OS);
anatofuz
parents:
diff changeset
190 return OS << '"';
anatofuz
parents:
diff changeset
191 }
anatofuz
parents:
diff changeset
192
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
193 bool fromJSON(const llvm::json::Value &E, TraceLevel &Out, llvm::json::Path P) {
150
anatofuz
parents:
diff changeset
194 if (auto S = E.getAsString()) {
anatofuz
parents:
diff changeset
195 if (*S == "off") {
anatofuz
parents:
diff changeset
196 Out = TraceLevel::Off;
anatofuz
parents:
diff changeset
197 return true;
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
198 }
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
199 if (*S == "messages") {
150
anatofuz
parents:
diff changeset
200 Out = TraceLevel::Messages;
anatofuz
parents:
diff changeset
201 return true;
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
202 }
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
203 if (*S == "verbose") {
150
anatofuz
parents:
diff changeset
204 Out = TraceLevel::Verbose;
anatofuz
parents:
diff changeset
205 return true;
anatofuz
parents:
diff changeset
206 }
anatofuz
parents:
diff changeset
207 }
anatofuz
parents:
diff changeset
208 return false;
anatofuz
parents:
diff changeset
209 }
anatofuz
parents:
diff changeset
210
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
211 bool fromJSON(const llvm::json::Value &E, SymbolKind &Out, llvm::json::Path P) {
150
anatofuz
parents:
diff changeset
212 if (auto T = E.getAsInteger()) {
anatofuz
parents:
diff changeset
213 if (*T < static_cast<int>(SymbolKind::File) ||
anatofuz
parents:
diff changeset
214 *T > static_cast<int>(SymbolKind::TypeParameter))
anatofuz
parents:
diff changeset
215 return false;
anatofuz
parents:
diff changeset
216 Out = static_cast<SymbolKind>(*T);
anatofuz
parents:
diff changeset
217 return true;
anatofuz
parents:
diff changeset
218 }
anatofuz
parents:
diff changeset
219 return false;
anatofuz
parents:
diff changeset
220 }
anatofuz
parents:
diff changeset
221
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
222 bool fromJSON(const llvm::json::Value &E, SymbolKindBitset &Out,
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
223 llvm::json::Path P) {
150
anatofuz
parents:
diff changeset
224 if (auto *A = E.getAsArray()) {
anatofuz
parents:
diff changeset
225 for (size_t I = 0; I < A->size(); ++I) {
anatofuz
parents:
diff changeset
226 SymbolKind KindOut;
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
227 if (fromJSON((*A)[I], KindOut, P.index(I)))
150
anatofuz
parents:
diff changeset
228 Out.set(size_t(KindOut));
anatofuz
parents:
diff changeset
229 }
anatofuz
parents:
diff changeset
230 return true;
anatofuz
parents:
diff changeset
231 }
anatofuz
parents:
diff changeset
232 return false;
anatofuz
parents:
diff changeset
233 }
anatofuz
parents:
diff changeset
234
anatofuz
parents:
diff changeset
235 SymbolKind adjustKindToCapability(SymbolKind Kind,
anatofuz
parents:
diff changeset
236 SymbolKindBitset &SupportedSymbolKinds) {
anatofuz
parents:
diff changeset
237 auto KindVal = static_cast<size_t>(Kind);
anatofuz
parents:
diff changeset
238 if (KindVal >= SymbolKindMin && KindVal <= SupportedSymbolKinds.size() &&
anatofuz
parents:
diff changeset
239 SupportedSymbolKinds[KindVal])
anatofuz
parents:
diff changeset
240 return Kind;
anatofuz
parents:
diff changeset
241
anatofuz
parents:
diff changeset
242 switch (Kind) {
anatofuz
parents:
diff changeset
243 // Provide some fall backs for common kinds that are close enough.
anatofuz
parents:
diff changeset
244 case SymbolKind::Struct:
anatofuz
parents:
diff changeset
245 return SymbolKind::Class;
anatofuz
parents:
diff changeset
246 case SymbolKind::EnumMember:
anatofuz
parents:
diff changeset
247 return SymbolKind::Enum;
anatofuz
parents:
diff changeset
248 default:
anatofuz
parents:
diff changeset
249 return SymbolKind::String;
anatofuz
parents:
diff changeset
250 }
anatofuz
parents:
diff changeset
251 }
anatofuz
parents:
diff changeset
252
anatofuz
parents:
diff changeset
253 SymbolKind indexSymbolKindToSymbolKind(index::SymbolKind Kind) {
anatofuz
parents:
diff changeset
254 switch (Kind) {
anatofuz
parents:
diff changeset
255 case index::SymbolKind::Unknown:
anatofuz
parents:
diff changeset
256 return SymbolKind::Variable;
anatofuz
parents:
diff changeset
257 case index::SymbolKind::Module:
anatofuz
parents:
diff changeset
258 return SymbolKind::Module;
anatofuz
parents:
diff changeset
259 case index::SymbolKind::Namespace:
anatofuz
parents:
diff changeset
260 return SymbolKind::Namespace;
anatofuz
parents:
diff changeset
261 case index::SymbolKind::NamespaceAlias:
anatofuz
parents:
diff changeset
262 return SymbolKind::Namespace;
anatofuz
parents:
diff changeset
263 case index::SymbolKind::Macro:
anatofuz
parents:
diff changeset
264 return SymbolKind::String;
anatofuz
parents:
diff changeset
265 case index::SymbolKind::Enum:
anatofuz
parents:
diff changeset
266 return SymbolKind::Enum;
anatofuz
parents:
diff changeset
267 case index::SymbolKind::Struct:
anatofuz
parents:
diff changeset
268 return SymbolKind::Struct;
anatofuz
parents:
diff changeset
269 case index::SymbolKind::Class:
anatofuz
parents:
diff changeset
270 return SymbolKind::Class;
anatofuz
parents:
diff changeset
271 case index::SymbolKind::Protocol:
anatofuz
parents:
diff changeset
272 return SymbolKind::Interface;
anatofuz
parents:
diff changeset
273 case index::SymbolKind::Extension:
anatofuz
parents:
diff changeset
274 return SymbolKind::Interface;
anatofuz
parents:
diff changeset
275 case index::SymbolKind::Union:
anatofuz
parents:
diff changeset
276 return SymbolKind::Class;
anatofuz
parents:
diff changeset
277 case index::SymbolKind::TypeAlias:
anatofuz
parents:
diff changeset
278 return SymbolKind::Class;
anatofuz
parents:
diff changeset
279 case index::SymbolKind::Function:
anatofuz
parents:
diff changeset
280 return SymbolKind::Function;
anatofuz
parents:
diff changeset
281 case index::SymbolKind::Variable:
anatofuz
parents:
diff changeset
282 return SymbolKind::Variable;
anatofuz
parents:
diff changeset
283 case index::SymbolKind::Field:
anatofuz
parents:
diff changeset
284 return SymbolKind::Field;
anatofuz
parents:
diff changeset
285 case index::SymbolKind::EnumConstant:
anatofuz
parents:
diff changeset
286 return SymbolKind::EnumMember;
anatofuz
parents:
diff changeset
287 case index::SymbolKind::InstanceMethod:
anatofuz
parents:
diff changeset
288 case index::SymbolKind::ClassMethod:
anatofuz
parents:
diff changeset
289 case index::SymbolKind::StaticMethod:
anatofuz
parents:
diff changeset
290 return SymbolKind::Method;
anatofuz
parents:
diff changeset
291 case index::SymbolKind::InstanceProperty:
anatofuz
parents:
diff changeset
292 case index::SymbolKind::ClassProperty:
anatofuz
parents:
diff changeset
293 case index::SymbolKind::StaticProperty:
anatofuz
parents:
diff changeset
294 return SymbolKind::Property;
anatofuz
parents:
diff changeset
295 case index::SymbolKind::Constructor:
anatofuz
parents:
diff changeset
296 case index::SymbolKind::Destructor:
anatofuz
parents:
diff changeset
297 return SymbolKind::Constructor;
anatofuz
parents:
diff changeset
298 case index::SymbolKind::ConversionFunction:
anatofuz
parents:
diff changeset
299 return SymbolKind::Function;
anatofuz
parents:
diff changeset
300 case index::SymbolKind::Parameter:
173
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
301 case index::SymbolKind::NonTypeTemplateParm:
150
anatofuz
parents:
diff changeset
302 return SymbolKind::Variable;
anatofuz
parents:
diff changeset
303 case index::SymbolKind::Using:
anatofuz
parents:
diff changeset
304 return SymbolKind::Namespace;
173
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
305 case index::SymbolKind::TemplateTemplateParm:
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
306 case index::SymbolKind::TemplateTypeParm:
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
307 return SymbolKind::TypeParameter;
150
anatofuz
parents:
diff changeset
308 }
anatofuz
parents:
diff changeset
309 llvm_unreachable("invalid symbol kind");
anatofuz
parents:
diff changeset
310 }
anatofuz
parents:
diff changeset
311
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
312 bool fromJSON(const llvm::json::Value &Params, ClientCapabilities &R,
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
313 llvm::json::Path P) {
150
anatofuz
parents:
diff changeset
314 const llvm::json::Object *O = Params.getAsObject();
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
315 if (!O) {
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
316 P.report("expected object");
150
anatofuz
parents:
diff changeset
317 return false;
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
318 }
150
anatofuz
parents:
diff changeset
319 if (auto *TextDocument = O->getObject("textDocument")) {
anatofuz
parents:
diff changeset
320 if (auto *SemanticHighlighting =
anatofuz
parents:
diff changeset
321 TextDocument->getObject("semanticHighlightingCapabilities")) {
anatofuz
parents:
diff changeset
322 if (auto SemanticHighlightingSupport =
anatofuz
parents:
diff changeset
323 SemanticHighlighting->getBoolean("semanticHighlighting"))
173
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
324 R.TheiaSemanticHighlighting = *SemanticHighlightingSupport;
150
anatofuz
parents:
diff changeset
325 }
173
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
326 if (TextDocument->getObject("semanticTokens"))
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
327 R.SemanticTokens = true;
150
anatofuz
parents:
diff changeset
328 if (auto *Diagnostics = TextDocument->getObject("publishDiagnostics")) {
anatofuz
parents:
diff changeset
329 if (auto CategorySupport = Diagnostics->getBoolean("categorySupport"))
anatofuz
parents:
diff changeset
330 R.DiagnosticCategory = *CategorySupport;
anatofuz
parents:
diff changeset
331 if (auto CodeActions = Diagnostics->getBoolean("codeActionsInline"))
anatofuz
parents:
diff changeset
332 R.DiagnosticFixes = *CodeActions;
anatofuz
parents:
diff changeset
333 if (auto RelatedInfo = Diagnostics->getBoolean("relatedInformation"))
anatofuz
parents:
diff changeset
334 R.DiagnosticRelatedInformation = *RelatedInfo;
anatofuz
parents:
diff changeset
335 }
anatofuz
parents:
diff changeset
336 if (auto *Completion = TextDocument->getObject("completion")) {
anatofuz
parents:
diff changeset
337 if (auto *Item = Completion->getObject("completionItem")) {
anatofuz
parents:
diff changeset
338 if (auto SnippetSupport = Item->getBoolean("snippetSupport"))
anatofuz
parents:
diff changeset
339 R.CompletionSnippets = *SnippetSupport;
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
340 if (const auto *DocumentationFormat =
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
341 Item->getArray("documentationFormat")) {
173
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
342 for (const auto &Format : *DocumentationFormat) {
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
343 if (fromJSON(Format, R.CompletionDocumentationFormat, P))
173
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
344 break;
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
345 }
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
346 }
150
anatofuz
parents:
diff changeset
347 }
anatofuz
parents:
diff changeset
348 if (auto *ItemKind = Completion->getObject("completionItemKind")) {
anatofuz
parents:
diff changeset
349 if (auto *ValueSet = ItemKind->get("valueSet")) {
anatofuz
parents:
diff changeset
350 R.CompletionItemKinds.emplace();
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
351 if (!fromJSON(*ValueSet, *R.CompletionItemKinds,
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
352 P.field("textDocument")
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
353 .field("completion")
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
354 .field("completionItemKind")
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
355 .field("valueSet")))
150
anatofuz
parents:
diff changeset
356 return false;
anatofuz
parents:
diff changeset
357 }
anatofuz
parents:
diff changeset
358 }
anatofuz
parents:
diff changeset
359 if (auto EditsNearCursor = Completion->getBoolean("editsNearCursor"))
anatofuz
parents:
diff changeset
360 R.CompletionFixes = *EditsNearCursor;
anatofuz
parents:
diff changeset
361 }
anatofuz
parents:
diff changeset
362 if (auto *CodeAction = TextDocument->getObject("codeAction")) {
anatofuz
parents:
diff changeset
363 if (CodeAction->getObject("codeActionLiteralSupport"))
anatofuz
parents:
diff changeset
364 R.CodeActionStructure = true;
anatofuz
parents:
diff changeset
365 }
anatofuz
parents:
diff changeset
366 if (auto *DocumentSymbol = TextDocument->getObject("documentSymbol")) {
anatofuz
parents:
diff changeset
367 if (auto HierarchicalSupport =
anatofuz
parents:
diff changeset
368 DocumentSymbol->getBoolean("hierarchicalDocumentSymbolSupport"))
anatofuz
parents:
diff changeset
369 R.HierarchicalDocumentSymbol = *HierarchicalSupport;
anatofuz
parents:
diff changeset
370 }
anatofuz
parents:
diff changeset
371 if (auto *Hover = TextDocument->getObject("hover")) {
anatofuz
parents:
diff changeset
372 if (auto *ContentFormat = Hover->getArray("contentFormat")) {
anatofuz
parents:
diff changeset
373 for (const auto &Format : *ContentFormat) {
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
374 if (fromJSON(Format, R.HoverContentFormat, P))
150
anatofuz
parents:
diff changeset
375 break;
anatofuz
parents:
diff changeset
376 }
anatofuz
parents:
diff changeset
377 }
anatofuz
parents:
diff changeset
378 }
anatofuz
parents:
diff changeset
379 if (auto *Help = TextDocument->getObject("signatureHelp")) {
anatofuz
parents:
diff changeset
380 R.HasSignatureHelp = true;
anatofuz
parents:
diff changeset
381 if (auto *Info = Help->getObject("signatureInformation")) {
anatofuz
parents:
diff changeset
382 if (auto *Parameter = Info->getObject("parameterInformation")) {
anatofuz
parents:
diff changeset
383 if (auto OffsetSupport = Parameter->getBoolean("labelOffsetSupport"))
anatofuz
parents:
diff changeset
384 R.OffsetsInSignatureHelp = *OffsetSupport;
anatofuz
parents:
diff changeset
385 }
anatofuz
parents:
diff changeset
386 }
anatofuz
parents:
diff changeset
387 }
anatofuz
parents:
diff changeset
388 if (auto *Rename = TextDocument->getObject("rename")) {
anatofuz
parents:
diff changeset
389 if (auto RenameSupport = Rename->getBoolean("prepareSupport"))
anatofuz
parents:
diff changeset
390 R.RenamePrepareSupport = *RenameSupport;
anatofuz
parents:
diff changeset
391 }
anatofuz
parents:
diff changeset
392 }
anatofuz
parents:
diff changeset
393 if (auto *Workspace = O->getObject("workspace")) {
anatofuz
parents:
diff changeset
394 if (auto *Symbol = Workspace->getObject("symbol")) {
anatofuz
parents:
diff changeset
395 if (auto *SymbolKind = Symbol->getObject("symbolKind")) {
anatofuz
parents:
diff changeset
396 if (auto *ValueSet = SymbolKind->get("valueSet")) {
anatofuz
parents:
diff changeset
397 R.WorkspaceSymbolKinds.emplace();
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
398 if (!fromJSON(*ValueSet, *R.WorkspaceSymbolKinds,
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
399 P.field("workspace")
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
400 .field("symbol")
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
401 .field("symbolKind")
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
402 .field("valueSet")))
150
anatofuz
parents:
diff changeset
403 return false;
anatofuz
parents:
diff changeset
404 }
anatofuz
parents:
diff changeset
405 }
anatofuz
parents:
diff changeset
406 }
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
407 if (auto *SemanticTokens = Workspace->getObject("semanticTokens")) {
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
408 if (auto RefreshSupport = SemanticTokens->getBoolean("refreshSupport"))
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
409 R.SemanticTokenRefreshSupport = *RefreshSupport;
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
410 }
150
anatofuz
parents:
diff changeset
411 }
anatofuz
parents:
diff changeset
412 if (auto *Window = O->getObject("window")) {
anatofuz
parents:
diff changeset
413 if (auto WorkDoneProgress = Window->getBoolean("workDoneProgress"))
anatofuz
parents:
diff changeset
414 R.WorkDoneProgress = *WorkDoneProgress;
anatofuz
parents:
diff changeset
415 if (auto Implicit = Window->getBoolean("implicitWorkDoneProgressCreate"))
anatofuz
parents:
diff changeset
416 R.ImplicitProgressCreation = *Implicit;
anatofuz
parents:
diff changeset
417 }
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
418 if (auto *General = O->getObject("general")) {
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
419 if (auto *StaleRequestSupport = General->getObject("staleRequestSupport")) {
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
420 if (auto Cancel = StaleRequestSupport->getBoolean("cancel"))
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
421 R.CancelsStaleRequests = *Cancel;
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
422 }
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
423 }
150
anatofuz
parents:
diff changeset
424 if (auto *OffsetEncoding = O->get("offsetEncoding")) {
anatofuz
parents:
diff changeset
425 R.offsetEncoding.emplace();
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
426 if (!fromJSON(*OffsetEncoding, *R.offsetEncoding,
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
427 P.field("offsetEncoding")))
150
anatofuz
parents:
diff changeset
428 return false;
anatofuz
parents:
diff changeset
429 }
anatofuz
parents:
diff changeset
430 return true;
anatofuz
parents:
diff changeset
431 }
anatofuz
parents:
diff changeset
432
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
433 bool fromJSON(const llvm::json::Value &Params, InitializeParams &R,
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
434 llvm::json::Path P) {
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
435 llvm::json::ObjectMapper O(Params, P);
150
anatofuz
parents:
diff changeset
436 if (!O)
anatofuz
parents:
diff changeset
437 return false;
anatofuz
parents:
diff changeset
438 // We deliberately don't fail if we can't parse individual fields.
anatofuz
parents:
diff changeset
439 // Failing to handle a slightly malformed initialize would be a disaster.
anatofuz
parents:
diff changeset
440 O.map("processId", R.processId);
anatofuz
parents:
diff changeset
441 O.map("rootUri", R.rootUri);
anatofuz
parents:
diff changeset
442 O.map("rootPath", R.rootPath);
anatofuz
parents:
diff changeset
443 O.map("capabilities", R.capabilities);
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
444 if (auto *RawCaps = Params.getAsObject()->getObject("capabilities"))
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
445 R.rawCapabilities = *RawCaps;
150
anatofuz
parents:
diff changeset
446 O.map("trace", R.trace);
anatofuz
parents:
diff changeset
447 O.map("initializationOptions", R.initializationOptions);
anatofuz
parents:
diff changeset
448 return true;
anatofuz
parents:
diff changeset
449 }
anatofuz
parents:
diff changeset
450
anatofuz
parents:
diff changeset
451 llvm::json::Value toJSON(const WorkDoneProgressCreateParams &P) {
anatofuz
parents:
diff changeset
452 return llvm::json::Object{{"token", P.token}};
anatofuz
parents:
diff changeset
453 }
anatofuz
parents:
diff changeset
454
anatofuz
parents:
diff changeset
455 llvm::json::Value toJSON(const WorkDoneProgressBegin &P) {
anatofuz
parents:
diff changeset
456 llvm::json::Object Result{
anatofuz
parents:
diff changeset
457 {"kind", "begin"},
anatofuz
parents:
diff changeset
458 {"title", P.title},
anatofuz
parents:
diff changeset
459 };
anatofuz
parents:
diff changeset
460 if (P.cancellable)
anatofuz
parents:
diff changeset
461 Result["cancellable"] = true;
anatofuz
parents:
diff changeset
462 if (P.percentage)
anatofuz
parents:
diff changeset
463 Result["percentage"] = 0;
173
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
464
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
465 // FIXME: workaround for older gcc/clang
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
466 return std::move(Result);
150
anatofuz
parents:
diff changeset
467 }
anatofuz
parents:
diff changeset
468
anatofuz
parents:
diff changeset
469 llvm::json::Value toJSON(const WorkDoneProgressReport &P) {
anatofuz
parents:
diff changeset
470 llvm::json::Object Result{{"kind", "report"}};
anatofuz
parents:
diff changeset
471 if (P.cancellable)
anatofuz
parents:
diff changeset
472 Result["cancellable"] = *P.cancellable;
anatofuz
parents:
diff changeset
473 if (P.message)
anatofuz
parents:
diff changeset
474 Result["message"] = *P.message;
anatofuz
parents:
diff changeset
475 if (P.percentage)
anatofuz
parents:
diff changeset
476 Result["percentage"] = *P.percentage;
173
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
477 // FIXME: workaround for older gcc/clang
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
478 return std::move(Result);
150
anatofuz
parents:
diff changeset
479 }
anatofuz
parents:
diff changeset
480
anatofuz
parents:
diff changeset
481 llvm::json::Value toJSON(const WorkDoneProgressEnd &P) {
anatofuz
parents:
diff changeset
482 llvm::json::Object Result{{"kind", "end"}};
anatofuz
parents:
diff changeset
483 if (P.message)
anatofuz
parents:
diff changeset
484 Result["message"] = *P.message;
173
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
485 // FIXME: workaround for older gcc/clang
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
486 return std::move(Result);
150
anatofuz
parents:
diff changeset
487 }
anatofuz
parents:
diff changeset
488
anatofuz
parents:
diff changeset
489 llvm::json::Value toJSON(const MessageType &R) {
anatofuz
parents:
diff changeset
490 return static_cast<int64_t>(R);
anatofuz
parents:
diff changeset
491 }
anatofuz
parents:
diff changeset
492
anatofuz
parents:
diff changeset
493 llvm::json::Value toJSON(const ShowMessageParams &R) {
anatofuz
parents:
diff changeset
494 return llvm::json::Object{{"type", R.type}, {"message", R.message}};
anatofuz
parents:
diff changeset
495 }
anatofuz
parents:
diff changeset
496
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
497 bool fromJSON(const llvm::json::Value &Params, DidOpenTextDocumentParams &R,
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
498 llvm::json::Path P) {
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
499 llvm::json::ObjectMapper O(Params, P);
150
anatofuz
parents:
diff changeset
500 return O && O.map("textDocument", R.textDocument);
anatofuz
parents:
diff changeset
501 }
anatofuz
parents:
diff changeset
502
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
503 bool fromJSON(const llvm::json::Value &Params, DidCloseTextDocumentParams &R,
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
504 llvm::json::Path P) {
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
505 llvm::json::ObjectMapper O(Params, P);
150
anatofuz
parents:
diff changeset
506 return O && O.map("textDocument", R.textDocument);
anatofuz
parents:
diff changeset
507 }
anatofuz
parents:
diff changeset
508
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
509 bool fromJSON(const llvm::json::Value &Params, DidSaveTextDocumentParams &R,
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
510 llvm::json::Path P) {
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
511 llvm::json::ObjectMapper O(Params, P);
173
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
512 return O && O.map("textDocument", R.textDocument);
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
513 }
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
514
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
515 bool fromJSON(const llvm::json::Value &Params, DidChangeTextDocumentParams &R,
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
516 llvm::json::Path P) {
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
517 llvm::json::ObjectMapper O(Params, P);
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
518 return O && O.map("textDocument", R.textDocument) &&
150
anatofuz
parents:
diff changeset
519 O.map("contentChanges", R.contentChanges) &&
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
520 O.map("wantDiagnostics", R.wantDiagnostics) &&
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
521 mapOptOrNull(Params, "forceRebuild", R.forceRebuild, P);
150
anatofuz
parents:
diff changeset
522 }
anatofuz
parents:
diff changeset
523
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
524 bool fromJSON(const llvm::json::Value &E, FileChangeType &Out,
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
525 llvm::json::Path P) {
150
anatofuz
parents:
diff changeset
526 if (auto T = E.getAsInteger()) {
anatofuz
parents:
diff changeset
527 if (*T < static_cast<int>(FileChangeType::Created) ||
anatofuz
parents:
diff changeset
528 *T > static_cast<int>(FileChangeType::Deleted))
anatofuz
parents:
diff changeset
529 return false;
anatofuz
parents:
diff changeset
530 Out = static_cast<FileChangeType>(*T);
anatofuz
parents:
diff changeset
531 return true;
anatofuz
parents:
diff changeset
532 }
anatofuz
parents:
diff changeset
533 return false;
anatofuz
parents:
diff changeset
534 }
anatofuz
parents:
diff changeset
535
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
536 bool fromJSON(const llvm::json::Value &Params, FileEvent &R,
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
537 llvm::json::Path P) {
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
538 llvm::json::ObjectMapper O(Params, P);
150
anatofuz
parents:
diff changeset
539 return O && O.map("uri", R.uri) && O.map("type", R.type);
anatofuz
parents:
diff changeset
540 }
anatofuz
parents:
diff changeset
541
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
542 bool fromJSON(const llvm::json::Value &Params, DidChangeWatchedFilesParams &R,
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
543 llvm::json::Path P) {
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
544 llvm::json::ObjectMapper O(Params, P);
150
anatofuz
parents:
diff changeset
545 return O && O.map("changes", R.changes);
anatofuz
parents:
diff changeset
546 }
anatofuz
parents:
diff changeset
547
anatofuz
parents:
diff changeset
548 bool fromJSON(const llvm::json::Value &Params,
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
549 TextDocumentContentChangeEvent &R, llvm::json::Path P) {
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
550 llvm::json::ObjectMapper O(Params, P);
150
anatofuz
parents:
diff changeset
551 return O && O.map("range", R.range) && O.map("rangeLength", R.rangeLength) &&
anatofuz
parents:
diff changeset
552 O.map("text", R.text);
anatofuz
parents:
diff changeset
553 }
anatofuz
parents:
diff changeset
554
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
555 bool fromJSON(const llvm::json::Value &Params, DocumentRangeFormattingParams &R,
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
556 llvm::json::Path P) {
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
557 llvm::json::ObjectMapper O(Params, P);
150
anatofuz
parents:
diff changeset
558 return O && O.map("textDocument", R.textDocument) && O.map("range", R.range);
anatofuz
parents:
diff changeset
559 }
anatofuz
parents:
diff changeset
560
anatofuz
parents:
diff changeset
561 bool fromJSON(const llvm::json::Value &Params,
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
562 DocumentOnTypeFormattingParams &R, llvm::json::Path P) {
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
563 llvm::json::ObjectMapper O(Params, P);
150
anatofuz
parents:
diff changeset
564 return O && O.map("textDocument", R.textDocument) &&
anatofuz
parents:
diff changeset
565 O.map("position", R.position) && O.map("ch", R.ch);
anatofuz
parents:
diff changeset
566 }
anatofuz
parents:
diff changeset
567
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
568 bool fromJSON(const llvm::json::Value &Params, DocumentFormattingParams &R,
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
569 llvm::json::Path P) {
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
570 llvm::json::ObjectMapper O(Params, P);
150
anatofuz
parents:
diff changeset
571 return O && O.map("textDocument", R.textDocument);
anatofuz
parents:
diff changeset
572 }
anatofuz
parents:
diff changeset
573
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
574 bool fromJSON(const llvm::json::Value &Params, DocumentSymbolParams &R,
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
575 llvm::json::Path P) {
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
576 llvm::json::ObjectMapper O(Params, P);
150
anatofuz
parents:
diff changeset
577 return O && O.map("textDocument", R.textDocument);
anatofuz
parents:
diff changeset
578 }
anatofuz
parents:
diff changeset
579
anatofuz
parents:
diff changeset
580 llvm::json::Value toJSON(const DiagnosticRelatedInformation &DRI) {
anatofuz
parents:
diff changeset
581 return llvm::json::Object{
anatofuz
parents:
diff changeset
582 {"location", DRI.location},
anatofuz
parents:
diff changeset
583 {"message", DRI.message},
anatofuz
parents:
diff changeset
584 };
anatofuz
parents:
diff changeset
585 }
anatofuz
parents:
diff changeset
586
anatofuz
parents:
diff changeset
587 llvm::json::Value toJSON(const Diagnostic &D) {
anatofuz
parents:
diff changeset
588 llvm::json::Object Diag{
anatofuz
parents:
diff changeset
589 {"range", D.range},
anatofuz
parents:
diff changeset
590 {"severity", D.severity},
anatofuz
parents:
diff changeset
591 {"message", D.message},
anatofuz
parents:
diff changeset
592 };
anatofuz
parents:
diff changeset
593 if (D.category)
anatofuz
parents:
diff changeset
594 Diag["category"] = *D.category;
anatofuz
parents:
diff changeset
595 if (D.codeActions)
anatofuz
parents:
diff changeset
596 Diag["codeActions"] = D.codeActions;
anatofuz
parents:
diff changeset
597 if (!D.code.empty())
anatofuz
parents:
diff changeset
598 Diag["code"] = D.code;
anatofuz
parents:
diff changeset
599 if (!D.source.empty())
anatofuz
parents:
diff changeset
600 Diag["source"] = D.source;
anatofuz
parents:
diff changeset
601 if (D.relatedInformation)
anatofuz
parents:
diff changeset
602 Diag["relatedInformation"] = *D.relatedInformation;
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
603 if (!D.data.empty())
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
604 Diag["data"] = llvm::json::Object(D.data);
173
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
605 // FIXME: workaround for older gcc/clang
150
anatofuz
parents:
diff changeset
606 return std::move(Diag);
anatofuz
parents:
diff changeset
607 }
anatofuz
parents:
diff changeset
608
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
609 bool fromJSON(const llvm::json::Value &Params, Diagnostic &R,
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
610 llvm::json::Path P) {
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
611 llvm::json::ObjectMapper O(Params, P);
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
612 if (!O)
150
anatofuz
parents:
diff changeset
613 return false;
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
614 if (auto *Data = Params.getAsObject()->getObject("data"))
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
615 R.data = *Data;
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
616 return O.map("range", R.range) && O.map("message", R.message) &&
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
617 mapOptOrNull(Params, "severity", R.severity, P) &&
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
618 mapOptOrNull(Params, "category", R.category, P) &&
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
619 mapOptOrNull(Params, "code", R.code, P) &&
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
620 mapOptOrNull(Params, "source", R.source, P);
150
anatofuz
parents:
diff changeset
621 }
anatofuz
parents:
diff changeset
622
173
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
623 llvm::json::Value toJSON(const PublishDiagnosticsParams &PDP) {
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
624 llvm::json::Object Result{
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
625 {"uri", PDP.uri},
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
626 {"diagnostics", PDP.diagnostics},
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
627 };
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
628 if (PDP.version)
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
629 Result["version"] = PDP.version;
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
630 return std::move(Result);
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
631 }
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
632
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
633 bool fromJSON(const llvm::json::Value &Params, CodeActionContext &R,
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
634 llvm::json::Path P) {
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
635 llvm::json::ObjectMapper O(Params, P);
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
636 if (!O || !O.map("diagnostics", R.diagnostics))
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
637 return false;
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
638 O.map("only", R.only);
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
639 return true;
150
anatofuz
parents:
diff changeset
640 }
anatofuz
parents:
diff changeset
641
anatofuz
parents:
diff changeset
642 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const Diagnostic &D) {
anatofuz
parents:
diff changeset
643 OS << D.range << " [";
anatofuz
parents:
diff changeset
644 switch (D.severity) {
anatofuz
parents:
diff changeset
645 case 1:
anatofuz
parents:
diff changeset
646 OS << "error";
anatofuz
parents:
diff changeset
647 break;
anatofuz
parents:
diff changeset
648 case 2:
anatofuz
parents:
diff changeset
649 OS << "warning";
anatofuz
parents:
diff changeset
650 break;
anatofuz
parents:
diff changeset
651 case 3:
anatofuz
parents:
diff changeset
652 OS << "note";
anatofuz
parents:
diff changeset
653 break;
anatofuz
parents:
diff changeset
654 case 4:
anatofuz
parents:
diff changeset
655 OS << "remark";
anatofuz
parents:
diff changeset
656 break;
anatofuz
parents:
diff changeset
657 default:
anatofuz
parents:
diff changeset
658 OS << "diagnostic";
anatofuz
parents:
diff changeset
659 break;
anatofuz
parents:
diff changeset
660 }
anatofuz
parents:
diff changeset
661 return OS << '(' << D.severity << "): " << D.message << "]";
anatofuz
parents:
diff changeset
662 }
anatofuz
parents:
diff changeset
663
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
664 bool fromJSON(const llvm::json::Value &Params, CodeActionParams &R,
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
665 llvm::json::Path P) {
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
666 llvm::json::ObjectMapper O(Params, P);
150
anatofuz
parents:
diff changeset
667 return O && O.map("textDocument", R.textDocument) &&
anatofuz
parents:
diff changeset
668 O.map("range", R.range) && O.map("context", R.context);
anatofuz
parents:
diff changeset
669 }
anatofuz
parents:
diff changeset
670
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
671 bool fromJSON(const llvm::json::Value &Params, WorkspaceEdit &R,
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
672 llvm::json::Path P) {
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
673 llvm::json::ObjectMapper O(Params, P);
150
anatofuz
parents:
diff changeset
674 return O && O.map("changes", R.changes);
anatofuz
parents:
diff changeset
675 }
anatofuz
parents:
diff changeset
676
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
677 bool fromJSON(const llvm::json::Value &Params, ExecuteCommandParams &R,
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
678 llvm::json::Path P) {
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
679 llvm::json::ObjectMapper O(Params, P);
150
anatofuz
parents:
diff changeset
680 if (!O || !O.map("command", R.command))
anatofuz
parents:
diff changeset
681 return false;
anatofuz
parents:
diff changeset
682
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
683 const auto *Args = Params.getAsObject()->get("arguments");
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
684 if (!Args)
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
685 return true; // Missing args is ok, argument is null.
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
686 const auto *ArgsArray = Args->getAsArray();
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
687 if (!ArgsArray) {
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
688 P.field("arguments").report("expected array");
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
689 return false;
150
anatofuz
parents:
diff changeset
690 }
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
691 if (ArgsArray->size() > 1) {
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
692 P.field("arguments").report("Command should have 0 or 1 argument");
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
693 return false;
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
694 } else if (ArgsArray->size() == 1) {
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
695 R.argument = ArgsArray->front();
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
696 }
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
697 return true;
150
anatofuz
parents:
diff changeset
698 }
anatofuz
parents:
diff changeset
699
anatofuz
parents:
diff changeset
700 llvm::json::Value toJSON(const SymbolInformation &P) {
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
701 llvm::json::Object O{
150
anatofuz
parents:
diff changeset
702 {"name", P.name},
anatofuz
parents:
diff changeset
703 {"kind", static_cast<int>(P.kind)},
anatofuz
parents:
diff changeset
704 {"location", P.location},
anatofuz
parents:
diff changeset
705 {"containerName", P.containerName},
anatofuz
parents:
diff changeset
706 };
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
707 if (P.score)
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
708 O["score"] = *P.score;
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
709 return std::move(O);
150
anatofuz
parents:
diff changeset
710 }
anatofuz
parents:
diff changeset
711
anatofuz
parents:
diff changeset
712 llvm::raw_ostream &operator<<(llvm::raw_ostream &O,
anatofuz
parents:
diff changeset
713 const SymbolInformation &SI) {
anatofuz
parents:
diff changeset
714 O << SI.containerName << "::" << SI.name << " - " << toJSON(SI);
anatofuz
parents:
diff changeset
715 return O;
anatofuz
parents:
diff changeset
716 }
anatofuz
parents:
diff changeset
717
anatofuz
parents:
diff changeset
718 bool operator==(const SymbolDetails &LHS, const SymbolDetails &RHS) {
anatofuz
parents:
diff changeset
719 return LHS.name == RHS.name && LHS.containerName == RHS.containerName &&
anatofuz
parents:
diff changeset
720 LHS.USR == RHS.USR && LHS.ID == RHS.ID;
anatofuz
parents:
diff changeset
721 }
anatofuz
parents:
diff changeset
722
anatofuz
parents:
diff changeset
723 llvm::json::Value toJSON(const SymbolDetails &P) {
anatofuz
parents:
diff changeset
724 llvm::json::Object Result{{"name", llvm::json::Value(nullptr)},
anatofuz
parents:
diff changeset
725 {"containerName", llvm::json::Value(nullptr)},
anatofuz
parents:
diff changeset
726 {"usr", llvm::json::Value(nullptr)},
anatofuz
parents:
diff changeset
727 {"id", llvm::json::Value(nullptr)}};
anatofuz
parents:
diff changeset
728
anatofuz
parents:
diff changeset
729 if (!P.name.empty())
anatofuz
parents:
diff changeset
730 Result["name"] = P.name;
anatofuz
parents:
diff changeset
731
anatofuz
parents:
diff changeset
732 if (!P.containerName.empty())
anatofuz
parents:
diff changeset
733 Result["containerName"] = P.containerName;
anatofuz
parents:
diff changeset
734
anatofuz
parents:
diff changeset
735 if (!P.USR.empty())
anatofuz
parents:
diff changeset
736 Result["usr"] = P.USR;
anatofuz
parents:
diff changeset
737
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
738 if (P.ID)
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
739 Result["id"] = P.ID.str();
150
anatofuz
parents:
diff changeset
740
173
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
741 // FIXME: workaround for older gcc/clang
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
742 return std::move(Result);
150
anatofuz
parents:
diff changeset
743 }
anatofuz
parents:
diff changeset
744
anatofuz
parents:
diff changeset
745 llvm::raw_ostream &operator<<(llvm::raw_ostream &O, const SymbolDetails &S) {
anatofuz
parents:
diff changeset
746 if (!S.containerName.empty()) {
anatofuz
parents:
diff changeset
747 O << S.containerName;
anatofuz
parents:
diff changeset
748 llvm::StringRef ContNameRef;
anatofuz
parents:
diff changeset
749 if (!ContNameRef.endswith("::")) {
anatofuz
parents:
diff changeset
750 O << " ";
anatofuz
parents:
diff changeset
751 }
anatofuz
parents:
diff changeset
752 }
anatofuz
parents:
diff changeset
753 O << S.name << " - " << toJSON(S);
anatofuz
parents:
diff changeset
754 return O;
anatofuz
parents:
diff changeset
755 }
anatofuz
parents:
diff changeset
756
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
757 bool fromJSON(const llvm::json::Value &Params, WorkspaceSymbolParams &R,
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
758 llvm::json::Path P) {
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
759 llvm::json::ObjectMapper O(Params, P);
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
760 return O && O.map("query", R.query) &&
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
761 mapOptOrNull(Params, "limit", R.limit, P);
150
anatofuz
parents:
diff changeset
762 }
anatofuz
parents:
diff changeset
763
anatofuz
parents:
diff changeset
764 llvm::json::Value toJSON(const Command &C) {
anatofuz
parents:
diff changeset
765 auto Cmd = llvm::json::Object{{"title", C.title}, {"command", C.command}};
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
766 if (!C.argument.getAsNull())
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
767 Cmd["arguments"] = llvm::json::Array{C.argument};
150
anatofuz
parents:
diff changeset
768 return std::move(Cmd);
anatofuz
parents:
diff changeset
769 }
anatofuz
parents:
diff changeset
770
anatofuz
parents:
diff changeset
771 const llvm::StringLiteral CodeAction::QUICKFIX_KIND = "quickfix";
anatofuz
parents:
diff changeset
772 const llvm::StringLiteral CodeAction::REFACTOR_KIND = "refactor";
anatofuz
parents:
diff changeset
773 const llvm::StringLiteral CodeAction::INFO_KIND = "info";
anatofuz
parents:
diff changeset
774
anatofuz
parents:
diff changeset
775 llvm::json::Value toJSON(const CodeAction &CA) {
anatofuz
parents:
diff changeset
776 auto CodeAction = llvm::json::Object{{"title", CA.title}};
anatofuz
parents:
diff changeset
777 if (CA.kind)
anatofuz
parents:
diff changeset
778 CodeAction["kind"] = *CA.kind;
anatofuz
parents:
diff changeset
779 if (CA.diagnostics)
anatofuz
parents:
diff changeset
780 CodeAction["diagnostics"] = llvm::json::Array(*CA.diagnostics);
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
781 if (CA.isPreferred)
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
782 CodeAction["isPreferred"] = true;
150
anatofuz
parents:
diff changeset
783 if (CA.edit)
anatofuz
parents:
diff changeset
784 CodeAction["edit"] = *CA.edit;
anatofuz
parents:
diff changeset
785 if (CA.command)
anatofuz
parents:
diff changeset
786 CodeAction["command"] = *CA.command;
anatofuz
parents:
diff changeset
787 return std::move(CodeAction);
anatofuz
parents:
diff changeset
788 }
anatofuz
parents:
diff changeset
789
anatofuz
parents:
diff changeset
790 llvm::raw_ostream &operator<<(llvm::raw_ostream &O, const DocumentSymbol &S) {
anatofuz
parents:
diff changeset
791 return O << S.name << " - " << toJSON(S);
anatofuz
parents:
diff changeset
792 }
anatofuz
parents:
diff changeset
793
anatofuz
parents:
diff changeset
794 llvm::json::Value toJSON(const DocumentSymbol &S) {
anatofuz
parents:
diff changeset
795 llvm::json::Object Result{{"name", S.name},
anatofuz
parents:
diff changeset
796 {"kind", static_cast<int>(S.kind)},
anatofuz
parents:
diff changeset
797 {"range", S.range},
anatofuz
parents:
diff changeset
798 {"selectionRange", S.selectionRange}};
anatofuz
parents:
diff changeset
799
anatofuz
parents:
diff changeset
800 if (!S.detail.empty())
anatofuz
parents:
diff changeset
801 Result["detail"] = S.detail;
anatofuz
parents:
diff changeset
802 if (!S.children.empty())
anatofuz
parents:
diff changeset
803 Result["children"] = S.children;
anatofuz
parents:
diff changeset
804 if (S.deprecated)
anatofuz
parents:
diff changeset
805 Result["deprecated"] = true;
173
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
806 // FIXME: workaround for older gcc/clang
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
807 return std::move(Result);
150
anatofuz
parents:
diff changeset
808 }
anatofuz
parents:
diff changeset
809
anatofuz
parents:
diff changeset
810 llvm::json::Value toJSON(const WorkspaceEdit &WE) {
anatofuz
parents:
diff changeset
811 llvm::json::Object FileChanges;
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
812 for (auto &Change : WE.changes)
150
anatofuz
parents:
diff changeset
813 FileChanges[Change.first] = llvm::json::Array(Change.second);
anatofuz
parents:
diff changeset
814 return llvm::json::Object{{"changes", std::move(FileChanges)}};
anatofuz
parents:
diff changeset
815 }
anatofuz
parents:
diff changeset
816
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
817 bool fromJSON(const llvm::json::Value &Params, TweakArgs &A,
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
818 llvm::json::Path P) {
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
819 llvm::json::ObjectMapper O(Params, P);
150
anatofuz
parents:
diff changeset
820 return O && O.map("file", A.file) && O.map("selection", A.selection) &&
anatofuz
parents:
diff changeset
821 O.map("tweakID", A.tweakID);
anatofuz
parents:
diff changeset
822 }
anatofuz
parents:
diff changeset
823
anatofuz
parents:
diff changeset
824 llvm::json::Value toJSON(const TweakArgs &A) {
anatofuz
parents:
diff changeset
825 return llvm::json::Object{
anatofuz
parents:
diff changeset
826 {"tweakID", A.tweakID}, {"selection", A.selection}, {"file", A.file}};
anatofuz
parents:
diff changeset
827 }
anatofuz
parents:
diff changeset
828
anatofuz
parents:
diff changeset
829 llvm::json::Value toJSON(const ApplyWorkspaceEditParams &Params) {
anatofuz
parents:
diff changeset
830 return llvm::json::Object{{"edit", Params.edit}};
anatofuz
parents:
diff changeset
831 }
anatofuz
parents:
diff changeset
832
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
833 bool fromJSON(const llvm::json::Value &Response, ApplyWorkspaceEditResponse &R,
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
834 llvm::json::Path P) {
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
835 llvm::json::ObjectMapper O(Response, P);
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
836 return O && O.map("applied", R.applied) &&
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
837 O.map("failureReason", R.failureReason);
150
anatofuz
parents:
diff changeset
838 }
anatofuz
parents:
diff changeset
839
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
840 bool fromJSON(const llvm::json::Value &Params, TextDocumentPositionParams &R,
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
841 llvm::json::Path P) {
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
842 llvm::json::ObjectMapper O(Params, P);
150
anatofuz
parents:
diff changeset
843 return O && O.map("textDocument", R.textDocument) &&
anatofuz
parents:
diff changeset
844 O.map("position", R.position);
anatofuz
parents:
diff changeset
845 }
anatofuz
parents:
diff changeset
846
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
847 bool fromJSON(const llvm::json::Value &Params, CompletionContext &R,
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
848 llvm::json::Path P) {
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
849 llvm::json::ObjectMapper O(Params, P);
150
anatofuz
parents:
diff changeset
850 int TriggerKind;
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
851 if (!O || !O.map("triggerKind", TriggerKind) ||
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
852 !mapOptOrNull(Params, "triggerCharacter", R.triggerCharacter, P))
150
anatofuz
parents:
diff changeset
853 return false;
anatofuz
parents:
diff changeset
854 R.triggerKind = static_cast<CompletionTriggerKind>(TriggerKind);
anatofuz
parents:
diff changeset
855 return true;
anatofuz
parents:
diff changeset
856 }
anatofuz
parents:
diff changeset
857
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
858 bool fromJSON(const llvm::json::Value &Params, CompletionParams &R,
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
859 llvm::json::Path P) {
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
860 if (!fromJSON(Params, static_cast<TextDocumentPositionParams &>(R), P) ||
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
861 !mapOptOrNull(Params, "limit", R.limit, P))
150
anatofuz
parents:
diff changeset
862 return false;
anatofuz
parents:
diff changeset
863 if (auto *Context = Params.getAsObject()->get("context"))
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
864 return fromJSON(*Context, R.context, P.field("context"));
150
anatofuz
parents:
diff changeset
865 return true;
anatofuz
parents:
diff changeset
866 }
anatofuz
parents:
diff changeset
867
anatofuz
parents:
diff changeset
868 static llvm::StringRef toTextKind(MarkupKind Kind) {
anatofuz
parents:
diff changeset
869 switch (Kind) {
anatofuz
parents:
diff changeset
870 case MarkupKind::PlainText:
anatofuz
parents:
diff changeset
871 return "plaintext";
anatofuz
parents:
diff changeset
872 case MarkupKind::Markdown:
anatofuz
parents:
diff changeset
873 return "markdown";
anatofuz
parents:
diff changeset
874 }
anatofuz
parents:
diff changeset
875 llvm_unreachable("Invalid MarkupKind");
anatofuz
parents:
diff changeset
876 }
anatofuz
parents:
diff changeset
877
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
878 bool fromJSON(const llvm::json::Value &V, MarkupKind &K, llvm::json::Path P) {
150
anatofuz
parents:
diff changeset
879 auto Str = V.getAsString();
anatofuz
parents:
diff changeset
880 if (!Str) {
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
881 P.report("expected string");
150
anatofuz
parents:
diff changeset
882 return false;
anatofuz
parents:
diff changeset
883 }
anatofuz
parents:
diff changeset
884 if (*Str == "plaintext")
anatofuz
parents:
diff changeset
885 K = MarkupKind::PlainText;
anatofuz
parents:
diff changeset
886 else if (*Str == "markdown")
anatofuz
parents:
diff changeset
887 K = MarkupKind::Markdown;
anatofuz
parents:
diff changeset
888 else {
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
889 P.report("unknown markup kind");
150
anatofuz
parents:
diff changeset
890 return false;
anatofuz
parents:
diff changeset
891 }
anatofuz
parents:
diff changeset
892 return true;
anatofuz
parents:
diff changeset
893 }
anatofuz
parents:
diff changeset
894
anatofuz
parents:
diff changeset
895 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, MarkupKind K) {
anatofuz
parents:
diff changeset
896 return OS << toTextKind(K);
anatofuz
parents:
diff changeset
897 }
anatofuz
parents:
diff changeset
898
anatofuz
parents:
diff changeset
899 llvm::json::Value toJSON(const MarkupContent &MC) {
anatofuz
parents:
diff changeset
900 if (MC.value.empty())
anatofuz
parents:
diff changeset
901 return nullptr;
anatofuz
parents:
diff changeset
902
anatofuz
parents:
diff changeset
903 return llvm::json::Object{
anatofuz
parents:
diff changeset
904 {"kind", toTextKind(MC.kind)},
anatofuz
parents:
diff changeset
905 {"value", MC.value},
anatofuz
parents:
diff changeset
906 };
anatofuz
parents:
diff changeset
907 }
anatofuz
parents:
diff changeset
908
anatofuz
parents:
diff changeset
909 llvm::json::Value toJSON(const Hover &H) {
anatofuz
parents:
diff changeset
910 llvm::json::Object Result{{"contents", toJSON(H.contents)}};
anatofuz
parents:
diff changeset
911
anatofuz
parents:
diff changeset
912 if (H.range.hasValue())
anatofuz
parents:
diff changeset
913 Result["range"] = toJSON(*H.range);
anatofuz
parents:
diff changeset
914
anatofuz
parents:
diff changeset
915 return std::move(Result);
anatofuz
parents:
diff changeset
916 }
anatofuz
parents:
diff changeset
917
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
918 bool fromJSON(const llvm::json::Value &E, CompletionItemKind &Out,
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
919 llvm::json::Path P) {
150
anatofuz
parents:
diff changeset
920 if (auto T = E.getAsInteger()) {
anatofuz
parents:
diff changeset
921 if (*T < static_cast<int>(CompletionItemKind::Text) ||
anatofuz
parents:
diff changeset
922 *T > static_cast<int>(CompletionItemKind::TypeParameter))
anatofuz
parents:
diff changeset
923 return false;
anatofuz
parents:
diff changeset
924 Out = static_cast<CompletionItemKind>(*T);
anatofuz
parents:
diff changeset
925 return true;
anatofuz
parents:
diff changeset
926 }
anatofuz
parents:
diff changeset
927 return false;
anatofuz
parents:
diff changeset
928 }
anatofuz
parents:
diff changeset
929
anatofuz
parents:
diff changeset
930 CompletionItemKind
anatofuz
parents:
diff changeset
931 adjustKindToCapability(CompletionItemKind Kind,
anatofuz
parents:
diff changeset
932 CompletionItemKindBitset &SupportedCompletionItemKinds) {
anatofuz
parents:
diff changeset
933 auto KindVal = static_cast<size_t>(Kind);
anatofuz
parents:
diff changeset
934 if (KindVal >= CompletionItemKindMin &&
anatofuz
parents:
diff changeset
935 KindVal <= SupportedCompletionItemKinds.size() &&
anatofuz
parents:
diff changeset
936 SupportedCompletionItemKinds[KindVal])
anatofuz
parents:
diff changeset
937 return Kind;
anatofuz
parents:
diff changeset
938
anatofuz
parents:
diff changeset
939 switch (Kind) {
anatofuz
parents:
diff changeset
940 // Provide some fall backs for common kinds that are close enough.
anatofuz
parents:
diff changeset
941 case CompletionItemKind::Folder:
anatofuz
parents:
diff changeset
942 return CompletionItemKind::File;
anatofuz
parents:
diff changeset
943 case CompletionItemKind::EnumMember:
anatofuz
parents:
diff changeset
944 return CompletionItemKind::Enum;
anatofuz
parents:
diff changeset
945 case CompletionItemKind::Struct:
anatofuz
parents:
diff changeset
946 return CompletionItemKind::Class;
anatofuz
parents:
diff changeset
947 default:
anatofuz
parents:
diff changeset
948 return CompletionItemKind::Text;
anatofuz
parents:
diff changeset
949 }
anatofuz
parents:
diff changeset
950 }
anatofuz
parents:
diff changeset
951
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
952 bool fromJSON(const llvm::json::Value &E, CompletionItemKindBitset &Out,
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
953 llvm::json::Path P) {
150
anatofuz
parents:
diff changeset
954 if (auto *A = E.getAsArray()) {
anatofuz
parents:
diff changeset
955 for (size_t I = 0; I < A->size(); ++I) {
anatofuz
parents:
diff changeset
956 CompletionItemKind KindOut;
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
957 if (fromJSON((*A)[I], KindOut, P.index(I)))
150
anatofuz
parents:
diff changeset
958 Out.set(size_t(KindOut));
anatofuz
parents:
diff changeset
959 }
anatofuz
parents:
diff changeset
960 return true;
anatofuz
parents:
diff changeset
961 }
anatofuz
parents:
diff changeset
962 return false;
anatofuz
parents:
diff changeset
963 }
anatofuz
parents:
diff changeset
964
anatofuz
parents:
diff changeset
965 llvm::json::Value toJSON(const CompletionItem &CI) {
anatofuz
parents:
diff changeset
966 assert(!CI.label.empty() && "completion item label is required");
anatofuz
parents:
diff changeset
967 llvm::json::Object Result{{"label", CI.label}};
anatofuz
parents:
diff changeset
968 if (CI.kind != CompletionItemKind::Missing)
anatofuz
parents:
diff changeset
969 Result["kind"] = static_cast<int>(CI.kind);
anatofuz
parents:
diff changeset
970 if (!CI.detail.empty())
anatofuz
parents:
diff changeset
971 Result["detail"] = CI.detail;
173
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
972 if (CI.documentation)
150
anatofuz
parents:
diff changeset
973 Result["documentation"] = CI.documentation;
anatofuz
parents:
diff changeset
974 if (!CI.sortText.empty())
anatofuz
parents:
diff changeset
975 Result["sortText"] = CI.sortText;
anatofuz
parents:
diff changeset
976 if (!CI.filterText.empty())
anatofuz
parents:
diff changeset
977 Result["filterText"] = CI.filterText;
anatofuz
parents:
diff changeset
978 if (!CI.insertText.empty())
anatofuz
parents:
diff changeset
979 Result["insertText"] = CI.insertText;
anatofuz
parents:
diff changeset
980 if (CI.insertTextFormat != InsertTextFormat::Missing)
anatofuz
parents:
diff changeset
981 Result["insertTextFormat"] = static_cast<int>(CI.insertTextFormat);
anatofuz
parents:
diff changeset
982 if (CI.textEdit)
anatofuz
parents:
diff changeset
983 Result["textEdit"] = *CI.textEdit;
anatofuz
parents:
diff changeset
984 if (!CI.additionalTextEdits.empty())
anatofuz
parents:
diff changeset
985 Result["additionalTextEdits"] = llvm::json::Array(CI.additionalTextEdits);
anatofuz
parents:
diff changeset
986 if (CI.deprecated)
anatofuz
parents:
diff changeset
987 Result["deprecated"] = CI.deprecated;
173
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
988 Result["score"] = CI.score;
150
anatofuz
parents:
diff changeset
989 return std::move(Result);
anatofuz
parents:
diff changeset
990 }
anatofuz
parents:
diff changeset
991
anatofuz
parents:
diff changeset
992 llvm::raw_ostream &operator<<(llvm::raw_ostream &O, const CompletionItem &I) {
anatofuz
parents:
diff changeset
993 O << I.label << " - " << toJSON(I);
anatofuz
parents:
diff changeset
994 return O;
anatofuz
parents:
diff changeset
995 }
anatofuz
parents:
diff changeset
996
anatofuz
parents:
diff changeset
997 bool operator<(const CompletionItem &L, const CompletionItem &R) {
anatofuz
parents:
diff changeset
998 return (L.sortText.empty() ? L.label : L.sortText) <
anatofuz
parents:
diff changeset
999 (R.sortText.empty() ? R.label : R.sortText);
anatofuz
parents:
diff changeset
1000 }
anatofuz
parents:
diff changeset
1001
anatofuz
parents:
diff changeset
1002 llvm::json::Value toJSON(const CompletionList &L) {
anatofuz
parents:
diff changeset
1003 return llvm::json::Object{
anatofuz
parents:
diff changeset
1004 {"isIncomplete", L.isIncomplete},
anatofuz
parents:
diff changeset
1005 {"items", llvm::json::Array(L.items)},
anatofuz
parents:
diff changeset
1006 };
anatofuz
parents:
diff changeset
1007 }
anatofuz
parents:
diff changeset
1008
anatofuz
parents:
diff changeset
1009 llvm::json::Value toJSON(const ParameterInformation &PI) {
anatofuz
parents:
diff changeset
1010 assert((PI.labelOffsets.hasValue() || !PI.labelString.empty()) &&
anatofuz
parents:
diff changeset
1011 "parameter information label is required");
anatofuz
parents:
diff changeset
1012 llvm::json::Object Result;
anatofuz
parents:
diff changeset
1013 if (PI.labelOffsets)
anatofuz
parents:
diff changeset
1014 Result["label"] =
anatofuz
parents:
diff changeset
1015 llvm::json::Array({PI.labelOffsets->first, PI.labelOffsets->second});
anatofuz
parents:
diff changeset
1016 else
anatofuz
parents:
diff changeset
1017 Result["label"] = PI.labelString;
anatofuz
parents:
diff changeset
1018 if (!PI.documentation.empty())
anatofuz
parents:
diff changeset
1019 Result["documentation"] = PI.documentation;
anatofuz
parents:
diff changeset
1020 return std::move(Result);
anatofuz
parents:
diff changeset
1021 }
anatofuz
parents:
diff changeset
1022
anatofuz
parents:
diff changeset
1023 llvm::json::Value toJSON(const SignatureInformation &SI) {
anatofuz
parents:
diff changeset
1024 assert(!SI.label.empty() && "signature information label is required");
anatofuz
parents:
diff changeset
1025 llvm::json::Object Result{
anatofuz
parents:
diff changeset
1026 {"label", SI.label},
anatofuz
parents:
diff changeset
1027 {"parameters", llvm::json::Array(SI.parameters)},
anatofuz
parents:
diff changeset
1028 };
anatofuz
parents:
diff changeset
1029 if (!SI.documentation.empty())
anatofuz
parents:
diff changeset
1030 Result["documentation"] = SI.documentation;
anatofuz
parents:
diff changeset
1031 return std::move(Result);
anatofuz
parents:
diff changeset
1032 }
anatofuz
parents:
diff changeset
1033
anatofuz
parents:
diff changeset
1034 llvm::raw_ostream &operator<<(llvm::raw_ostream &O,
anatofuz
parents:
diff changeset
1035 const SignatureInformation &I) {
anatofuz
parents:
diff changeset
1036 O << I.label << " - " << toJSON(I);
anatofuz
parents:
diff changeset
1037 return O;
anatofuz
parents:
diff changeset
1038 }
anatofuz
parents:
diff changeset
1039
anatofuz
parents:
diff changeset
1040 llvm::json::Value toJSON(const SignatureHelp &SH) {
anatofuz
parents:
diff changeset
1041 assert(SH.activeSignature >= 0 &&
anatofuz
parents:
diff changeset
1042 "Unexpected negative value for number of active signatures.");
anatofuz
parents:
diff changeset
1043 assert(SH.activeParameter >= 0 &&
anatofuz
parents:
diff changeset
1044 "Unexpected negative value for active parameter index");
anatofuz
parents:
diff changeset
1045 return llvm::json::Object{
anatofuz
parents:
diff changeset
1046 {"activeSignature", SH.activeSignature},
anatofuz
parents:
diff changeset
1047 {"activeParameter", SH.activeParameter},
anatofuz
parents:
diff changeset
1048 {"signatures", llvm::json::Array(SH.signatures)},
anatofuz
parents:
diff changeset
1049 };
anatofuz
parents:
diff changeset
1050 }
anatofuz
parents:
diff changeset
1051
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1052 bool fromJSON(const llvm::json::Value &Params, RenameParams &R,
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1053 llvm::json::Path P) {
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1054 llvm::json::ObjectMapper O(Params, P);
150
anatofuz
parents:
diff changeset
1055 return O && O.map("textDocument", R.textDocument) &&
anatofuz
parents:
diff changeset
1056 O.map("position", R.position) && O.map("newName", R.newName);
anatofuz
parents:
diff changeset
1057 }
anatofuz
parents:
diff changeset
1058
anatofuz
parents:
diff changeset
1059 llvm::json::Value toJSON(const DocumentHighlight &DH) {
anatofuz
parents:
diff changeset
1060 return llvm::json::Object{
anatofuz
parents:
diff changeset
1061 {"range", toJSON(DH.range)},
anatofuz
parents:
diff changeset
1062 {"kind", static_cast<int>(DH.kind)},
anatofuz
parents:
diff changeset
1063 };
anatofuz
parents:
diff changeset
1064 }
anatofuz
parents:
diff changeset
1065
anatofuz
parents:
diff changeset
1066 llvm::json::Value toJSON(const FileStatus &FStatus) {
anatofuz
parents:
diff changeset
1067 return llvm::json::Object{
anatofuz
parents:
diff changeset
1068 {"uri", FStatus.uri},
anatofuz
parents:
diff changeset
1069 {"state", FStatus.state},
anatofuz
parents:
diff changeset
1070 };
anatofuz
parents:
diff changeset
1071 }
anatofuz
parents:
diff changeset
1072
173
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
1073 constexpr unsigned SemanticTokenEncodingSize = 5;
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
1074 static llvm::json::Value encodeTokens(llvm::ArrayRef<SemanticToken> Toks) {
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
1075 llvm::json::Array Result;
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1076 Result.reserve(SemanticTokenEncodingSize * Toks.size());
173
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
1077 for (const auto &Tok : Toks) {
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
1078 Result.push_back(Tok.deltaLine);
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
1079 Result.push_back(Tok.deltaStart);
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
1080 Result.push_back(Tok.length);
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
1081 Result.push_back(Tok.tokenType);
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
1082 Result.push_back(Tok.tokenModifiers);
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
1083 }
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
1084 assert(Result.size() == SemanticTokenEncodingSize * Toks.size());
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
1085 return std::move(Result);
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
1086 }
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
1087
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
1088 bool operator==(const SemanticToken &L, const SemanticToken &R) {
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
1089 return std::tie(L.deltaLine, L.deltaStart, L.length, L.tokenType,
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
1090 L.tokenModifiers) == std::tie(R.deltaLine, R.deltaStart,
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
1091 R.length, R.tokenType,
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
1092 R.tokenModifiers);
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
1093 }
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
1094
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
1095 llvm::json::Value toJSON(const SemanticTokens &Tokens) {
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
1096 return llvm::json::Object{{"resultId", Tokens.resultId},
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
1097 {"data", encodeTokens(Tokens.tokens)}};
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
1098 }
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
1099
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
1100 llvm::json::Value toJSON(const SemanticTokensEdit &Edit) {
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
1101 return llvm::json::Object{
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
1102 {"start", SemanticTokenEncodingSize * Edit.startToken},
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
1103 {"deleteCount", SemanticTokenEncodingSize * Edit.deleteTokens},
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
1104 {"data", encodeTokens(Edit.tokens)}};
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
1105 }
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
1106
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1107 llvm::json::Value toJSON(const SemanticTokensOrDelta &TE) {
173
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
1108 llvm::json::Object Result{{"resultId", TE.resultId}};
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
1109 if (TE.edits)
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
1110 Result["edits"] = *TE.edits;
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
1111 if (TE.tokens)
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
1112 Result["data"] = encodeTokens(*TE.tokens);
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
1113 return std::move(Result);
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
1114 }
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
1115
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1116 bool fromJSON(const llvm::json::Value &Params, SemanticTokensParams &R,
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1117 llvm::json::Path P) {
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1118 llvm::json::ObjectMapper O(Params, P);
173
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
1119 return O && O.map("textDocument", R.textDocument);
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
1120 }
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
1121
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1122 bool fromJSON(const llvm::json::Value &Params, SemanticTokensDeltaParams &R,
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1123 llvm::json::Path P) {
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1124 llvm::json::ObjectMapper O(Params, P);
173
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
1125 return O && O.map("textDocument", R.textDocument) &&
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
1126 O.map("previousResultId", R.previousResultId);
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
1127 }
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
1128
150
anatofuz
parents:
diff changeset
1129 llvm::raw_ostream &operator<<(llvm::raw_ostream &O,
anatofuz
parents:
diff changeset
1130 const DocumentHighlight &V) {
anatofuz
parents:
diff changeset
1131 O << V.range;
anatofuz
parents:
diff changeset
1132 if (V.kind == DocumentHighlightKind::Read)
anatofuz
parents:
diff changeset
1133 O << "(r)";
anatofuz
parents:
diff changeset
1134 if (V.kind == DocumentHighlightKind::Write)
anatofuz
parents:
diff changeset
1135 O << "(w)";
anatofuz
parents:
diff changeset
1136 return O;
anatofuz
parents:
diff changeset
1137 }
anatofuz
parents:
diff changeset
1138
anatofuz
parents:
diff changeset
1139 bool fromJSON(const llvm::json::Value &Params,
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1140 DidChangeConfigurationParams &CCP, llvm::json::Path P) {
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1141 llvm::json::ObjectMapper O(Params, P);
150
anatofuz
parents:
diff changeset
1142 return O && O.map("settings", CCP.settings);
anatofuz
parents:
diff changeset
1143 }
anatofuz
parents:
diff changeset
1144
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1145 bool fromJSON(const llvm::json::Value &Params, ClangdCompileCommand &CDbUpdate,
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1146 llvm::json::Path P) {
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1147 llvm::json::ObjectMapper O(Params, P);
150
anatofuz
parents:
diff changeset
1148 return O && O.map("workingDirectory", CDbUpdate.workingDirectory) &&
anatofuz
parents:
diff changeset
1149 O.map("compilationCommand", CDbUpdate.compilationCommand);
anatofuz
parents:
diff changeset
1150 }
anatofuz
parents:
diff changeset
1151
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1152 bool fromJSON(const llvm::json::Value &Params, ConfigurationSettings &S,
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1153 llvm::json::Path P) {
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1154 llvm::json::ObjectMapper O(Params, P);
150
anatofuz
parents:
diff changeset
1155 if (!O)
anatofuz
parents:
diff changeset
1156 return true; // 'any' type in LSP.
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1157 return mapOptOrNull(Params, "compilationDatabaseChanges",
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1158 S.compilationDatabaseChanges, P);
150
anatofuz
parents:
diff changeset
1159 }
anatofuz
parents:
diff changeset
1160
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1161 bool fromJSON(const llvm::json::Value &Params, InitializationOptions &Opts,
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1162 llvm::json::Path P) {
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1163 llvm::json::ObjectMapper O(Params, P);
150
anatofuz
parents:
diff changeset
1164 if (!O)
anatofuz
parents:
diff changeset
1165 return true; // 'any' type in LSP.
anatofuz
parents:
diff changeset
1166
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1167 return fromJSON(Params, Opts.ConfigSettings, P) &&
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1168 O.map("compilationDatabasePath", Opts.compilationDatabasePath) &&
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1169 mapOptOrNull(Params, "fallbackFlags", Opts.fallbackFlags, P) &&
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1170 mapOptOrNull(Params, "clangdFileStatus", Opts.FileStatus, P);
150
anatofuz
parents:
diff changeset
1171 }
anatofuz
parents:
diff changeset
1172
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1173 bool fromJSON(const llvm::json::Value &E, TypeHierarchyDirection &Out,
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1174 llvm::json::Path P) {
150
anatofuz
parents:
diff changeset
1175 auto T = E.getAsInteger();
anatofuz
parents:
diff changeset
1176 if (!T)
anatofuz
parents:
diff changeset
1177 return false;
anatofuz
parents:
diff changeset
1178 if (*T < static_cast<int>(TypeHierarchyDirection::Children) ||
anatofuz
parents:
diff changeset
1179 *T > static_cast<int>(TypeHierarchyDirection::Both))
anatofuz
parents:
diff changeset
1180 return false;
anatofuz
parents:
diff changeset
1181 Out = static_cast<TypeHierarchyDirection>(*T);
anatofuz
parents:
diff changeset
1182 return true;
anatofuz
parents:
diff changeset
1183 }
anatofuz
parents:
diff changeset
1184
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1185 bool fromJSON(const llvm::json::Value &Params, TypeHierarchyParams &R,
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1186 llvm::json::Path P) {
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1187 llvm::json::ObjectMapper O(Params, P);
150
anatofuz
parents:
diff changeset
1188 return O && O.map("textDocument", R.textDocument) &&
anatofuz
parents:
diff changeset
1189 O.map("position", R.position) && O.map("resolve", R.resolve) &&
anatofuz
parents:
diff changeset
1190 O.map("direction", R.direction);
anatofuz
parents:
diff changeset
1191 }
anatofuz
parents:
diff changeset
1192
anatofuz
parents:
diff changeset
1193 llvm::raw_ostream &operator<<(llvm::raw_ostream &O,
anatofuz
parents:
diff changeset
1194 const TypeHierarchyItem &I) {
anatofuz
parents:
diff changeset
1195 return O << I.name << " - " << toJSON(I);
anatofuz
parents:
diff changeset
1196 }
anatofuz
parents:
diff changeset
1197
anatofuz
parents:
diff changeset
1198 llvm::json::Value toJSON(const TypeHierarchyItem &I) {
anatofuz
parents:
diff changeset
1199 llvm::json::Object Result{{"name", I.name},
anatofuz
parents:
diff changeset
1200 {"kind", static_cast<int>(I.kind)},
anatofuz
parents:
diff changeset
1201 {"range", I.range},
anatofuz
parents:
diff changeset
1202 {"selectionRange", I.selectionRange},
anatofuz
parents:
diff changeset
1203 {"uri", I.uri}};
anatofuz
parents:
diff changeset
1204
anatofuz
parents:
diff changeset
1205 if (I.detail)
anatofuz
parents:
diff changeset
1206 Result["detail"] = I.detail;
anatofuz
parents:
diff changeset
1207 if (I.deprecated)
anatofuz
parents:
diff changeset
1208 Result["deprecated"] = I.deprecated;
anatofuz
parents:
diff changeset
1209 if (I.parents)
anatofuz
parents:
diff changeset
1210 Result["parents"] = I.parents;
anatofuz
parents:
diff changeset
1211 if (I.children)
anatofuz
parents:
diff changeset
1212 Result["children"] = I.children;
anatofuz
parents:
diff changeset
1213 if (I.data)
anatofuz
parents:
diff changeset
1214 Result["data"] = I.data;
anatofuz
parents:
diff changeset
1215 return std::move(Result);
anatofuz
parents:
diff changeset
1216 }
anatofuz
parents:
diff changeset
1217
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1218 bool fromJSON(const llvm::json::Value &Params, TypeHierarchyItem &I,
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1219 llvm::json::Path P) {
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1220 llvm::json::ObjectMapper O(Params, P);
150
anatofuz
parents:
diff changeset
1221
anatofuz
parents:
diff changeset
1222 // Required fields.
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1223 return O && O.map("name", I.name) && O.map("kind", I.kind) &&
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1224 O.map("uri", I.uri) && O.map("range", I.range) &&
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1225 O.map("selectionRange", I.selectionRange) &&
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1226 mapOptOrNull(Params, "detail", I.detail, P) &&
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1227 mapOptOrNull(Params, "deprecated", I.deprecated, P) &&
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1228 mapOptOrNull(Params, "parents", I.parents, P) &&
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1229 mapOptOrNull(Params, "children", I.children, P) &&
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1230 mapOptOrNull(Params, "data", I.data, P);
150
anatofuz
parents:
diff changeset
1231 }
anatofuz
parents:
diff changeset
1232
anatofuz
parents:
diff changeset
1233 bool fromJSON(const llvm::json::Value &Params,
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1234 ResolveTypeHierarchyItemParams &R, llvm::json::Path P) {
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1235 llvm::json::ObjectMapper O(Params, P);
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1236 return O && O.map("item", R.item) && O.map("resolve", R.resolve) &&
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1237 O.map("direction", R.direction);
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1238 }
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1239
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1240 bool fromJSON(const llvm::json::Value &Params, ReferenceContext &R,
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1241 llvm::json::Path P) {
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1242 llvm::json::ObjectMapper O(Params, P);
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1243 return O && O.mapOptional("includeDeclaration", R.includeDeclaration);
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1244 }
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1245
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1246 bool fromJSON(const llvm::json::Value &Params, ReferenceParams &R,
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1247 llvm::json::Path P) {
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1248 TextDocumentPositionParams &Base = R;
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1249 llvm::json::ObjectMapper O(Params, P);
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1250 return fromJSON(Params, Base, P) && O && O.mapOptional("context", R.context);
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1251 }
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1252
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1253 llvm::json::Value toJSON(SymbolTag Tag) {
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1254 return llvm::json::Value{static_cast<int>(Tag)};
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1255 }
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1256
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1257 llvm::json::Value toJSON(const CallHierarchyItem &I) {
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1258 llvm::json::Object Result{{"name", I.name},
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1259 {"kind", static_cast<int>(I.kind)},
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1260 {"range", I.range},
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1261 {"selectionRange", I.selectionRange},
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1262 {"uri", I.uri}};
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1263 if (!I.tags.empty())
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1264 Result["tags"] = I.tags;
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1265 if (!I.detail.empty())
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1266 Result["detail"] = I.detail;
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1267 if (!I.data.empty())
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1268 Result["data"] = I.data;
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1269 return std::move(Result);
150
anatofuz
parents:
diff changeset
1270 }
anatofuz
parents:
diff changeset
1271
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1272 bool fromJSON(const llvm::json::Value &Params, CallHierarchyItem &I,
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1273 llvm::json::Path P) {
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1274 llvm::json::ObjectMapper O(Params, P);
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1275
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1276 // Populate the required fields only. We don't care about the
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1277 // optional fields `Tags` and `Detail` for the purpose of
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1278 // client --> server communication.
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1279 return O && O.map("name", I.name) && O.map("kind", I.kind) &&
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1280 O.map("uri", I.uri) && O.map("range", I.range) &&
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1281 O.map("selectionRange", I.selectionRange) &&
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1282 mapOptOrNull(Params, "data", I.data, P);
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1283 }
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1284
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1285 bool fromJSON(const llvm::json::Value &Params,
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1286 CallHierarchyIncomingCallsParams &C, llvm::json::Path P) {
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1287 llvm::json::ObjectMapper O(Params, P);
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1288 return O.map("item", C.item);
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1289 }
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1290
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1291 llvm::json::Value toJSON(const CallHierarchyIncomingCall &C) {
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1292 return llvm::json::Object{{"from", C.from}, {"fromRanges", C.fromRanges}};
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1293 }
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1294
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1295 bool fromJSON(const llvm::json::Value &Params,
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1296 CallHierarchyOutgoingCallsParams &C, llvm::json::Path P) {
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1297 llvm::json::ObjectMapper O(Params, P);
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1298 return O.map("item", C.item);
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1299 }
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1300
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1301 llvm::json::Value toJSON(const CallHierarchyOutgoingCall &C) {
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1302 return llvm::json::Object{{"to", C.to}, {"fromRanges", C.fromRanges}};
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1303 }
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1304
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1305 bool fromJSON(const llvm::json::Value &Params, InlayHintsParams &R,
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1306 llvm::json::Path P) {
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1307 llvm::json::ObjectMapper O(Params, P);
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1308 return O && O.map("textDocument", R.textDocument);
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1309 }
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1310
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1311 llvm::json::Value toJSON(InlayHintKind K) {
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1312 switch (K) {
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1313 case InlayHintKind::ParameterHint:
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1314 return "parameter";
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1315 case InlayHintKind::TypeHint:
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1316 return "type";
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1317 }
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1318 llvm_unreachable("Unknown clang.clangd.InlayHintKind");
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1319 }
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1320
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1321 llvm::json::Value toJSON(const InlayHint &H) {
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1322 return llvm::json::Object{
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1323 {"range", H.range}, {"kind", H.kind}, {"label", H.label}};
150
anatofuz
parents:
diff changeset
1324 }
anatofuz
parents:
diff changeset
1325
anatofuz
parents:
diff changeset
1326 static const char *toString(OffsetEncoding OE) {
anatofuz
parents:
diff changeset
1327 switch (OE) {
anatofuz
parents:
diff changeset
1328 case OffsetEncoding::UTF8:
anatofuz
parents:
diff changeset
1329 return "utf-8";
anatofuz
parents:
diff changeset
1330 case OffsetEncoding::UTF16:
anatofuz
parents:
diff changeset
1331 return "utf-16";
anatofuz
parents:
diff changeset
1332 case OffsetEncoding::UTF32:
anatofuz
parents:
diff changeset
1333 return "utf-32";
anatofuz
parents:
diff changeset
1334 case OffsetEncoding::UnsupportedEncoding:
anatofuz
parents:
diff changeset
1335 return "unknown";
anatofuz
parents:
diff changeset
1336 }
anatofuz
parents:
diff changeset
1337 llvm_unreachable("Unknown clang.clangd.OffsetEncoding");
anatofuz
parents:
diff changeset
1338 }
anatofuz
parents:
diff changeset
1339 llvm::json::Value toJSON(const OffsetEncoding &OE) { return toString(OE); }
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1340 bool fromJSON(const llvm::json::Value &V, OffsetEncoding &OE,
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1341 llvm::json::Path P) {
150
anatofuz
parents:
diff changeset
1342 auto Str = V.getAsString();
anatofuz
parents:
diff changeset
1343 if (!Str)
anatofuz
parents:
diff changeset
1344 return false;
anatofuz
parents:
diff changeset
1345 OE = llvm::StringSwitch<OffsetEncoding>(*Str)
anatofuz
parents:
diff changeset
1346 .Case("utf-8", OffsetEncoding::UTF8)
anatofuz
parents:
diff changeset
1347 .Case("utf-16", OffsetEncoding::UTF16)
anatofuz
parents:
diff changeset
1348 .Case("utf-32", OffsetEncoding::UTF32)
anatofuz
parents:
diff changeset
1349 .Default(OffsetEncoding::UnsupportedEncoding);
anatofuz
parents:
diff changeset
1350 return true;
anatofuz
parents:
diff changeset
1351 }
anatofuz
parents:
diff changeset
1352 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, OffsetEncoding Enc) {
anatofuz
parents:
diff changeset
1353 return OS << toString(Enc);
anatofuz
parents:
diff changeset
1354 }
anatofuz
parents:
diff changeset
1355
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1356 bool fromJSON(const llvm::json::Value &Params, SelectionRangeParams &S,
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1357 llvm::json::Path P) {
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1358 llvm::json::ObjectMapper O(Params, P);
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1359 return O && O.map("textDocument", S.textDocument) &&
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1360 O.map("positions", S.positions);
150
anatofuz
parents:
diff changeset
1361 }
anatofuz
parents:
diff changeset
1362
anatofuz
parents:
diff changeset
1363 llvm::json::Value toJSON(const SelectionRange &Out) {
anatofuz
parents:
diff changeset
1364 if (Out.parent) {
anatofuz
parents:
diff changeset
1365 return llvm::json::Object{{"range", Out.range},
anatofuz
parents:
diff changeset
1366 {"parent", toJSON(*Out.parent)}};
anatofuz
parents:
diff changeset
1367 }
anatofuz
parents:
diff changeset
1368 return llvm::json::Object{{"range", Out.range}};
anatofuz
parents:
diff changeset
1369 }
anatofuz
parents:
diff changeset
1370
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1371 bool fromJSON(const llvm::json::Value &Params, DocumentLinkParams &R,
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1372 llvm::json::Path P) {
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1373 llvm::json::ObjectMapper O(Params, P);
150
anatofuz
parents:
diff changeset
1374 return O && O.map("textDocument", R.textDocument);
anatofuz
parents:
diff changeset
1375 }
anatofuz
parents:
diff changeset
1376
anatofuz
parents:
diff changeset
1377 llvm::json::Value toJSON(const DocumentLink &DocumentLink) {
anatofuz
parents:
diff changeset
1378 return llvm::json::Object{
anatofuz
parents:
diff changeset
1379 {"range", DocumentLink.range},
anatofuz
parents:
diff changeset
1380 {"target", DocumentLink.target},
anatofuz
parents:
diff changeset
1381 };
anatofuz
parents:
diff changeset
1382 }
anatofuz
parents:
diff changeset
1383
221
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1384 bool fromJSON(const llvm::json::Value &Params, FoldingRangeParams &R,
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1385 llvm::json::Path P) {
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1386 llvm::json::ObjectMapper O(Params, P);
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1387 return O && O.map("textDocument", R.textDocument);
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1388 }
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1389
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1390 llvm::json::Value toJSON(const FoldingRange &Range) {
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1391 llvm::json::Object Result{
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1392 {"startLine", Range.startLine},
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1393 {"endLine", Range.endLine},
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1394 };
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1395 if (Range.startCharacter)
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1396 Result["startCharacter"] = Range.startCharacter;
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1397 if (Range.endCharacter)
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1398 Result["endCharacter"] = Range.endCharacter;
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1399 if (Range.kind)
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1400 Result["kind"] = *Range.kind;
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1401 return Result;
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1402 }
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1403
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1404 llvm::json::Value toJSON(const MemoryTree &MT) {
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1405 llvm::json::Object Out;
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1406 int64_t Total = MT.self();
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1407 Out["_self"] = Total;
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1408 for (const auto &Entry : MT.children()) {
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1409 auto Child = toJSON(Entry.getSecond());
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1410 Total += *Child.getAsObject()->getInteger("_total");
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1411 Out[Entry.first] = std::move(Child);
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1412 }
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1413 Out["_total"] = Total;
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1414 return Out;
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1415 }
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1416
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1417 bool fromJSON(const llvm::json::Value &Params, ASTParams &R,
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1418 llvm::json::Path P) {
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1419 llvm::json::ObjectMapper O(Params, P);
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1420 return O && O.map("textDocument", R.textDocument) && O.map("range", R.range);
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1421 }
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1422
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1423 llvm::json::Value toJSON(const ASTNode &N) {
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1424 llvm::json::Object Result{
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1425 {"role", N.role},
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1426 {"kind", N.kind},
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1427 };
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1428 if (!N.children.empty())
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1429 Result["children"] = N.children;
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1430 if (!N.detail.empty())
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1431 Result["detail"] = N.detail;
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1432 if (!N.arcana.empty())
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1433 Result["arcana"] = N.arcana;
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1434 if (N.range)
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1435 Result["range"] = *N.range;
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1436 return Result;
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1437 }
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1438
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1439 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const ASTNode &Root) {
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1440 std::function<void(const ASTNode &, unsigned)> Print = [&](const ASTNode &N,
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1441 unsigned Level) {
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1442 OS.indent(2 * Level) << N.role << ": " << N.kind;
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1443 if (!N.detail.empty())
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1444 OS << " - " << N.detail;
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1445 OS << "\n";
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1446 for (const ASTNode &C : N.children)
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1447 Print(C, Level + 1);
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1448 };
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1449 Print(Root, 0);
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1450 return OS;
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1451 }
79ff65ed7e25 LLVM12 Original
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 173
diff changeset
1452
150
anatofuz
parents:
diff changeset
1453 } // namespace clangd
anatofuz
parents:
diff changeset
1454 } // namespace clang