Vimconf.live: Neovim Builtin LSP

all right so here we go let's get started because we've got a lot to do and i'm hoping we have enough time for me to show you guys basically like a few examples we can walk through some example code i'll show you some cool sort of like extensions that you can build pretty easily and uh i i first off just have to say i rewrote my presentation and look at me in the 30 seconds in between begins and my presentations is like oh my goodness look at me it seems like the coolest way to do presentations in the terminal uh jetbrains mono is the font okay so let's get started and i'll try and show you guys some examples please if you want to see some code for some of the examples let me know and we can try and do it okay because i have several tabs up ready for us to do them so what is language server protocol the basic idea is that hey editors want to do basically a bunch of the same things in code regardless of the language so let's try and make a protocol that allows editors to get that sort of semantic info for languages without having to re-implement plugins every time and so it was first created in june 2016 by microsoft and they were working with red hat and uh code envy to get it working so for me it's very exciting because it tries to at least if not solve it at least is trying to help one of these big m times and problems right where you have m editors and n languages so every time you want to like add support for your new language or make some feature for a language you have to implement it m times which is quite annoying when you are trying to make a feature that's like quite common like go to definition or something like that and what lsp tries to do is take that m times n problem and make it an m plus n problem right just m editors need to implement lsp and n languages need to implement lsp and then suddenly that's a much more tractable style problem and in fact i i think not only does it reduce sort of that the scale i think it also motivates people more to make those improvements and tools and work basically so not only does it make the work smaller but it feels more effective when you do it so it's very exciting because you're like oh i just implemented you know go to definition for neovim and now i can do that in any language so i think it's a very exciting very cool stuff how does it work it's the basic premise is quite simple you've got a client it sends a request to the server the server's like okie doke i'll process that and sends it back to the client and then the client does stuff right so for us the client's neobin it runs a server server handles communication with other servers other language servers right and basically the way that it works is more or less like any of them will say hey uh we can do go to definition can you do go to definition and then my front end yes uh sort of in some ways i guess for neopiment um right and so we they sort of handshake and agree about what they can do and then after that uh the client is able to send requests uh so like go to definition or completion or workspace symbols these kinds of things and it also should handle notifications sent by the server right so if a server sort of has something to say like hey i there's a linting error on this line then the client should be able to handle that and then of course the client does stuff to make it happen so the server is just the thing that does all sort of that semantic understanding of the code and i the main reason i put this slide here is neovim ships with the client it does not ship with your servers so you'll need to install servers for them to work or do anything uh it would be quite a nightmare to manage every single server in one place right so instead you need to go and install those for yourself just like you would install like you know for python you could use pip to install the language server or something like that but you'll be you're sort of in charge of that kind of part of the experience so uh just a little background b and lsp um we've got right here i'll zoom in a little bit this is my first repo implementing lsp the first commit for this was 2016. we had implemented a bunch of stuff for lsp actually and this is almost all written in vimscript at the time uh lua was not as big of a feature at the time and wasn't as easy to use and prabear who's actually doing the other talk right now worked quite a bit with me and was working on his in parallel at uh them lsp which is still around today and still doing really good stuff so uh if you use vim you can check out vim lsp uh this supports them any of them though as far as i know that started back in 2016 that was when my lsp journey uh began so it's been quite a while we can actually see my first issue that i made about it uh language server implementation for neovim also in 2016 of october you know i made some fancy graphs we had a lot of chats about it there's like a lot of things you can probably see lots of things lots of talk and then i made the first edition of the pr for neovim and you can see here i had written about 4 000 lines of code but it wasn't done and i started a different job that didn't really allow me the time or space to do the open source work i wanted which i eventually left but in that time um there was a second pr by h michael who took it even further got more stuff done reworked a lot of it made it even better and then finally the sort of more of the final version that you see today was done by ashkan or norcali on github and you can see this nice diff of plus 5556 minus one now that's a feature right there that's a feature um another reason i put final right here and actually what's pretty interesting and i think quite exciting about a project like neobim is you know this started in 2016 and finished in 2019 and over that time the ideas matured and developed and got better and better and better and i think neobin is a really cool project like that because uh you know this kind of work gets picked up by someone who has the time and moves it along and we can keep those big features happening so it's quite quite exciting um cool so i put only put final on ash cans because these are all the people who have committed to the lsp files um so it's a pretty good amount of people already who have committed something in those files in the last i don't know not even a whole year yet so that's very exciting it's very active and people are doing cool work uh to make that happen i also want to just give a few shout outs to other sort of language server protocol style things if you're interested uh you don't have to use built-in lsp there are other options that you can use a language client coke.embim i know a lot of people use vim dash lse ycm and vim lsp as i mentioned before oh it's conqueror of completion uh prime so i'll try to explain a little bit about the reasoning of why we wanted to build do this built in uh if you're really interested you can check some of those pr's about like and issues about maybe the longer term reasoning of why we thought it would be really cool to add this and then really helpful for people but basically the general idea is okay we already have some precedent for this kind of thing there's c scope if you're not familiar that's sort of like language server but just for c and that's already built in and has been built in for a long time and so it's like okay we okay we sort of have this general idea we might want to do this the second part is okay um we we want something that can use the newest features of neovim but without having to maintain tons of like version checks and all this other stuff right so if you want to use virtual text or you want to support uh incremental updates well you know it's much easier if you can just write the code and have it run together with neovin so we actually like decrease a lot of maintenance burden for ourself and for other people by shipping it directly with neovit and i think the last part is maybe the most convincing at least for me reason why it should be built in is that the lsp protocol itself is really just like building blocks to things you want to do with your editor like you want to go to the definition well it's cool if we have a protocol that anyone can use to uh interact with neovim that you can just say go to definition you don't have to learn all of the neoven specifics about the right commands to use and what order all these other kinds of things you can actually just reuse the code that we use for lsp in like your plugin because it's just available to you to use so i think those are like three pretty compelling reasons why you would want to do this and i think like it also helps support this open protocol and sort of helps further the ability for neovim to be extensible so we're going to do a little bit of a tutorial just really short on how you can get started the first thing i would do is i would check out mvim lsp configs so this used to just be called mvm lsp but it was quite confusing i'll talk about that shortly and the way that if you already have for example like the go language server installed you just need to put this somewhere in your repo either in a lua file or within a lua here doc and then boom now you're talking to the go language server and you're able to have stuff working for that sometimes you might start doing more complicated setup and we allow you to do that so this one's really cool because this communicates with alua language server on startup and it actually tells it hey uh here's the version of lua i'm using here's my path which includes my plugins here's how you can find the files for vim so that you get actual completion these kinds of other things so it's really cool that we can actually sort of like compute those things at run time or based on you know like functions so that you can get even better integration to like the project that you're working on or the language that you're working with so i think that's really cool so you can sort of evolve your setup as you need starting from sometimes just this simple example and working up to maybe more complicated ones that fit your style of development or the work or the project that you're in i will just once again mention lsp configs is just where the configs are so the built-in lsp ships with neovimcore and is available to everyone this repo is just to help you get started on it it's just a small note i think people get quite confused about it so i just wanted to make sure i brought that up today while we have a chance to talk about it one other sort of core i guess like thing when you're getting started is this idea of on attach this is a function that you can pass to setup file setup functions in the uh mlsp configs and allows you to do things only in buffers that are getting attached to a server so what what do i mean by that basically what you can do is you could make your own function and this is i just made it so that i didn't have to write so much text on every line this is basically just a way of doing like a normal mapping and then this is like go to definition right control right bracket and you can map that to lua vim.sp buff.definition uh enter so this means that only in buffers that have a language server client attached to them do i make my sort of built-in uh vim movements or bindings interact with the lsp and other places then i don't i don't do that right so if i don't have an lsp set up for like go or you know some other language then it will still just use the built-in features um as as they would normally and this allows me to continue to like sort of refine and work on doing just like the best vim experience that i can make learning the right learning the right stuff that feels natural for me um and you can even do things like checking if the current file is a certain file type and doing special auto commands associated with the buffer and we're going to come back to this auto command in a little bit when we do one of the examples so like i said here this is pretty much just a way of saying like hey normally shift k means go show me the help docs for this this just like hovers that so i can give you a quick example here when we go here and we call that function hover you can see it says hey here's an example funk and the things that it has this is for this is for lua right and i think that's uh that's pretty cool so you can do that or you can do go to definition and it'll work and it'll go to the definition over here someone asked is there any cpu load when using lsp it depends on your lsp and it depends how much work you're doing um it is like it will run some of your cpu right like it's gonna do semantic understanding of the code but i think for like a lot of uh lsps they're designed to be run in the background and they do like you know they'll be slowly indexing or things like that and they're designed not to basically like spin up to ten thousand percent of all your cpus so no need to run node if your language server doesn't run note correct so i'm running some nakolua language server which is a combination of lua and then like c plus plus basically so it's just compiled into a binary and we just communicate directly over standard i o and then it runs some of the stuff in process in neovim and some of the stuff in a background job so that's basically you know two simple examples of going to definition and uh showing the hover and i would recommend that you guys basically like try and try and see if you can make the mappings for lsp match how you would normally do the things in vim and it'll start to feel like a very vim like experience yes it reuses the same server oh across multiple neo-event processes it would be possible to do but i don't know of anyone who's doing that right now they communicate over standard io to each other okay so here's a few examples of some functions that you might like to use in your project when you're setting up things i already showed you hover and definition um code action is like you can do auto imports for like um for typescript i've had it work before where you know you type the name it's not imported yet uh you can run vim.lsp.buff.codaction and it says hey do you want to import this and i say yes i do and it auto imports it into the file so it's like that's what a language server generally can do with code actions um renames pretty cool so if we go to here and we like let's say we make this function again right this example function here even though it has the same name they are not the same function this one's inside of a different scope but if i do um oops that's not the one that i want to do that's not the thing either i don't remember what my mapping is now because i am doing a demo so we'll just do the osp rename oh yeah i remember it now so then says hey what do you want the new name to be in then i'll say uh please work since it's a live demo sweet okay right so it changed this these two but it doesn't change down here so it's it's cool it's not just like search and replace right it's going to try and do semantic understanding of your code there's lots of really cool stuff uh like that uh that i think is very very nice cool yes lspd rename is a great feature for refactoring um prime it works for across files if your language server supports that so that's language server dependent but if your language server submits back to you multiple edits over different files it will work big time plus one indeed one other one that's really cool is the signature help so if we're writing a function like this i can actually see the signature help for what the function looks like which i think is quite nice to remember and so i could be typing one two and i can ask for the signature help again right so that's pretty cool so there's lots of these sort of like literal little ideas along the way um that are very helpful and they're sort of just like general purpose uh like editor things that you'd like to be able to do so i think help vim.lsp.buff shows you tons of different things that you can do and they're basically they're designed in a way that most of them don't even have to be called with any arguments they just infer what you want to do based on where your cursor is or things like that so it's really really convenient for mappings other stuff if you're writing um if you're sort of like writing code to interact with the lsp you're writing a plugin vim.lsp.org has a a lot of very helpful utilities and this is somewhat of the beginning of a standard library for both lsp and for neovim and lua and now you can do things like have jump to location which is great because uh now you can just reuse jump to location you don't have to write all the code to remember how to jump between different locations and we use jump to location inside of neovim it's built in lsp and it can it keeps track of tag stack and all that kind of stuff so actually if i uh go to the definition of this file or this function here and i hit control t it'll jump back out the tag stack but that's just using neovim's built-in tag stack feature it is not maintaining its own tag stack feature so these i think are many of them are actually very exciting building blocks for neobim in ways that you can basically start using these to write your own funk or you write your own plugins like oh i hate that i have to manage the tag stack every time i move between places well then don't let neo them do it for you and i think we'll over time hopefully expose more of these functions and allow people to use them really well uh yes and there are some tagstec improvements in a pr that we won't discuss on stream okay so that that makes sense so far that's sort of like some of the building blocks of what we can do i'm gonna do a few goals and as we go through these goals i hope to i don't know if i want to say prove um but maybe encourage you guys to believe that we are accomplishing these goals or at least making great progress on them so we want it to be lightweight we want it to be extensible we want it to be customizable and we want it to basically be in for me at least reusable so what do i mean by each of those lightweight and this shouldn't be a huge project it shouldn't take a million things not to say that there isn't a place for those kinds of projects some people like them and prefer them and that's great but obviously we can't do that inside of neo-mcor we have to have some other restraints so it's actually quite exciting i just ran this quite recently and we only have we have less than three thousand lines of uh three thousand lines of code to uh to implement the language server protocol and all of the associated things that i'm basically showing you today um so oh a couple questions here uh did anyone can you use built-in lsp without lua configuration um you can use it inside of init.vim by basically doing like lua here here docs so if you do something like lua or uh yeah like this i i don't write this off enough you could do something like this where then you do require and then lsp uh dot you know pios or whatever dot set up so you can do it inside of here this can just be in your init.bin for example you don't have to have a separate lua file you could also call this i would recommend less but you could do something like this lua eval and then require like and then lsp uh dot pyos.setup or something as well that'll also execute that in a lua process but i would recommend at least trying out some of the stuff for lsp can you guys uh you guys can't hear the my twitch notifications right okay um someone else asks docs or tutorials about writing your own i would just copy and paste exactly as tito said the editor communities love lsp but do the programming language development communities know about it definitely especially some newer languages i'm going to show you some cool features in rust i don't use rust but i i like to pretend i do for you guys so that i can look really cool and smart but i'm actually not a rust user you know what i mean you guys know how it is um cool stuff oh sorry built-in envelopes beavers coke enven versus all these other ones lots of parallel effort well yeah there are lots of parallel effort but many of them have slightly different goals i think and so that's okay they're sort of aiming for different things and also there is going to be definitely at least a time of like bike shedding where we're all sort of like fighting things into like the way that we think is best and we're gonna be like working on those and all that stuff and that's great that helps us come to a better end solution i think than if we all just said like oh we're just gonna do it this way always and there's no other way to do it so i think it's good that they're sort of i guess like competition but i don't feel that we're competing with each other i think we're all just trying to make like them and neo them a better place if that makes sense where to get started with lua for neobin first you can watch my talk yesterday and then i linked a great guide and then lua guide in there uh probably tito or someone can link it here okay so um can there be multiple language servers serving a specific file yes although there are a few other uh bugs but that's okay all right so let's let's go to an example of extensible right what do i mean what what what can we do with extensibility the first let's first do a very that's the one uh a very simple example which is just like this is pretty much what the request looks like for go to definition okay you make some params you say hey i'm in a text document and it's this file and i'm at this position i'd like to go to the definition of this thing right so you make this request and you send it to the server and then the server is going to send you back some response that just looks like this all right it's like hey you've got this file you know now it's in definition.lua and the start is here and the end is here and so then you can then you could write some function to take this result and basically you can check like hey um okay we're going to try and jump to this location if we have a list of them then we might also open the quick fix this is basically the default implementation for text document slash definition but for me sometimes or maybe for you occasionally you don't want the quick fix window open so what could you do all you'd have to do is basically make a function very similar you could remove these and then you can just do vim.lsp.callbacks set this for text document definition equal to the new callback that you have and then it works now we will reuse that callback in place of the one that we ship by default so it's very very easy to sort of like override um any sort of behavior that neo them ships with by default you can also for particular requests pass a callback and use that as well but this sort of the way to set a global callback handler so this i'm going to show you guys a quick example that hopefully works of how we imp uh on stream maybe a week or two ago we implemented a sort of server specific extension rust has this idea of inlay hints which i think is pretty cool and basically what it is is uh i made this thing it's just inlay hints so you can call it and the first thing is like it can do stuff like uh whoops did i oh i didn't execute this okay it can just tell you what the type is of the thing on the line that you're on which is pretty cool right so it's like hey this one's an i32 okay what is this one whoops uh this one's a u8 this one's a person very cool right so that's pretty neat um and we and i can show the code if you guys are interested we can go through the code i don't know if people want to see it or not um but what's really cool is since uh we just wrote the function and we sort of understand generally what's happening we can actually make it run all the time on save and then it can look like this and i did a little bit of prettying to make it uh lined up because i like it lined up not everyone likes it lined up so that's just an option you can turn that on or off but now it just tells you all of the different types of the rust code that you're writing as you go and this is sent back by the language server so every time you write your file you can just make it happen right and and this is actually quite simple we implemented this in maybe 70 lines of code and less than two hours on stream and obviously um you know two hours on stream that's uh that's not as much that it takes longer to do it on stream basically um actually yes prime i have another extension is called tweet rust and every time i open a rust file it just sends out a tweet reminding people that i use rust and not only that but i understand it so that's a separate extension i can show that maybe in the after q a you know what i mean it's just like in the after q a i can show you how we did that right um so so that's cool but we'll probably have to do that at another time so do you guys do you guys want to see the source code for this how we did this um otherwise uh i can keep going on on with the conversation question is there a way to restart the lsp yeah you can shut it down and edit the file again uh we'll probably add one okay i can yeah we can we can do it hopefully i'll show i'll show you guys okay um yeah okay so here's basically the idea there's a little bit of boilerplate here that i do to allow people to um pass in some different highlight options but you wouldn't actually have to do this um if you were just writing it for yourself you could just write the function that you want but basically this just gets a callback that returns that will handle the result okay and effectively what happens is it just says it gets each of the hints that's in the result the result actually looks like this it just has a bunch of inlay hints lists and so they have a kind arrange and a label okay and so what you can do with that is we go through the hints basically we find where they're stored we do a little bit of magic to determine how we should align them we make a little function to say hey we need to display the virtual text of this hint which uses uh enven buffs that virtual text which is really cool and then you can and we just check to make sure like hey we don't have any other virtual text on this line because we don't want to overwrite it because it's kind of low priority um virtual text and so then we just basically for each hint we display the virtual text now uh we could go over the code for longer i don't want to spend too much time on exactly like vim api right but this is uh effectively all we're doing here right we're just going to have this function that looks at the hints it turns the hints into some text and we display that text on the line right and so then to make the request all we have to do is we use vim dot buff request you can pass in zero for the current buff number we say hey uh rust analyzer please give me inlay hints we get the parameters and then we pass in this function so you could just as easily if you were writing this for yourself you could do something like let me do buff request you know zero rust analyzer i don't know if i can type and like hints and then you can do something like here params go here right and then you could just write some function that takes a result like this and this stuff is documented in the help and then it could just be like print the first thing i like to do is i just do something like vim.inspec results so this like basically just lets you you know like see what the results are okay um let me make sure i didn't miss anything else oh yeah telescope.endum is what i use for the finding the projects any recommended optimizations for using lsp with huge projects i'll show you one that i think is pretty cool uh in a little bit hrishi um have you seen the presentation jonathan rowe preventing the collapse of civilization he rants because alice view we now have microservice architecture running on the machine what do you think about that uh i haven't seen the presentation and i'm not sure that i agree with each of those items oh exactly what is being said there but we could talk about it maybe sometime uh later or at the end of the stream if other people don't have questions uh okay so does that make sense you guys generally see what i'm what i'm doing uh doing here like it's pretty easy you just make a request you say the method that you want to do you pass the parameters and then you can give it a function to run okay so that's all we did that's all we did and then we made that um i don't actually want to write this we made what i think at least is a pretty cool example of uh like showing some highlights and stuff like that right so that's one example of how at least i think it's quite easy to extend uh the lsp right so now let's let's go on to not just extend but we can also customize it quite well um in core it is going to be impossible to cover every scenario that every oh sweet awesome thanks adam um it's going to be impossible to cover basically like every single possible case that someone's going to want to uh do so the bjorn and justin always say this phrase strong opinions easily overrideable or at least they've been saying it lately and i really like that phrase because it goes it is exactly what i want to have happen for lsp so we already showed one example of how you could simply just override the default callback but i'll show another example uh quickly of how easy it is to do something which is like workspace um jimmy jimmy yeah i know that strong opinions loosely held is the way that people normally say it but that's not what i'm saying here i'm saying neil them is gonna ship often with strong opinions like better defaults or with certain things turned on or off that maybe like vim doesn't do by default but what we want is for each of them to be easily overrideable right okay we want people to be able to take those over quickly and easily so it's uh it's a sort of a general idea for what we want to do for any of them right the first time you open neo them you shouldn't feel like holy holy cow i'm lost i can't even see the text i'm doing i don't know what's happening um yes uh strong defaults much flexibility choose to on prime that's a good one as well strong opinions but stronger overrides right okay so i'll do a quick example here of workspace symbol so what is workspace symbol workspace symbol is basically a request where you can ask the language server hey i want all the things in my workspace that look like this symbol and what it normally does is it just puts all those into the quick fix list in fact um do we do we have this oh we do okay cool we have this built in by default so let me just open up like one of the files here and we can do something like lsp.buff.workspace symbol uh we don't need any quer right and so this this puts basically like all of the functions and variables all 5000 of them in this and related files into one quick fix right but that's not that helpful at least for me like this is not that helpful of a method it can be helpful if you have like a particular query maybe that you're looking for but it's not that helpful right so what you can do instead is you can sort of customize that last bit of behavior instead of putting it into the quick fix we can instead do is you can put it into your own fuzzy finder so that's what we're doing here and so we can sort of search over all of the symbols that i have in this project so if i search for like reset selection you know it finds this reset selection i can hit enter and we go to that definition which is pretty cool or uh you know we can we can search for this and then we can say like i don't know we want to search for actions close okay it's like i know it's file and actions and it's function close we'll go there boom we're there so instead so that's like that next step of customization or next step of implementation that's like really exciting about the built-in lsp at least for me is that not only can you extend it for things that don't exist in lsp standard but you can also take those standard things and make it just the way that you want it to be right does that make sense do you guys follow what does everyone understand like what i'm generally saying um oh yeah we can do uh for those of you wondering we can do uh this and split the file now but yeah so okay does that is that all you guys is i just want to make sure that before we move on the extensibility and the customizability are my two favorite features of the built-in lsp this is all just an head yeah um uh yeah what was what was your question sebastian i missed it could there be a benefit to using lsp for natural languages as well huh um perhaps if you had uh some like thing that you wanted to do you could use like an lsp to you could make like a dictionary lsp or something like that right where you're able to do something like go to the definition of a word and opens up like the dictionary or something like that i'm not sure exactly what you're looking for though uh sebastian english grammar refactor yeah maybe a rename you know if you're writing a novel and you decided you hated the character's name you could do that um okay uh we'll we'll try and move on because i want to make sure we get to the end i'm getting pretty close uh we oh right i wanted to show how easy this part was to write workspace symbol so what's really cool is i actually just reused uh neovim's built-in request for workspace workspace symbol right we get the results back and then i just do a little bit of transformation what's great is the transformation from symbols to quick fix items already exists in vim.lsp right so okay how much time do i have left adam uh so so what's great is i didn't have to write any of the code to understand how workspace symbol really works that was already happening and then i can just use the results of that to do whatever i need uh to do right does that do does that make sense i think it's quite exciting that uh we're providing sort of these building blocks for people to build on top of uh for further plug-ins or for whatever they want to do to make the vim experience great for them i think uh for people who are unaware i think these are some really great plug-ins uh completion.nbm is what i use to give that auto-completion feel right uh there's diagnostic.nvim which helps with some of the defaults in core that we have not yet ironed out and it has a much better i think default experience for people there's lsp status to provide cool stuff like telling you if you have any errors in your file um right this tells me hey you've got one error and one unexpected thing so that's pretty cool and so there's there's some very exciting things going on here and what's cool is none of these are in neovimcore and they're each they're each available to sort of augment the experience without having to do you know crazy amounts of work or things like that each one can be sort of focused on making just that thing better without having to be required in court and one pretty cool project as well is this uh embankment metals if you guys haven't seen it uh you could check it out sometime because they they have some really cool stuff here and they basically set up i is getting close to ide level in a in a good way not like a bad way of so many custom attachments and extensions that are great for this metal ls so it's cool i think we're sort of on the right track generally that we are working towards building this customizable and extensible language server sort of framework within the oven and that's basically that's basically all that i have to say about it now i will take some more questions for uh what people are wondering about does diagnostics not also show virtual text errors um oh it it should show the virtual text errors but it'll only show you like what's on the screen currently right so status can help you do some other things like that uh michael no problem no problem and if there's something that uh huge projects recommendations i'm not sure i know what you mean uh i've used i oh i use built-in clang for neo them we can we can i can show you uh where we can go to something like executor c we can go to like and lua so if i want to like look at none of those are that good of examples where do we have so here's a function here right that i want to go to this is just using built-in lsp i can go to that function and it knows it knows the function i mean neovim's a pretty decent sized project i don't have to do anything special to make it work i wonder how crazy this would be um does it not have yeah i don't know so so i i don't know i think i don't have any special recommendations for huge projects lsps are built generally to be able to handle that kind of stuff if you were going to create a reading list for someone to effectively use native lsp what would that be i would i guess it's sort of hard to hard to say effectively use native lsp i would read some of the help about it i would maybe check some people's configs about what they're doing with a built-in lsp and i think um so like you can look at mine i show what kind of mappings i'm doing and how i do them and how i set up different configurations you can read some of the comments and questions on enven mlsp configs um yeah i i don't know i think uh i i don't have any super great recommendations except just trying to play with it and explore and see how far you can get and maybe try and like write an extension for a language or customize some piece of behavior and i think that'll sort of lead you to each of the different features that you need to know status shows progress of the server yeah that's lsp status uh which is pretty cool what about refactoring the extra method to another file with the callback be responsible to create the new file or the lsb server the client would be responsible for creating the new file so we would have i don't even know if that's supported or not sort of like that complete refactor one but i don't know uh i have never tried to do exactly that yet lastly so i don't have a great great answer for you there i would love a blog post about piping lsp results into fuzzy finders okay um i mean i showed you the source code if you want it okay i can just post that but maybe i could try and write something it's not it's really not that difficult uh depending on how configurable your fuzzy finder is uh any other questions agreed oh cool awesome thanks carl i'm glad you're glad i'm glad you enjoyed it [Music] very glad very glad to help you guys out to do what i can uh oh no this one's just there we go just hanging out you know hanging out in the oven all right i'm i'm glad everybody had a great time if you uh if you want to ask questions stop by on twitch follow me on github message me on git or whatever all of that's real great so uh let let me know what you guys are interested in happy to help make issues on make issues on neovim if there's things that you at least want to work through or talk about happy to work with people to try and make it better really appreciate all the love and support and once again big shout out to all the people doing work in neovimcor making lsp better i listed all their names but uh yeah big shout out to all of them and i really appreciate it it's very uh fun seeing everybody get excited and new contributors happen so all right i think uh with that i am all done and you can go back to whatever you're going to do next i'll see you guys all in chat see ya

Channel: TJ DeVries

Views: 16,883

Rating: 4.9908676 out of 5

Keywords: Neovim, Programming, Language Server Protocol, Lua

Id: C9X5VF9ASac

Length: 43min 24sec (2604 seconds)

Published: Tue Sep 08 2020