Insticksmodulen LSP (språkserver)¶

Kodintelligens driven av Language Server Protocol — våglinjer vid fel, navigering, pekhjälp, komplettering, signaturhjälp, formatering, sök referenser, byt namn och gå till symbol — för varje språk som har en språkserver. Redigeraren talar med servern över LSP; insticksmodulen är klienten. Vilka servrar som finns är datadrivet (en liten JSON per språk), så C++/clangd nedan är bara en av flera medföljande definitioner.

Redigeraren levererar inte och laddar inte ned servrar

En språkserver är ett separat program som du installerar en gång. MTE identifierar en installerad server och pekar den mot ditt projekt; den levererar aldrig någon. Se Skaffa en språkserver.

Nuvarande funktioner¶

Funktion	Hur
Diagnostik	Fel och varningar från servern visas som vågiga understrykningar (rött = fel, bärnstensfärgat = varning, blått = information, grått = tips), uppdaterade medan du skriver.
Gå till definitionen	Sätt markören på en symbol och tryck på F12, eller använd Sök ▸ Kodnavigering ▸ Gå till definitionen. Hoppar till definitionen och öppnar en annan fil vid behov.
Sök referenser	Markör på en symbol → Shift+F12 (eller Sök ▸ Kodnavigering ▸ Sök referenser). Resultaten öppnas i en nedre panel Referenser, grupperade per fil med en förhandsvisning av källraden; dubbelklicka för att hoppa.
Pekhjälp	Låt pekaren vila över en symbol; ett popup-fönster visar dess typ eller signatur och dokumentationen (återgiven från serverns Markdown).
Komplettering	Ctrl+Space begär kompletteringar från servern och väver in dem i redigerarens kompletteringsfönster (före de inbyggda förslagen från nyckelord och buffert), filtrerade medan du skriver.
Signaturhjälp	Att skriva ett anropets `(` eller ett `,` visar ett anropstips med funktionens signatur och den aktiva parametern färgmarkerad; `)` stänger det.
Formatera dokumentet	Alt+Shift+F (`⌃⌥F` på macOS; eller Redigera ▸ Formatera dokumentet) formaterar om hela dokumentet via servern, i ett enda ångrasteg. Stilen styrs av serverns egen konfiguration (för clangd en fil `.clang-format`).
Sök referenser (listad ovan)	—
Byt namn på symbolen	Markör på en symbol → Shift+F6 (eller Redigera ▸ Byt namn på symbolen). Ange ett nytt namn; varje användning uppdateras. När namnbytet sträcker sig över flera filer ombeds du bekräfta först — varje fil öppnas, ändras och lämnas ändrad för att du ska granska och spara den.
Gå till symbol (i filen)	Ctrl+Shift+O öppnar kommandopaletten med varje symbol i den aktuella filen (funktioner, klasser, metoder…); skriv för att filtrera, Enter hoppar. Varje rad visar symbolens sort och dess behållare.
Gå till symbol i arbetsytan	Ctrl+T söker symboler i hela projektet medan du skriver (servern matchar frågan); Enter öppnar filen vid symbolen.

Väljarna för gå till symbol är kommandopalettens symbollägen — se Kommandopalett.

Kommandona gråtonas tills en server körs

Gå till definitionen, Sök referenser, Formatera dokumentet och Byt namn på symbolen är bara aktiverade när en språkserver för den aktuella filens språk är Redo — och när servern i sitt handslag rapporterade att den stöder begäran. I en fil utan konfigurerad server, eller medan en startar, startar om eller har gett upp, är menyposterna gråtonade i stället för att inte göra något när de trycks. Statusindikatorn nedan säger vilket det är. Starta om språkservrarna gråtonas aldrig: det är utvägen ur en server som gett upp.

Referenser och namnbyten över filer kräver serverns index

Sök referenser och Byt namn når andra filer först när servern indexerat projektet. För C/C++ betyder det en compile_commands.json (se nedan) och clangds bakgrundsindex; utan det arbetar de bara på den aktuella filen.

Namnbyte ångras per fil tills vidare

Ett namnbyte över flera filer tillämpas en fil i taget, så varje fil är sitt eget ångrasteg (bekräftelsedialogen säger det). Granska de ändrade flikarna innan du sparar.

Högerklicka på en symbol i texten så erbjuder menyn, under redigeringskommandona, Gå till definitionen, Sök referenser, Byt namn på symbolen och Formatera dokumentet. Varje post visas bara när samma kommando i huvudmenyn skulle fungera just nu — en språkserver för filen är redo och stöder det, och för namnbyte och formatering är dokumentet inte skrivskyddat. I en vanlig textfil, i marginalen till vänster om texten eller medan servern startar visas ingen av dem.

Posterna verkar på den symbol du högerklickade på, inte på den under markören; markören och markeringen stannar där de var. Byt namn föreslår markeringen som gammalt namn när du högerklickade inuti den, och annars ordet under pekaren. Formatera dokumentet formaterar alltid hela dokumentet. En meny som öppnas från tangentbordet verkar vid markören.

