Přidání rozšíření protokolu jazykového serveru
Protokol LSP (Language Server Protocol) je běžný protokol ve formě JSON RPC verze 2.0, který slouží k poskytování funkcí služby jazyka různým editorům kódu. Pomocí protokolu můžou vývojáři napsat jeden server jazyka, který poskytuje funkce jazykových služeb, jako je IntelliSense, diagnostika chyb, vyhledání všech odkazů atd. pro různé editory kódu, které podporují LSP. Tradičně lze jazykové služby v sadě Visual Studio přidat pomocí gramatických souborů TextMate k poskytování základních funkcí, jako je zvýraznění syntaxe nebo psaní vlastních jazykových služeb, které používají úplnou sadu rozhraní API rozšiřitelnosti sady Visual Studio k poskytování bohatších dat. S podporou sady Visual Studio pro LSP je k dispozici třetí možnost.
služba protokolu 
Pokud chcete zajistit co nejlepší uživatelské prostředí, zvažte také implementaci jazykové konfigurace, která poskytuje místní zpracování mnoha stejných operací, a proto může zlepšit výkon mnoha operací editoru specifických pro jazyk podporovaných LSP.
Protokol jazykového serveru
implementace protokolu jazykového serveru 
Tento článek popisuje, jak vytvořit rozšíření sady Visual Studio, které používá jazykový server založený na LSP. Předpokládá se, že jste už vyvinuli jazykový server založený na LSP a chcete ho jenom integrovat do sady Visual Studio.
Pro podporu v sadě Visual Studio můžou jazykové servery komunikovat s klientem (Visual Studio) prostřednictvím jakéhokoli mechanismu přenosu založeného na datových proudech, například:
- Standardní vstupní a výstupní datové proudy
- Pojmenované kanály
- Zásuvky (pouze TCP)
Záměrem LSP a jeho podpory v sadě Visual Studio je onboardovat jazykové služby, které nejsou součástí produktu Visual Studio. V sadě Visual Studio není určeno rozšířit stávající jazykové služby (například C#). Pokud chcete rozšířit existující jazyky, projděte si průvodce rozšiřitelností jazykové služby (například "Roslyn" .NET Compiler Platform) nebo si přečtěte Rozšíření editoru a jazykových služeb.
Další informace o samotném protokolu najdete v dokumentaci zde.
Další informace o tom, jak vytvořit server ukázkového jazyka nebo jak integrovat existující jazykový server do editoru Visual Studio Code, najdete v dokumentaci zde.
Podporované funkce protokolu jazykového serveru
Následující tabulky ukazují, které funkce LSP jsou v sadě Visual Studio podporované:
| Zpráva | Má podporu v sadě Visual Studio |
|---|---|
| inicializovat | Ano |
| inicializovaný | Ano |
| vypnutí | Ano |
| výstup | Ano |
| $/cancelRequest | Ano |
| okno/zobrazZprávu | Ano |
| window/showMessageRequest | Ano |
| okno/zprávaProtoku | Ano |
| telemetrie/událost | |
| klient/registrovatSchopnost | |
| client/zrušitRegistraciSchopnosti | |
| workspace/didChangeConfiguration | Ano |
| workspace/didChangeWatchedFiles | Ano |
| pracovní prostor/symbol | Ano |
| workspace/executeCommand | Ano |
| workspace/applyEdit | Ano |
| textDocument/publishDiagnostics | Ano |
| textový dokument/didOpen | Ano |
| textový dokument/didChange | Ano |
| textDocument/willSave | |
| textDocument/willSaveWaitUntil | |
| textový dokument/didSave | Ano |
| textovýDokument/zavřelSe | Ano |
| textDocument/completion | Ano |
| dokončení/vyřešení | Ano |
| textový dokument/najetí myší | Ano |
| textDocument/signatureHelp | Ano |
| textový dokument/odkazy | Ano |
| zvýraznění dokumentu ve formátu textDocument/documentHighlight | Ano |
| textDocument/documentSymbol | Ano |
| textDocument/formátování | Ano |
| textovýDokument/formátováníRozsahu | Ano |
| textDocument/onTypeFormátování | |
| textovýDokument/definice | Ano |
| textDocument/codeAction | Ano |
| textDocument/codeLens | |
| codeLens /resolve | |
| textDocument/documentLink | |
| resolveOdkazNaDokument | |
| textový dokument nebo přejmenování | Ano |
Začněte
Poznámka
Od sady Visual Studio 2017 verze 15.8 je součástí sady Visual Studio podpora protokolu common Language Server Protocol. Pokud jste vytvořili rozšíření LSP pomocí verze Preview Language Server Client VSIX, přestanou po upgradu na verzi 15.8 nebo vyšší fungovat. Aby rozšíření LSP fungovala znovu, budete muset udělat toto:
Odinstalujte protokol Microsoft Visual Studio Language Server Preview VSIX.
Počínaje verzí 15.8 se při každém upgradu v sadě Visual Studio automaticky zjistí a odstraní VSIX ve verzi Preview.
Aktualizujte odkaz NuGet na nejnovější verzi, která není ve verzi Preview pro balíčky LSP .
Odeberte závislost na sadě Microsoft Visual Studio Language Server Protocol Preview VSIX v manifestu VSIX.
Ujistěte se, že VSIX určuje Visual Studio 2017 verze 15.8 Preview 3 jako dolní mez cíle instalace.
Opětovné sestavení a opětovné nasazení
Vytvoření projektu VSIX
Pokud chcete vytvořit rozšíření jazykové služby pomocí jazykového serveru založeného na LSP, nejprve se ujistěte, že máte pro svou instanci VS nainstalovanou sadu funkcí vývoje rozšíření Visual Studio.
Dále vytvořte nový projekt VSIX tak, že přejdete na Soubor>Nový projekt>Visual C#>Rozšiřitelnost>VSIX projekt:
Instalace jazykového serveru a modulu runtime
Ve výchozím nastavení rozšíření vytvořená pro podporu jazykových serverů založených na LSP v sadě Visual Studio neobsahují samotné jazykové servery ani moduly runtime potřebné ke spuštění. Vývojáři rozšíření zodpovídají za distribuci jazykových serverů a běhových prostředí. Existuje několik způsobů, jak to udělat:
- Jazykové servery mohou být vloženy do VSIX jako soubory obsahu.
- Vytvořte MSI pro instalaci jazykového serveru nebo potřebných runtime.
- Uveďte pokyny pro Marketplace, které uživatele informují o tom, jak získat moduly runtime a jazykové servery.
Gramatické soubory TextMate
LSP neobsahuje specifikaci, jak poskytnout barevné zvýrazňování textu pro jazyky. Vývojáři rozšíření můžou k poskytování vlastních barev pro jazyky v sadě Visual Studio použít gramatický soubor TextMate. Pokud chcete přidat vlastní gramatické nebo motivové soubory TextMate, postupujte takto:
Ve svém rozšíření vytvořte složku s názvem Grammars (nebo může být jakýkoli název, který zvolíte).
Do složky gramatiky zahrňte jakékoli soubory *.tmlanguage, *.plist, *.tmthemenebo *.json, které chcete pro tvorbu vlastních barevných schémat.
Spropitné
Soubor .tmtheme definuje, jak se obory mapují na klasifikace sady Visual Studio (pojmenované barevné klíče). Pokyny najdete v globálním souboru .tmtheme ve složce %ProgramFiles(x86)%\Microsoft Visual Studio\ verze<>\<SKU>\Common7\IDE\CommonExtensions\Microsoft\TextMate\Starterkit\Themesg adresář.
Vytvořte soubor .pkgdef a přidejte řádek podobný tomuto:
[$RootKey$\TextMate\Repositories] "MyLang"="$PackageFolder$\Grammars"Klikněte pravým tlačítkem na soubory a vyberte Vlastnosti. Změňte akci Build na Content a změňte vlastnost Include in VSIX na hodnotu true.
Po dokončení předchozích kroků se do instalačního adresáře balíčku přidá složka Grammars jako zdroj úložiště s názvem MyLang (MyLang je jen název pro nejednoznačnost a může to být jakýkoli jedinečný řetězec). Všechny gramatiky (.tmlanguage soubory) a soubory motivu (.tmtheme soubory) v tomto adresáři jsou považovány za potenciální a nahrazují výchozí gramatiky, které poskytuje TextMate. Pokud deklarované přípony gramatického souboru odpovídají příponě otevřeného souboru, textMate krokuje.
Vytvoření jednoduchého klienta jazyka
Hlavní rozhraní – ILanguageClient
Po vytvoření projektu VSIX přidejte do projektu následující balíčky NuGet:
Poznámka
Při závislosti na balíčku NuGet po dokončení předchozích kroků se do projektu přidají také balíčky Newtonsoft.Json a StreamJsonRpc. Neaktualizujte tyto balíčky, pokud si nejste jisti, že tyto nové verze budou nainstalovány ve verzi sady Visual Studio, kterou vaše rozšíření cílí. Sestavení nebudou zahrnuta do VSIX; místo toho se vyberou z instalačního adresáře sady Visual Studio. Pokud odkazujete na novější verzi sestavení, než je nainstalované na počítači uživatele, rozšíření nebude fungovat.
Pak můžete vytvořit novou třídu, která implementuje rozhraní ILanguageClient, což je hlavní rozhraní potřebné pro klienty jazyků připojující se k jazykovému serveru založenému na LSP.
Následuje ukázka:
namespace MockLanguageExtension
{
[ContentType("bar")]
[Export(typeof(ILanguageClient))]
public class BarLanguageClient : ILanguageClient
{
public string Name => "Bar Language Extension";
public IEnumerable<string> ConfigurationSections => null;
public object InitializationOptions => null;
public IEnumerable<string> FilesToWatch => null;
public event AsyncEventHandler<EventArgs> StartAsync;
public event AsyncEventHandler<EventArgs> StopAsync;
public async Task<Connection> ActivateAsync(CancellationToken token)
{
await Task.Yield();
ProcessStartInfo info = new ProcessStartInfo();
info.FileName = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "Server", @"MockLanguageServer.exe");
info.Arguments = "bar";
info.RedirectStandardInput = true;
info.RedirectStandardOutput = true;
info.UseShellExecute = false;
info.CreateNoWindow = true;
Process process = new Process();
process.StartInfo = info;
if (process.Start())
{
return new Connection(process.StandardOutput.BaseStream, process.StandardInput.BaseStream);
}
return null;
}
public async Task OnLoadedAsync()
{
await StartAsync.InvokeAsync(this, EventArgs.Empty);
}
public Task OnServerInitializeFailedAsync(Exception e)
{
return Task.CompletedTask;
}
public Task OnServerInitializedAsync()
{
return Task.CompletedTask;
}
}
}
Hlavní metody, které je potřeba implementovat, jsou OnLoadedAsync a ActivateAsync. OnLoadedAsync je volána, když Visual Studio načetlo vaše rozšíření a váš jazykový server je připraven být spuštěn. V této metodě můžete buď ihned vyvolat delegát StartAsync a signalizovat tak, že se má spustit jazykový server, nebo můžete provést další logiku a vyvolat StartAsync později. Pokud chcete aktivovat jazykový server, musíte někdy zavolat StartAsync.
ActivateAsync je metoda, která je nakonec vyvolána pomocí volání delegáta StartAsync. Obsahuje logiku pro spuštění jazykového serveru a navázání připojení k němu. Musí se vrátit objekt připojení, který obsahuje datové proudy pro zápis na server a čtení ze serveru. Všechny zde vyvolané výjimky jsou zachyceny a zobrazeny uživateli prostřednictvím zprávy InfoBaru v sadě Visual Studio.
Aktivace
Po implementaci třídy klienta jazyka budete muset definovat dva atributy, abyste mohli definovat, jak se načte do sady Visual Studio a jak se aktivuje:
[Export(typeof(ILanguageClient))]
[ContentType("bar")]
MEF
Visual Studio ke správě bodů rozšiřitelnosti používá MEF (Managed Extensibility Framework). Atribut Export označuje Visual Studio, že tato třída by měla být zpracována jako rozšiřující bod a načtena v příslušné době.
Pokud chcete použít MEF, musíte také definovat MEF jako prostředek v manifestu VSIX.
Otevřete návrháře manifestu VSIX a přejděte na kartu Prostředky:
Kliknutím na Nový vytvořte novou položku:
- Typ: Microsoft.VisualStudio.MefComponent
- Zdroj: Projekt v aktuálním řešení
- Project: [Váš projekt]
Definice typu obsahu
V současné době je jediným způsobem, jak načíst příponu jazykového serveru založeného na LSP, typ obsahu souboru. To znamená, že při definování třídy klienta jazyka (která implementuje ILanguageClient), budete muset definovat typy souborů, které při otevření způsobí načtení rozšíření. Pokud nejsou otevřeny žádné soubory odpovídající vašemu definovanému typu obsahu, rozšíření se nenačte.
To se provádí definováním jedné nebo více tříd ContentTypeDefinition:
namespace MockLanguageExtension
{
public class BarContentDefinition
{
[Export]
[Name("bar")]
[BaseDefinition(CodeRemoteContentDefinition.CodeRemoteContentTypeName)]
internal static ContentTypeDefinition BarContentTypeDefinition;
[Export]
[FileExtension(".bar")]
[ContentType("bar")]
internal static FileExtensionToContentTypeDefinition BarFileExtensionDefinition;
}
}
V předchozím příkladu se vytvoří definice typu obsahu pro soubory, které mají příponu souboru končící na .bar. Definice typu obsahu je pojmenována "bar" a musí vycházet z CodeRemoteContentTypeName.
Po přidání definice typu obsahu můžete definovat, kdy se má načíst rozšíření jazykového klienta ve třídě klienta jazyka:
[ContentType("bar")]
[Export(typeof(ILanguageClient))]
public class BarLanguageClient : ILanguageClient
{
}
Přidání podpory pro jazykové servery LSP nevyžaduje implementaci vlastního projektového systému v sadě Visual Studio. Zákazníci můžou otevřít jeden soubor nebo složku v sadě Visual Studio, aby mohli začít používat vaši jazykovou službu. Podpora jazykových serverů LSP je ve skutečnosti navržená tak, aby fungovala pouze ve scénářích s otevřenými složkami nebo soubory. Pokud je implementovaný vlastní projektový systém, některé funkce (například nastavení) nebudou fungovat.
Pokročilé funkce
Nastavení
K dispozici je podpora vlastních nastavení specifických pro jazyk a server, ale stále probíhá jeho vylepšení. Nastavení jsou specifická pro to, co jazykový server podporuje, a obvykle řídí, jak jazykový server generuje data. Například server jazyka může mít nastavení maximálního počtu nahlášených chyb. Autoři rozšíření by definovali výchozí hodnotu, kterou můžou změnit uživatelé pro konkrétní projekty.
Pomocí následujícího postupu přidejte podporu nastavení do rozšíření jazykové služby LSP:
Přidejte do projektu soubor JSON (například MockLanguageExtensionSettings.json), který obsahuje nastavení a jejich výchozí hodnoty. Například:
{ "foo.maxNumberOfProblems": -1 }Klikněte pravým tlačítkem myši na soubor JSON a vyberte Vlastnosti. Změňte akci Sestavení na "Content" a vlastnost "Include in VSIX" na true.
Implementujte sekce konfigurace a vraťte seznam předpon pro nastavení definovaná v souboru JSON (ve Visual Studio Code by to odpovídalo názvu sekce konfigurace v package.json):
public IEnumerable<string> ConfigurationSections { get { yield return "foo"; } }Přidejte do projektu soubor .pkgdef (přidejte nový textový soubor a změňte příponu souboru na .pkgdef). Soubor pkgdef by měl obsahovat tyto informace:
[$RootKey$\OpenFolder\Settings\VSWorkspaceSettings\[settings-name]] @="$PackageFolder$\[settings-file-name].json"Ukázka:
[$RootKey$\OpenFolder\Settings\VSWorkspaceSettings\MockLanguageExtension] @="$PackageFolder$\MockLanguageExtensionSettings.json"Klikněte pravým tlačítkem na soubor .pkgdef a vyberte Vlastnosti. Změňte akci Sestavení na Obsah a vlastnost Zahrnout do VSIX na hodnotu true.
Otevřete soubor source.extension.vsixmanifest a přidejte prostředek na záložce Asset:
- Typ: Microsoft.VisualStudio.VsPackage
- zdrojový: Soubor v systému souborů
- Cesta: [Cesta k souboru .pkgdef]
Úpravy nastavení pracovního prostoru uživatelem
Uživatel otevře pracovní prostor obsahující soubory, které vlastní váš server.
Uživatel přidá soubor do složky .vs s názvem VSWorkspaceSettings.json.
Uživatel přidá řádek do souboru VSWorkspaceSettings.json pro nastavení, které server poskytuje. Například:
{ "foo.maxNumberOfProblems": 10 }
Povolení trasování diagnostiky
Trasování diagnostiky je možné povolit pro výstup všech zpráv mezi klientem a serverem, což může být užitečné při ladění problémů. Pokud chcete povolit trasování diagnostiky, postupujte takto:
- Otevřete nebo vytvořte soubor nastavení pracovního prostoru VSWorkspaceSettings.json (viz "Úpravy nastavení pro pracovní prostor uživatele").
- Do souboru JSON nastavení přidejte následující řádek:
{
"foo.trace.server": "Off"
}
Existují tři možné hodnoty pro úroveň podrobností trasování:
- "Vypnuto": trasování je zcela deaktivováno.
- Zprávy: Trasování je zapnuté, ale sleduje se pouze název metody a ID odpovědi.
- "Podrobné": trasování je zapnuté; Celá zpráva rpc je trasována.
Když je trasování zapnuté, obsah se zapíše do souboru v adresáři %temp%\VisualStudio\L SP. Protokol se řídí formátem pojmenování [LanguageClientName]-[Datetime Stamp].log. Trasování je v současné době možné povolit pouze pro scénáře s otevřenými složkami. Otevření jednoho souboru pro aktivaci jazykového serveru nemá podporu trasování diagnostiky.
Vlastní zprávy
Existují rozhraní API, která usnadňují předávání zpráv a přijímání zpráv ze serveru jazyka, které nejsou součástí standardního protokolu jazykového serveru. Pro zpracování vlastních zpráv implementujte ILanguageClientCustomMessage2 rozhraní v klientské třídě jazyka. knihovnu VS-StreamJsonRpc se používá k přenosu vlastních zpráv mezi vaším jazykovým klientem a jazykovým serverem. Vzhledem k tomu, že rozšíření jazyka LSP je stejně jako jakékoli jiné rozšíření sady Visual Studio, můžete se rozhodnout přidat do sady Visual Studio další funkce (které LSP nepodporuje) (pomocí jiných rozhraní API sady Visual Studio) ve vašem rozšíření prostřednictvím vlastních zpráv.
Příjem vlastních zpráv
Pokud chcete přijímat vlastní zprávy z jazykového serveru, implementujte vlastnost [CustomMessageTarget]((/dotnet/api/microsoft.visualstudio.languageserver.client.ilanguageclientcustommessage.custommessagetarget) na ILanguageClientCustomMessage2 a vraťte objekt, který ví, jak zpracovat vlastní zprávy. Příklad níže:
Vlastnost (/dotnet/api/microsoft.visualstudio.languageserver.client.ilanguageclientcustommessage.custommessagetarget) u ILanguageClientCustomMessage2 a vrátí objekt, který ví, jak zpracovat vlastní zprávy. Příklad níže:
internal class MockCustomLanguageClient : MockLanguageClient, ILanguageClientCustomMessage2
{
private JsonRpc customMessageRpc;
public MockCustomLanguageClient() : base()
{
CustomMessageTarget = new CustomTarget();
}
public object CustomMessageTarget
{
get;
set;
}
public class CustomTarget
{
public void OnCustomNotification(JToken arg)
{
// Provide logic on what happens OnCustomNotification is called from the language server
}
public string OnCustomRequest(string test)
{
// Provide logic on what happens OnCustomRequest is called from the language server
}
}
}
Odesílání vlastních zpráv
Pokud chcete odesílat vlastní zprávy na jazykový server, implementujte metodu AttachForCustomMessageAsync na ILanguageClientCustomMessage2. Tato metoda se vyvolá, když je váš jazykový server spuštěný a připravený přijímat zprávy. Objekt JsonRpc se předá jako parametr, který pak můžete zachovat k odesílání zpráv na jazykový server pomocí rozhraní API VS-StreamJsonRpc. Příklad níže:
internal class MockCustomLanguageClient : MockLanguageClient, ILanguageClientCustomMessage2
{
private JsonRpc customMessageRpc;
public MockCustomLanguageClient() : base()
{
CustomMessageTarget = new CustomTarget();
}
public async Task AttachForCustomMessageAsync(JsonRpc rpc)
{
await Task.Yield();
this.customMessageRpc = rpc;
}
public async Task SendServerCustomNotification(object arg)
{
await this.customMessageRpc.NotifyWithParameterObjectAsync("OnCustomNotification", arg);
}
public async Task<string> SendServerCustomMessage(string test)
{
return await this.customMessageRpc.InvokeAsync<string>("OnCustomRequest", test);
}
}
Střední vrstva
Vývojář rozšíření někdy může chtít zachytit zprávy LSP odeslané a přijaté ze serveru jazyků. Vývojář rozšíření může například chtít změnit parametr zprávy odeslaný pro konkrétní zprávu LSP nebo upravit výsledky vrácené z jazykového serveru pro funkci LSP (například dokončení). V případě potřeby můžou vývojáři rozšíření použít rozhraní API MiddleLayer k zachycení zpráv LSP.
Chcete-li zachytit konkrétní zprávu, vytvořte třídu, která implementuje ILanguageClientMiddleLayer rozhraní. Pak implementujte rozhraní ILanguageClientCustomMessage2 ve třídě vašeho jazykového klienta a vraťte instanci vašeho objektu ve vlastnosti MiddleLayer. Příklad níže:
public class MockLanguageClient : ILanguageClient, ILanguageClientCustomMessage2
{
public object MiddleLayer => DiagnosticsFilterMiddleLayer.Instance;
private class DiagnosticsFilterMiddleLayer : ILanguageClientMiddleLayer
{
internal readonly static DiagnosticsFilterMiddleLayer Instance = new DiagnosticsFilterMiddleLayer();
private DiagnosticsFilterMiddleLayer() { }
public bool CanHandle(string methodName)
{
return methodName == "textDocument/publishDiagnostics";
}
public async Task HandleNotificationAsync(string methodName, JToken methodParam, Func<JToken, Task> sendNotification)
{
if (methodName == "textDocument/publishDiagnostics")
{
var diagnosticsToFilter = (JArray)methodParam["diagnostics"];
// ony show diagnostics of severity 1 (error)
methodParam["diagnostics"] = new JArray(diagnosticsToFilter.Where(diagnostic => diagnostic.Value<int?>("severity") == 1));
}
await sendNotification(methodParam);
}
public async Task<JToken> HandleRequestAsync(string methodName, JToken methodParam, Func<JToken, Task<JToken>> sendRequest)
{
return await sendRequest(methodParam);
}
}
}
Funkce střední vrstvy je stále ve vývoji a ještě není komplexní.
Ukázkové rozšíření jazykového serveru LSP
Pokud chcete zobrazit zdrojový kód ukázkového rozšíření pomocí rozhraní API klienta LSP v sadě Visual Studio, podívejte se na VSSDK-Extensibility-Samples LSP ukázka.
FAQ
chci vytvořit vlastní projektový systém, který doplní jazykový server LSP, aby poskytoval bohatší podporu funkcí v sadě Visual Studio, jak to mám udělat?
Podpora jazykových serverů založených na LSP v sadě Visual Studio spoléhá na funkci open folder a je navržená tak, aby nevyžaduje vlastní systém projektů. Můžete vytvořit vlastní systém projektů podle pokynů zde, ale některé funkce, jako jsou nastavení, nemusí fungovat. Výchozí logikou inicializace pro jazykové servery LSP je předání umístění kořenové složky aktuálně otevřené složky, takže pokud používáte vlastní projektový systém, možná budete muset během inicializace zadat vlastní logiku, aby se zajistilo, že váš jazykový server může začít správně.
Jak přidám podporu ladicího programu?
V budoucí verzi poskytneme podporu pro společný protokol ladění .
Pokud už je nainstalovaná jazyková služba podporovaná v sadě VS (například JavaScript), můžu stále nainstalovat rozšíření jazykového serveru LSP, které nabízí další funkce (například linting)?
Ano, ale ne všechny funkce budou správně fungovat. Konečným cílem rozšíření jazykových serverů LSP je povolit jazykové služby, které visual Studio nativně nepodporuje. Můžete vytvořit rozšíření, která nabízejí další podporu pomocí jazykových serverů LSP, ale některé funkce (například IntelliSense) nebudou bezproblémové. Obecně se doporučuje, aby se pro poskytování nových jazykových prostředí používala rozšíření jazyka LSP, a ne rozšíření stávajících jazykových serverů.
Kde můžu publikovat dokončený jazykový server LSP VSIX?
Pokyny k Marketplace najdete tady.