The bottom emoji breaks rust-analyzer

$ sudo apt install emacs-nox

$ cargo new bottom
     Created binary (application) `bottom` package
$ cd bottom/
$ emacs

;; in `~/.emacs`

(require 'package)
(add-to-list 'package-archives '("melpa" . "https://melpa.org/packages/"))
(add-to-list 'package-archives '("gnu"   . "https://elpa.gnu.org/packages/"))

(package-refresh-contents)
(package-install 'use-package)

(require 'use-package-ensure)
(setq use-package-always-ensure t)

(use-package rustic)
(use-package lsp-mode
  :ensure
  :commands lsp
  :custom
  ;; what to use when checking on-save. "check" is default, I prefer clippy
  (lsp-rust-analyzer-cargo-watch-command "clippy")
  (lsp-eldoc-render-all t)
  (lsp-idle-delay 0.6)
  (lsp-rust-analyzer-server-display-inlay-hints t)
  :config
  (add-hook 'lsp-mode-hook 'lsp-ui-mode))

(use-package lsp-ui
  :ensure
  :commands lsp-ui-mode
  :custom
  (lsp-ui-peek-always-show t)
  (lsp-ui-sideline-enable nil)
  (lsp-ui-doc-enable t))

(custom-set-variables
 ;; custom-set-variables was added by Custom.
 ;; If you edit it by hand, you could mess it up, so be careful.
 ;; Your init file should contain only one such instance.
 ;; If there is more than one, they won't work right.
 '(package-selected-packages '(lsp-ui rustic lsp-mode ## cmake-mode)))
(custom-set-faces
 ;; custom-set-faces was added by Custom.
 ;; If you edit it by hand, you could mess it up, so be careful.
 ;; Your init file should contain only one such instance.
 ;; If there is more than one, they won't work right.
 )

$ which rust-analyzer
/home/amos/.cargo/bin/rust-analyzer

$ rust-analyzer --version
rust-analyzer 0.0.0 (caf23f291 2022-07-11)

$ rm $(which rust-analyzer)

$ emacs src/main.rs

(cut)
Server rls:83343/starting exited (check corresponding stderr buffer
for details). Do you want to restart it? (y or n)

$ which rustc
/home/amos/.cargo/bin/rustc

$ rustc -V
rustc 1.67.1 (d5a82bbd2 2023-02-07)

$ rustup show active-toolchain
stable-x86_64-unknown-linux-gnu (default)

$ rustup which rustc
/home/amos/.rustup/toolchains/stable-x86_64-unknown-linux-gnu/bin/rustc

$ ~/.rustup/toolchains/stable-x86_64-unknown-linux-gnu/bin/rustc -V
rustc 1.67.1 (d5a82bbd2 2023-02-07)

$ rustup component add rust-analyzer
info: downloading component 'rust-analyzer'
info: installing component 'rust-analyzer'

$ which rust-analyzer

(it prints nothing)

$ rustup which rust-analyzer
/home/amos/.rustup/toolchains/stable-x86_64-unknown-linux-gnu/bin/rust-analyzer

$ ~/.rustup/toolchains/stable-x86_64-unknown-linux-gnu/bin/rust-analyzer
{}
[ERROR rust_analyzer] Unexpected error: expected initialize request, got error: receiving on an empty and disconnected channel
expected initialize request, got error: receiving on an empty and disconnected channel

$ emacs src/main.rs
(cut)
Server rls:86574/starting exited (check corresponding stderr buffer for details).
Do you want to restart it? (y or n)

$ $(rustup which rust-analyzer) --version
rust-analyzer 1.67.1 (d5a82bb 2023-02-07)

$ $(rustup +1.67.0 which rust-analyzer) --version
rust-analyzer 1.67.0 (fc594f1 2023-01-24)

$ unzip -l rust-lang.rust-analyzer-0.4.1398@linux-x64.vsix
Archive:  rust-lang.rust-analyzer-0.4.1398@linux-x64.vsix
  Length      Date    Time    Name
---------  ---------- -----   ----
     2637  2023-02-10 00:29   extension.vsixmanifest
      462  2023-02-10 00:29   [Content_Types].xml
    15341  2023-02-09 18:46   extension/icon.png
     1036  2023-02-09 18:46   extension/language-configuration.json
    12006  2023-02-09 18:46   extension/LICENSE.txt
   415788  2023-02-10 00:29   extension/out/main.js
   298705  2023-02-09 18:46   extension/package-lock.json
    86857  2023-02-10 00:29   extension/package.json
      756  2023-02-09 18:46   extension/ra_syntax_tree.tmGrammar.json
     2422  2023-02-10 00:29   extension/README.md
 41073816  2023-02-10 00:29   extension/server/rust-analyzer
   648798  2023-02-10 00:29   extension/node_modules/d3-graphviz/build/d3-graphviz.min.js
   279449  2023-02-10 00:29   extension/node_modules/d3/dist/d3.min.js
---------                     -------
 42838073                     13 files

$ which rls
/home/amos/.cargo/bin/rls

$ rls
error: 'rls' is not installed for the toolchain 'stable-x86_64-unknown-linux-gnu'
To install, run `rustup component add rls`

$ echo $?
1

;; under (use-package lsp-mode
;; in the :custom block
  (lsp-rust-analyzer-server-command (list (string-trim (shell-command-to-string "rustup which rust-analyzer"))))

$ chmod +x ~/.cargo/bin/rust-analyzer
$ hash -r
$ rust-analyzer --version
rust-analyzer 1.67.1 (d5a82bb 2023-02-07)

;; in `~/.emacs`

;; cut: everything before that line

(require 'use-package-ensure)
(setq use-package-always-ensure t)

(use-package rustic)
;; 👇 new!
(use-package company-mode)

fn main() {
  // 🥺
  println!("Hello, world!");
}

fn main() {
    println!("{:02x?}", "abc".as_bytes());
}

$ cargo run --quiet
[61, 62, 63]

$ cargo add widestring
    Updating crates.io index
      Adding widestring v1.0.2 to dependencies.
             Features:
             + alloc
             + std

fn main() {
    // this is a macro, it does the right thing
    let s = widestring::u16str!("abc");
    println!("{:04x?}", s.as_slice());
}

$ cargo run --quiet
[0061, 0062, 0063]

fn main() {
    // this is a macro, it does the right thing
    let s = widestring::u16str!("abc");
    {
        let u16s = s.as_slice();
        let (_, u8s, _) = unsafe { u16s.align_to::<u8>() };
        println!("{:02x?}", u8s);
    }
}

fn u16_slice_to_u8_slice(s: &[u16]) -> &[u8] {
    unsafe {
        // Safety: u8 slices don't require any alignment, it really doesn't
        // get any smaller without bit-twiddling
        s.align_to::<u8>().1
    }
}

fn main() {
    // this is a macro, it does the right thing
    let s = widestring::u16str!("abc");
    {
        let u16s = s.as_slice();
        let u8s = u16_slice_to_u8_slice(u16s);
        println!("{:02x?}", u8s);
    }
}

$ cargo run --quiet
[61, 00, 62, 00, 63, 00]

const S: &str = "é";

fn main() {
    println!("{S:?}");
    println!("UTF-8   {:02x?}", S.as_bytes());
    println!(
        "UTF-16  {:02x?}",
        u16_slice_to_u8_slice((widestring::u16str!(S)).as_slice())
    );
}

fn u16_slice_to_u8_slice(s: &[u16]) -> &[u8] {
    unsafe {
        // Safety: u8 slices don't require any alignment, it really doesn't
        // get any smaller without bit-twiddling
        s.align_to::<u8>().1
    }
}

$ cargo run -q
"é"
UTF-8   [c3, a9]
UTF-16  [e9, 00]

$ cargo run -q
"œ"
UTF-8   [c5, 93]
UTF-16  [53, 01]

$ cargo run -q
"ぁ"
UTF-8   [e3, 81, 81]
UTF-16  [41, 30]

const S: &str = "ぁ";

fn main() {
    println!("{S:?}");
    println!("UTF-8   {:02x?}", S.as_bytes());
    println!("UTF-16  {:02x?}", (widestring::u16str!(S)).as_slice());
}

$ cargo run -q
"ぁ"
UTF-8   [e3, 81, 81]
UTF-16  [3041]

$ cargo run -q
"𠀀"
UTF-8   [f0, a0, 80, 80]
UTF-16  [d840, dc00]

$ cargo run -q
"🥺"
UTF-8   [f0, 9f, a5, ba]
UTF-16  [d83e, dd7a]

$ gdb --quiet
(cut)
(gdb) p/x 0xd83e - 0xd800
$1 = 0x3e
(gdb) p/x 0xdd7a - 0xdc00
$2 = 0x17a

(continued)

(gdb) p/t 0x3e
$3 = 111110
(gdb) p/t 0x17a
$4 = 101111010

(continued)

(gdb) p/x (0x3e << 10) + 0x17a + 0x10000
$5 = 0x1f97a

fn main() {
    let mut s = String::from("amos");
    s.replace_range(0..1, "c");
    dbg!(s);
}

$ cargo run -q
[src/main.rs:4] s = "cmos"

fn main() {
    let mut s = String::from("amos");
    // why b'c'? because 'c' is a char, whereas b'c' is a u8 (a byte).
    unsafe { s.as_bytes_mut()[0] = b'c' };
    dbg!(s);
}

fn main() {
    let mut s = String::from("🥺");
    unsafe {
        s.as_bytes_mut()[3] = b'#';
    };
    dbg!(s);
}

$ cargo run --quiet
[src/main.rs:6] s = "�#"

fn main() {
    let mut s = String::from("🥺");
    s.replace_range(3..4, "#");
    dbg!(s);
}

$ cargo run --quiet
thread 'main' panicked at 'assertion failed: self.is_char_boundary(n)', /rustc/d5a82bbd26e1ad8b7401f6a718a9c57c96905483/library/alloc/src/string.rs:1811:29
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

$ RUST_BACKTRACE=1 cargo run --quiet
thread 'main' panicked at 'assertion failed: self.is_char_boundary(n)', /rustc/d5a82bbd26e1ad8b7401f6a718a9c57c96905483/library/alloc/src/string.rs:1811:29
stack backtrace:
   0: rust_begin_unwind
             at /rustc/d5a82bbd26e1ad8b7401f6a718a9c57c96905483/library/std/src/panicking.rs:575:5
   1: core::panicking::panic_fmt
             at /rustc/d5a82bbd26e1ad8b7401f6a718a9c57c96905483/library/core/src/panicking.rs:64:14
   2: core::panicking::panic
             at /rustc/d5a82bbd26e1ad8b7401f6a718a9c57c96905483/library/core/src/panicking.rs:111:5
   3: alloc::string::String::replace_range
             at /rustc/d5a82bbd26e1ad8b7401f6a718a9c57c96905483/library/alloc/src/string.rs:1811:29
   4: bottom::main
             at ./src/main.rs:3:5
   5: core::ops::function::FnOnce::call_once
             at /rustc/d5a82bbd26e1ad8b7401f6a718a9c57c96905483/library/core/src/ops/function.rs:507:5
note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace.

// in `src/main.zig`

const std = @import("std");
const ChildProcess = std.ChildProcess;
const StdIo = ChildProcess.StdIo;
const File = std.fs.File;
const Thread = std.Thread;

const DEBUG = false;
const DEBUG_LEAKS = false;
const CLEANUP_STREAMS_WORKAROUND_NAME = ".cleanupStreamsWorkaround";

fn debug(comptime fmt: []const u8, args: anytype) void {
    if (DEBUG) {
        std.debug.print(fmt, args);
    }
}

pub fn main() !void {
    var alloc: std.mem.Allocator = undefined; // like the behavior

    var gpa: ?std.heap.GeneralPurposeAllocator(.{}) = undefined;
    // this `defer` cannot live inside the `if DEBUG_LEAKS` block, because then
    // the allocator would be deinitialized before our program even runs.
    defer if (gpa) |*g| {
        std.debug.print("Checking for memory leaks...\n", .{});
        std.debug.assert(!g.deinit());
    };

    if (DEBUG_LEAKS) {
        // can't figure out how to elide the type name here
        // assigning apparently promotes from `GPA` to `?GPA`
        gpa = std.heap.GeneralPurposeAllocator(.{}){};
        // ...but we still need to 'unwrap' it here (could get away
        // with a temporary variable)
        alloc = gpa.?.allocator();
    } else {
        alloc = std.heap.page_allocator;
    }

    // note: on Linux, this ends up using `fork+execve`. this is a bad idea,
    // as others have found out before: https://github.com/golang/go/issues/5838
    //
    // I was curious why passing `rustup` here worked: for me it had to either
    // parse `PATH` or go through a shell of some sort. Turns out it _does_ parse
    // `PATH` (falling back to `/usr/local/bin:/bin:/usr/bin`) and then does
    // a _bunch_ of `execve` calls in a row, continuing until it doesn't return
    // "AccessDenied" or "FileNotFound".
    var res = try ChildProcess.exec(.{ // anonymous struct literal
        // C99 syntax, yum
        .allocator = alloc,
        .argv = &[_][]const u8{ "rustup", "which", "rust-analyzer" },
    });
    // `ExecResult` doesn't have a `deinit` method, if you don't call these
    // you have a leak
    defer alloc.free(res.stdout);
    defer alloc.free(res.stderr);

    var ra_path = x: { // block with a label
        // I'm not sure why I have to pass `u8` here instead of it being inferred
        var splits = std.mem.split(u8, res.stdout, "\n");
        // breaking the label - blocks aren't expressions, so this is how
        // it's done. note that `first()` doesn't return `?[]const u8`, it's
        // infallible
        break :x splits.first();
    };
    // ra_path is a slice of res.stdout, so we can't free it first
    debug("RA path = '{s}'\n", .{ra_path});

    var proc = ChildProcess.init(
        // the array length can be inferred (from `_`), but the element type cannot
        &[_][]const u8{ra_path},
        alloc,
    );
    // nothing's stopping you from assigning `proc.stdin` etc. at this stage
    // but it won't do anything.
    proc.stdin_behavior = StdIo.Pipe;
    proc.stdout_behavior = StdIo.Pipe;
    proc.stderr_behavior = StdIo.Inherit;
    try proc.spawn();

    // the first argument is `SpawnConfig`, its only member right now
    // is `stack_size`, which defaults to 16MiB.
    //
    // the third argument is a tuple, which corresponds to the arguments of
    // the function you pass. the function takes a single argument which is an
    // anonyomus struct, hence the `.{.{}}` dance
    var copy_stdin = try Thread.spawn(.{}, forward, .{.{ .alloc = alloc, .dir = "to-server", .src = std.io.getStdIn(), .dst = &proc.stdin.?, .close_on_eof = true }});
    // this avoids an `expected *T but got *const T` error
    var our_stdout = std.io.getStdOut();

    // close_on_eof is omitted here, so it takes the default value (which is nice)
    var copy_stdout = try Thread.spawn(.{}, forward, .{.{ .alloc = alloc, .dir = "from-server", .src = proc.stdout.?, .dst = &our_stdout }});

    copy_stdin.join();
    copy_stdout.join();

    var term = try proc.wait();
    // note: "structs implement Debug", sort of — printing a `StringHashMap`
    // will make you really sad. any field that's `[]const u8` will be printed
    // as an array of numbers
    debug("term = {}\n", .{term});

    try std.fs.cwd().deleteFile(CLEANUP_STREAMS_WORKAROUND_NAME);
}

// note: `!void` means "return any error or void" (and then you can match on that).
// we could also list every possible error type we return, but it's a lot:
// error{AccessDenied,BadPathName,DeviceBusy,FileBusy,FileLocksNotSupported,
// FileNotFound,FileTooBig,InvalidHandle,InvalidUtf8,IsDir,NameTooLong,NoDevice,
// NoSpaceLeft,NotDir,PathAlreadyExists,PipeBusy,ProcessFdQuotaExceeded,
// SharingViolation,SymLinkLoop,SystemFdQuotaExceeded,SystemResources,
// Unexpected,WouldBlock}
//
// dst is a pointer, because we have to be able to close it _and_ replace it
// with a valid file descriptor, see below.
fn forward(args: struct { alloc: std.mem.Allocator, dir: []const u8, src: File, dst: *File, close_on_eof: bool = false }) !void {
    // note: no destructuring assignment, gotta keep the language small 🤷
    var alloc = args.alloc;
    var src = args.src;
    var dst = args.dst;

    // note: removing the `@as` complains about something comptime related
    var msg_number = @as(usize, 1);
    // note: try is sorta like `?` in Rust, it bubbles up any error
    var tmp = try std.fs.openDirAbsolute("/tmp", .{});

    // you can have tagged enums but you need to define two types
    const StageTag = enum {
        headers,
        body,
    };
    const Stage = union(StageTag) { headers: void, body: struct {
        headers: std.StringHashMap([]const u8),
        content_length: usize,
    } };

    var stage = Stage{
        // `{}` is void, not sure why
        .headers = {},
    };

    const delimiter = "\r\n\r\n";
    // note: intentionally starting with a small buffer to test realloc
    var buffer: []u8 = try alloc.alloc(u8, 10);
    // this makes me nervous, what if `buffer` is re-assigned before free-ing?
    // which value gets freed, the first one or the last one?
    defer alloc.free(buffer);

    // using `@as` would've been an option here too, not sure why
    // some std library code prefers `@as` to this:
    var read: usize = 0;

    while (true) {
        debug("buffer is {} bytes\n", .{buffer.len});

        // note: this does nothing in ReleaseFast and ReleaseSmall modes
        std.debug.assert(read < buffer.len);

        var n = try src.read(buffer[read..]);
        debug("read {}\n", .{n});
        if (n == 0) {
            debug("zero-length read, probably EOF\n", .{});
            if (args.close_on_eof) {
                dst.close();
                // `Process.wait` closes any stream that has StdIo.Pipe behavior,
                // but since we've already closed it, it'll reach "unreachable"
                // code when it notices close returned .EBADF.
                // Unfortunately we really _do_ need to close it here, so we
                // substitute another valid file descriptor to work around this.
                dst.* = try std.fs.cwd().createFile(CLEANUP_STREAMS_WORKAROUND_NAME, .{});
            }
            return;
        }
        read += n;
        debug("{} bytes in buffer\n", .{read});

        switch (stage) {
            StageTag.headers => {
                debug("Looking for CRLF\n", .{});
                x: {
                    // `orelse` unwraps optionals, going from `?T` to `T`.
                    // we use a labelled break to break out of this switch arm
                    // if we haven't found CRLF yet.
                    //
                    // we once again have to specify `u8` even though we're
                    // passing a `[]u8`
                    //
                    // note: `buffer[..n]` is not valid syntax, but `buffer[n..]` is.
                    var index = std.mem.indexOf(u8, buffer[0..n], delimiter) orelse break :x;

                    debug("found CRLF at {}\n", .{index});
                    var msg = buffer[0..index];
                    debug("msg = {s}\n", .{msg});

                    // this hashes keys as strings - `AutoHashMap` is very
                    // unhappy if you try to use it with `[]const u8` keys
                    var headers = std.StringHashMap([]const u8).init(alloc);

                    var splits = std.mem.split(u8, msg, "\r\n");
                    while (splits.next()) |line| {
                        var tokens = std.mem.split(u8, line, ": ");
                        // essentially "strdup", very important since there's no
                        // concept of ownership in zig: de/re-allocating after
                        // that would make the hashmap point to garbage
                        var k = try alloc.dupe(u8, tokens.next().?);
                        var v = try alloc.dupe(u8, tokens.next().?);
                        try headers.put(k, v);
                    }

                    var content_length_s = headers.get("Content-Length").?;
                    var content_length = try std.fmt.parseUnsigned(usize, content_length_s, 10);
                    debug("content-length = {}\n", .{content_length});

                    // note: overlapping src/dst are fine as long as you're
                    // copying to the left, not to the right.
                    std.mem.copy(u8, buffer, buffer[index + delimiter.len ..]);
                    read -= (index + delimiter.len);

                    stage = Stage{
                        .body = .{
                            .headers = headers,
                            .content_length = content_length,
                        },
                    };
                }
            },
            // note: if we used |head| we'd get a copy of the struct, which means
            // a copy of the hashmap, which means we couldn't deinit it.
            StageTag.body => |*head| {
                if (read >= head.content_length) {
                    var body = buffer[0..head.content_length];

                    var msg_dst_path = try std.fmt.allocPrint(alloc, "{s}-{d:0>3}.bin", .{ args.dir, msg_number });
                    // note: unlike Go, `defer` happens at the end of the scope
                    // (a block is a scope, an if is a scope), not on function return
                    defer alloc.free(msg_dst_path);

                    msg_number += 1;
                    // note: this is why we opened `/tmp`, zig's stdlib is dead
                    // set on using `openat`.
                    var msg_dst = try tmp.createFile(msg_dst_path, .{});
                    defer msg_dst.close();

                    var iter = head.headers.iterator();
                    while (iter.next()) |entry| {
                        debug("header: {s}: {s}\n", .{ entry.key_ptr.*, entry.value_ptr.* });
                        var header_line = try std.fmt.allocPrint(alloc, "{s}: {s}\r\n", .{ entry.key_ptr.*, entry.value_ptr.* });
                        defer alloc.free(header_line);

                        try dst.writeAll(header_line);
                        try msg_dst.writeAll(header_line);
                    }
                    try dst.writeAll("\r\n");
                    try msg_dst.writeAll("\r\n");
                    try dst.writeAll(body);
                    try msg_dst.writeAll(body);

                    std.mem.copy(u8, buffer, buffer[head.content_length..]);
                    read -= head.content_length;

                    var free_iter = head.headers.iterator();
                    while (free_iter.next()) |entry| {
                        // key/values need to be freed _before_ calling deinit
                        // if you remove `.*` from these, the compiler will crash
                        // with a monochrome message (it's usually colored)
                        alloc.free(entry.key_ptr.*);
                        alloc.free(entry.value_ptr.*);
                    }
                    head.headers.deinit();

                    stage = Stage{
                        .headers = {},
                    };
                }
                // otherwise keep reading
            },
        }

        if (read >= buffer.len) {
            buffer = try alloc.realloc(buffer, buffer.len * 2);
            debug("re-allocated buffer, new len = {}\n", .{buffer.len});
        }
    }
}

const std = @import("std");

pub fn build(b: *std.build.Builder) void {
    // Standard target options allows the person running `zig build` to choose
    // what target to build for. Here we do not override the defaults, which
    // means any target is allowed, and the default is native. Other options
    // for restricting supported target set are available.
    const target = b.standardTargetOptions(.{});

    // Standard release options allow the person running `zig build` to select
    // between Debug, ReleaseSafe, ReleaseFast, and ReleaseSmall.
    const mode = b.standardReleaseOptions();

    const exe = b.addExecutable("lsp-proxy", "src/main.zig");
    exe.setTarget(target);
    exe.setBuildMode(mode);
    exe.install();

    const run_cmd = exe.run();
    run_cmd.step.dependOn(b.getInstallStep());
    if (b.args) |args| {
        run_cmd.addArgs(args);
    }

    const run_step = b.step("run", "Run the app");
    run_step.dependOn(&run_cmd.step);

    const exe_tests = b.addTest("src/main.zig");
    exe_tests.setTarget(target);
    exe_tests.setBuildMode(mode);

    const test_step = b.step("test", "Run unit tests");
    test_step.dependOn(&exe_tests.step);
}

$ time zig build -Drelease-fast
zig build -Drelease-fast  6.30s user 0.32s system 101% cpu 6.551 total

$ cp zig-out/bin/lsp-proxy ~/.cargo/bin/rust-analyzer

{
  "jsonrpc": "2.0",
  "method": "initialize",
  "params": {
    "processId": 252882,
    "rootPath": "/home/amos/bearcove/bottom",
    "clientInfo": {
      "name": "emacs",
      "version": "GNU Emacs 27.1 (build 1, x86_64-pc-linux-gnu, GTK+ Version 3.24.30, cairo version 1.16.0)\n of 2022-01-24, modified by Debian"
    },
    "rootUri": "file:///home/amos/bearcove/bottom",
    "capabilities": {
      "workspace": {
        "workspaceEdit": {
          "documentChanges": true,
          "resourceOperations": [
            "create",
            "rename",
            "delete"
          ]
        },
        "applyEdit": true,
        "symbol": {
          "symbolKind": {
            "valueSet": [
              1,
              2,
              3,
              4,
              5,
              6,
              7,
              8,
              9,
              10,
              11,
              12,
              13,
              14,
              15,
              16,
              17,
              18,
              19,
              20,
              21,
              22,
              23,
              24,
              25,
              26
            ]
          }
        },
        "executeCommand": {
          "dynamicRegistration": false
        },
        "didChangeWatchedFiles": {
          "dynamicRegistration": true
        },
        "workspaceFolders": true,
        "configuration": true,
        "codeLens": {
          "refreshSupport": true
        },
        "fileOperations": {
          "didCreate": false,
          "willCreate": false,
          "didRename": true,
          "willRename": true,
          "didDelete": false,
          "willDelete": false
        }
      },
      "textDocument": {
        "declaration": {
          "dynamicRegistration": true,
          "linkSupport": true
        },
        "definition": {
          "dynamicRegistration": true,
          "linkSupport": true
        },
        "references": {
          "dynamicRegistration": true
        },
        "implementation": {
          "dynamicRegistration": true,
          "linkSupport": true
        },
        "typeDefinition": {
          "dynamicRegistration": true,
          "linkSupport": true
        },
        "synchronization": {
          "willSave": true,
          "didSave": true,
          "willSaveWaitUntil": true
        },
        "documentSymbol": {
          "symbolKind": {
            "valueSet": [
              1,
              2,
              3,
              4,
              5,
              6,
              7,
              8,
              9,
              10,
              11,
              12,
              13,
              14,
              15,
              16,
              17,
              18,
              19,
              20,
              21,
              22,
              23,
              24,
              25,
              26
            ]
          },
          "hierarchicalDocumentSymbolSupport": true
        },
        "formatting": {
          "dynamicRegistration": true
        },
        "rangeFormatting": {
          "dynamicRegistration": true
        },
        "onTypeFormatting": {
          "dynamicRegistration": true
        },
        "rename": {
          "dynamicRegistration": true,
          "prepareSupport": true
        },
        "codeAction": {
          "dynamicRegistration": true,
          "isPreferredSupport": true,
          "codeActionLiteralSupport": {
            "codeActionKind": {
              "valueSet": [
                "",
                "quickfix",
                "refactor",
                "refactor.extract",
                "refactor.inline",
                "refactor.rewrite",
                "source",
                "source.organizeImports"
              ]
            }
          },
          "resolveSupport": {
            "properties": [
              "edit",
              "command"
            ]
          },
          "dataSupport": true
        },
        "completion": {
          "completionItem": {
            "snippetSupport": false,
            "documentationFormat": [
              "markdown",
              "plaintext"
            ],
            "resolveAdditionalTextEditsSupport": true,
            "insertReplaceSupport": true,
            "deprecatedSupport": true,
            "resolveSupport": {
              "properties": [
                "documentation",
                "detail",
                "additionalTextEdits",
                "command"
              ]
            },
            "insertTextModeSupport": {
              "valueSet": [
                1,
                2
              ]
            }
          },
          "contextSupport": true,
          "dynamicRegistration": true
        },
        "signatureHelp": {
          "signatureInformation": {
            "parameterInformation": {
              "labelOffsetSupport": true
            }
          },
          "dynamicRegistration": true
        },
        "documentLink": {
          "dynamicRegistration": true,
          "tooltipSupport": true
        },
        "hover": {
          "contentFormat": [
            "markdown",
            "plaintext"
          ],
          "dynamicRegistration": true
        },
        "foldingRange": {
          "dynamicRegistration": true
        },
        "selectionRange": {
          "dynamicRegistration": true
        },
        "callHierarchy": {
          "dynamicRegistration": false
        },
        "typeHierarchy": {
          "dynamicRegistration": true
        },
        "publishDiagnostics": {
          "relatedInformation": true,
          "tagSupport": {
            "valueSet": [
              1,
              2
            ]
          },
          "versionSupport": true
        },
        "linkedEditingRange": {
          "dynamicRegistration": true
        }
      },
      "window": {
        "workDoneProgress": true,
        "showDocument": {
          "support": true
        }
      },
      "experimental": {
        "snippetTextEdit": null
      }
    },
    "initializationOptions": {
      "diagnostics": {
        "enable": true,
        "enableExperimental": false,
        "disabled": [

        ],
        "warningsAsHint": [

        ],
        "warningsAsInfo": [

        ]
      },
      "imports": {
        "granularity": {
          "enforce": false,
          "group": "crate"
        },
        "group": true,
        "merge": {
          "glob": true
        },
        "prefix": "plain"
      },
      "lruCapacity": null,
      "checkOnSave": {
        "enable": true,
        "command": "clippy",
        "extraArgs": [

        ],
        "features": [

        ],
        "overrideCommand": [

        ]
      },
      "files": {
        "exclude": [

        ],
        "watcher": "client",
        "excludeDirs": [

        ]
      },
      "cargo": {
        "allFeatures": false,
        "noDefaultFeatures": false,
        "features": [

        ],
        "target": null,
        "runBuildScripts": true,
        "loadOutDirsFromCheck": true,
        "autoreload": true,
        "useRustcWrapperForBuildScripts": true,
        "unsetTest": [

        ]
      },
      "rustfmt": {
        "extraArgs": [

        ],
        "overrideCommand": [

        ],
        "rangeFormatting": {
          "enable": false
        }
      },
      "inlayHints": {
        "bindingModeHints": false,
        "chainingHints": false,
        "closingBraceHints": {
          "enable": true,
          "minLines": 25
        },
        "closureReturnTypeHints": false,
        "lifetimeElisionHints": {
          "enable": "never",
          "useParameterNames": false
        },
        "maxLength": null,
        "parameterHints": false,
        "reborrowHints": "never",
        "renderColons": true,
        "typeHints": {
          "enable": true,
          "hideClosureInitialization": false,
          "hideNamedConstructor": false
        }
      },
      "completion": {
        "addCallParenthesis": true,
        "addCallArgumentSnippets": true,
        "postfix": {
          "enable": true
        },
        "autoimport": {
          "enable": true
        },
        "autoself": {
          "enable": true
        }
      },
      "callInfo": {
        "full": true
      },
      "procMacro": {
        "enable": true
      },
      "rustcSource": null,
      "linkedProjects": [

      ],
      "highlighting": {
        "strings": true
      },
      "experimental": {
        "procAttrMacros": true
      }
    },
    "workDoneToken": "1"
  },
  "id": 1
}

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "capabilities": {
      "textDocumentSync": {
        "openClose": true,
        "change": 2,
        "save": {

        }
      },
      "selectionRangeProvider": true,
      "hoverProvider": true,
      "completionProvider": {
        "resolveProvider": true,
        "triggerCharacters": [
          ":",
          ".",
          "'",
          "("
        ],
        "completionItem": {
          "labelDetailsSupport": false
        }
      },
      "signatureHelpProvider": {
        "triggerCharacters": [
          "(",
          ",",
          "<"
        ]
      },
      "definitionProvider": true,
      "typeDefinitionProvider": true,
      "implementationProvider": true,
      "referencesProvider": true,
      "documentHighlightProvider": true,
      "documentSymbolProvider": true,
      "workspaceSymbolProvider": true,
      "codeActionProvider": {
        "codeActionKinds": [
          "",
          "quickfix",
          "refactor",
          "refactor.extract",
          "refactor.inline",
          "refactor.rewrite"
        ],
        "resolveProvider": true
      },
      "codeLensProvider": {
        "resolveProvider": true
      },
      "documentFormattingProvider": true,
      "documentRangeFormattingProvider": false,
      "documentOnTypeFormattingProvider": {
        "firstTriggerCharacter": "=",
        "moreTriggerCharacter": [
          ".",
          ">",
          "{"
        ]
      },
      "renameProvider": {
        "prepareProvider": true
      },
      "foldingRangeProvider": true,
      "declarationProvider": true,
      "workspace": {
        "fileOperations": {
          "willRename": {
            "filters": [
              {
                "scheme": "file",
                "pattern": {
                  "glob": "**/*.rs",
                  "matches": "file"
                }
              },
              {
                "scheme": "file",
                "pattern": {
                  "glob": "**",
                  "matches": "folder"
                }
              }
            ]
          }
        }
      },
      "callHierarchyProvider": true,
      "semanticTokensProvider": {
        "legend": {
          "tokenTypes": [
            "comment",
            "decorator",
            "enumMember",
            "enum",
            "function",
            "interface",
            "keyword",
            "macro",
            "method",
            "namespace",
            "number",
            "operator",
            "parameter",
            "property",
            "string",
            "struct",
            "typeParameter",
            "variable",
            "angle",
            "arithmetic",
            "attribute",
            "attributeBracket",
            "bitwise",
            "boolean",
            "brace",
            "bracket",
            "builtinAttribute",
            "builtinType",
            "character",
            "colon",
            "comma",
            "comparison",
            "constParameter",
            "derive",
            "deriveHelper",
            "dot",
            "escapeSequence",
            "formatSpecifier",
            "generic",
            "label",
            "lifetime",
            "logical",
            "macroBang",
            "parenthesis",
            "punctuation",
            "selfKeyword",
            "selfTypeKeyword",
            "semicolon",
            "typeAlias",
            "toolModule",
            "union",
            "unresolvedReference"
          ],
          "tokenModifiers": [
            "documentation",
            "declaration",
            "static",
            "defaultLibrary",
            "async",
            "attribute",
            "callable",
            "constant",
            "consuming",
            "controlFlow",
            "crateRoot",
            "injected",
            "intraDocLink",
            "library",
            "mutable",
            "public",
            "reference",
            "trait",
            "unsafe"
          ]
        },
        "range": true,
        "full": {
          "delta": true
        }
      },
      "inlayHintProvider": {
        "resolveProvider": true
      },
      "experimental": {
        "externalDocs": true,
        "hoverRange": true,
        "joinLines": true,
        "matchingBrace": true,
        "moveItem": true,
        "onEnter": true,
        "openCargoToml": true,
        "parentModule": true,
        "runnables": {
          "kinds": [
            "cargo"
          ]
        },
        "ssr": true,
        "workspaceSymbolScopeKindFiltering": true
      }
    },
    "serverInfo": {
      "name": "rust-analyzer",
      "version": "1.67.1 (d5a82bb 2023-02-07)"
    }
  }
}

fn main() {
  // 🥺
  println!("Hello, world!");
}

{
  "jsonrpc": "2.0",
  "method": "textDocument/didChange",
  "params": {
    "textDocument": {
      "uri": "file:///home/amos/bearcove/bottom/src/main.rs",
      "version": 1
    },
    "contentChanges": [
      {
        "range": {
          "start": {
            "line": 1,
            "character": 7
          },
          "end": {
            "line": 1,
            "character": 7
          }
        },
        "rangeLength": 0,
        "text": "🥺"
      }
    ]
  }
}

{
  "jsonrpc": "2.0",
  "method": "textDocument/codeAction",
  "params": {
    "textDocument": {
      "uri": "file:///home/amos/bearcove/bottom/src/main.rs"
    },
    "range": {
      "start": {
        "line": 1,
        "character": 8
      },
      "end": {
        "line": 1,
        "character": 8
      }
    },
    "context": {
      "diagnostics": [

      ]
    }
  },
  "id": 17
}

$ node
Welcome to Node.js v18.14.0.
Type ".help" for more information.
> new TextEncoder().encode("é")
Uint8Array(2) [ 195, 169 ]
> new TextEncoder().encode("é")
Uint8Array(3) [ 101, 204, 129 ]

> "é".length
1
> "é".charAt(0)
"é"

> "é".length
2
> "é".charAt(0)
'e'
> "é".charAt(1)
'́'

> new TextEncoder("utf-8").encode("🥺")
Uint8Array(4) [ 240, 159, 165, 186 ]

> "🥺".length
2
> "🥺".charAt(0)
'\ud83e'
> "🥺".charAt(1)
'\udd7a'

> "👨‍👩‍👦".length
8

> [..."👨‍👩‍👦"]
[ '👨', '‍', '👩', '‍', '👦' ]

> var s = "👨‍👩‍👦"; for (let i = 0; i < s.length; i++) { console.log(s.charCodeAt(i).toString(16)) }
d83d
dc68
200d
d83d
dc69
200d
d83d
dc66

> var s = "👨‍👩‍👦"; [0, 2, 3, 5, 7].map(i => `U+${s.codePointAt(i).toString(16)}`)
[ 'U+1f468', 'U+200d', 'U+1f469', 'U+200d', 'U+dc66' ]

> for (const c of "👨‍👩‍👦") { console.log(`U+${c.codePointAt(0).toString(16)}`) }
U+1f468
U+200d
U+1f469
U+200d
U+1f466

"start": {
  "line": 1,
  "character": 8
}

// in `rust-analyzer/crates/ide-db/src/line_index.rs`

#[derive(Clone, Debug, PartialEq, Eq)]
pub struct LineIndex {
    /// Offset the the beginning of each line, zero-based
    pub(crate) newlines: Vec<TextSize>,
    /// List of non-ASCII characters on each line
    pub(crate) utf16_lines: NoHashHashMap<u32, Vec<Utf16Char>>,
}

#[derive(Clone, Debug, Hash, PartialEq, Eq)]
pub(crate) struct Utf16Char {
    /// Start offset of a character inside a line, zero-based
    pub(crate) start: TextSize,
    /// End offset of a character inside a line, zero-based
    pub(crate) end: TextSize,
}

impl LineIndex {
    fn utf8_to_utf16_col(&self, line: u32, col: TextSize) -> usize {
        let mut res: usize = col.into();
        if let Some(utf16_chars) = self.utf16_lines.get(&line) {
            for c in utf16_chars {
                if c.end <= col {
                    res -= usize::from(c.len()) - c.len_utf16();
                } else {
                    // From here on, all utf16 characters come *after* the character we are mapping,
                    // so we don't need to take them into account
                    break;
                }
            }
        }
        res
    }
}

impl Utf16Char {
    /// Returns the length in 8-bit UTF-8 code units.
    fn len(&self) -> TextSize {
        self.end - self.start
    }

    /// Returns the length in 16-bit UTF-16 code units.
    fn len_utf16(&self) -> usize {
        //                             👇
        if self.len() == TextSize::from(4) {
            2
        } else {
            1
        }
    }
}