Där plattformen visar kortkommandon i snabbmenyer (Windows) visar varje post sitt kortkommando — det som gäller, inklusive dina egna ändringar i Tilldela kortkommandon. I macOS visar snabbmenyer inga kortkommandon.

Hur dina ändringar når servern¶

Att skriva skickar inte ett meddelande per tangenttryckning. Ändringar slås ihop under en bråkdel av en sekund och skickas sedan som en ändring — och som ett enda ändrat intervall snarare än hela filen, när servern säger att den klarar det (de flesta gör det). En stor fil kostar därför några tiotals byte per skrivskur i stället för en kopia av sig själv.

Allt som frågar servern om texten — pekhjälp, gå till definitionen, sök referenser, byt namn, formatera, komplettering, signaturhjälp — skickar den väntande ändringen först, så att ett svar aldrig hänvisar till en version du redan lämnat. Att spara en fil gör detsamma.

Att starta en server blockerar inte heller redigeraren: processen startas i bakgrunden och statussegmentet visar … tills den slutfört sitt handslag. En serverbinär som hänger sig vid start kostar dig inget annat än det språket.

Ett tak för hur många problem som ritas

Högst 2000 våglinjer ritas per dokument. Bortom det är filen ändå oläsbar, och varje extra markör kostar redigeraren verklig tid — så när en fil ger fler visas de första 2000 och statusraden säger Visar de första 2000 av N problem i den här filen, i stället för att antalet tyst ser mindre ut än det är. Det är oftast ett tecken på att servern ser felaktigt på filen: en saknad kompileringsdatabas, eller en genererad fil som inte är tänkt att kompilera på egen hand.

Serverns statusindikator¶

Statusraden visar ett kompakt segment LSP: (till vänster om de andra insticksmodulssegmenten) som sammanfattar varje språkserver som är relevant för dina öppna filer:

LSP: cpp ✓ · no compile database  python ↻2  rust ✗

Tecken	Betydelse
`…`	Startar — servern har startats och utför handslaget.
`✓`	Redo — betjänar begäranden.
`↻n`	Startar om — servern stoppade oväntat; automatiskt omstartsförsök n är inplanerat.
`✗`	Ingen server installerad för det här språket. Installera en (se nedan), och välj sedan Starta om språkservrarna.
`⚠`	Gav upp — servern fortsatte krascha och de automatiska omstarterna upphörde. Bara en manuell omstart väcker den.

Ett språk kan bära en kort precisering efter tecknet — servern körs, och något i ditt projekt begränsar ändå vad den kan svara på. Bara en visas i taget, den allvarligaste först:

Precisering	Betydelse
`· server not responding`	Flera begäranden i rad blev obesvarade. Servern lever men har fastnat; Visa språkserverns logg, sedan Starta om språkservrarna. Preciseringen försvinner i samma stund servern svarar på något.
`· no compile database`	C/C++-servern körs men kan bara se den fil du har öppen — se C/C++-projekt behöver `compile_commands.json`.
`· no Cargo.toml`, `· no go.mod`, `· no tsconfig.json`, …	Projektet har ingen av de filer den här servern behöver för att förstå det som ett projekt. Den fungerar ändå på den öppna filen; svar över filgränser förblir ofullständiga tills filen finns. Det exakta namnet är det servern helst vill ha — se Vad varje server behöver från ditt projekt.

Segmentet visas när det första dokumentet med ett konfigurerat språk öppnas, följer bara språk du faktiskt har dokument öppna för — att stänga ett språks sista fil tar bort dess post (att öppna en igen tar tillbaka den direkt) — och döljs helt när inget sådant dokument återstår.

Sök ▸ Kodnavigering ▸ Visa språkserverns logg visar den senaste utdatan från varje körande server. Det är där en server förklarar sig: en saknad verktygskedja, en oläsbar konfigurationsfil, ett projekt den vägrade läsa in. Fönstret är ett vanligt fönster med ändringsbar storlek — varje språk är en rubrik som namnger den server som körs för det, texten går att markera, Kopiera lägger hela loggen i urklipp, och den storlek du ger fönstret kommer ihåg.

Om en server kraschar¶

En språkserver som avslutas oväntat startas om automatiskt med en ökande fördröjning (1 s, 2 s, 4 s… med tak vid 30 s). Medan detta sker visar indikatorn ↻n och en avisering på statusraden rapporterar den första kraschen. Efter en lyckad omstart annonseras dina öppna dokument på nytt för servern och diagnostiken kommer tillbaka av sig själv; inaktuella våglinjer från den döda servern rensas direkt. Redigering blockeras aldrig.

Efter 5 misslyckade försök i rad ger insticksmodulen upp: indikatorn visar ✗, en avisering pekar dig mot inställningarna, och språket förblir mörkt tills du startar om det manuellt. En server som gått fint i minst en minut får en ny uppsättning försök när den senare kraschar.

Manuell omstart — endera av:

Sök ▸ Kodnavigering ▸ Starta om språkservrarna (inget standardkortkommando; finns även i kommandopaletten), eller
knappen Sök igen / starta om servrarna i Inställningar ▸ Språkserver.

