Rust IDE

[hoary oasis]

What IDE do you use for rust?

I use visual studio code with rust-analyzer

[radiant knot]

that's pretty much the default, best-supported setup

[radiant narwhal]

here's a previous thread on the subject:
https://discord.com/channels/273534239310479360/938907999567757392

[calm granite]

would argue, Jetbrain's Rust addon is really good aswell

[unkempt storm]

Vim/neovim make a pretty good rust ide with the right plugins, but I'd only recommend that if you're already familiar with vim

[calm granite]

https://github.com/NvChad/NvChad + rust-analyzer 🤔

[orchid blade]

Whether you prefer working with code from the command line, or using rich graphical editors, there’s a Rust integration available for your editor of choice. Or you can build your own using the Rust Language Server.

https://www.rust-lang.org/tools

[visual ridge]

100%, it's even better with CLion & their LLDB interface

[calm granite]

yeah the debugging capabilities are insane

[delicate barn]

would argue you need CLion to have a comparable experience

[visual ridge]

It's still very good in their other IDEs but CLion is definitely better

[calm granite]

well yeah, CLion comes with better integrations for native debugging

but it is still supported trought LLDB on other IDEs

i have CLion, i gotta enjoy CLion

the fact that the Rust extention is maintained by Jetbrains themselves makes it really good too

[real island]

CLion with the Rust extension is absolutely amazing.

[high berry]

You can debug Rust?

[visual ridge]

Yup

Interactive debugging with breakpoints et al

You need CLion though

Which is one of JetBrains paid for IDEs

I have it for free through GitHub student pack

[high berry]

Me too

I love it

If only it wasn't hideously expensive for my third world salary

[cobalt burrow]

the trick is making your employer to pay for your work tools

[high berry]

Yeah, my current one doesn't. They are a VSC house, and I don't like it.

[calm granite]

[ripe sonnet]

Emacs with lsp-mode!

[radiant knot]

clion + jetbrains rust is very very good

even though it uses a gig of ram lul

[calm granite]

i'm fine with my 10yo PC with CLion so ?

and i have both my browser and testing envorinements open

[earnest field]

Neovim with nvim-lsp is great stuff

[radiant knot]

i use clion and vscode

[halcyon oriole]

I'm using rust-analyzer with kakoune on unix-like systems and vscode on windows because jetbrains ides are unecessary heavy

[tacit bolt]

what are some resources/plugins you would recommend for configuring neovim?

[earnest field]

