This will be a (hopefully coherent) story about how Rust LSPs work, from the perspective of both rust-analyzer and Rust Glancer: how things that seem easy turn out to be hard, things that seem hard turn out to be even harder, and things I didn't expect to exist at all somehow do.

LSP is more of a guess game, where at each step all you are presented with is the potentially incorrect state, and your goal is to guess what would make sense for the user.

TL;DR: I believe Odin’s inline assembly is currently the best out of any language.

The most important aspects are of this article listed below. I am not aware of any other assembly (GCC/Clang/Rust/Go…) that would combine all of these aspects:

* Inline assembly is organized into asm “templates”, similar to and callable as procedures.
* asm templates integrate with rest of the code, through bindings specifying clobbers, pinned, tied, and scratch registers.
* Assembly syntax is unified across ISAs and consistent with Odin syntax.
* Assembly is fully type checked, just like rest of Odin code.
* Understanding that assembly is actually typed.
* Real semantic diagnostics via core:rexcode encoding tables.
* It was built in ~7 days.

To print a comma-separated list, a concise idiom is to optionally print the comma first, before the element:

for (items, 0..) |item, item_index| {
    if (item_index > 0) std.debug.print(", ");
    std.debug.print("{}", .{item});
}