För att se varför en server är missnöjd innan du startar om den, använd Sök ▸ Kodnavigering ▸ Visa språkserverns logg.

Båda river ned varje server, kör om sökningen med de aktuella inställningarna, och nollställer felbudgeten — använd dem efter att ha installerat en saknad server eller rättat en trasig.

Skaffa en språkserver¶

Installera servern för ditt språk och se till att den finns i din PATH (eller ange en uttrycklig sökväg i inställningarna). Hittas ingen gör funktionen helt enkelt inget för det språket — statusindikatorn visar ✗ och loggen noterar en engångsledtråd, men inget avbryter dig.

MTE levererar serverdefinitioner (inte servrarna) för många språk, så för de flesta behöver bara servern installeras — ingen JSON-redigering. De medföljande definitionerna täcker C/C++, Objective-C, Python, Rust, Go, TypeScript, JavaScript, C#, Java, Kotlin, Swift, HTML, CSS/SCSS/Less, JSON, YAML och skalskript.

Språk	Server	Var du får den
C/C++	clangd	`winget install LLVM.LLVM` (Windows), komponenten «C++ Clang tools» i Visual Studios installerare, `brew install llvm` (macOS), eller din distributions paket `clang-tools-extra`.
Python	pyright eller pylsp	`npm i -g pyright` (kräver Node.js), eller `pip install python-lsp-server` (kräver bara Python).
TypeScript/JS	typescript-language-server	`npm i -g typescript-language-server typescript`.
Rust	rust-analyzer	`rustup component add rust-analyzer`.
Go	gopls	`go install golang.org/x/tools/gopls@latest`.
C#	csharp-ls eller OmniSharp	`dotnet tool install -g csharp-ls` (ett enda dotnet-verktyg, prövas först), eller ladda ned en OmniSharp-utgåva.
Java	jdtls (Eclipse JDT Language Server)	`brew install jdtls` (macOS), eller packa upp en utgåva och lägg dess `bin` i din `PATH`.

Kontrollera i en terminal, till exempel med clangd --version eller where clangd / which clangd. För ett språk som MTE inte levererar en definition för lägger du till en enligt Lägga till ett språk.

Python: pyright eller pylsp¶

Python har två medföljande definitioner, och OctoEdit kör den som faktiskt är installerad:

pyright (pyright-langserver) prövas först. Det är ett npm-paket, så det kräver Node.js: npm i -g pyright.
pylsp (python-lsp-server) används när pyright inte hittas. Det är ett pip-paket och kräver bara Python: pip install python-lsp-server.

Är båda installerade vinner pyright. Det finns en inställningsrad för Python (en aktiveringsflagga, en sökvägsåsidosättning), och den gäller den server som används — att ange en uttrycklig sökväg till en pylsp-körbar fil kör pylsp med dess startargument, inte pyrights. Visa språkserverns logg namnger den server som faktiskt körs.

Flera servrar för ett språk

Det här är en allmän mekanism, inte ett specialfall för Python: ett språk får ha hur många medföljande definitioner som helst, ordnade av ett fält priority, och den första vars körbara fil hittas på din maskin är den som startar. C# fungerar på samma sätt — csharp-ls först, OmniSharp sedan — eftersom de två tar olika startargument och bara en av dem kan vara rätt.

Java: serverns egen arbetsyta¶

jdtls vägrar starta utan en egen skrivbar arbetsytekatalog (-data). OctoEdit tillhandahåller en automatiskt, per projekt, under sin datamapp för insticksmoduler:

<user data>/plugins/org.mte.lsp/jdtls-workspaces/<project id>/

Du behöver aldrig skapa eller namnge den. Att ta bort mappen är ofarligt — jdtls bygger den på nytt, till priset av en omindexering.

Ställa i ordning på Windows¶

En färsk Windows-maskin har oftast ingen av clangd, cmake, ninja, node eller python i sin PATH. Det här avsnittet säger var var och en kommer ifrån och hur du kontrollerar den. Du behöver normalt inte redigera PATH själv — OctoEdit söker också igenom de ekosystemkataloger som listas nedan.

Du vill ha	Installera	Var det hamnar
clangd (C/C++)	`winget install LLVM.LLVM`	`C:\Program Files\LLVM\bin\clangd.exe`
cmake och ninja	Komponenten «C++ CMake tools for Windows» i Visual Studio Installer	`…\Microsoft Visual Studio\2022\<edition>\Common7\IDE\CommonExtensions\Microsoft\CMake\CMake\bin` och `…\CMake\Ninja` — inte i din `PATH`, men nåbara genom Visual Studios utvecklarmiljö (se nedan). En fristående `winget install Kitware.CMake` / `winget install Ninja-build.Ninja` lägger dem i `PATH` i stället.
pyright (Python)	`winget install OpenJS.NodeJS.LTS`, sedan `npm i -g pyright`	`%APPDATA%\npm\pyright-langserver.cmd`
pylsp (Python, ingen Node behövs)	Python från Microsoft Store eller python.org, sedan `pip install python-lsp-server`	`%LOCALAPPDATA%\Packages\PythonSoftwareFoundation.Python.3._\LocalCache\local-packages\Python3\Scripts\pylsp.exe` (Store) eller `%APPDATA%\Python\Python3\Scripts\pylsp.exe`