My setup, though it's not really rust-specific) is:
nvim-lsp with rust-analyzer for LSP
nvim-cmp for completion
nvim-tree-sitter (+ the rust parser)
telescope (git_files lets you navigate the entire git repo, which in Rust's case happens to be the entire project)
nvim-dap for debugging

[native galleon]

In my experience Clion with Intellij-Rust has worked better than VSCode with rust-analyzer. I also love the autocompletion on Cargo.toml dependency versions and crate features, which VSCode does not yet have as far as I know. I do use both, but mostly CLion.

[neat blade]

that is like not true

anyway just here to shill doom emacs

[radiant knot]

rust-analyzer is best-in-class and iirc officially focuses on the experience within vscode

you can make the argument that neovim or some other language client just work as well, and that's true. but IME they are always sort of second-class next to vscode when it comes to how well things are tested

[neat blade]

its still all provided via an LSP

[radiant knot]

I know what an LSP is

i'm saying not all language clients are equal

[neat blade]

in my experience emacs is the same as vscode but ik the bindings

[radiant knot]

so my experience is with coc-neovim mostly. i know of bugs that are neither attributable to the client nor the server (both follow the spec), but will never be fixed because rust-analyzer devs focus on vscode when it comes to ensuring overall good experience

then you have hacks like https://github.com/pr2502/ra-multiplex which exist exactly because rust-analyzer doesn't do a lot to cater to short-lived editor sessions, which are much more common in a terminal-based editor than vscode

[radiant knot]

I share the same view as you. Even though there are tons of plugins in vscode that have things like cargo.toml support clion just does a better job and makes things feel neater.

[radiant knot]

sublime + ra

[vestal geode]

Few years back coc.nvim was the slowest thing ever, it used to spawn multiple heavy nodejs threads and makes the whole setup potato. I used it for couple years but then switched to nvim-lsp. I don't what's the stat of coc.nvim, i guess they improved.

[sonic anvil]

i use clion with the rust plugin, i tried vscode with its own rust plugin but had problems setting the environment and it didn't work very well

but there are some issues with the clion and rust plugin like the type inference doesn't always work like how the compiler does and it often misses issues with the borrowing system which makes it hard as a beginner to learn because i need to wait for it to compile in order to get the error

[cobalt burrow]

just in case,you do know about the "Run external linter to analyze code on the fly" mode, right? https://plugins.jetbrains.com/plugin/8182-rust/docs/rust-code-analysis.html#external-linters

[sonic anvil]

i did not actually

i will try that thanks

[calm granite]

bottom bar, right side

[radiant knot]

Anyone know why you dont get hints for macros in club? Like I can do use macros and such for clion

Like when using other libraries like serde

[calm granite]

adding support for procedural macros is not possible is it ?

[unkempt storm]

Since proc macros are Turing complete and can generate arbitrary code from arbitrary input, any support for proc macros would need to be on a per-macro basis

Like, with declarative macros at least the compiler knows what role each part of input plays, like, if it's an expression, a type, just a directly-matched token, etc; so it's possible to treat parts of the input as code and know that it can be analysed properly as code; and often know for certain that the same input will exist in some form in the output. But with proc macros, there's no guarantee that any part of input correlates to any part of output.

[calm granite]

i know that CLion can add highlighting for items in declarative macros but procs, as mentioned, are just too powerful

[clear mortar]

CLion has experimental support for proc macro expansion

[unkempt storm]

Do you mean, hinting based on the expansion of the macro? Or just previewing the expansion?

[calm granite]

gotta go try and see

[radiant knot]

i can highlight my cursor over and see what it's about

but apart from that i can't really do much

[sand violet]

The one true editor, Emacs

[unkempt storm]

I have since started using helix and it is:
1: as capable as my previous neovim setup, but without needing any plugins (at least not yet)
2: so much more expressive

[little finch]

Chaotic evil: Visual Studio 2022 (/s)

incredible fact thnough, you actually can use the profiling tools that VS provides with rust, running VS22, at least with this extension. I haven't tested without

[orchid blade]

wow

[brazen gorge]

CLion with the rust plugin feels like it was just made for rust

plus with CLion you can use the debugger for rust too

[visual ridge]

the debugger is just LLDB with a nice interface lol, nothing particularly fancy

[cobalt burrow]

s/LLDB/LLDB with custom patches and GDB/

[visual ridge]

Ah ok

Still, the nicest thing is the interface

[cobalt burrow]

well,there're a lot of other moving parts too. for example, https://www.jetbrains.com/help/clion/debug-as-root.html required a lot of internal machinery to work properly

[visual ridge]

intellij products are always nice to use 🙃 it's one of the reasons I have the full pro pack

only thing I ever have against them is the insane amount of ram usage but tbh any good IDE is going to have that problem so

[calm granite]

you can tweak JVM args

and yeah the Rust plugin for the JB pkatform is from JB themselves

[brazen gorge]

imagine how much more efficient they’d be if they were written in rust 😛

[visual ridge]

[cobalt burrow]

yeah, i'm afraid that any advanced rust ide just needs to store lots of data about the codebase. in case of ijrust it certainly can be optimized more but at least some low hanging optimizations were already implemented (manually crafted PSI stubs, for example)

[visual ridge]

every (good) IDE suffers from it, it just sucks :P

[native galleon]

Anyone else excited to try the upcoming Jetbrains Fleet IDE? It seems to be like a Jetbrains' own VSCode

[visual ridge]

Yup I'm excited lol

[sharp yew]

Bit late to this(I just jumped into this channel) 🙂 but I’m suspecting that they’re kicking off their dogfooding strategy with Rust to address a lot of the concerns with their JetBrains products. You can see some of the Rust tools that they’re implementing in the new Fleet product. I’m only speculating here, but I could see that as a good strategy for boosting performance in the backend whilst also retaining their support for Kotlin and using it for the frontend such as UI and CI/CD in Space

I don’t have a computer atm and have been using my iPad for dev work - so I decided to embrace Helix-editor as my editor of choice. It’s been pretty good so far! A few kinks here and there such as pasting long files which locks up the program, but it’s been great in terms of LSP support

[unkempt storm]

I remember clipboard pasting (with shift+insert) being slow on my desktop (it basically treated it as typing out the clipboard content) until I learned space p does clipboard paste without that issue.
Maybe that's the same issue you're having?

[sharp yew]

Ah yeah true I think you’re right! I only use cmd + v. Thanks for pointing that out

[unkempt storm]

You're welcome!

[cobalt burrow]

🤔 it feels like people significantly overestimate the amount of rust code in fleet - it's only used by a couple of relatively small modules

[sharp yew]

Yeah totally. There are a minute number of modules that are implemented in Rust in Fleet. But what I’m alluding to is that there could be a precedent that’s set to test out how it fairs for them

[cobalt burrow]

well, maybe - there's a significant amount of rust sympathizers here, including the CTO himself. on the other hand, Rust was meant to be used more widely in Fleet but early experiments gave mixed results for anything but the most low-level stuff that doesn't rely too much on the ecosystem. also, the war isn't helping with resources for experiments at all - many hundreds of russian employees are being relocated away and those who refused are already laid off.

[sharp yew]

@cobalt burrow Oh interesting regarding the experiments. Have you got anything for me to read on? I’d love to know more.

I also didn’t even consider how JB is being affected by the war. Thanks for pointing that out

[cobalt burrow]

i don't think that there were any official publications on that - i just participated briefly in one of these experiments (webrender-based frontend) as my "20% project" back when i was in the clion team

[sharp yew]

Ohh gotcha! Well thanks for sharing some insights then

[ocean rain]

Vim and the rust coc lsp

[tame arch]

I use visual studio 2022 without any kind of intellisense/rust-analyzer

[brazen gorge]

I use notepad

[grizzled owl]

I used to use vscode with rust-analyzer but it stopped working for a multi crate project with only a few external crates. So I started using Jetbrains, it's kinda bloatware but it does not fail

[calm granite]

it is fat but it is worth, im waiting to see how will JetBrains new Fleet IDE get over that

they really seem to like Rust given the Rust extension is from JetBrains themselves

[cobalt burrow]

(as i've said a few messages before) there's a significant amount of rust sympathizers in jb, but overall the company is a jvm stronghold and won't move away from it too much. rust is unlikely to be used for anything that can be done in kotlin

[cobalt burrow]

as far as i know 1) fleet uses a new architecture that forbids freezing of the gui thread 2) everything is as modular as it can get, but if you enable many smart features you're basically getting all the same "bloat" from the main idea platform

