yum-mirror/slang

Making it easier to work with shaders

git clone https://git.yummers.dev/yum-mirror/slang

Yong HeLanguageServer: Enhance auto completion for override. (#7465)4d517794e

master
branchesmasterall refs →
32.2 KiB817 linesraw
1#include "slang-language-server-protocol.h"
2
3namespace Slang
4{
5namespace LanguageServerProtocol
6{
7static const StructRttiInfo _makeTextDocumentSyncOptionsRtti()
8{
9    TextDocumentSyncOptions obj;
10    StructRttiBuilder builder(&obj, "LanguageServerProtocol::TextDocumentSyncOptions", nullptr);
11    builder.addField("change", &obj.change);
12    builder.addField("openClose", &obj.openClose);
13    builder.ignoreUnknownFields();
14    return builder.make();
15}
16const StructRttiInfo TextDocumentSyncOptions::g_rttiInfo = _makeTextDocumentSyncOptionsRtti();
17
18static const StructRttiInfo _makeWorkDoneProgressParamsRtti()
19{
20    WorkDoneProgressParams obj;
21    StructRttiBuilder builder(&obj, "LanguageServerProtocol::WorkDoneProgressParams", nullptr);
22    builder.addField("workDoneToken", &obj.workDoneToken, StructRttiInfo::Flag::Optional);
23    builder.ignoreUnknownFields();
24    return builder.make();
25}
26const StructRttiInfo WorkDoneProgressParams::g_rttiInfo = _makeWorkDoneProgressParamsRtti();
27
28static const StructRttiInfo _makeInlayHintOptionsRtti()
29{
30    InlayHintOptions obj;
31    StructRttiBuilder builder(&obj, "LanguageServerProtocol::InlayHintOptions", nullptr);
32    builder.addField("resolveProvider", &obj.resolveProvider);
33    builder.ignoreUnknownFields();
34    return builder.make();
35}
36const StructRttiInfo InlayHintOptions::g_rttiInfo = _makeInlayHintOptionsRtti();
37
38static const StructRttiInfo _makeDocumentOnTypeFormattingOptionsRtti()
39{
40    DocumentOnTypeFormattingOptions obj;
41    StructRttiBuilder builder(
42        &obj,
43        "LanguageServerProtocol::DocumentOnTypeFormattingOptions",
44        nullptr);
45    builder.addField("firstTriggerCharacter", &obj.firstTriggerCharacter);
46    builder.addField("moreTriggerCharacter", &obj.moreTriggerCharacter);
47    builder.ignoreUnknownFields();
48    return builder.make();
49}
50const StructRttiInfo DocumentOnTypeFormattingOptions::g_rttiInfo =
51    _makeDocumentOnTypeFormattingOptionsRtti();
52
53static const StructRttiInfo _makeCompletionOptionsRtti()
54{
55    CompletionOptions obj;
56    StructRttiBuilder builder(
57        &obj,
58        "LanguageServerProtocol::CompletionOptions",
59        &WorkDoneProgressParams::g_rttiInfo);
60    builder.addField("triggerCharacters", &obj.triggerCharacters);
61    builder.addField("resolveProvider", &obj.resolveProvider);
62    builder.addField("allCommitCharacters", &obj.allCommitCharacters);
63    builder.ignoreUnknownFields();
64    return builder.make();
65}
66const StructRttiInfo CompletionOptions::g_rttiInfo = _makeCompletionOptionsRtti();
67
68static const StructRttiInfo _makeSemanticTokensLegendRtti()
69{
70    SemanticTokensLegend obj;
71    StructRttiBuilder builder(&obj, "LanguageServerProtocol::SemanticTokensLegend", nullptr);
72    builder.addField("tokenTypes", &obj.tokenTypes);
73    builder.addField("tokenModifiers", &obj.tokenModifiers);
74    builder.ignoreUnknownFields();
75    return builder.make();
76}
77const StructRttiInfo SemanticTokensLegend::g_rttiInfo = _makeSemanticTokensLegendRtti();
78
79static const StructRttiInfo _makeSemanticTokensOptionsRtti()
80{
81    SemanticTokensOptions obj;
82    StructRttiBuilder builder(&obj, "LanguageServerProtocol::SemanticTokensOptions", nullptr);
83    builder.addField("legend", &obj.legend);
84    builder.addField("range", &obj.range);
85    builder.addField("full", &obj.full);
86    builder.ignoreUnknownFields();
87    return builder.make();
88}
89const StructRttiInfo SemanticTokensOptions::g_rttiInfo = _makeSemanticTokensOptionsRtti();
90
91static const StructRttiInfo _makeSignatureHelpOptionsRtti()
92{
93    SignatureHelpOptions obj;
94    StructRttiBuilder builder(&obj, "LanguageServerProtocol::SignatureHelpOptions", nullptr);
95    builder.addField("triggerCharacters", &obj.triggerCharacters);
96    builder.addField("retriggerCharacters", &obj.retriggerCharacters);
97    builder.ignoreUnknownFields();
98    return builder.make();
99}
100const StructRttiInfo SignatureHelpOptions::g_rttiInfo = _makeSignatureHelpOptionsRtti();
101
102static const StructRttiInfo _makeTextDocumentItemRtti()
103{
104    TextDocumentItem obj;
105    StructRttiBuilder builder(&obj, "LanguageServerProtocol::TextDocumentItem", nullptr);
106    builder.addField("uri", &obj.uri);
107    builder.addField("version", &obj.version);
108    builder.addField("languageId", &obj.languageId);
109    builder.addField("text", &obj.text);
110    builder.ignoreUnknownFields();
111    return builder.make();
112}
113const StructRttiInfo TextDocumentItem::g_rttiInfo = _makeTextDocumentItemRtti();
114
115static const StructRttiInfo _makeTextDocumentIdentifierRtti()
116{
117    TextDocumentIdentifier obj;
118    StructRttiBuilder builder(&obj, "LanguageServerProtocol::TextDocumentIdentifier", nullptr);
119    builder.addField("uri", &obj.uri);
120    builder.ignoreUnknownFields();
121    return builder.make();
122}
123const StructRttiInfo TextDocumentIdentifier::g_rttiInfo = _makeTextDocumentIdentifierRtti();
124
125static const StructRttiInfo _makeVersionedTextDocumentIdentifierRtti()
126{
127    VersionedTextDocumentIdentifier obj;
128    StructRttiBuilder builder(
129        &obj,
130        "LanguageServerProtocol::VersionedTextDocumentIdentifier",
131        nullptr);
132    builder.addField("uri", &obj.uri);
133    builder.addField("version", &obj.version);
134    builder.ignoreUnknownFields();
135    return builder.make();
136}
137const StructRttiInfo VersionedTextDocumentIdentifier::g_rttiInfo =
138    _makeVersionedTextDocumentIdentifierRtti();
139
140static const StructRttiInfo _makePositionRtti()
141{
142    Position obj;
143    StructRttiBuilder builder(&obj, "LanguageServerProtocol::Position", nullptr);
144    builder.addField("line", &obj.line);
145    builder.addField("character", &obj.character);
146    builder.ignoreUnknownFields();
147    return builder.make();
148}
149const StructRttiInfo Position::g_rttiInfo = _makePositionRtti();
150
151static const StructRttiInfo _makeRangeRtti()
152{
153    Range obj;
154    StructRttiBuilder builder(&obj, "LanguageServerProtocol::Range", nullptr);
155    builder.addField("start", &obj.start);
156    builder.addField("end", &obj.end);
157    builder.ignoreUnknownFields();
158    return builder.make();
159}
160const StructRttiInfo Range::g_rttiInfo = _makeRangeRtti();
161
162static const StructRttiInfo _makeTextEditRtti()
163{
164    TextEdit obj;
165    StructRttiBuilder builder(&obj, "LanguageServerProtocol::TextEdit", nullptr);
166    builder.addField("range", &obj.range);
167    builder.addField("newText", &obj.newText);
168    builder.ignoreUnknownFields();
169    return builder.make();
170}
171const StructRttiInfo TextEdit::g_rttiInfo = _makeTextEditRtti();
172
173static const StructRttiInfo _makeDidOpenTextDocumentRtti()
174{
175    DidOpenTextDocumentParams obj;
176    StructRttiBuilder builder(&obj, "LanguageServerProtocol::DidOpenTextDocumentParams", nullptr);
177    builder.addField("textDocument", &obj.textDocument);
178    builder.ignoreUnknownFields();
179    return builder.make();
180}
181const StructRttiInfo DidOpenTextDocumentParams::g_rttiInfo = _makeDidOpenTextDocumentRtti();
182const UnownedStringSlice DidOpenTextDocumentParams::methodName =
183    UnownedStringSlice::fromLiteral("textDocument/didOpen");
184
185static const StructRttiInfo _makeTextDocumentContentChangeEventRtti()
186{
187    TextDocumentContentChangeEvent obj;
188    StructRttiBuilder builder(
189        &obj,
190        "LanguageServerProtocol::TextDocumentContentChangeEvent",
191        nullptr);
192    builder.addField("range", &obj.range, StructRttiInfo::Flag::Optional);
193    builder.addField("text", &obj.text);
194    builder.ignoreUnknownFields();
195    return builder.make();
196}
197const StructRttiInfo TextDocumentContentChangeEvent::g_rttiInfo =
198    _makeTextDocumentContentChangeEventRtti();
199
200static const StructRttiInfo _makeDidChangeTextDocumentParamsRtti()
201{
202    DidChangeTextDocumentParams obj;
203    StructRttiBuilder builder(&obj, "LanguageServerProtocol::DidChangeTextDocumentParams", nullptr);
204    builder.addField("textDocument", &obj.textDocument);
205    builder.addField("contentChanges", &obj.contentChanges);
206    builder.ignoreUnknownFields();
207    return builder.make();
208}
209const StructRttiInfo DidChangeTextDocumentParams::g_rttiInfo =
210    _makeDidChangeTextDocumentParamsRtti();
211const UnownedStringSlice DidChangeTextDocumentParams::methodName =
212    UnownedStringSlice::fromLiteral("textDocument/didChange");
213
214
215static const StructRttiInfo _makeDidCloseTextDocumentParamsRtti()
216{
217    DidCloseTextDocumentParams obj;
218    StructRttiBuilder builder(&obj, "LanguageServerProtocol::DidCloseTextDocumentParams", nullptr);
219    builder.addField("textDocument", &obj.textDocument);
220    builder.ignoreUnknownFields();
221    return builder.make();
222}
223const StructRttiInfo DidCloseTextDocumentParams::g_rttiInfo = _makeDidCloseTextDocumentParamsRtti();
224const UnownedStringSlice DidCloseTextDocumentParams::methodName =
225    UnownedStringSlice::fromLiteral("textDocument/didClose");
226
227static const StructRttiInfo _makeWorkspaceFoldersServerCapabilitiesRtti()
228{
229    WorkspaceFoldersServerCapabilities obj;
230    StructRttiBuilder builder(
231        &obj,
232        "LanguageServerProtocol::WorkspaceFoldersServerCapabilities",
233        nullptr);
234    builder.addField("supported", &obj.supported);
235    builder.addField("changeNotifications", &obj.changeNotifications);
236    builder.ignoreUnknownFields();
237    return builder.make();
238}
239const StructRttiInfo WorkspaceFoldersServerCapabilities::g_rttiInfo =
240    _makeWorkspaceFoldersServerCapabilitiesRtti();
241
242static const StructRttiInfo _makeWorkspaceCapabilitiesRtti()
243{
244    WorkspaceCapabilities obj;
245    StructRttiBuilder builder(&obj, "LanguageServerProtocol::WorkspaceCapabilities", nullptr);
246    builder.addField("workspaceFolders", &obj.workspaceFolders);
247    builder.ignoreUnknownFields();
248    return builder.make();
249}
250const StructRttiInfo WorkspaceCapabilities::g_rttiInfo = _makeWorkspaceCapabilitiesRtti();
251
252static const StructRttiInfo _makeServerCapabilitiesRtti()
253{
254    ServerCapabilities obj;
255    StructRttiBuilder builder(&obj, "LanguageServerProtocol::ServerCapabilities", nullptr);
256    builder.addField("positionEncoding", &obj.positionEncoding);
257    builder.addField("textDocumentSync", &obj.textDocumentSync);
258    builder.addField("workspace", &obj.workspace);
259    builder.addField("hoverProvider", &obj.hoverProvider);
260    builder.addField("inlayHintProvider", &obj.inlayHintProvider);
261    builder.addField("documentOnTypeFormattingProvider", &obj.documentOnTypeFormattingProvider);
262    builder.addField("documentFormattingProvider", &obj.documentFormattingProvider);
263    builder.addField("documentRangeFormattingProvider", &obj.documentRangeFormattingProvider);
264    builder.addField("definitionProvider", &obj.definitionProvider);
265    builder.addField("completionProvider", &obj.completionProvider);
266    builder.addField("semanticTokensProvider", &obj.semanticTokensProvider);
267    builder.addField("signatureHelpProvider", &obj.signatureHelpProvider);
268    builder.addField("documentSymbolProvider", &obj.documentSymbolProvider);
269    builder.ignoreUnknownFields();
270    return builder.make();
271}
272const StructRttiInfo ServerCapabilities::g_rttiInfo = _makeServerCapabilitiesRtti();
273
274static const StructRttiInfo _makeVSServerCapabilitiesRtti()
275{
276    VSServerCapabilities obj;
277    StructRttiBuilder builder(&obj, "LanguageServerProtocol::ServerCapabilities", nullptr);
278    builder.addField("positionEncoding", &obj.positionEncoding);
279    builder.addField("textDocumentSync", &obj.textDocumentSync);
280    builder.addField("workspace", &obj.workspace);
281    builder.addField("hoverProvider", &obj.hoverProvider);
282    builder.addField("inlayHintProvider", &obj.inlayHintProvider);
283    builder.addField("documentOnTypeFormattingProvider", &obj.documentOnTypeFormattingProvider);
284    builder.addField("documentFormattingProvider", &obj.documentFormattingProvider);
285    builder.addField("documentRangeFormattingProvider", &obj.documentRangeFormattingProvider);
286    builder.addField("definitionProvider", &obj.definitionProvider);
287    builder.addField("completionProvider", &obj.completionProvider);
288    builder.addField("semanticTokensProvider", &obj.semanticTokensProvider);
289    builder.addField("signatureHelpProvider", &obj.signatureHelpProvider);
290    builder.addField("documentSymbolProvider", &obj.documentSymbolProvider);
291    builder.addField("_vs_projectContextProvider", &obj._vs_projectContextProvider);
292    builder.ignoreUnknownFields();
293    return builder.make();
294}
295const StructRttiInfo VSServerCapabilities::g_rttiInfo = _makeVSServerCapabilitiesRtti();
296
297static const StructRttiInfo _makeServerInfoRtti()
298{
299    ServerInfo obj;
300    StructRttiBuilder builder(&obj, "LanguageServerProtocol::ServerInfo", nullptr);
301    builder.addField("name", &obj.name);
302    builder.addField("version", &obj.version);
303    builder.ignoreUnknownFields();
304    return builder.make();
305}
306const StructRttiInfo ServerInfo::g_rttiInfo = _makeServerInfoRtti();
307
308
309static const StructRttiInfo _makeInitializeResultRtti()
310{
311    InitializeResult obj;
312    StructRttiBuilder builder(&obj, "LanguageServerProtocol::InitializeResult", nullptr);
313    builder.addField("capabilities", &obj.capabilities);
314    builder.addField("serverInfo", &obj.serverInfo);
315    builder.ignoreUnknownFields();
316    return builder.make();
317}
318const StructRttiInfo InitializeResult::g_rttiInfo = _makeInitializeResultRtti();
319
320static const StructRttiInfo _makeVSInitializeResultRtti()
321{
322    VSInitializeResult obj;
323    StructRttiBuilder builder(&obj, "LanguageServerProtocol::VSInitializeResult", nullptr);
324    builder.addField("capabilities", &obj.capabilities);
325    builder.addField("serverInfo", &obj.serverInfo);
326    builder.ignoreUnknownFields();
327    return builder.make();
328}
329const StructRttiInfo VSInitializeResult::g_rttiInfo = _makeVSInitializeResultRtti();
330
331const UnownedStringSlice InitializeParams::methodName =
332    UnownedStringSlice::fromLiteral("initialize");
333
334const UnownedStringSlice ShutdownParams::methodName = UnownedStringSlice::fromLiteral("shutdown");
335
336const UnownedStringSlice ExitParams::methodName = UnownedStringSlice::fromLiteral("exit");
337
338static const StructRttiInfo _makeWorkspaceFolderRtti()
339{
340    WorkspaceFolder obj;
341    StructRttiBuilder builder(&obj, "LanguageServerProtocol::WorkspaceFolder", nullptr);
342    builder.addField("uri", &obj.uri);
343    builder.addField("name", &obj.name);
344    builder.ignoreUnknownFields();
345    return builder.make();
346}
347const StructRttiInfo WorkspaceFolder::g_rttiInfo = _makeWorkspaceFolderRtti();
348
349static const StructRttiInfo _makeInitializeParamsRtti()
350{
351    InitializeParams obj;
352    StructRttiBuilder builder(&obj, "LanguageServerProtocol::InitializeParams", nullptr);
353    builder.addField("workspaceFolders", &obj.workspaceFolders, StructRttiInfo::Flag::Optional);
354    builder.ignoreUnknownFields();
355    return builder.make();
356}
357const StructRttiInfo InitializeParams::g_rttiInfo = _makeInitializeParamsRtti();
358
359static const StructRttiInfo _makeNullResponseRtti()
360{
361    NullResponse obj;
362    StructRttiBuilder builder(&obj, "LanguageServerProtocol::NullResponse", nullptr);
363    return builder.make();
364}
365const StructRttiInfo NullResponse::g_rttiInfo = _makeNullResponseRtti();
366
367NullResponse* NullResponse::get()
368{
369    static NullResponse result = {};
370    return &result;
371}
372
373static const StructRttiInfo _makeLocationRtti()
374{
375    Location obj;
376    StructRttiBuilder builder(&obj, "LanguageServerProtocol::Location", nullptr);
377    builder.addField("uri", &obj.uri);
378    builder.addField("range", &obj.range);
379    builder.ignoreUnknownFields();
380    return builder.make();
381}
382const StructRttiInfo Location::g_rttiInfo = _makeLocationRtti();
383
384static const StructRttiInfo _makeDiagnosticRelatedInformationRtti()
385{
386    DiagnosticRelatedInformation obj;
387    StructRttiBuilder builder(
388        &obj,
389        "LanguageServerProtocol::DiagnosticRelatedInformation",
390        nullptr);
391    builder.addField("location", &obj.location);
392    builder.addField("message", &obj.message);
393    builder.ignoreUnknownFields();
394    return builder.make();
395}
396const StructRttiInfo DiagnosticRelatedInformation::g_rttiInfo =
397    _makeDiagnosticRelatedInformationRtti();
398
399static const StructRttiInfo _makeDiagnosticRtti()
400{
401    Diagnostic obj;
402    StructRttiBuilder builder(&obj, "LanguageServerProtocol::Diagnostic", nullptr);
403    builder.addField("code", &obj.code);
404    builder.addField("message", &obj.message);
405    builder.addField("range", &obj.range);
406    builder.addField("relatedInformation", &obj.relatedInformation);
407    builder.addField("severity", &obj.severity);
408    builder.addField("source", &obj.source);
409    builder.ignoreUnknownFields();
410    return builder.make();
411}
412const StructRttiInfo Diagnostic::g_rttiInfo = _makeDiagnosticRtti();
413
414static const StructRttiInfo _makePublishDiagnosticsParamsRtti()
415{
416    PublishDiagnosticsParams obj;
417    StructRttiBuilder builder(&obj, "LanguageServerProtocol::PublishDiagnosticsParams", nullptr);
418    builder.addField("uri", &obj.uri);
419    builder.addField("diagnostics", &obj.diagnostics);
420    builder.ignoreUnknownFields();
421    return builder.make();
422}
423const StructRttiInfo PublishDiagnosticsParams::g_rttiInfo = _makePublishDiagnosticsParamsRtti();
424
425static const StructRttiInfo _makeTextDocumentPositionParamsRtti()
426{
427    TextDocumentPositionParams obj;
428    StructRttiBuilder builder(&obj, "LanguageServerProtocol::TextDocumentPositionParams", nullptr);
429    builder.addField("textDocument", &obj.textDocument);
430    builder.addField("position", &obj.position);
431    builder.ignoreUnknownFields();
432    return builder.make();
433}
434const StructRttiInfo TextDocumentPositionParams::g_rttiInfo = _makeTextDocumentPositionParamsRtti();
435
436static const StructRttiInfo _makeHoverParamsRtti()
437{
438    HoverParams obj;
439    StructRttiBuilder builder(
440        &obj,
441        "LanguageServerProtocol::HoverParams",
442        &WorkDoneProgressParams::g_rttiInfo);
443    builder.addField("textDocument", &obj.textDocument);
444    builder.addField("position", &obj.position);
445    builder.ignoreUnknownFields();
446    return builder.make();
447}
448const StructRttiInfo HoverParams::g_rttiInfo = _makeHoverParamsRtti();
449const UnownedStringSlice HoverParams::methodName =
450    UnownedStringSlice::fromLiteral("textDocument/hover");
451
452static const StructRttiInfo _makeMarkupContentRtti()
453{
454    MarkupContent obj;
455    StructRttiBuilder builder(&obj, "LanguageServerProtocol::MarkupContent", nullptr);
456    builder.addField("kind", &obj.kind);
457    builder.addField("value", &obj.value);
458    builder.ignoreUnknownFields();
459    return builder.make();
460}
461const StructRttiInfo MarkupContent::g_rttiInfo = _makeMarkupContentRtti();
462
463static const StructRttiInfo _makeHoverRtti()
464{
465    Hover obj;
466    StructRttiBuilder builder(&obj, "LanguageServerProtocol::Hover", nullptr);
467    builder.addField("contents", &obj.contents);
468    builder.addField("range", &obj.range);
469    builder.ignoreUnknownFields();
470    return builder.make();
471}
472const StructRttiInfo Hover::g_rttiInfo = _makeHoverRtti();
473
474static const StructRttiInfo _makeCompletionContextRtti()
475{
476    CompletionContext obj;
477    StructRttiBuilder builder(&obj, "LanguageServerProtocol::CompletionContext", nullptr);
478    builder.addField("triggerKind", &obj.triggerKind);
479    builder.addField("triggerCharacter", &obj.triggerCharacter, StructRttiInfo::Flag::Optional);
480    builder.ignoreUnknownFields();
481    return builder.make();
482}
483const StructRttiInfo CompletionContext::g_rttiInfo = _makeCompletionContextRtti();
484
485static const StructRttiInfo _makeDefinitionParamsRtti()
486{
487    DefinitionParams obj;
488    StructRttiBuilder builder(
489        &obj,
490        "LanguageServerProtocol::DefinitionParams",
491        &WorkDoneProgressParams::g_rttiInfo);
492    builder.addField("textDocument", &obj.textDocument);
493    builder.addField("position", &obj.position);
494    builder.ignoreUnknownFields();
495    return builder.make();
496}
497const StructRttiInfo DefinitionParams::g_rttiInfo = _makeDefinitionParamsRtti();
498const UnownedStringSlice DefinitionParams::methodName =
499    UnownedStringSlice::fromLiteral("textDocument/definition");
500
501static const StructRttiInfo _makeCompletionParamsRtti()
502{
503    CompletionParams obj;
504    StructRttiBuilder builder(
505        &obj,
506        "LanguageServerProtocol::CompletionParams",
507        &WorkDoneProgressParams::g_rttiInfo);
508    builder.addField("textDocument", &obj.textDocument);
509    builder.addField("position", &obj.position);
510    builder.addField("context", &obj.context, StructRttiInfo::Flag::Optional);
511    builder.ignoreUnknownFields();
512    return builder.make();
513}
514const StructRttiInfo CompletionParams::g_rttiInfo = _makeCompletionParamsRtti();
515const UnownedStringSlice CompletionParams::methodName =
516    UnownedStringSlice::fromLiteral("textDocument/completion");
517
518static const StructRttiInfo _makeCompletionItemRtti()
519{
520    CompletionItem obj;
521    StructRttiBuilder builder(&obj, "LanguageServerProtocol::CompletionItem", nullptr);
522    builder.addField("label", &obj.label, StructRttiInfo::Flag::Optional);
523    builder.addField("detail", &obj.detail, StructRttiInfo::Flag::Optional);
524    builder.addField("kind", &obj.kind, StructRttiInfo::Flag::Optional);
525    builder.addField("sortText", &obj.sortText, StructRttiInfo::Flag::Optional);
526    builder.addField("documentation", &obj.documentation, StructRttiInfo::Flag::Optional);
527    builder.addField("data", &obj.data, StructRttiInfo::Flag::Optional);
528    builder.addField("commitCharacters", &obj.commitCharacters, StructRttiInfo::Flag::Optional);
529    builder.ignoreUnknownFields();
530    return builder.make();
531}
532const StructRttiInfo CompletionItem::g_rttiInfo = _makeCompletionItemRtti();
533
534static const StructRttiInfo _makeTextEditCompletionItemRtti()
535{
536    TextEditCompletionItem obj;
537    StructRttiBuilder builder(&obj, "LanguageServerProtocol::TextEditCompletionItem", nullptr);
538    builder.addField("label", &obj.label, StructRttiInfo::Flag::Optional);
539    builder.addField("detail", &obj.detail, StructRttiInfo::Flag::Optional);
540    builder.addField("kind", &obj.kind, StructRttiInfo::Flag::Optional);
541    builder.addField("documentation", &obj.documentation, StructRttiInfo::Flag::Optional);
542    builder.addField("data", &obj.data, StructRttiInfo::Flag::Optional);
543    builder.addField("textEdit", &obj.textEdit, StructRttiInfo::Flag::Optional);
544    builder.addField("commitCharacters", &obj.commitCharacters, StructRttiInfo::Flag::Optional);
545    builder.ignoreUnknownFields();
546    return builder.make();
547}
548const StructRttiInfo TextEditCompletionItem::g_rttiInfo = _makeTextEditCompletionItemRtti();
549
550static const StructRttiInfo _makeSemanticTokensParamsRtti()
551{
552    SemanticTokensParams obj;
553    StructRttiBuilder builder(
554        &obj,
555        "LanguageServerProtocol::SemanticTokensParams",
556        &WorkDoneProgressParams::g_rttiInfo);
557    builder.addField("textDocument", &obj.textDocument);
558    builder.ignoreUnknownFields();
559    return builder.make();
560}
561const StructRttiInfo SemanticTokensParams::g_rttiInfo = _makeSemanticTokensParamsRtti();
562const UnownedStringSlice SemanticTokensParams::methodName =
563    UnownedStringSlice::fromLiteral("textDocument/semanticTokens/full");
564
565static const StructRttiInfo _makeSemanticTokensRtti()
566{
567    SemanticTokens obj;
568    StructRttiBuilder builder(&obj, "LanguageServerProtocol::SemanticTokens", nullptr);
569    builder.addField("resultId", &obj.resultId);
570    builder.addField("data", &obj.data);
571    builder.ignoreUnknownFields();
572    return builder.make();
573}
574const StructRttiInfo SemanticTokens::g_rttiInfo = _makeSemanticTokensRtti();
575
576static const StructRttiInfo _makeSignatureHelpParamsRtti()
577{
578    SignatureHelpParams obj;
579    StructRttiBuilder builder(
580        &obj,
581        "LanguageServerProtocol::SignatureHelpParams",
582        &WorkDoneProgressParams::g_rttiInfo);
583    builder.addField("textDocument", &obj.textDocument);
584    builder.addField("position", &obj.position);
585    builder.ignoreUnknownFields();
586    return builder.make();
587}
588const StructRttiInfo SignatureHelpParams::g_rttiInfo = _makeSignatureHelpParamsRtti();
589const UnownedStringSlice SignatureHelpParams::methodName =
590    UnownedStringSlice::fromLiteral("textDocument/signatureHelp");
591
592static const StructRttiInfo _makeParameterInformationRtti()
593{
594    ParameterInformation obj;
595    StructRttiBuilder builder(&obj, "LanguageServerProtocol::ParameterInformation", nullptr);
596    builder.addField("label", &obj.label);
597    builder.addField("documentation", &obj.documentation, StructRttiInfo::Flag::Optional);
598    builder.ignoreUnknownFields();
599    return builder.make();
600}
601const StructRttiInfo ParameterInformation::g_rttiInfo = _makeParameterInformationRtti();
602
603static const StructRttiInfo _makeSignatureInformationRtti()
604{
605    SignatureInformation obj;
606    StructRttiBuilder builder(&obj, "LanguageServerProtocol::SignatureInformation", nullptr);
607    builder.addField("label", &obj.label);
608    builder.addField("parameters", &obj.parameters);
609    builder.addField("documentation", &obj.documentation, StructRttiInfo::Flag::Optional);
610    builder.ignoreUnknownFields();
611    return builder.make();
612}
613const StructRttiInfo SignatureInformation::g_rttiInfo = _makeSignatureInformationRtti();
614
615static const StructRttiInfo _makeSignatureHelpRtti()
616{
617    SignatureHelp obj;
618    StructRttiBuilder builder(&obj, "LanguageServerProtocol::SignatureHelp", nullptr);
619    builder.addField("signatures", &obj.signatures);
620    builder.addField("activeParameter", &obj.activeParameter);
621    builder.addField("activeSignature", &obj.activeSignature);
622    builder.ignoreUnknownFields();
623    return builder.make();
624}
625const StructRttiInfo SignatureHelp::g_rttiInfo = _makeSignatureHelpRtti();
626
627static const StructRttiInfo _makeDidChangeConfigurationParamsRtti()
628{
629    DidChangeConfigurationParams obj;
630    StructRttiBuilder builder(
631        &obj,
632        "LanguageServerProtocol::DidChangeConfigurationParams",
633        nullptr);
634    builder.addField("settings", &obj.settings, StructRttiInfo::Flag::Optional);
635    builder.ignoreUnknownFields();
636    return builder.make();
637}
638const StructRttiInfo DidChangeConfigurationParams::g_rttiInfo =
639    _makeDidChangeConfigurationParamsRtti();
640const UnownedStringSlice DidChangeConfigurationParams::methodName =
641    UnownedStringSlice::fromLiteral("workspace/didChangeConfiguration");
642
643static const StructRttiInfo _makeConfigurationItemRtti()
644{
645    ConfigurationItem obj;
646    StructRttiBuilder builder(&obj, "LanguageServerProtocol::ConfigurationItem", nullptr);
647    builder.addField("section", &obj.section, StructRttiInfo::Flag::Optional);
648    builder.ignoreUnknownFields();
649    return builder.make();
650}
651const StructRttiInfo ConfigurationItem::g_rttiInfo = _makeConfigurationItemRtti();
652
653static const StructRttiInfo _makeConfigurationParamsRtti()
654{
655    ConfigurationParams obj;
656    StructRttiBuilder builder(&obj, "LanguageServerProtocol::ConfigurationParams", nullptr);
657    builder.addField("items", &obj.items, StructRttiInfo::Flag::Optional);
658    builder.ignoreUnknownFields();
659    return builder.make();
660}
661const StructRttiInfo ConfigurationParams::g_rttiInfo = _makeConfigurationParamsRtti();
662const UnownedStringSlice ConfigurationParams::methodName =
663    UnownedStringSlice::fromLiteral("workspace/configuration");
664
665static const StructRttiInfo _makeRegistrationRtti()
666{
667    Registration obj;
668    StructRttiBuilder builder(&obj, "LanguageServerProtocol::Registration", nullptr);
669    builder.addField("id", &obj.id, StructRttiInfo::Flag::Optional);
670    builder.addField("method", &obj.method, StructRttiInfo::Flag::Optional);
671    builder.ignoreUnknownFields();
672    return builder.make();
673}
674const StructRttiInfo Registration::g_rttiInfo = _makeRegistrationRtti();
675
676static const StructRttiInfo _makeRegistrationParamsRtti()
677{
678    RegistrationParams obj;
679    StructRttiBuilder builder(&obj, "LanguageServerProtocol::RegistrationParams", nullptr);
680    builder.addField("registrations", &obj.registrations, StructRttiInfo::Flag::Optional);
681    builder.ignoreUnknownFields();
682    return builder.make();
683}
684const StructRttiInfo RegistrationParams::g_rttiInfo = _makeRegistrationParamsRtti();
685
686static const StructRttiInfo _makeCancelParamsRtti()
687{
688    CancelParams obj;
689    StructRttiBuilder builder(&obj, "LanguageServerProtocol::CancelParams", nullptr);
690    builder.addField("id", &obj.id, StructRttiInfo::Flag::Optional);
691    builder.ignoreUnknownFields();
692    return builder.make();
693}
694const StructRttiInfo CancelParams::g_rttiInfo = _makeCancelParamsRtti();
695
696static const StructRttiInfo _makeLogMessageParamsRtti()
697{
698    LogMessageParams obj;
699    StructRttiBuilder builder(&obj, "LanguageServerProtocol::LogMessageParams", nullptr);
700    builder.addField("type", &obj.type, StructRttiInfo::Flag::Optional);
701    builder.addField("message", &obj.message, StructRttiInfo::Flag::Optional);
702    builder.ignoreUnknownFields();
703    return builder.make();
704}
705const StructRttiInfo LogMessageParams::g_rttiInfo = _makeLogMessageParamsRtti();
706const UnownedStringSlice LogMessageParams::methodName =
707    UnownedStringSlice::fromLiteral("window/logMessage");
708
709static const StructRttiInfo _makeDocumentSymbolParamsRtti()
710{
711    DocumentSymbolParams obj;
712    StructRttiBuilder builder(
713        &obj,
714        "LanguageServerProtocol::DocumentSymbolParams",
715        &WorkDoneProgressParams::g_rttiInfo);
716    builder.addField("textDocument", &obj.textDocument);
717    builder.ignoreUnknownFields();
718    return builder.make();
719}
720const StructRttiInfo DocumentSymbolParams::g_rttiInfo = _makeDocumentSymbolParamsRtti();
721const UnownedStringSlice DocumentSymbolParams::methodName =
722    UnownedStringSlice::fromLiteral("textDocument/documentSymbol");
723
724static const StructRttiInfo _makeDocumentSymbolRtti()
725{
726    DocumentSymbol obj;
727    StructRttiBuilder builder(&obj, "LanguageServerProtocol::DocumentSymbol", nullptr);
728    builder.addField("name", &obj.name);
729    builder.addField("detail", &obj.detail);
730    builder.addField("kind", &obj.kind);
731    builder.addField("range", &obj.range);
732    builder.addField("selectionRange", &obj.selectionRange);
733    builder.addField("children", &obj.children);
734    builder.ignoreUnknownFields();
735    return builder.make();
736}
737const StructRttiInfo DocumentSymbol::g_rttiInfo = _makeDocumentSymbolRtti();
738
739static const StructRttiInfo _makeInlayHintParamsRtti()
740{
741    InlayHintParams obj;
742    StructRttiBuilder builder(&obj, "LanguageServerProtocol::InlayHintParams", nullptr);
743    builder.addField("range", &obj.range);
744    builder.addField("textDocument", &obj.textDocument);
745    builder.ignoreUnknownFields();
746    return builder.make();
747}
748const StructRttiInfo InlayHintParams::g_rttiInfo = _makeInlayHintParamsRtti();
749const UnownedStringSlice InlayHintParams::methodName =
750    UnownedStringSlice::fromLiteral("textDocument/inlayHint");
751
752static const StructRttiInfo _makeInlayHintRtti()
753{
754    InlayHint obj;
755    StructRttiBuilder builder(&obj, "LanguageServerProtocol::InlayHint", nullptr);
756    builder.addField("position", &obj.position);
757    builder.addField("label", &obj.label);
758    builder.addField("kind", &obj.kind);
759    builder.addField("paddingLeft", &obj.paddingLeft);
760    builder.addField("paddingRight", &obj.paddingRight);
761    builder.addField("textEdits", &obj.textEdits);
762
763    builder.ignoreUnknownFields();
764    return builder.make();
765}
766const StructRttiInfo InlayHint::g_rttiInfo = _makeInlayHintRtti();
767
768static const StructRttiInfo _makeDocumentFormattingParamsRtti()
769{
770    DocumentFormattingParams obj;
771    StructRttiBuilder builder(&obj, "LanguageServerProtocol::DocumentFormattingParams", nullptr);
772    builder.addField("textDocument", &obj.textDocument);
773    builder.ignoreUnknownFields();
774    return builder.make();
775}
776const StructRttiInfo DocumentFormattingParams::g_rttiInfo = _makeDocumentFormattingParamsRtti();
777const UnownedStringSlice DocumentFormattingParams::methodName =
778    UnownedStringSlice::fromLiteral("textDocument/formatting");
779
780static const StructRttiInfo _makeDocumentRangeFormattingParamsRtti()
781{
782    DocumentRangeFormattingParams obj;
783    StructRttiBuilder builder(
784        &obj,
785        "LanguageServerProtocol::DocumentRangeFormattingParams",
786        nullptr);
787    builder.addField("textDocument", &obj.textDocument);
788    builder.addField("range", &obj.range);
789    builder.ignoreUnknownFields();
790    return builder.make();
791}
792const StructRttiInfo DocumentRangeFormattingParams::g_rttiInfo =
793    _makeDocumentRangeFormattingParamsRtti();
794const UnownedStringSlice DocumentRangeFormattingParams::methodName =
795    UnownedStringSlice::fromLiteral("textDocument/rangeFormatting");
796
797static const StructRttiInfo _makeDocumentOnTypeFormattingParamsRtti()
798{
799    DocumentOnTypeFormattingParams obj;
800    StructRttiBuilder builder(
801        &obj,
802        "LanguageServerProtocol::DocumentOnTypeFormattingParams",
803        nullptr);
804    builder.addField("textDocument", &obj.textDocument);
805    builder.addField("position", &obj.position);
806    builder.addField("ch", &obj.ch);
807    builder.ignoreUnknownFields();
808    return builder.make();
809}
810const StructRttiInfo DocumentOnTypeFormattingParams::g_rttiInfo =
811    _makeDocumentOnTypeFormattingParamsRtti();
812const UnownedStringSlice DocumentOnTypeFormattingParams::methodName =
813    UnownedStringSlice::fromLiteral("textDocument/onTypeFormatting");
814
815} // namespace LanguageServerProtocol
816
817} // namespace Slang