Kontrollera vad som är synligt. I en vanlig kommandotolk eller PowerShell:

where clangd
where cmake
where ninja
where pyright-langserver
where pylsp

where söker bara i din PATH. Ett verktyg den inte kan hitta kan ändå hittas av OctoEdit, eftersom sökningen också täcker ekosystemkatalogerna ovan — Pythons skriptkataloger ligger i synnerhet aldrig i PATH. Förblir ett språk ✗ efter att dess server installerats, använd Sök ▸ Kodnavigering ▸ Starta om språkservrarna, som kör om hela sökningen.

Genereringen av kompileringsdatabasen körs inuti Visual Studios utvecklarmiljö. När OctoEdit kör CMake åt dig (nedan) lokaliserar den först Visual Studio — genom VSINSTALLDIR, annars vswhere.exe — och kapslar anropet i den installationens VsDevCmd.bat -arch=x64. Det är det som lägger cl, Windows SDK och Visual Studios egna cmake/ninja på sökvägen för just det kommandot, så att redigeraren inte behöver dem i din PATH alls. Utan Visual Studio (en maskin med bara clang eller MinGW) görs anropet rakt av i redigerarens egen miljö, och loggen säger det; du behöver då själv ha cmake och ninja nåbara, och en kompilator som CMake kan identifiera.

Generera om på begäran. Sök ▸ Kodnavigering ▸ Generera kompileringsdatabas… kör samma generering när som helst — även när en databas redan finns (den konfigureras om på plats) och när du tidigare svarat Fråga inte för det här projektet. Posten är alltid tillgänglig — kan den inte generera säger den varför på statusraden (inget C/C++-dokument, ingen projektmapp, ingen CMakeLists.txt i projektets rot, ingen cmake, eller ingen generator här som kan exportera en) i stället för att vara gråtonad av ett skäl du inte kan se.

Var svaret «fråga inte» lagras. Fråga inte för det här projektet behålls per projektrot i %APPDATA%\7-bits\OctoEdit.ini, under plugins/org.mte.lsp/noCompileDbPrompt/<hash> (projektsökvägen hashas eftersom en sökväg inte är en giltig inställningsnyckel). Att köra Generera kompileringsdatabas… rensar det för det projektet.

Var OctoEdit letar efter en server¶

Du ska inte behöva konfigurera något. Efter att ha installerat en server räcker det att öppna en mapp och en källfil. I tur och ordning prövar redigeraren:

en uttrycklig sökväg som du angett i inställningarna — auktoritativ: löses den inte förblir språket mörkt i stället för att tyst falla tillbaka på något annat;
din PATH, för serverns kommando och varje känt alias (clangd-20, clangd-19, …);
installationsplatserna i serverns definition för ditt operativsystem;
en inbyggd lista med ekosystemkataloger.

	Genomsökta ekosystemkataloger
Windows	npm:s globala prefix och `%APPDATA%\npm`, `%LOCALAPPDATA%\Microsoft\WinGet\Links`, `%USERPROFILE%\.cargo\bin`, `%USERPROFILE%\go\bin` och `%LOCALAPPDATA%\go\bin`, `%USERPROFILE%\.dotnet\tools`, `%ProgramFiles%\LLVM\bin`, `%ProgramFiles%\nodejs`, och Pythons skriptkataloger per användare: `%APPDATA%\Python\Python3\Scripts`, `%LOCALAPPDATA%\Packages\PythonSoftwareFoundation.Python.3._\LocalCache\local-packages\Python3\Scripts` (Python från Microsoft Store) och `%LOCALAPPDATA%\Programs\Python\Python3*\Scripts`
macOS	`/opt/homebrew/bin` och `/opt/homebrew/opt/llvm/bin` (Homebrews clangd bor i den andra — den länkas aldrig in i den första), `/usr/local/bin`, `/usr/local/opt/llvm/bin`, `~/.cargo/bin`, `~/go/bin`, `~/.local/bin`, `~/.npm-global/bin`, `~/.dotnet/tools`, `~/Library/Python/3.*/bin`
Linux	`/usr/local/bin`, `/usr/lib/llvm*/bin`, Linuxbrew, och samma `~/.cargo/bin`, `~/go/bin`, `~/.local/bin`, `~/.npm-global/bin`, `~/.dotnet/tools`

Posterna med * är riktiga jokertecken: den versionskatalog Python skapar (Python313, 3.13, eller Stores …Python.3.13_qbz5n2kfra8p0) matchas mot det som faktiskt finns på disken, nyast först. Det är dit pip install python-lsp-server lägger pylsp, och det är därför det inte kräver någon PATH-ändring att installera det.

macOS: att starta från Finder mot från en terminal