[calm granite]

yeah

[little finch]

doesn't vs have really bad code navigation without some language plugins? i remember it not accounting for tokens like '/"/=/etc, like notepad, without the aforementioned

at least that's my experience writing js on the side in a project with vs22

[tame arch]

VS has language highlighting, which is all I need since I made a custom template for rust.
With this template I get the full power of the IDE, which includes breakpoints, and built-in profiling.

[little finch]

ah, i see

the profiling is great

[tame arch]

as it turns out VS can pretty much work with any language as long as there is a .pdb

[little finch]

crucial even

[little finch]

yep

[tame arch]

here is the template in case anybody is mildly curious https://github.com/Razordor/Rust-VS-Template

[elfin surge]

is there anything beyond syntax highlighting without a bulky editor like VSCode?
i can’t get emacs to work well

[visual ridge]

It is possible to get emacs working with rust-analyzer iirc

@elfin surge

https://rust-analyzer.github.io/manual.html#emacs

[elfin surge]

i got rustic working but there is no code completion
the only thing i see is syntax highlighting and indents

also it’s been pretty annoying so i’d prefer not to use it

[brazen gorge]

if you like vim, rust-lang/rust.vim is pretty good

[elfin surge]

i dont
making it work will take as long as if not longer than emacs

[blazing tree]

I use Atom

[radiant knot]

I personally use hxd.