Ett program som startas från Finder eller Dock ärver inte PATH från din skalprofil — macOS ger det en minimal (/usr/bin:/bin:/usr/sbin:/sbin). Homebrew, Cargo, Go och npm skulle alla vara osynliga. OctoEdit frågar därför ditt inloggningsskal vad dess PATH är och söker även igenom den, och lämnar den resulterande miljön till den server den startar — så att en server installerad med något av de verktygen hittas oavsett hur du startar redigeraren.

Servern startas en gång per språk och stängs av med redigeraren.

C/C++-projekt behöver `compile_commands.json`¶

clangd förstår din kod korrekt bara när den känner kompileringsflaggorna, från en kompileringsdatabas (compile_commands.json). Utan en faller clangd tillbaka på gissningar och funktioner över filgränser (sök referenser, byt namn) förblir begränsade till den öppna filen. clangd startas ändå i båda fallen.

Ett C/C++-projekt räknas som konfigurerat när det har något av:

en compile_commands.json i projektets rot eller i en av de byggkataloger OctoEdit genomsöker (build/, Build/, out/, out/build/, cmake-build-debug/, cmake-build-release/, .mte-compile-commands/);
en compile_flags.txt i projektets rot;
en konfigurationsfil .clangd i projektets rot.

clangd läser de två senare själv, så inget rapporteras för dem.

När ingen av dem finns — för varje C/C++-projekt, oavsett vilket byggsystem det använder — visar statussegmentet · no compile database och ett meddelande på statusraden säger det en gång. Inget blockeras; ingen dialogruta avbryter ditt skrivande.

Låta OctoEdit generera den (CMake-projekt)¶

Har projektets rot en CMakeLists.txt och en CMake som faktiskt skulle producera en databas, erbjuds du detta en gång per projekt:

Generera — kör CMake i bakgrunden, endast konfigurering: inget kompileras och dina egna byggkataloger lämnas orörda. Resultatet hamnar i <project>/.mte-compile-commands/. Vid framgång startas clangd om mot den nya databasen; vid misslyckande visas de sista raderna i CMake-loggen, tillsammans med det exakta kommando som prövades så att du kan upprepa det själv.
Så gör du det manuellt — visar samma kommando utan att köra det.
Fråga inte för det här projektet — kommer ihåg per projektrot.

Både fönstret «så här gör du det manuellt» och felfönstret visar den exakta kommandoraden i en markerbar kodruta, ovanför en enda knapp Kopiera vars verktygstips säger vad den tar med: kommandot ensamt, eller kommandot tillsammans med slutet av CMake-loggen när en sådan finns. Felfönstret går att ändra storlek på och kommer ihåg den storlek du ger det — vart och ett av de här fönstren kommer ihåg sin egen storlek, så att förstora serverloggen får inte ett instruktionsfönster på två rader att öppnas lika stort.

Du är inte begränsad till det ena erbjudandet: Sök ▸ Kodnavigering ▸ Generera kompileringsdatabas… startar samma generering när du vill — efter att ha lagt till filer, efter att ha ändrat byggalternativ, eller efter att ha svarat Fråga inte för det här projektet (vilket den rensar). En befintlig databas konfigureras om på plats. Posten är alltid tillgänglig; kan den inte generera säger den varför på statusraden.

Dina förinställningar kommer först. Har projektet en CMakePresets.json (eller en CMakeUserPresets.json) konfigurerar OctoEdit med en av dina förinställningar i stället för att hitta på en kommandorad — cmake --preset <name> -B <project>/.mte-compile-commands -DCMAKE_EXPORT_COMPILE_COMMANDS=ON. På så sätt är generatorn, verktygsuppsättningen och förinställningens block environment (en QT6_DIR, en SDK-sökväg) de som projektet redan förlitar sig på, och CMake tillämpar dem själv. Förinställningar som är dolda, som ett condition utesluter på ditt operativsystem, eller som konfigurerar med en generator som inte kan exportera, hoppas över; ett namn som innehåller debug föredras. Din egen byggkatalog rörs aldrig — redigeraren omdirigerar alltid utdatan med -B.

På Windows körs CMake inuti en utvecklarmiljö från Visual Studio. En redigerare som startats från Utforskaren eller Startmenyn har ingen cl i sin PATH, och CMake skulle då tyst nöja sig med vilken annan kompilator den än hittar — inklusive den clang.exe som följer med inuti en Visual Studio-installation, vilken omgående misslyckas med MSVC-specifika inställningar. OctoEdit lokaliserar därför Visual Studio med vswhere och kapslar anropet i VsDevCmd.bat -arch=x64. Finns inget Visual Studio installerat (en maskin med MinGW eller bara clang) görs anropet rakt av och loggen säger det.

Ett tidigare misslyckat försök städas bort före ett nytt försök: dess CMakeCache.txt skulle annars låsa fast den kompilator som misslyckades. En katalog som redan innehåller en fungerande compile_commands.json konfigureras om på plats, aldrig borttagen.

Varför erbjudandet ibland inte visas

CMAKE_EXPORT_COMPILE_COMMANDS respekteras bara av generatorerna Ninja och Makefile; Visual Studio-generatorn ignorerar det och skriver ingen databas. På Windows visas erbjudandet därför, för ett projekt utan användbar förinställning, bara när ninja finns i din PATH. När ett projekts enda tillämpliga förinställningar är Visual Studio-förinställningar och det inte heller finns någon Ninja, säger OctoEdit vilken förinställning som stod i vägen i stället för att erbjuda sig att köra något som inte kunde fungera.

Generera den själv (CMake)¶

CMAKE_EXPORT_COMPILE_COMMANDS respekteras bara av generatorerna Ninja och Makefile — Visual Studio-generatorn ignorerar det (den producerar ingen compile_commands.json ens med flaggan satt). Generera därför databasen med Ninja, i en egen katalog, skild från den du normalt bygger i: CMake vägrar konfigurera om en befintlig byggkatalog med en annan generator, så ett projekt du vanligtvis bygger med Visual Studio behöver en egen Ninja-katalog.

Detta är ett steg med endast konfigurering (inget fullständigt bygge behövs). Från projektets rot:

cmake -S . -B .mte-compile-commands -G Ninja -DCMAKE_EXPORT_COMPILE_COMMANDS=ON

.mte-compile-commands/ är en av de kataloger MTE genomsöker, så den resulterande compile_commands.json hittas automatiskt. Vilken genomsökt katalog som helst fungerar också (build/, out/, cmake-build-*, eller projektets rot) — håll den bara skild från en katalog som konfigurerats med en annan generator.
Kör det från en miljö där projektet faktiskt konfigurerar: rätt kompilator i PATH (till exempel en x64 Native Tools Command Prompt på Windows) och alla variabler ditt projekt behöver (såsom QT6_DIR för ett Qt-projekt). Kan cmake inte hitta din kompilator eller SDK blir databasen tom eller saknar inkluderingsvägar och clangd indexerar dåligt.
Öppna mappen på nytt efteråt. Loggen bör inte längre säga «no compile_commands.json»; ge clangd en stund att bygga sitt bakgrundsindex innan referenser och namnbyten sträcker sig över filer.

Andra byggsystem: Bear (bear -- make), compiledb, Meson, Bazel med flera kan alla producera en compile_commands.json som insticksmodulen hittar.

Vilken server som betjänar vilken fil¶

Filnamnet avgör. Varje serverdefinition listar de filtillägg den betjänar, och den första definition som gör anspråk på en fils filtillägg är den som startar. Matchningen bortser från skiftläge, och bara den sista punkten räknas — Deploy.Prod.SH är ett skalskript.

Detta är medvetet oberoende av syntaxfärgningen. Att stänga av färgningen, eller att öppna en fil större än färgningens storleksgräns, kostar dig inte längre också språkservern.

Colorizer-id:t är fortfarande en reserv

Gör ingen definition anspråk på filtillägget faller OctoEdit tillbaka på det språk-id färgningsmotorn tilldelat. Det håller en handskriven definition fungerande när den namnger ett språk men inte listar några filtillägg.

Det namn servern får veta är en andra, separat sak: LSP har sitt eget ordförråd av språk-id:n, och flera av dem stämmer inte med OctoEdits. En .sh-fil annonseras som shellscript, en .scss som scss, en .jsx som javascriptreact, en .mm som objective-cpp. Servrar som beter sig olika per språk — CSS-servern, TypeScript-servern — behöver att detta stämmer.

Filtillägg	Betjänas av	Annonseras som
`.cpp` `.cxx` `.cc` `.h` `.hpp` `.hh` `.hxx` `.ipp` `.inl`	clangd	`cpp`
`.c`	clangd	`c`
`.m` / `.mm`	clangd	`objective-c` / `objective-cpp`
`.sh` `.bash` `.zsh` `.ksh`	bash-language-server	`shellscript`
`.css` / `.scss` / `.less`	vscode-css-language-server	`css` / `scss` / `less`
`.ts` `.mts` `.cts` / `.tsx`	typescript-language-server	`typescript` / `typescriptreact`
`.js` `.mjs` `.cjs` / `.jsx`	typescript-language-server	`javascript` / `javascriptreact`
`.json` / `.jsonc` `.json5`	vscode-json-language-server	`json` / `jsonc`

.h görs anspråk på av C/C++-definitionen snarare än av Objective-C-definitionen — båda kör clangd, som själv avgör vad en header innehåller.

Vad varje server behöver från ditt projekt¶

Flera servrar fungerar ordentligt bara när en viss fil ligger i projektets rot. När den saknas säger statusindikatorn det i stället för att låtsas att allt är bra:

Språk	Vill ha	Utan den
Rust	`Cargo.toml`	läser rust-analyzer inte in lådan alls.
Go	`go.mod`	kan gopls inte lösa modulen.
TypeScript	`tsconfig.json` (eller `package.json`)	är svar för hela projektet otillgängliga.
JavaScript	`jsconfig.json` (eller `package.json`)	som ovan.
Python (pyright)	`pyproject.toml` / `pyrightconfig.json` / `setup.py`	fungerar pyright ändå; den använder bara standardvärden för importrötter och stränghet.
Java	`pom.xml` / `build.gradle`	kan jdtls inte bygga en klassökväg.
C/C++	`compile_commands.json`	se avsnittet ovan.