[elfin surge]

atom is a little heavier than vscode

[muted night]

i also am seeking something lighter than vscode

[violet prism]

I've been using Clion and the Rust Language plugin.
It skemtimes is a bit odd - I kinda work by Compiler Driven Development

[elfin surge]

i’m using sublime rn
it basically does just syntax highlighting but i guess it’s fine.

[unkempt storm]

I'm using helix more and more and I can't get over how powerful it feels compared to vim
And I've used vim for almost 10 years straight

[low rampart]

I've always used vscode

[radiant acorn]

neovim

https://github.com/notusknot/dotfiles-nix/tree/main/config/nvim

i like it more than vscode

[radiant knot]

Clion. I just love the ergonomics and the ecosystem. The actual Rust plugin....less so.

[tall bloom]

what about that new one built in rust

[unkempt storm]

You mean helix?

http://helix-editor.com

[tall bloom]

that too. But i was thinking of the GUI one that kinda looks like vscode

[radiant knot]

rust-analyzer + errorlens + codelldb in vscod(ium) is definitely a very productive, high quality experience, the official "Rust" plugin is deprecated

[brazen gorge]

you mean jetbrains fleet?

it's not really built in rust

its built in kotlin with a rust daemon

but yeah it looks very promising, won't know until it comes out of closed preview

[radiant knot]

I'm personally really excited for fleet. Native polyglot support looks really awesome since I'm about to add dart to my workflow. I'm really excited for jetbrains to focus more on remote development too. Love the idea of centralizing everything onto one machine.

[brazen gorge]

yeah, the remote development was already a great feature, that + code with me is gonna be great

[tall bloom]

i was more thinking lapce

which kinda seemed like they wanted rust first. Fleet with rust analyzer would prob be pretty good though

[runic bloom]

does anyone have experience with adding extra arguments to the vscode run/debug config in json? I need to run my unit tests sequentially and cargo test -- --test-threads=1 works fine in the command line and even in clion, but it seems to be ignored when I add the -- --test-threads=1 part in the vscode config

here's the config

{
    "type": "lldb",
    "request": "launch",
    "name": "Debug unit tests in executable 'project'",
    "cargo": {
        "args": [
            "test",
            "--no-run",
            "--package",
            "project",
            "--bin",
            "project",
             "--",
             "--test-threads=1"
        ],
        "filter": {
            "name": "project",
            "kind": "bin"
        }
    },
    "args": [],
    "cwd": "${workspaceFolder}"
}

[cerulean isle]

thank you for making me try errorlens - it is very cool

[calm granite]

you added it after -- which tells cargo to ignore every subsequent argument and pass it as an argument the app

[runic bloom]

but the command is written like that on The Book™

this is the output if I take out the --:
```Running cargo test --no-run --bin my-project --package my-project --message-format=json -- --test-threads=1...
error: Found argument '--bin my-project' which wasn't expected, or isn't valid in this context

Did you mean '--bin'?

If you tried to supply `--bin my-project` as a value rather than a flag, use `-- --bin my-project`

USAGE:
cargo.exe test --no-run --bin [<NAME>]

For more information try --help```

[calm granite]

i highly doubt that, place -- at the very end

[runic bloom]

still the same output as above

the only difference is that it says did you mean '--test' instead of '--bin'

[visual ridge]

This seems more like a discussion for #dev-tools?

[runic bloom]

sure, I'll post it there
thanks

[runic bloom]

take a look https://doc.rust-lang.org/book/ch11-02-running-tests.html#running-tests-in-parallel-or-consecutively

[calm granite]

oh huh then i guess this argument goes to the generated tester itself

[runic bloom]

never heard of that, what do you mean?

[calm granite]

cargo test compiles a testing executable, and that executable itself has its own set of arguments, it says that in the very same page

[runic bloom]

oh, right, so it must mean that in the launch.config I need to find a way to pass those arguments to the binary

but I still have to figure out how

for comparison, in CLion I just put -- --test-threads=1 at the end of the command string and it works

[runic bloom]

I finally found a way, do you want to post it?

[brazen gorge]

gitlens is also useful, especially if you're working on a collaborative project or maintaining older code

[radiant knot]

I believe jetbrains mentioned they're going to be pushing LSP support, but, they also seem to be invested in bringing their own native intellij plugin to fleet. Makes me worry that RA may be a second class citizen, and their rust plugin has some long standing performance and stability issues esp. with the GNU toolchain.

I switched to jetbrains products because VScode and all the plugins did not play nice on my machine. CLion is much more stable for me but the code analysis integration with cargo-check and clippy are very laggy and much more prone to false positives somehow.

[calm granite]

i almost never encountered issues with CLion + IJ-Rust

[jaunty wigeon]

Both main types of setups have their pros and cons. I tend to favor IntelliJ Rust plugin (with CLion) but I also like to use Rust Analyzer + LSP client (usually VSCode) sometimes. It depends.

I think it's pretty easy to predict that Rust Analyzer and LSP technology will win out. It tends to offer better integration. The problem is just that VSCode's UX is pretty bad.

I think once JetBrains releases a stable version of Fleet, there will be a clear winner. JetBrains offers a superior developer experience. The problem is that their current architecture doesn't play well with LSP. Fleet intends to support the protocol. That would mean we get to have the UX provided by JetBrains and the language integration and support of LSP-powered technologies such as Rust Analyzer.

We're just in a sort of weird place right now. Rust's boom in popularity makes it difficult to create tooling that keeps up with the language. It's like we're all constantly playing catchup.

I think a lot of people tend to look at it as "RA / LSP vs IntelliJ plugin" but it's not really like that. They both benefit from each other and clearly derive inspiration from each other. I think the most likely scenario is that the IntelliJ plugin and Rust Analyzer will essentially converge, with the IntelliJ plugin gradually being phased out.

[somber cliff]

they're made by the same person

[jaunty wigeon]

What is?

[somber cliff]

RA and the intellij plugin

[jaunty wigeon]

Where did you get that idea? That's simply not true.

[somber cliff]

I forgot where i saw the congrats post for matklad and intellij

but if you lookup the repositories

he's top contributor for both (excluding bots)

[cobalt burrow]

https://github.com/intellij-rust/intellij-rust/graphs/contributors matklad was a lead ijrust dev for the first couple of years indeed - before he started ra

[somber cliff]

ok slight lie cause there's another jetbrains employee that's actually the top contributor now

[somber cliff]

which happens to have responded here haha. hi 👋

[jaunty wigeon]

Correct. The IntelliJ Rust plugin was what inspired him to create his own implementation.

I don't think it's accurate to claim that they are both "made by the same person". I do understand what you're saying, though.

[cobalt burrow]

:D

[cobalt burrow]

I think it's pretty easy to predict that Rust Analyzer and LSP technology will win out. It tends to offer better integration.
btw, what kind of integration do you mean here? one of the reasons to keep developing ijrust is that we're not limited by lsp and thus can provide tighter integration with the idea platform (and fleet in future)

[brazen gorge]

honestly if fleet has a setting similar to vscode where you manually save and then rust analyzer runs, that’d be perfect (currently in CLion the choice is manually clicking an obscure button to run analysis or having it run every time you stop typing)

[cobalt burrow]

sounds like https://github.com/intellij-rust/intellij-rust/issues/7765.
atm you can get a similar workflow by selecting a cargo clippy (or check) run configuration: running the normal build command (ctrl+9 by default) should use the same profile and show the build panel with all errors and warnings now. the errors won't be highlighted in the editor though.

maybe this was your "obscure button" option, not sure :D

[jaunty wigeon]

My apologies for the very vague assertion with regard to "better integration". I will elaborate.

I believe the best solution involves an implementation that leverages LSP to create a "base" or foundation to build upon. Once you have that, you could, hypothetically, build your own extensions and features that enhance the capabilities provided by LSP. LSP has its limits. I cannot speak for JetBrains as I don't work for them, however, I have a strong feeling that they understand this.