Lägga till ett språk¶

Servrar beskrivs av JSON-filer som insticksmodulen läser in vid start från <editor>/lsp-servers/*.json, plus din egen mapp. Varje post kopplar ett språk till dess kommando plus ledtrådar för sökningen:

{
    "language":    "cpp",
    "languageId":  "cpp",
    "languageIds": { ".c": "c" },
    "command":     "clangd",
    "aliases":     ["clangd-20", "clangd-19"],
    "args":        ["--background-index", "--log=verbose"],
    "extensions":  [".cpp", ".h", ".hpp", ".c"],
    "projectMarkers": [],
    "searchDirs":      ["${LLVM}/bin", "${ProgramFiles}/LLVM/bin"],
    "searchDirsMac":   ["/opt/homebrew/opt/llvm/bin"],
    "searchDirsLinux": ["/usr/lib/llvm-20/bin"],
    "docsAnchor":  "cpp-clangd",
    "compileCommandsArg": "--compile-commands-dir=${dir}"
}

language är OctoEdits eget id för språket — nyckeln som inställningssidan, statussegmentet och anslutningen grupperas efter. command/aliases är de namn på körbara filer som prövas i PATH.
extensions är den primära kopplingen fil till språk (se ovan). Ta med punkten.
args är ett vektorelement per argument. ["--background-index", "--log=verbose"] skickar två argument; ["--background-index --log=verbose"] skickar ett argument som råkar innehålla ett mellanslag, vilket varje server avvisar — och eftersom den då avslutas omedelbart ser resultatet ut som en kraschslinga snarare än ett stavfel. OctoEdit varnar om den formen i diagnostikloggen när den läser in din fil.
languageId (valfritt) är det id som skickas till servern i didOpen; det är som standard language. Använd det när LSP-specifikationens namn skiljer sig från vårt (bash → shellscript, objc → objective-c).
languageIds (valfritt) åsidosätter languageId per filtillägg, för en server som betjänar flera språk i specifikationen.
projectMarkers (valfritt) är de filnamn servern vill ha i projektets rot. Finns inget av dem där säger statussegmentet ingen <first marker>; det stoppar aldrig servern.
searchDirs är listan över installationsplatser för Windows; searchDirsMac och searchDirsLinux är dess motsvarigheter per plattform. Alla tre expanderar ${VAR}, och POSIX-listorna expanderar även ett inledande ~. En post vars variabler inte är satta hoppas över i stället för att bli en meningslös sökväg.
args får använda två platshållare: ${dataDir}, insticksmodulens skrivbara datamapp, och ${rootHash}, ett kort stabilt id för det aktuella projektet. Det är så jdtls får sitt -data <dir>. En platshållare som inte kan lösas lämnas kvar ordagrant i argumentet i stället för att expanderas till ingenting.
compileCommandsArg (valfritt) läggs till sist, med ${dir} ersatt av den funna databaskatalogen — det är så clangd pekas mot compile_commands.json.
priority (valfritt, standard 0) ordnar flera definitioner av samma språk: det lägsta talet prövas först, och den första definition vars körbara fil hittas är den som startar. Det är så Python får pyright (priority: 0) med pylsp (priority: 10) som reserv.

Dina egna serverdefinitioner¶

De medföljande definitionerna bor inuti installationskatalogen, som inte är din att redigera (Program Files på Windows, ett signerat programpaket på macOS). Lägg dina egna bredvid dem i stället: Inställningar ▸ Språkserver ▸ Öppna mappen med användarens serverdefinitioner skapar och öppnar

<user data>/plugins/org.mte.lsp/lsp-servers/

Varje *.json i den läses in efter den medföljande uppsättningen, och:

en fil vars language och command stämmer med en medföljande definition ersätter den — det är så du ändrar clangds argument eller lägger till en sökkatalog;
allt annat läggs till — en andra server för ett språk vi levererar, eller ett språk OctoEdit inte levererar något för alls.

En fil som inte är giltig JSON, eller som saknar language eller command, hoppas över och rapporteras i diagnostikloggen i stället för att tyst kosta dig ett språk.

Definitioner läses en gång, vid start: starta om redigeraren efter att ha redigerat dem (knappen Sök om / starta om servrar kör om sökningen, inte inläsningen).

En minimal egen definition: <user data>/…/lsp-servers/zig.json

{
    "language":   "zig",
    "command":    "zls",
    "extensions": [".zig", ".zon"],
    "projectMarkers": ["build.zig"],
    "searchDirs":      ["${LOCALAPPDATA}/zls"],
    "searchDirsMac":   ["/opt/homebrew/bin", "~/.local/bin"],
    "searchDirsLinux": ["~/.local/bin"]
}

Vilken mapp servern får¶

En språkserver behöver veta var projektet är: rust-analyzer läser inte in en låda utan det, gopls behöver modulroten, pyright läser pyrightconfig.json från den, och clangd letar efter sin databas där.

Med en mapp öppen (Fil ▸ Öppna mapp) hör filer inuti den till den mappen.
För en fil utanför den öppna mappen, eller utan någon mapp öppen alls, vandrar OctoEdit uppåt från filen och letar efter compile_commands.json, compile_flags.txt, .clangd, CMakeLists.txt, Cargo.toml, go.mod, pyrightconfig.json, pyproject.toml, setup.py, tsconfig.json, package.json, pom.xml, build.gradle, en .sln, .git, och slutligen en .editorconfig som deklarerar root = true. Filens egen katalog är reserven, så att en server aldrig lämnas utan ett projekt.
Att öppna mappen efter filen fungerar. Servrar som förstår ändringar av arbetsytemappar får veta om den nya mappen; resten startas om, och dina öppna dokument annonseras automatiskt på nytt för dem. Ingen manuell omstart behövs.

Felsökning¶

Symtom	Vad du kontrollerar
Segmentet `LSP:` visas aldrig	Ingen serverdefinition gör anspråk på den här filens filtillägg. Se vilken server som betjänar vilken fil, eller lägg till en definition.
`· server not responding`	Servern har slutat svara. Visa språkserverns logg, sedan Starta om språkservrarna.
`✗` för ett språk du installerat en server för	Bekräfta att den körbara filen verkligen finns där: `where clangd` (Windows) / `which clangd` (macOS, Linux). Välj sedan Sök ▸ Kodnavigering ▸ Starta om språkservrarna, som kör om hela sökningen.
`⚠`	Servern startade och fortsatte sedan krascha. Visa språkserverns logg namnger oftast skälet; rätta det och välj sedan Starta om språkservrarna.
`· no compile database` i ett C/C++-projekt	Se ovan. Sök referenser och Byt namn ser bara den öppna filen tills det är åtgärdat.
Kompletteringen ger inget i en C++-fil	Den filen saknas troligen i `compile_commands.json` (en header som ingen översättningsenhet inkluderar, eller en fil som lagts till sedan databasen genererades). Generera om den.
Allt fungerar vid start från en terminal men inte från Finder	Rapportera det — uppslagningen av inloggningsskalets `PATH` är tänkt att göra de två identiska. Visa språkserverns logg och diagnostikloggen noterar vad som söktes igenom.
En server behöver en projektfil du inte har	`typescript-language-server` behöver paketet `typescript`, gopls en `go.mod`, rust-analyzer en `Cargo.toml`, pyright en `pyrightconfig.json`/`pyproject.toml` för svar över hela projektet.

Inställningar för språkservern¶

Inställningar ▸ Språkserver listar varje språk som det finns en serverdefinition för. Per språk kan du:

Aktivera / inaktivera servern (ett inaktiverat språk startar aldrig någon).
Ange en uttrycklig sökväg till den körbara filen (med Bläddra…). Den här åsidosättningen vinner över sökningen i PATH/searchDirs ovan — användbart när servern inte finns i PATH eller när du vill ha ett visst bygge.
Lägga till Extra argument, tillagda efter definitionens egna — till exempel --log=verbose för clangd. Raden delas upp som en kommandorad, så sätt citattecken runt ett värde som innehåller mellanslag.

Sökvägsfältet är en sökväg, inte en kommandorad

Att skriva C:\tools\clangd.exe --log=verbose i Sökväg till programmet ber OctoEdit hitta en fil vars namn slutar på .exe --log=verbose, vilket inte finns — språket rapporterar då ingen server alls. Lägg den körbara filen i sökvägsfältet och dess argument i Extra argument. Händer det ändå säger diagnostikloggen det med tydliga ord.

Ändringar får effekt när du trycker på OK / Verkställ: har någon aktiveringsflagga eller sökväg faktiskt ändrats startas servrarna om automatiskt med de nya inställningarna (en orörd sida stör aldrig de körande servrarna). Knappen Sök igen / starta om servrarna framtvingar dessutom en nedrivning och ny sökning med de aktuella inställningarna — användbart efter att ha installerat en server redigeraren tidigare inte kunde hitta, och den nollställer också budgeten för omstart efter krasch.

Öppna mappen med användarens serverdefinitioner skapar och öppnar den mapp som beskrivs i Dina egna serverdefinitioner.

Begränsningar¶

Färgning av kod inuti pekhjälpsfönster tillämpas inte (texten formateras — fetstil, rubriker, fast bredd för kod — men syntaxfärgas inte).
Noggrannheten beror på servern: för C/C++ faller clangd utan compile_commands.json tillbaka på tumregler och resultaten kan bli ofullständiga.
OctoEdit installerar eller laddar aldrig ned en server. Den hittar en du installerat och startar den; finns ingen förblir funktionen mörk och statussegmentet säger det.
En serverprocess per språk, delad av varje öppet projekt i det språket. Ett andra projekt läggs till som en arbetsytemapp när servern stöder det; annars betjänas det under det första projektets rot.
Kotlin, Swift och Objective-C får kodintelligens men ingen syntaxfärgning — redigeraren har ingen färgläggare för dem ännu. De två är oberoende nu, så servern fungerar oavsett.
Serverdefinitioner läses en gång vid start; att redigera dem (dina eller de medföljande) kräver en omstart av redigeraren.