JetBrains is not like Microsoft; JetBrains has historically been focused on one thing (developer tooling, IDE's) and on doing that one thing extraordinarily well. I would be lying if I were to say that I fully understand how IDE's work.

I'm not an expert or anything. I was just stating some general trends that I've observed. I think the introduction of the language server protocol has just made things sort of strange.

For example, remote (SSH / Docker containers) development is probably going to be a big thing. If I'm on my Macbook and want to write Rust code that'll be running on Linux, the easiest solution right now is to use VSCode to do that. VSCode is the only way to utilize that technology right now in a productive way.

With that said, I think that will not be true for very long. I'm extremely excited for Fleet. JB does amazing work so I can't wait for it. I also may just not understand what Fleet really is... but I'm assuming from what I've seen that it will have the capabilities that will make for an ideal dev environment for Rust.

[cobalt burrow]

just want to note it's not like jb is going to abandon its main platform in favor of fleet (at least any time soon) - there're other onging projects for remote development, like https://blog.jetbrains.com/blog/2021/12/03/dive-into-jetbrains-gateway

[brazen gorge]

hmm, I meant more like pressing ctrl s to see them highlighted in the editor, but tbh I can live without it so not a big deal

im just waiting for fleet public preview

[jaunty wigeon]

I understand that. I wouldn't expect them to. I just hope that they do invest into things like remote development. It's a big selling point for some people. For others, it may not matter. I really don't know :/

Yea, external tools can be run on save but they will not output highlighting to the editor. I imagine that would be very hard to do since there is not really a common interface or API to work with.

Anyway, I just want to make sure it's clear that I am not saying jb is doing things wrong or what not. Quite the opposite. I'm literally working in CLion as we speak. I normally resort to vscode or neovim only for features that are rather esoteric.

[cobalt burrow]

"run external linter on the fly" already parses json output from cargo/clippy/rustc and shows in-editor highlighting based on that - this logic is "just" not generalized for other workflows, so i guess on-demand mode will get in-editor highlighting someday too

[jaunty wigeon]

That's a really good point. I absolutely love how the new "Actions on Save" feature was implemented. Being able to run clippy "on the fly" was always a huge reason why I love my clion setup. The recent edition of being able to run external linter with custom arguments and toolchain is awesome. Those are some of my favorite features

Also, I can't seem to find a setup that allows such precise code navigation. The various "Go to..." actions simply are not as good in VSCode. I feel like I'm now just praising JB lol.

I still think that IntelliJ Rust and Rust Analyzer both have their merits.

[willow vessel]

Using Intellij rust is actually really good anyways

[radiant knot]

Clion, can't recognize my toolchain

[brazen gorge]

anyone know how well fleet will perform compared to CLion?

[somber cliff]

should be way similar/faster than vscode if their claims are true

I'm still not convinced that the jvm is fast. But I guess it's not the tool but how you use it.

[brazen gorge]

I mean

vscode is electron isnt it

[somber cliff]

I mean i'm convinced that the jvm can be used to build a fast and lightweight text editor it's just I don't really trust what future updates would do to the editor. Plus I still don't like the jvm anyways

[brazen gorge]

its plausible

[somber cliff]

yeah and it's not fast

if I had to bet it's faster than vscode slower than sublime

[brazen gorge]

and hopefully if anyone knows how to optimize kotlin code it's jb

[somber cliff]

I wish there was a good well supported native editor similar to vscode.

vscode is so damn slow sometimes

[visual ridge]

JVM is one of the fastest interpreted runtimes out there, it's incredibly well optimized

[somber cliff]

agreed but garbage collector stutters

[thin sequoia]

I like to use vscode with a few rust specific extensions. Error lens is great but, can be annoying. better toml is great, crates is a must have and, rust-analyzer is preinstalled when I made my first .rs file XD

[visual ridge]

GCs stutter in any interpreter, they're not perfect. JVM has one of the best around though

[cobalt burrow]

idea's freezes are almost never caused by gc, at least for the last 17 or so years.

it's the read/write action threading system is usually to blame - https://plugins.jetbrains.com/docs/intellij/general-threading-rules.html - basically, it's too easy to accidentally either lock the ui thread or do too much computation inside it. it was an ok-ish approach in early 2000th but by modern standards it's a hard-to-debug legacy. there's a long-running initiative to find a way to get rid of it without breaking all the idea codebase and third-party plugins but we're not there yet.

meanwhile fleet's ui was built from scratch without this issue.

[calm granite]

yeah, the JVM is still an impressive achievement, and the main drawback is the memory footprint

and the GC is only an issue when incorrect configured

[tawny parrot]

neovim + vim-lsp

[lament pulsar]

I think that Visual Studio would be the best IDE for Rust in Windows. Think about it.

Too bad that there's almost no extensions for that, and those that exist aren't very stable.

[unkempt storm]

"think about it" isn't really an argument except for people already familiar with (and enjoying) developing in Visual Studio

[tall bloom]

visual studio is the worst IDE. Not just for rust. For any language

[lament pulsar]

Why?

[tall bloom]

because its so laggy and cluttered. Theres also vscode

[visual ridge]

I don't really have much of an opinion here but if you're finding VS laggy and cluttered... well, I can agree with the cluttered part - a lot of the UI doesn't make sense if you're not used to it. However laggy; you're probably on an older version of VS

[lament pulsar]

yeah

[visual ridge]

Last few times I've used VS (mostly for the profiling tools and building OSS C/++ projects etc) it's been incredibly light on ram and very fast/responsive

[unkempt storm]

My experience using vs for just about all my coding at work over the last 2 years: it's an ide for c#. If I need to use c#, I'll use vs. otherwise, I'll use vim helix

It's not exceptionally anything as far as I can tell

But, I guess that tells me that unlike a lot of IDEs, it doesn't often get in the way of what I'm trying to do (outside of a few frustrating recurrent issues with the designer view and resx files)

[lament pulsar]

I think that Visual Studio would be great for rust.

[unkempt storm]

Is there anything to that beyond "think about it"?

[lament pulsar]

Visual Studio as an IDE for C++, therefore debugging for C++ which means low level debugging. Low level debugging for Rust would be nice

[visual ridge]

Try CLion if you want good debugging for Rust

[lament pulsar]

clion cost money

[visual ridge]

However LLDB and GDB both work with rust programs

[visual ridge]

Depends what you use it for

[lament pulsar]

hobby projects

[visual ridge]

JetBrains have so many ways to get discounts

well yeah that isn't covered

[lament pulsar]

plus in visual studio you have a "Configure Project" window, where you can configure the compiler with a gui. It could be useful to configure Cargo like that

[jaunty wigeon]

I switched today to an (older) macbook pro that runs ubuntu. I have an extra laptop and so I use it like one would use a container or vm.

For some reason, it seems to be running CLion really, really well. Perhaps I borked my vmoptions and caused some issue on my macbook (the newer 2018 macbook pro that runs MacOS).

Anyway, idk. CLion + Rust plugin is imho the best IDE setup. There are definitely some occasions where Rust Analyzer is able to provide information that IJ-Rust cannot (yet) but those cases are pretty rare. The opposite is very rarely true.

[lethal shore]

I used to use CLion for rust projects, but I recently switched to vscode + RA since it's a bit lighter on resources and feels more snappy IMO

[peak heart]

Just installed Clion trial based on people using it here, but immediately getting detected errors (use of moved value, possible uninitialized value) when the project compiles and runs just fine. Anyone else had this?

[visual ridge]

Yeah the memory check errors aren't always perfect. I've submitted a bug report or 2 and had it fixed near instantaneously in the past when I've come across them. I'd post about it in #dev-tools.

If it's a pressing issue though you can tell CLion to use the output from cargo check.

[visual ridge]

CLion admittedly isn't as snappy as VSCode on less powerful machines, that's probably what you're running into

[peak heart]

Yeah didn't have this issue with Idea by JetBrains also, but the debugging sounds interesting in Clion. I'll try submitting a bug report thx

[jaunty wigeon]

It's good also to be aware of the experimental checks that are / are not on by default.

There are some features (and inspections) that are considered "experimental" although imho they've proven to be quite stable. I believe some of these may have changed recently. Not 100% sure. Just something to consider when searching for answers to why you are getting incorrect error results

Yea, I did a fresh install of CLion today and I'm glad you guys brought that stuff up because I just checked the experimental settings. Features such as build script evaluation and procedural macro expansion aren't enabled by default due to being considered unstable.

[lethal shore]

My system is pretty powerful though

[visual ridge]

¯_(ツ)_/¯

Idk your system but I used to find CLion laggy on my old laptop

[tribal wren]

IntelliJ + Rust Plugin best

[mellow trellis]

Except for today. It is giving me all kinds of inline errors, but cargo build and clippy give 0 errors or warnings

[mellow trellis]

yeah i have the same issue now

I have just invalidated all caches in CLion and that fixed it

[peak heart]

Thank you I will try that. Actually suddenly have the issue in Idea IDE too, it's like suite wide suddenly. I will try to clear cache

Hmm even that didn't solve it. I'll wait for their support to get back to me

[lament pulsar]

Can intellij do the same as Clion?

I mean Clion is Intellij based

[mellow trellis]

It doesn't have native profiling support I think

[lament pulsar]

I heard someone say to me that, Clion can be free if you play your cards right.
Do you guys pay for Clion, or use some kind of loophole?

I want to try Clion

[visual ridge]

I get it on a student license. All I write is OSS stuff & private unsold projects

[lament pulsar]

So if I fill in my student email address. Would my school be able to see it?

[lament pulsar]

^

[visual ridge]

I got it through the GitHub student pack, I authorized my student status through GitHub ¯_(ツ)_/¯

I've no idea if your school would be able to see anything, but I don't think they would, and even if they did, why does it matter?

[lament pulsar]

Idk, I think that it would be weird for them to see that.

[visual ridge]

Why? You're just using the email to verify that it's an actual educational organisation. If your school saw anything it would likely just be proof that you're going out of your way to learn stuff outside of school.

[lament pulsar]

Okay, i'm going to get a "GitHub Student Developer Pack" first, and then send that to JetBrains.

[visual ridge]

not exactly how it works

https://education.github.com/pack

Follow the instructions here

get the student pack

[lament pulsar]

@visual ridge a verifiable school issued email address?

Isn't it just a normal school email address=

[visual ridge]

is one way to get the pack, yes

[visual ridge]

your school needs to be recognised by GitHub as an educational institution

if it isn't already then they'll recognise most schools fairly easily

there are also other ways to verify

[lament pulsar]

like the ones jetbrains offers?

or github?

[visual ridge]

Both

Read up on the options, all the info you need is on the websites

[lament pulsar]

My current school isn't valid, but my school in my next school-year is. So i gotta wait

[peak heart]

I tried for an OSS license but my project only has 50 stars so... Guess I'll have to see how generous jetbrains is feeling lol

[left geyser]

Just throwing this out there: vim + rust-analyzer is just as good of a tool as any of them. The only issue I've had with this setup is that sometimes you need to close out of vim and reopen (possibly there is a refresh command for rust-analyzer) sometimes.

[radiant acorn]

agreed

[brazen gorge]

if your school hands out student ids, you can use that to verify

my high school wasn't shown as supported but they accepted me automatically anyways

[tawny parrot]

Starting to learn rust with neovim and vim lsp altough it's a bit slow (probably a rust-analyzer problem rather then a neovim/vim-lsp problem) it's good

[brazen gorge]

true, but tbh since I use a ton of different languages at the moment I really dont wanna go through the whole thing of installing plugins for all of them

[radiant acorn]

what plugin are you using for lsp?

[calm granite]

neovim supports lsps as of 5.0 and rust-analyzer is the golden standart everywhere

[tawny parrot]

vim-lsp

[radiant acorn]

neovim native lsp is standardized now, you should try it

very fast in my experience

[tawny parrot]

i want to try it

the documentation is very confusing

and I never got it to work

can you share your config? Is it lua? @radiant acorn

[radiant acorn]

https://github.com/neovim/nvim-lspconfig

yeo

https://github.com/notusknot/dotfiles-nix/tree/main/config/nvim

[tawny parrot]

thank you

[radiant acorn]

(if youre using nix/home manager i have a live stream setting it up)

[radiant knot]

I use the linux terminator terminal.

on a debian distro.

[radiant knot]

oh wait this renamed from #text-editor

This is my setup

Sublime + Rust analyzer

Colour scheme is One dark

Theme is default dark