From f09ffb63dbce3314e1be7059831e5a81e43eea2c Mon Sep 17 00:00:00 2001
From: Techatrix <19954306+Techatrix@users.noreply.github.com>
Date: Sat, 19 Nov 2022 00:49:59 +0100
Subject: [PATCH 01/22] don't format files with syntax errors (#766)

* don't format files with syntax errors

* Remove showMessage

Co-authored-by: Auguste Rame <19855629+SuperAuguste@users.noreply.github.com>
---
 src/Server.zig | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/Server.zig b/src/Server.zig
index d8de20e..3a439ce 100644
--- a/src/Server.zig
+++ b/src/Server.zig
@@ -2098,6 +2098,10 @@ fn formattingHandler(server: *Server, writer: anytype, id: types.RequestId, req:
         return try respondGeneric(writer, id, null_result_response);
     };
 
+    if (handle.tree.errors.len != 0) {
+        return try respondGeneric(writer, id, null_result_response);
+    }
+
     const formatted = try handle.tree.render(server.allocator);
     defer server.allocator.free(formatted);
 

From 245e11e033b1dea6c20231da480d07a1bbca7d9f Mon Sep 17 00:00:00 2001
From: halting <halting@riseup.net>
Date: Sat, 19 Nov 2022 16:59:12 -0300
Subject: [PATCH 02/22] snippets for primitive types (#767)

---
 src/data/snippets.zig | 28 ++++++++++++++++++++++++++--
 1 file changed, 26 insertions(+), 2 deletions(-)

diff --git a/src/data/snippets.zig b/src/data/snippets.zig
index 8479f52..8d428df 100644
--- a/src/data/snippets.zig
+++ b/src/data/snippets.zig
@@ -23,8 +23,6 @@ pub const generic = [_]Snipped{
     .{ .label = "align", .kind = .Keyword },
     .{ .label = "allowzero", .kind = .Keyword },
     .{ .label = "and", .kind = .Keyword },
-    .{ .label = "anyframe", .kind = .Keyword },
-    .{ .label = "anytype", .kind = .Keyword },
     .{ .label = "asm", .kind = .Keyword },
     .{ .label = "async", .kind = .Keyword },
     .{ .label = "await", .kind = .Keyword },
@@ -86,4 +84,30 @@ pub const generic = [_]Snipped{
     .{ .label = "log warn", .kind = .Snippet, .text = "std.log.warn(\"$1\", .{$0});" },
     .{ .label = "log info", .kind = .Snippet, .text = "std.log.info(\"$1\", .{$0});" },
     .{ .label = "log debug", .kind = .Snippet, .text = "std.log.debug(\"$1\", .{$0});" },
+
+    // types
+    .{ .label = "anyopaque", .kind = .Keyword },
+    .{ .label = "anyerror", .kind = .Keyword },
+    .{ .label = "anyframe", .kind = .Keyword },
+    .{ .label = "noreturn", .kind = .Keyword },
+    .{ .label = "type", .kind = .Keyword },
+    .{ .label = "bool", .kind = .Keyword },
+    .{ .label = "void", .kind = .Keyword },
+    .{ .label = "isize", .kind = .Keyword },
+    .{ .label = "usize", .kind = .Keyword },
+    .{ .label = "i8", .kind = .Keyword },
+    .{ .label = "i16", .kind = .Keyword },
+    .{ .label = "i32", .kind = .Keyword },
+    .{ .label = "i64", .kind = .Keyword },
+    .{ .label = "i128", .kind = .Keyword },
+    .{ .label = "u8", .kind = .Keyword },
+    .{ .label = "u16", .kind = .Keyword },
+    .{ .label = "u32", .kind = .Keyword },
+    .{ .label = "u64", .kind = .Keyword },
+    .{ .label = "u128", .kind = .Keyword },
+    .{ .label = "f16", .kind = .Keyword },
+    .{ .label = "f32", .kind = .Keyword },
+    .{ .label = "f64", .kind = .Keyword },
+    .{ .label = "f80", .kind = .Keyword },
+    .{ .label = "f128", .kind = .Keyword },
 };

From 5f3d58edeb60d71f3d6153b879e9c4ef8797690f Mon Sep 17 00:00:00 2001
From: halting <halting@riseup.net>
Date: Sun, 20 Nov 2022 17:16:15 -0300
Subject: [PATCH 03/22] fix anytype snippet (#769)

i forgot that
---
 src/data/snippets.zig | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/data/snippets.zig b/src/data/snippets.zig
index 8d428df..023e221 100644
--- a/src/data/snippets.zig
+++ b/src/data/snippets.zig
@@ -89,6 +89,7 @@ pub const generic = [_]Snipped{
     .{ .label = "anyopaque", .kind = .Keyword },
     .{ .label = "anyerror", .kind = .Keyword },
     .{ .label = "anyframe", .kind = .Keyword },
+    .{ .label = "anytype", .kind = .Keyword },
     .{ .label = "noreturn", .kind = .Keyword },
     .{ .label = "type", .kind = .Keyword },
     .{ .label = "bool", .kind = .Keyword },

From ea2caee3ad92c3c2f13ec392f751c12e1d02f4bd Mon Sep 17 00:00:00 2001
From: Techatrix <19954306+Techatrix@users.noreply.github.com>
Date: Mon, 21 Nov 2022 19:21:24 +0100
Subject: [PATCH 04/22] correctly find last full text change in applyTextEdits
 (#772)

---
 src/diff.zig | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/diff.zig b/src/diff.zig
index f0918bd..0d1f5ac 100644
--- a/src/diff.zig
+++ b/src/diff.zig
@@ -366,6 +366,7 @@ pub fn applyTextEdits(
         i -= 1;
         if (content_changes[i].range == null) {
             last_full_text_change = i;
+            continue;
         }
     }
 

From 4794f1e8d93dcdb17ce065f7d25da6bab3b18edf Mon Sep 17 00:00:00 2001
From: nullptrdevs <16590917+nullptrdevs@users.noreply.github.com>
Date: Tue, 22 Nov 2022 02:08:43 -0800
Subject: [PATCH 05/22] Disable label references until #728 is resolved

---
 src/Server.zig | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/Server.zig b/src/Server.zig
index 3a439ce..c624f28 100644
--- a/src/Server.zig
+++ b/src/Server.zig
@@ -2241,7 +2241,9 @@ fn generalReferencesHandler(server: *Server, writer: anytype, id: types.RequestI
     };
 
     const locations = if (pos_context == .label)
-        try references.labelReferences(allocator, decl, server.offset_encoding, include_decl)
+        // FIXME https://github.com/zigtools/zls/issues/728
+        // try references.labelReferences(allocator, decl, server.offset_encoding, include_decl)
+        std.ArrayListUnmanaged(types.Location){}
     else
         try references.symbolReferences(
             &server.arena,

From 1ced17266c0f6256c7c0ea515e2407ff56c2ee6b Mon Sep 17 00:00:00 2001
From: Techatrix <19954306+Techatrix@users.noreply.github.com>
Date: Wed, 23 Nov 2022 03:05:29 +0100
Subject: [PATCH 06/22] set TextDocumentSync to Incremental (#776)

---
 src/Server.zig | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Server.zig b/src/Server.zig
index c624f28..063d39f 100644
--- a/src/Server.zig
+++ b/src/Server.zig
@@ -1606,7 +1606,7 @@ fn initializeHandler(server: *Server, writer: anytype, id: types.RequestId, req:
                     },
                     .textDocumentSync = .{
                         .openClose = true,
-                        .change = .Full,
+                        .change = .Incremental,
                         .save = true,
                     },
                     .renameProvider = true,

From 29679ee6f8f9bb7ef64e0493b1a9dea88e338c94 Mon Sep 17 00:00:00 2001
From: Techatrix <19954306+Techatrix@users.noreply.github.com>
Date: Fri, 25 Nov 2022 22:31:27 +0100
Subject: [PATCH 07/22] move to stage2 (#781)

---
 build.zig                                        | 2 --
 tests/language_features/comptime_interpreter.zig | 2 +-
 2 files changed, 1 insertion(+), 3 deletions(-)

diff --git a/build.zig b/build.zig
index be88bfb..6cc9fd5 100644
--- a/build.zig
+++ b/build.zig
@@ -13,7 +13,6 @@ pub fn build(b: *std.build.Builder) !void {
 
     const mode = b.standardReleaseOptions();
     const exe = b.addExecutable("zls", "src/main.zig");
-    exe.use_stage1 = true;
     const exe_options = b.addOptions();
     exe.addOptions("build_options", exe_options);
 
@@ -134,7 +133,6 @@ pub fn build(b: *std.build.Builder) !void {
         });
     }
 
-    tests.use_stage1 = true;
     tests.addPackage(.{ .name = "zls", .source = .{ .path = "src/zls.zig" }, .dependencies = exe.packages.items });
     tests.setBuildMode(.Debug);
     tests.setTarget(target);
diff --git a/tests/language_features/comptime_interpreter.zig b/tests/language_features/comptime_interpreter.zig
index ae9311e..dd42a31 100644
--- a/tests/language_features/comptime_interpreter.zig
+++ b/tests/language_features/comptime_interpreter.zig
@@ -32,7 +32,7 @@ test "ComptimeInterpreter - basic test" {
 
     _ = try interpreter.interpret(0, null, .{});
 
-    var bool_type = try interpreter.createType(std.math.maxInt(std.zig.Ast.Node.Index), .{ .@"bool" = .{} });
+    var bool_type = try interpreter.createType(std.math.maxInt(std.zig.Ast.Node.Index), .{ .@"bool" = {} });
     var arg_false = ComptimeInterpreter.Value{
         .interpreter = &interpreter,
         .node_idx = std.math.maxInt(std.zig.Ast.Node.Index),

From aa14772cfeeacf75d65192e23798185cab0f4d10 Mon Sep 17 00:00:00 2001
From: Techatrix <19954306+Techatrix@users.noreply.github.com>
Date: Fri, 25 Nov 2022 22:32:08 +0100
Subject: [PATCH 08/22] use textDocument/willSaveWaitUntil for autofix (#780)

---
 src/Server.zig   | 97 +++++++++++++++++++++++++++++++++++-------------
 src/requests.zig | 22 ++++++++++-
 src/types.zig    |  2 +
 3 files changed, 94 insertions(+), 27 deletions(-)

diff --git a/src/Server.zig b/src/Server.zig
index 063d39f..9d895a0 100644
--- a/src/Server.zig
+++ b/src/Server.zig
@@ -52,6 +52,8 @@ const ClientCapabilities = struct {
     supports_snippets: bool = false,
     supports_semantic_tokens: bool = false,
     supports_inlay_hints: bool = false,
+    supports_will_save: bool = false,
+    supports_will_save_wait_until: bool = false,
     hover_supports_md: bool = false,
     completion_doc_supports_md: bool = false,
     label_details_support: bool = false,
@@ -445,6 +447,36 @@ fn getAstCheckDiagnostics(
     }
 }
 
+/// caller owns returned memory.
+fn autofix(server: *Server, allocator: std.mem.Allocator, handle: *const DocumentStore.Handle) !std.ArrayListUnmanaged(types.TextEdit) {
+    var diagnostics = std.ArrayListUnmanaged(types.Diagnostic){};
+    try getAstCheckDiagnostics(server, handle.*, &diagnostics);
+    
+    var builder = code_actions.Builder{
+        .arena = &server.arena,
+        .document_store = &server.document_store,
+        .handle = handle,
+        .offset_encoding = server.offset_encoding,
+    };
+
+    var actions = std.ArrayListUnmanaged(types.CodeAction){};
+    for (diagnostics.items) |diagnostic| {
+        try builder.generateCodeAction(diagnostic, &actions);
+    }
+
+    var text_edits = std.ArrayListUnmanaged(types.TextEdit){};
+    for (actions.items) |action| {
+        if (action.kind != .SourceFixAll) continue;
+
+        if (action.edit.changes.size != 1) continue;
+        const edits = action.edit.changes.get(handle.uri) orelse continue;
+
+        try text_edits.appendSlice(allocator, edits.items);
+    }
+
+    return text_edits;
+}
+
 fn typeToCompletion(
     server: *Server,
     list: *std.ArrayListUnmanaged(types.CompletionItem),
@@ -1580,6 +1612,10 @@ fn initializeHandler(server: *Server, writer: anytype, id: types.RequestId, req:
                 }
             }
         }
+        if(textDocument.synchronization) |synchronization| {
+            server.client_capabilities.supports_will_save = synchronization.willSave.value;
+            server.client_capabilities.supports_will_save_wait_until = synchronization.willSaveWaitUntil.value;
+        }
     }
 
     // NOTE: everything is initialized, we got the client capabilities
@@ -1608,6 +1644,8 @@ fn initializeHandler(server: *Server, writer: anytype, id: types.RequestId, req:
                         .openClose = true,
                         .change = .Incremental,
                         .save = true,
+                        .willSave = true,
+                        .willSaveWaitUntil = true,
                     },
                     .renameProvider = true,
                     .completionProvider = .{ .resolveProvider = false, .triggerCharacters = &[_][]const u8{ ".", ":", "@", "]" }, .completionItem = .{ .labelDetailsSupport = true } },
@@ -1832,31 +1870,10 @@ fn saveDocumentHandler(server: *Server, writer: anytype, id: types.RequestId, re
     if (handle.tree.errors.len != 0) return;
     if (!server.config.enable_ast_check_diagnostics) return;
     if (!server.config.enable_autofix) return;
+    if (server.client_capabilities.supports_will_save) return;
+    if (server.client_capabilities.supports_will_save_wait_until) return;
 
-    var diagnostics = std.ArrayListUnmanaged(types.Diagnostic){};
-    try getAstCheckDiagnostics(server, handle.*, &diagnostics);
-
-    var builder = code_actions.Builder{
-        .arena = &server.arena,
-        .document_store = &server.document_store,
-        .handle = handle,
-        .offset_encoding = server.offset_encoding,
-    };
-
-    var actions = std.ArrayListUnmanaged(types.CodeAction){};
-    for (diagnostics.items) |diagnostic| {
-        try builder.generateCodeAction(diagnostic, &actions);
-    }
-
-    var text_edits = std.ArrayListUnmanaged(types.TextEdit){};
-    for (actions.items) |action| {
-        if (action.kind != .SourceFixAll) continue;
-
-        if (action.edit.changes.size != 1) continue;
-        const edits = action.edit.changes.get(uri) orelse continue;
-
-        try text_edits.appendSlice(allocator, edits.items);
-    }
+    const text_edits = try server.autofix(allocator, handle);
 
     var workspace_edit = types.WorkspaceEdit{ .changes = .{} };
     try workspace_edit.changes.putNoClobber(allocator, uri, text_edits);
@@ -1885,6 +1902,35 @@ fn closeDocumentHandler(server: *Server, writer: anytype, id: types.RequestId, r
     server.document_store.closeDocument(req.params.textDocument.uri);
 }
 
+fn willSaveHandler(server: *Server, writer: anytype, id: types.RequestId, req: requests.WillSave) !void {
+    const tracy_zone = tracy.trace(@src());
+    defer tracy_zone.end();
+
+    if(server.client_capabilities.supports_will_save_wait_until) return;
+    try willSaveWaitUntilHandler(server, writer, id, req);
+}
+
+fn willSaveWaitUntilHandler(server: *Server, writer: anytype, id: types.RequestId, req: requests.WillSave) !void {
+    const tracy_zone = tracy.trace(@src());
+    defer tracy_zone.end();
+
+    if (!server.config.enable_ast_check_diagnostics) return;
+    if (!server.config.enable_autofix) return;
+
+    const allocator = server.arena.allocator();
+    const uri = req.params.textDocument.uri;
+    
+    const handle = server.document_store.getHandle(uri) orelse return;
+    if (handle.tree.errors.len != 0) return;
+
+    var text_edits = try server.autofix(allocator, handle);
+
+    return try send(writer, allocator, types.Response{
+        .id = id,
+        .result = .{.TextEdits = text_edits.toOwnedSlice(allocator)},
+    });
+}
+
 fn semanticTokensFullHandler(server: *Server, writer: anytype, id: types.RequestId, req: requests.SemanticTokensFull) !void {
     const tracy_zone = tracy.trace(@src());
     defer tracy_zone.end();
@@ -2764,7 +2810,6 @@ pub fn processJsonRpc(server: *Server, writer: anytype, json: []const u8) !void
     const method_map = .{
         .{ "initialized", void, initializedHandler },
         .{"$/cancelRequest"},
-        .{"textDocument/willSave"},
         .{ "initialize", requests.Initialize, initializeHandler },
         .{ "shutdown", void, shutdownHandler },
         .{ "exit", void, exitHandler },
@@ -2772,6 +2817,8 @@ pub fn processJsonRpc(server: *Server, writer: anytype, json: []const u8) !void
         .{ "textDocument/didChange", requests.ChangeDocument, changeDocumentHandler },
         .{ "textDocument/didSave", requests.SaveDocument, saveDocumentHandler },
         .{ "textDocument/didClose", requests.CloseDocument, closeDocumentHandler },
+        .{"textDocument/willSave", requests.WillSave, willSaveHandler},
+        .{"textDocument/willSaveWaitUntil", requests.WillSave, willSaveWaitUntilHandler},
         .{ "textDocument/semanticTokens/full", requests.SemanticTokensFull, semanticTokensFullHandler },
         .{ "textDocument/inlayHint", requests.InlayHint, inlayHintHandler },
         .{ "textDocument/completion", requests.Completion, completionHandler },
diff --git a/src/requests.zig b/src/requests.zig
index d926d4d..54ca772 100644
--- a/src/requests.zig
+++ b/src/requests.zig
@@ -154,6 +154,11 @@ pub const Initialize = struct {
             workspaceFolders: Default(bool, false),
         },
         textDocument: ?struct {
+            synchronization: ?struct {
+                willSave: Default(bool, false),
+                willSaveWaitUntil: Default(bool, false),
+                didSave: Default(bool, false),
+            },
             semanticTokens: Exists,
             inlayHint: Exists,
             hover: ?struct {
@@ -230,6 +235,19 @@ const TextDocumentIdentifierPositionRequest = struct {
     },
 };
 
+pub const SaveReason = enum(u32) {
+    Manual = 1,
+    AfterDelay = 2,
+    FocusOut = 3,
+};
+
+pub const WillSave = struct {
+    params: struct {
+        textDocument: TextDocumentIdentifier,
+        reason: SaveReason,
+    },
+};
+
 pub const SignatureHelp = struct {
     params: struct {
         textDocument: TextDocumentIdentifier,
@@ -291,6 +309,6 @@ pub const CodeAction = struct {
 
 pub const FoldingRange = struct {
     params: struct {
-        textDocument: TextDocumentIdentifier,  
+        textDocument: TextDocumentIdentifier,
     },
-};
\ No newline at end of file
+};
diff --git a/src/types.zig b/src/types.zig
index 2be811f..67100e6 100644
--- a/src/types.zig
+++ b/src/types.zig
@@ -441,6 +441,8 @@ const InitializeResult = struct {
         textDocumentSync: struct {
             openClose: bool,
             change: TextDocumentSyncKind,
+            willSave: bool,
+            willSaveWaitUntil: bool,
             save: bool,
         },
         renameProvider: bool,

From 369b851dc7c5f3c7d241fad0beb9b158590510c2 Mon Sep 17 00:00:00 2001
From: Auguste Rame <19855629+SuperAuguste@users.noreply.github.com>
Date: Fri, 25 Nov 2022 19:18:32 -0500
Subject: [PATCH 09/22] Revert "move to stage2 (#781)" (#783)

This reverts commit 29679ee6f8f9bb7ef64e0493b1a9dea88e338c94.
---
 build.zig                                        | 2 ++
 tests/language_features/comptime_interpreter.zig | 2 +-
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/build.zig b/build.zig
index 6cc9fd5..be88bfb 100644
--- a/build.zig
+++ b/build.zig
@@ -13,6 +13,7 @@ pub fn build(b: *std.build.Builder) !void {
 
     const mode = b.standardReleaseOptions();
     const exe = b.addExecutable("zls", "src/main.zig");
+    exe.use_stage1 = true;
     const exe_options = b.addOptions();
     exe.addOptions("build_options", exe_options);
 
@@ -133,6 +134,7 @@ pub fn build(b: *std.build.Builder) !void {
         });
     }
 
+    tests.use_stage1 = true;
     tests.addPackage(.{ .name = "zls", .source = .{ .path = "src/zls.zig" }, .dependencies = exe.packages.items });
     tests.setBuildMode(.Debug);
     tests.setTarget(target);
diff --git a/tests/language_features/comptime_interpreter.zig b/tests/language_features/comptime_interpreter.zig
index dd42a31..ae9311e 100644
--- a/tests/language_features/comptime_interpreter.zig
+++ b/tests/language_features/comptime_interpreter.zig
@@ -32,7 +32,7 @@ test "ComptimeInterpreter - basic test" {
 
     _ = try interpreter.interpret(0, null, .{});
 
-    var bool_type = try interpreter.createType(std.math.maxInt(std.zig.Ast.Node.Index), .{ .@"bool" = {} });
+    var bool_type = try interpreter.createType(std.math.maxInt(std.zig.Ast.Node.Index), .{ .@"bool" = .{} });
     var arg_false = ComptimeInterpreter.Value{
         .interpreter = &interpreter,
         .node_idx = std.math.maxInt(std.zig.Ast.Node.Index),

From 8731a37d1f4683c795ddbb5c16e69e4c1bba33d0 Mon Sep 17 00:00:00 2001
From: Aleksey Kladov <aleksey.kladov@gmail.com>
Date: Sat, 26 Nov 2022 01:14:33 +0000
Subject: [PATCH 10/22] textDocument/selectionRange

closes #777
---
 src/Server.zig                         | 75 ++++++++++++++++++++++---
 src/requests.zig                       |  7 +++
 src/types.zig                          |  8 ++-
 tests/lsp_features/selection_range.zig | 76 ++++++++++++++++++++++++++
 tests/tests.zig                        |  1 +
 5 files changed, 158 insertions(+), 9 deletions(-)
 create mode 100644 tests/lsp_features/selection_range.zig

diff --git a/src/Server.zig b/src/Server.zig
index 9d895a0..d39e86b 100644
--- a/src/Server.zig
+++ b/src/Server.zig
@@ -451,7 +451,7 @@ fn getAstCheckDiagnostics(
 fn autofix(server: *Server, allocator: std.mem.Allocator, handle: *const DocumentStore.Handle) !std.ArrayListUnmanaged(types.TextEdit) {
     var diagnostics = std.ArrayListUnmanaged(types.Diagnostic){};
     try getAstCheckDiagnostics(server, handle.*, &diagnostics);
-    
+
     var builder = code_actions.Builder{
         .arena = &server.arena,
         .document_store = &server.document_store,
@@ -1612,7 +1612,7 @@ fn initializeHandler(server: *Server, writer: anytype, id: types.RequestId, req:
                 }
             }
         }
-        if(textDocument.synchronization) |synchronization| {
+        if (textDocument.synchronization) |synchronization| {
             server.client_capabilities.supports_will_save = synchronization.willSave.value;
             server.client_capabilities.supports_will_save_wait_until = synchronization.willSaveWaitUntil.value;
         }
@@ -1662,7 +1662,7 @@ fn initializeHandler(server: *Server, writer: anytype, id: types.RequestId, req:
                     .documentFormattingProvider = true,
                     .documentRangeFormattingProvider = false,
                     .foldingRangeProvider = true,
-                    .selectionRangeProvider = false,
+                    .selectionRangeProvider = true,
                     .workspaceSymbolProvider = false,
                     .rangeProvider = false,
                     .documentProvider = true,
@@ -1906,7 +1906,7 @@ fn willSaveHandler(server: *Server, writer: anytype, id: types.RequestId, req: r
     const tracy_zone = tracy.trace(@src());
     defer tracy_zone.end();
 
-    if(server.client_capabilities.supports_will_save_wait_until) return;
+    if (server.client_capabilities.supports_will_save_wait_until) return;
     try willSaveWaitUntilHandler(server, writer, id, req);
 }
 
@@ -1919,7 +1919,7 @@ fn willSaveWaitUntilHandler(server: *Server, writer: anytype, id: types.RequestI
 
     const allocator = server.arena.allocator();
     const uri = req.params.textDocument.uri;
-    
+
     const handle = server.document_store.getHandle(uri) orelse return;
     if (handle.tree.errors.len != 0) return;
 
@@ -1927,7 +1927,7 @@ fn willSaveWaitUntilHandler(server: *Server, writer: anytype, id: types.RequestI
 
     return try send(writer, allocator, types.Response{
         .id = id,
-        .result = .{.TextEdits = text_edits.toOwnedSlice(allocator)},
+        .result = .{ .TextEdits = text_edits.toOwnedSlice(allocator) },
     });
 }
 
@@ -2690,6 +2690,64 @@ fn foldingRangeHandler(server: *Server, writer: anytype, id: types.RequestId, re
     });
 }
 
+fn selectionRangeHandler(server: *Server, writer: anytype, id: types.RequestId, req: requests.SelectionRange) !void {
+    const allocator = server.arena.allocator();
+    const handle = server.document_store.getHandle(req.params.textDocument.uri) orelse {
+        log.warn("Trying to get selection range of non existent document {s}", .{req.params.textDocument.uri});
+        return try respondGeneric(writer, id, null_result_response);
+    };
+
+    // For each of the input positons, we need to compute the stack of AST
+    // nodes/ranges which contain the position. At the moment, we do this in a
+    // super inefficient way, by iterationg _all_ nodes, selecting the ones that
+    // contain position, and then sorting.
+    //
+    // A faster algorithm would be to walk the tree starting from the root,
+    // descending into the child containing the position at every step.
+    var result = try allocator.alloc(*types.SelectionRange, req.params.positions.len);
+    var locs = try std.ArrayListUnmanaged(offsets.Loc).initCapacity(allocator, 32);
+    for (req.params.positions) |position, position_index| {
+        const index = offsets.positionToIndex(handle.text, position, server.offset_encoding);
+
+        locs.clearRetainingCapacity();
+        for (handle.tree.nodes.items(.data)) |_, i| {
+            const node = @intCast(u32, i);
+            const loc = offsets.nodeToLoc(handle.tree, node);
+            if (loc.start <= index and index <= loc.end) {
+                (try locs.addOne(allocator)).* = loc;
+            }
+        }
+
+        std.sort.sort(offsets.Loc, locs.items, {}, shorterLocsFirst);
+        {
+            var i: usize = 0;
+            while (i + 1 < locs.items.len) {
+                if (std.meta.eql(locs.items[i], locs.items[i + 1])) {
+                    _ = locs.orderedRemove(i);
+                } else {
+                    i += 1;
+                }
+            }
+        }
+
+        var selection_ranges = try allocator.alloc(types.SelectionRange, locs.items.len);
+        for (selection_ranges) |*range, i| {
+            range.range = offsets.locToRange(handle.text, locs.items[i], server.offset_encoding);
+            range.parent = if (i + 1 < selection_ranges.len) &selection_ranges[i + 1] else null;
+        }
+        result[position_index] = &selection_ranges[0];
+    }
+
+    try send(writer, allocator, types.Response{
+        .id = id,
+        .result = .{ .SelectionRange = result },
+    });
+}
+
+fn shorterLocsFirst(_: void, lhs: offsets.Loc, rhs: offsets.Loc) bool {
+    return (lhs.end - lhs.start) < (rhs.end - rhs.start);
+}
+
 // Needed for the hack seen below.
 fn extractErr(val: anytype) anyerror {
     val catch |e| return e;
@@ -2817,8 +2875,8 @@ pub fn processJsonRpc(server: *Server, writer: anytype, json: []const u8) !void
         .{ "textDocument/didChange", requests.ChangeDocument, changeDocumentHandler },
         .{ "textDocument/didSave", requests.SaveDocument, saveDocumentHandler },
         .{ "textDocument/didClose", requests.CloseDocument, closeDocumentHandler },
-        .{"textDocument/willSave", requests.WillSave, willSaveHandler},
-        .{"textDocument/willSaveWaitUntil", requests.WillSave, willSaveWaitUntilHandler},
+        .{ "textDocument/willSave", requests.WillSave, willSaveHandler },
+        .{ "textDocument/willSaveWaitUntil", requests.WillSave, willSaveWaitUntilHandler },
         .{ "textDocument/semanticTokens/full", requests.SemanticTokensFull, semanticTokensFullHandler },
         .{ "textDocument/inlayHint", requests.InlayHint, inlayHintHandler },
         .{ "textDocument/completion", requests.Completion, completionHandler },
@@ -2836,6 +2894,7 @@ pub fn processJsonRpc(server: *Server, writer: anytype, json: []const u8) !void
         .{ "textDocument/codeAction", requests.CodeAction, codeActionHandler },
         .{ "workspace/didChangeConfiguration", Config.DidChangeConfigurationParams, didChangeConfigurationHandler },
         .{ "textDocument/foldingRange", requests.FoldingRange, foldingRangeHandler },
+        .{ "textDocument/selectionRange", requests.SelectionRange, selectionRangeHandler },
     };
 
     if (zig_builtin.zig_backend == .stage1) {
diff --git a/src/requests.zig b/src/requests.zig
index 54ca772..466a7bd 100644
--- a/src/requests.zig
+++ b/src/requests.zig
@@ -312,3 +312,10 @@ pub const FoldingRange = struct {
         textDocument: TextDocumentIdentifier,
     },
 };
+
+pub const SelectionRange = struct {
+    params: struct {
+        textDocument: TextDocumentIdentifier,
+        positions: []types.Position,
+    },
+};
diff --git a/src/types.zig b/src/types.zig
index 67100e6..5ad7e62 100644
--- a/src/types.zig
+++ b/src/types.zig
@@ -44,6 +44,7 @@ pub const ResponseParams = union(enum) {
     CodeAction: []CodeAction,
     ApplyEdit: ApplyWorkspaceEditParams,
     FoldingRange: []FoldingRange,
+    SelectionRange: []*SelectionRange,
 };
 
 pub const Response = struct {
@@ -525,6 +526,11 @@ pub const DocumentHighlight = struct {
 };
 
 pub const FoldingRange = struct {
-    startLine: usize, 
+    startLine: usize,
     endLine: usize,
 };
+
+pub const SelectionRange = struct {
+    range: Range,
+    parent: ?*SelectionRange,
+};
diff --git a/tests/lsp_features/selection_range.zig b/tests/lsp_features/selection_range.zig
new file mode 100644
index 0000000..9eb7c5c
--- /dev/null
+++ b/tests/lsp_features/selection_range.zig
@@ -0,0 +1,76 @@
+const std = @import("std");
+const zls = @import("zls");
+const builtin = @import("builtin");
+
+const helper = @import("../helper.zig");
+const Context = @import("../context.zig").Context;
+const ErrorBuilder = @import("../ErrorBuilder.zig");
+
+const types = zls.types;
+const offsets = zls.offsets;
+const requests = zls.requests;
+
+const allocator: std.mem.Allocator = std.testing.allocator;
+
+test "selectionRange - empty" {
+    try testSelectionRange("<>", &.{});
+}
+
+test "seletionRange - smoke" {
+    try testSelectionRange(
+        \\fn main() void {
+        \\    const x = 1 <>+ 1;
+        \\}
+    , &.{ "1 + 1", "const x = 1 + 1", "{\n    const x = 1 + 1;\n}" });
+}
+
+fn testSelectionRange(source: []const u8, want: []const []const u8) !void {
+    var phr = try helper.collectClearPlaceholders(allocator, source);
+    defer phr.deinit(allocator);
+
+    var ctx = try Context.init();
+    defer ctx.deinit();
+
+    const test_uri: []const u8 = switch (builtin.os.tag) {
+        .windows => "file:///C:\\test.zig",
+        else => "file:///test.zig",
+    };
+
+    try ctx.requestDidOpen(test_uri, phr.new_source);
+
+    const position = offsets.locToRange(phr.new_source, phr.locations.items(.new)[0], .utf16).start;
+
+    const SelectionRange = struct {
+        range: types.Range,
+        parent: ?*@This(),
+    };
+
+    const request = requests.SelectionRange{ .params = .{
+        .textDocument = .{ .uri = test_uri },
+        .positions = &.{position},
+    } };
+
+    const response = try ctx.requestGetResponse(?[]SelectionRange, "textDocument/selectionRange", request);
+    defer response.deinit();
+
+    const selectionRanges: []SelectionRange = response.result orelse {
+        std.debug.print("Server returned `null` as the result\n", .{});
+        return error.InvalidResponse;
+    };
+
+    var got = std.ArrayList([]const u8).init(allocator);
+    defer got.deinit();
+
+    var it: ?*SelectionRange = &selectionRanges[0];
+    while (it) |r| {
+        const slice = offsets.rangeToSlice(phr.new_source, r.range, .utf16);
+        (try got.addOne()).* = slice;
+        it = r.parent;
+    }
+    const last = got.pop();
+    try std.testing.expectEqualStrings(phr.new_source, last);
+    try std.testing.expectEqual(want.len, got.items.len);
+    for (want) |w, i| {
+        try std.testing.expectEqualStrings(w, got.items[i]);
+    }
+}
diff --git a/tests/tests.zig b/tests/tests.zig
index f6a97a9..1951513 100644
--- a/tests/tests.zig
+++ b/tests/tests.zig
@@ -14,6 +14,7 @@ comptime {
     _ = @import("lsp_features/inlay_hints.zig");
     _ = @import("lsp_features/references.zig");
     _ = @import("lsp_features/completion.zig");
+    _ = @import("lsp_features/selection_range.zig");
 
     // Language features
     _ = @import("language_features/cimport.zig");

From 56a65f42bf950f4ad47a7c365ec445a57f6ca0ba Mon Sep 17 00:00:00 2001
From: Alexandros Naskos <alex_naskos@hotmail.com>
Date: Sat, 26 Nov 2022 19:22:16 +0200
Subject: [PATCH 11/22] Added tuple type support, fixed compilation with zig
 master branch (#786)

* Added tuple type support, fixed compilation with zig master branch

* Removed unneeded comment

* Bumped up minimum zig version required to build zls
---
 build.zig                   |  2 +-
 src/ComptimeInterpreter.zig |  7 ++++++-
 src/Server.zig              | 18 ++++++++++--------
 src/analysis.zig            | 35 ++++++++++++++++++++++++++++-------
 src/semantic_tokens.zig     |  4 +++-
 5 files changed, 48 insertions(+), 18 deletions(-)

diff --git a/build.zig b/build.zig
index be88bfb..859a449 100644
--- a/build.zig
+++ b/build.zig
@@ -6,7 +6,7 @@ const zls_version = std.builtin.Version{ .major = 0, .minor = 11, .patch = 0 };
 
 pub fn build(b: *std.build.Builder) !void {
     const current_zig = builtin.zig_version;
-    const min_zig = std.SemanticVersion.parse("0.10.0-dev.4458+b120c819d") catch return; // builtins changed to @min / @max
+    const min_zig = std.SemanticVersion.parse("0.11.0-dev.323+30eb2a175") catch return; // added tuple declaration support
     if (current_zig.order(min_zig).compare(.lt)) @panic(b.fmt("Your Zig version v{} does not meet the minimum build requirement of v{}", .{ current_zig, min_zig }));
 
     const target = b.standardTargetOptions(.{});
diff --git a/src/ComptimeInterpreter.zig b/src/ComptimeInterpreter.zig
index 587ade5..2548793 100644
--- a/src/ComptimeInterpreter.zig
+++ b/src/ComptimeInterpreter.zig
@@ -285,6 +285,7 @@ pub const ValueData = union(enum) {
 pub const FieldDefinition = struct {
     node_idx: Ast.Node.Index,
     /// Store name so tree doesn't need to be used to access field name
+    /// When the field is a tuple field, `name` will be an empty slice
     name: []const u8,
     @"type": Type,
     default_value: ?Value,
@@ -765,6 +766,7 @@ pub fn interpret(
             var buffer: [2]Ast.Node.Index = undefined;
             const members = ast.declMembers(tree, node_idx, &buffer);
 
+            var field_idx: usize = 0;
             for (members) |member| {
                 const maybe_container_field: ?zig.Ast.full.ContainerField = switch (tags[member]) {
                     .container_field => tree.containerField(member),
@@ -789,7 +791,9 @@ pub fn interpret(
                         continue;
                     }
 
-                    const name = tree.tokenSlice(field_info.ast.name_token);
+                    const name = if (field_info.ast.tuple_like)
+                        &[0]u8{}
+                    else tree.tokenSlice(field_info.ast.main_token);
                     const field = FieldDefinition{
                         .node_idx = member,
                         .name = name,
@@ -804,6 +808,7 @@ pub fn interpret(
                     };
 
                     try cont_type.getTypeInfoMutable().@"struct".fields.put(interpreter.allocator, name, field);
+                    field_idx += 1;
                 } else {
                     _ = try interpreter.interpret(member, container_scope, options);
                 }
diff --git a/src/Server.zig b/src/Server.zig
index d39e86b..2b0652f 100644
--- a/src/Server.zig
+++ b/src/Server.zig
@@ -683,14 +683,16 @@ fn nodeToCompletion(
         .container_field_init,
         => {
             const field = ast.containerField(tree, node).?;
-            try list.append(allocator, .{
-                .label = handle.tree.tokenSlice(field.ast.name_token),
-                .kind = .Field,
-                .documentation = doc,
-                .detail = analysis.getContainerFieldSignature(handle.tree, field),
-                .insertText = tree.tokenSlice(field.ast.name_token),
-                .insertTextFormat = .PlainText,
-            });
+            if (!field.ast.tuple_like) {
+                try list.append(allocator, .{
+                    .label = handle.tree.tokenSlice(field.ast.main_token),
+                    .kind = .Field,
+                    .documentation = doc,
+                    .detail = analysis.getContainerFieldSignature(handle.tree, field),
+                    .insertText = tree.tokenSlice(field.ast.main_token),
+                    .insertTextFormat = .PlainText,
+                });
+            }
         },
         .array_type,
         .array_type_sentinel,
diff --git a/src/analysis.zig b/src/analysis.zig
index 8804cba..757d602 100644
--- a/src/analysis.zig
+++ b/src/analysis.zig
@@ -226,7 +226,7 @@ pub fn getContainerFieldSignature(tree: Ast, field: Ast.full.ContainerField) []c
     if (field.ast.value_expr == 0 and field.ast.type_expr == 0 and field.ast.align_expr == 0) {
         return ""; // TODO display the container's type
     }
-    const start = offsets.tokenToIndex(tree, field.ast.name_token);
+    const start = offsets.tokenToIndex(tree, field.ast.main_token);
     const end_node = if (field.ast.value_expr != 0) field.ast.value_expr else field.ast.type_expr;
     const end = offsets.tokenToLoc(tree, ast.lastToken(tree, end_node)).end;
     return tree.source[start..end];
@@ -291,9 +291,21 @@ pub fn getDeclNameToken(tree: Ast, node: Ast.Node.Index) ?Ast.TokenIndex {
         },
 
         // containers
-        .container_field => tree.containerField(node).ast.name_token,
-        .container_field_init => tree.containerFieldInit(node).ast.name_token,
-        .container_field_align => tree.containerFieldAlign(node).ast.name_token,
+        .container_field => blk: {
+            const field = tree.containerField(node);
+            if (field.ast.tuple_like) break :blk null;
+            break :blk field.ast.main_token;
+        },
+        .container_field_init => blk: {
+            const field = tree.containerFieldInit(node);
+            if (field.ast.tuple_like) break :blk null;
+            break :blk field.ast.main_token;
+        },
+        .container_field_align => blk: {
+            const field = tree.containerFieldAlign(node);
+            if (field.ast.tuple_like) break :blk null;
+            break :blk field.ast.main_token;
+        },
 
         .identifier => main_token,
         .error_value => main_token + 2, // 'error'.<main_token +2>
@@ -1399,9 +1411,18 @@ pub fn nodeToString(tree: Ast, node: Ast.Node.Index) ?[]const u8 {
     const main_token = tree.nodes.items(.main_token)[node];
     var buf: [1]Ast.Node.Index = undefined;
     switch (tree.nodes.items(.tag)[node]) {
-        .container_field => return tree.tokenSlice(tree.containerField(node).ast.name_token),
-        .container_field_init => return tree.tokenSlice(tree.containerFieldInit(node).ast.name_token),
-        .container_field_align => return tree.tokenSlice(tree.containerFieldAlign(node).ast.name_token),
+        .container_field => {
+            const field = tree.containerField(node).ast;
+            return if (field.tuple_like) null else tree.tokenSlice(field.main_token);
+        },
+        .container_field_init => {
+            const field = tree.containerFieldInit(node).ast;
+            return if (field.tuple_like) null else tree.tokenSlice(field.main_token);
+        },
+        .container_field_align => {
+            const field = tree.containerFieldAlign(node).ast;
+            return if (field.tuple_like) null else tree.tokenSlice(field.main_token);
+        },
         .error_value => return tree.tokenSlice(data[node].rhs),
         .identifier => return tree.tokenSlice(main_token),
         .fn_proto,
diff --git a/src/semantic_tokens.zig b/src/semantic_tokens.zig
index b201d4b..2204e6f 100644
--- a/src/semantic_tokens.zig
+++ b/src/semantic_tokens.zig
@@ -999,7 +999,9 @@ fn writeContainerField(builder: *Builder, node: Ast.Node.Index, field_token_type
         try writeDocComments(builder, tree, docs);
 
     try writeToken(builder, container_field.comptime_token, .keyword);
-    if (field_token_type) |tok_type| try writeToken(builder, container_field.ast.name_token, tok_type);
+    if (!container_field.ast.tuple_like) {
+        if (field_token_type) |tok_type| try writeToken(builder, container_field.ast.main_token, tok_type);
+    }
 
     if (container_field.ast.type_expr != 0) {
         try callWriteNodeTokens(allocator, .{ builder, container_field.ast.type_expr });

From c3256c00e7180493592d4c0755ae8d95a0155aa9 Mon Sep 17 00:00:00 2001
From: Lee Cannon <leecannon@leecannon.xyz>
Date: Tue, 29 Nov 2022 22:50:09 +0000
Subject: [PATCH 12/22] pass correct zig-cache path (#789)

---
 src/DocumentStore.zig | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/DocumentStore.zig b/src/DocumentStore.zig
index 2b82bfe..a475af6 100644
--- a/src/DocumentStore.zig
+++ b/src/DocumentStore.zig
@@ -387,7 +387,7 @@ fn loadBuildConfiguration(
     const directory_path = try std.fs.path.resolve(arena_allocator, &.{ build_file_path, "../" });
 
     // TODO extract this option from `BuildAssociatedConfig.BuildOption`
-    const zig_cache_root: []const u8 = "zig-cache";
+    const zig_cache_root: []const u8 = try std.fs.path.join(arena_allocator, &.{ directory_path, "zig-cache" });
     // Since we don't compile anything and no packages should put their
     // files there this path can be ignored
     const zig_global_cache_root: []const u8 = "ZLS_DONT_CARE";

From 784047d9522c6f913df44fb662f953afe350b38f Mon Sep 17 00:00:00 2001
From: Techatrix <19954306+Techatrix@users.noreply.github.com>
Date: Thu, 1 Dec 2022 10:00:08 +0100
Subject: [PATCH 13/22] add a dummy cancelRequest implementation (#790)

---
 src/Server.zig | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/src/Server.zig b/src/Server.zig
index 2b0652f..e3175cc 100644
--- a/src/Server.zig
+++ b/src/Server.zig
@@ -1769,6 +1769,13 @@ fn exitHandler(server: *Server, writer: anytype, id: types.RequestId) noreturn {
     std.os.exit(error_code);
 }
 
+fn cancelRequestHandler(server: *Server, writer: anytype, id: types.RequestId) !void {
+    _ = id;
+    _ = writer;
+    _ = server;
+    // TODO implement $/cancelRequest
+}
+
 fn registerCapability(server: *Server, writer: anytype, method: []const u8) !void {
     const id = try std.fmt.allocPrint(server.arena.allocator(), "register-{s}", .{method});
     log.debug("Dynamically registering method '{s}'", .{method});
@@ -2869,10 +2876,10 @@ pub fn processJsonRpc(server: *Server, writer: anytype, json: []const u8) !void
 
     const method_map = .{
         .{ "initialized", void, initializedHandler },
-        .{"$/cancelRequest"},
         .{ "initialize", requests.Initialize, initializeHandler },
         .{ "shutdown", void, shutdownHandler },
         .{ "exit", void, exitHandler },
+        .{ "$/cancelRequest", void, cancelRequestHandler },
         .{ "textDocument/didOpen", requests.OpenDocument, openDocumentHandler },
         .{ "textDocument/didChange", requests.ChangeDocument, changeDocumentHandler },
         .{ "textDocument/didSave", requests.SaveDocument, saveDocumentHandler },

From f6f0a0dca5b0de4998831b3bbff1fe73f15dc158 Mon Sep 17 00:00:00 2001
From: Mikkel Gravgaard <mikkel@klokke.dk>
Date: Fri, 2 Dec 2022 10:01:09 +0100
Subject: [PATCH 14/22] Add aarch64-linux to targets (#795)

---
 .github/workflows/main.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index da458ac..0607ced 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -38,7 +38,7 @@ jobs:
       - name: Build artifacts
         if: ${{ matrix.os == 'ubuntu-latest' }}
         run: |
-          declare -a targets=("x86_64-windows" "x86_64-linux" "x86_64-macos" "x86-windows" "x86-linux" "aarch64-macos")
+          declare -a targets=("x86_64-windows" "x86_64-linux" "x86_64-macos" "x86-windows" "x86-linux" "aarch64-linux" "aarch64-macos")
           mkdir -p "artifacts/"
 
           for target in "${targets[@]}"; do

From 6ab2c68355a317a80285cacf62f7ea71ba1d6bf8 Mon Sep 17 00:00:00 2001
From: Auguste Rame <19855629+SuperAuguste@users.noreply.github.com>
Date: Fri, 2 Dec 2022 15:14:58 -0500
Subject: [PATCH 15/22] Allocgate 2.0 slain (#791)

* Allocgate 2.0 slain

* Tests now compile, but they fail

* Temporary bruteforce
---
 src/ComptimeInterpreter.zig            |  2 +-
 src/Server.zig                         |  4 ++--
 src/inlay_hints.zig                    |  2 +-
 src/semantic_tokens.zig                |  2 +-
 src/translate_c.zig                    |  2 +-
 src/uri.zig                            |  6 ++++--
 tests/helper.zig                       |  2 +-
 tests/lsp_features/completion.zig      | 24 +++++++++++++-----------
 tests/lsp_features/references.zig      |  2 +-
 tests/lsp_features/semantic_tokens.zig | 14 +++++++++-----
 10 files changed, 34 insertions(+), 26 deletions(-)

diff --git a/src/ComptimeInterpreter.zig b/src/ComptimeInterpreter.zig
index 2548793..231f60d 100644
--- a/src/ComptimeInterpreter.zig
+++ b/src/ComptimeInterpreter.zig
@@ -1122,7 +1122,7 @@ pub fn interpret(
                     if (index != params.len - 1)
                         try writer.writeAll(", ");
                 }
-                try interpreter.recordError(node_idx, "compile_log", final.toOwnedSlice());
+                try interpreter.recordError(node_idx, "compile_log", try final.toOwnedSlice());
 
                 return InterpretResult{ .nothing = {} };
             }
diff --git a/src/Server.zig b/src/Server.zig
index e3175cc..fcf6102 100644
--- a/src/Server.zig
+++ b/src/Server.zig
@@ -1288,7 +1288,7 @@ fn completeFieldAccess(server: *Server, handle: *const DocumentStore.Handle, sou
         }
     }
 
-    return completions.toOwnedSlice(allocator);
+    return try completions.toOwnedSlice(allocator);
 }
 
 fn formatDetailledLabel(item: *types.CompletionItem, alloc: std.mem.Allocator) !void {
@@ -1936,7 +1936,7 @@ fn willSaveWaitUntilHandler(server: *Server, writer: anytype, id: types.RequestI
 
     return try send(writer, allocator, types.Response{
         .id = id,
-        .result = .{ .TextEdits = text_edits.toOwnedSlice(allocator) },
+        .result = .{ .TextEdits = try text_edits.toOwnedSlice(allocator) },
     });
 }
 
diff --git a/src/inlay_hints.zig b/src/inlay_hints.zig
index 8524f07..579bbe2 100644
--- a/src/inlay_hints.zig
+++ b/src/inlay_hints.zig
@@ -73,7 +73,7 @@ const Builder = struct {
         });
     }
 
-    fn toOwnedSlice(self: *Builder) []types.InlayHint {
+    fn toOwnedSlice(self: *Builder) error{OutOfMemory}![]types.InlayHint {
         return self.hints.toOwnedSlice(self.allocator);
     }
 };
diff --git a/src/semantic_tokens.zig b/src/semantic_tokens.zig
index 2204e6f..d54464f 100644
--- a/src/semantic_tokens.zig
+++ b/src/semantic_tokens.zig
@@ -195,7 +195,7 @@ const Builder = struct {
         self.previous_position = start;
     }
 
-    fn toOwnedSlice(self: *Builder) []u32 {
+    fn toOwnedSlice(self: *Builder) error{OutOfMemory}![]u32 {
         return self.arr.toOwnedSlice(self.arena.allocator());
     }
 };
diff --git a/src/translate_c.zig b/src/translate_c.zig
index 32e1aa5..dcc7a31 100644
--- a/src/translate_c.zig
+++ b/src/translate_c.zig
@@ -152,7 +152,7 @@ pub fn translate(allocator: std.mem.Allocator, config: Config, include_dirs: []c
         var native_paths = std.zig.system.NativePaths.detect(allocator, target_info) catch break :blk null;
         defer native_paths.deinit();
 
-        break :blk native_paths.include_dirs.toOwnedSlice();
+        break :blk try native_paths.include_dirs.toOwnedSlice();
     };
     defer if (base_include_dirs) |dirs| {
         for (dirs) |path| {
diff --git a/src/uri.zig b/src/uri.zig
index 2b65603..6bc36bf 100644
--- a/src/uri.zig
+++ b/src/uri.zig
@@ -100,7 +100,7 @@ fn parseHex(c: u8) !u8 {
 pub fn parse(allocator: std.mem.Allocator, str: []const u8) ![]u8 {
     if (str.len < 7 or !std.mem.eql(u8, "file://", str[0..7])) return error.UriBadScheme;
 
-    const uri = try allocator.alloc(u8, str.len - (if (std.fs.path.sep == '\\') 8 else 7));
+    var uri = try allocator.alloc(u8, str.len - (if (std.fs.path.sep == '\\') 8 else 7));
     errdefer allocator.free(uri);
 
     const path = if (std.fs.path.sep == '\\') str[8..] else str[7..];
@@ -125,5 +125,7 @@ pub fn parse(allocator: std.mem.Allocator, str: []const u8) ![]u8 {
         i -= 1;
     }
 
-    return allocator.shrink(uri, i);
+    _ = allocator.resize(uri, i);
+
+    return uri;
 }
diff --git a/tests/helper.zig b/tests/helper.zig
index b70a734..0141e92 100644
--- a/tests/helper.zig
+++ b/tests/helper.zig
@@ -105,7 +105,7 @@ pub fn collectReplacePlaceholders(allocator: std.mem.Allocator, source: []const
 
     return CollectPlaceholdersResult{
         .locations = locations,
-        .new_source = new_source.toOwnedSlice(allocator),
+        .new_source = try new_source.toOwnedSlice(allocator),
     };
 }
 
diff --git a/tests/lsp_features/completion.zig b/tests/lsp_features/completion.zig
index ca3959d..ad5f90c 100644
--- a/tests/lsp_features/completion.zig
+++ b/tests/lsp_features/completion.zig
@@ -269,17 +269,19 @@ test "completion - union" {
 }
 
 test "completion - enum" {
-    try testCompletion(
-        \\const E = enum {
-        \\    alpha,
-        \\    beta,
-        \\};
-        \\const foo = E.<cursor>
-    , &.{
-        // TODO kind should be Enum
-        .{ .label = "alpha", .kind = .Field },
-        .{ .label = "beta", .kind = .Field },
-    });
+    // TODO: Fix this test
+    return error.SkipZigTest;
+    // try testCompletion(
+    //     \\const E = enum {
+    //     \\    alpha,
+    //     \\    beta,
+    //     \\};
+    //     \\const foo = E.<cursor>
+    // , &.{
+    //     // TODO kind should be Enum
+    //     .{ .label = "alpha", .kind = .Field },
+    //     .{ .label = "beta", .kind = .Field },
+    // });
 }
 
 test "completion - error union" {
diff --git a/tests/lsp_features/references.zig b/tests/lsp_features/references.zig
index f479c45..a595094 100644
--- a/tests/lsp_features/references.zig
+++ b/tests/lsp_features/references.zig
@@ -150,7 +150,7 @@ fn testReferences(source: []const u8) !void {
                 try locs.append(allocator, new_loc);
             }
 
-            break :blk locs.toOwnedSlice(allocator);
+            break :blk try locs.toOwnedSlice(allocator);
         };
         defer allocator.free(expected_locs);
 
diff --git a/tests/lsp_features/semantic_tokens.zig b/tests/lsp_features/semantic_tokens.zig
index 0cf4025..2d5a7d4 100644
--- a/tests/lsp_features/semantic_tokens.zig
+++ b/tests/lsp_features/semantic_tokens.zig
@@ -13,11 +13,15 @@ test "semantic tokens - empty" {
 }
 
 test "semantic tokens" {
-    try testSemanticTokens(
-        \\const std = @import("std");
-    ,
-        &.{ 0, 0, 5, 7, 0, 0, 6, 3, 0, 33, 0, 4, 1, 11, 0, 0, 2, 7, 12, 0, 0, 8, 5, 9, 0 },
-    );
+    // TODO: Fix this test
+    return error.SkipZigTest;
+
+    // try testSemanticTokens(
+    //     \\const std = @import("std");
+    // ,
+    //     &.{ 0, 0, 5, 7, 0, 0, 6, 3, 0, 33, 0, 4, 1, 11, 0, 0, 2, 7, 12, 0, 0, 8, 5, 9, 0 },
+    // );
+
     // TODO more tests
 }
 

From 3ab859a304537816f42a6dd1b8ed16804da6083e Mon Sep 17 00:00:00 2001
From: Alexandros Naskos <alex_naskos@hotmail.com>
Date: Fri, 2 Dec 2022 23:22:35 +0200
Subject: [PATCH 16/22] Make sure zig lib path retrieved from `zig env` is
 absolute (#799)

---
 src/Config.zig | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/src/Config.zig b/src/Config.zig
index ae7fd55..aa56127 100644
--- a/src/Config.zig
+++ b/src/Config.zig
@@ -150,9 +150,8 @@ pub fn configChanged(config: *Config, allocator: std.mem.Allocator, builtin_crea
         var env = getZigEnv(allocator, exe_path) orelse break :blk;
         defer std.json.parseFree(Env, env, .{ .allocator = allocator });
 
-        // We know this is allocated with `allocator`, we just steal it!
-        config.zig_lib_path = env.lib_dir.?;
-        env.lib_dir = null;
+        // Make sure the path is absolute
+        config.zig_lib_path = try std.fs.realpathAlloc(allocator, env.lib_dir.?);
         logger.info("Using zig lib path '{s}'", .{config.zig_lib_path.?});
     } else {
         logger.warn("Zig executable path not specified in zls.json and could not be found in PATH", .{});

From cfb0b023ad83e63074f4761ac11fd470678f49f2 Mon Sep 17 00:00:00 2001
From: Alex Kladov <aleksey.kladov@gmail.com>
Date: Sat, 3 Dec 2022 15:23:13 +0000
Subject: [PATCH 17/22] fix #801, IOOB in foldingRanges (#802)

* Add smoke tests for folding ranges

* fix index out of bounds in foldingRanges

closes #801

For invalid syntax trees, zig's parser seems to return bogus data where
startToken > endToken, which then causes everything else to crash.

This seems like a deeper issue, which needs to be fixed "properly", but
let's just paper over it here.
---
 src/Server.zig                       |  2 +-
 tests/lsp_features/folding_range.zig | 66 ++++++++++++++++++++++++++++
 tests/tests.zig                      |  5 ++-
 3 files changed, 70 insertions(+), 3 deletions(-)
 create mode 100644 tests/lsp_features/folding_range.zig

diff --git a/src/Server.zig b/src/Server.zig
index fcf6102..7aabb99 100644
--- a/src/Server.zig
+++ b/src/Server.zig
@@ -2454,7 +2454,7 @@ fn foldingRangeHandler(server: *Server, writer: anytype, id: types.RequestId, re
             end: Ast.TokenIndex,
             end_reach: Inclusivity,
         ) std.mem.Allocator.Error!bool {
-            const can_add = !tree.tokensOnSameLine(start, end);
+            const can_add = start < end and !tree.tokensOnSameLine(start, end);
             if (can_add) {
                 try addTokRange(p_ranges, tree, start, end, end_reach);
             }
diff --git a/tests/lsp_features/folding_range.zig b/tests/lsp_features/folding_range.zig
new file mode 100644
index 0000000..956d4f1
--- /dev/null
+++ b/tests/lsp_features/folding_range.zig
@@ -0,0 +1,66 @@
+const std = @import("std");
+const zls = @import("zls");
+const builtin = @import("builtin");
+
+const Context = @import("../context.zig").Context;
+
+const types = zls.types;
+const requests = zls.requests;
+
+const allocator: std.mem.Allocator = std.testing.allocator;
+
+test "foldingRange - empty" {
+    try testFoldingRange("", "[]");
+}
+
+test "foldingRange - smoke" {
+    try testFoldingRange(
+        \\fn main() u32 {
+        \\    return 1 + 1;
+        \\}
+    ,
+        \\[{"startLine":0,"endLine":1}]
+    );
+}
+
+test "foldingRange - #801" {
+    try testFoldingRange(
+        \\fn score(c: u8) !u32 {
+        \\    return switch(c) {
+        \\        'a'...'z' => c - 'a',
+        \\        'A'...'Z' => c - 'A',
+        \\        _ => error
+        \\    };
+        \\}
+    ,
+        \\[]
+    );
+}
+
+fn testFoldingRange(source: []const u8, expect: []const u8) !void {
+    var ctx = try Context.init();
+    defer ctx.deinit();
+
+    const test_uri: []const u8 = switch (builtin.os.tag) {
+        .windows => "file:///C:\\test.zig",
+        else => "file:///test.zig",
+    };
+
+    try ctx.requestDidOpen(test_uri, source);
+
+    const request = requests.FoldingRange{ .params = .{ .textDocument = .{ .uri = test_uri } } };
+
+    const response = try ctx.requestGetResponse(?[]types.FoldingRange, "textDocument/foldingRange", request);
+    defer response.deinit();
+
+    var actual = std.ArrayList(u8).init(allocator);
+    defer actual.deinit();
+
+    try std.json.stringify(response.result, .{}, actual.writer());
+    try expectEqualJson(expect, actual.items);
+}
+
+fn expectEqualJson(expect: []const u8, actual: []const u8) !void {
+    // TODO: Actually compare strings as JSON values.
+    return std.testing.expectEqualStrings(expect, actual);
+}
diff --git a/tests/tests.zig b/tests/tests.zig
index 1951513..d85c824 100644
--- a/tests/tests.zig
+++ b/tests/tests.zig
@@ -10,11 +10,12 @@ comptime {
     // TODO Document Synchronization
 
     // LSP features
-    _ = @import("lsp_features/semantic_tokens.zig");
+    _ = @import("lsp_features/completion.zig");
+    _ = @import("lsp_features/folding_range.zig");
     _ = @import("lsp_features/inlay_hints.zig");
     _ = @import("lsp_features/references.zig");
-    _ = @import("lsp_features/completion.zig");
     _ = @import("lsp_features/selection_range.zig");
+    _ = @import("lsp_features/semantic_tokens.zig");
 
     // Language features
     _ = @import("language_features/cimport.zig");

From 580469cd3292dd554ad30249a2ee9e117b42f84f Mon Sep 17 00:00:00 2001
From: Auguste Rame <19855629+SuperAuguste@users.noreply.github.com>
Date: Sat, 3 Dec 2022 21:35:51 -0500
Subject: [PATCH 18/22] Fix rogue resize, bump minimum version (#805)

---
 build.zig                              |  2 +-
 src/uri.zig                            |  6 ++----
 tests/lsp_features/completion.zig      |  2 +-
 tests/lsp_features/semantic_tokens.zig | 13 +++++--------
 4 files changed, 9 insertions(+), 14 deletions(-)

diff --git a/build.zig b/build.zig
index 859a449..e04a158 100644
--- a/build.zig
+++ b/build.zig
@@ -6,7 +6,7 @@ const zls_version = std.builtin.Version{ .major = 0, .minor = 11, .patch = 0 };
 
 pub fn build(b: *std.build.Builder) !void {
     const current_zig = builtin.zig_version;
-    const min_zig = std.SemanticVersion.parse("0.11.0-dev.323+30eb2a175") catch return; // added tuple declaration support
+    const min_zig = std.SemanticVersion.parse("0.11.0-dev.399+44ee1c885") catch return; // whereabouts allocgate 2.0
     if (current_zig.order(min_zig).compare(.lt)) @panic(b.fmt("Your Zig version v{} does not meet the minimum build requirement of v{}", .{ current_zig, min_zig }));
 
     const target = b.standardTargetOptions(.{});
diff --git a/src/uri.zig b/src/uri.zig
index 6bc36bf..95ce9a9 100644
--- a/src/uri.zig
+++ b/src/uri.zig
@@ -101,7 +101,7 @@ pub fn parse(allocator: std.mem.Allocator, str: []const u8) ![]u8 {
     if (str.len < 7 or !std.mem.eql(u8, "file://", str[0..7])) return error.UriBadScheme;
 
     var uri = try allocator.alloc(u8, str.len - (if (std.fs.path.sep == '\\') 8 else 7));
-    errdefer allocator.free(uri);
+    defer allocator.free(uri);
 
     const path = if (std.fs.path.sep == '\\') str[8..] else str[7..];
 
@@ -125,7 +125,5 @@ pub fn parse(allocator: std.mem.Allocator, str: []const u8) ![]u8 {
         i -= 1;
     }
 
-    _ = allocator.resize(uri, i);
-
-    return uri;
+    return try allocator.dupe(u8, uri[0..i]);
 }
diff --git a/tests/lsp_features/completion.zig b/tests/lsp_features/completion.zig
index ad5f90c..b5f18b9 100644
--- a/tests/lsp_features/completion.zig
+++ b/tests/lsp_features/completion.zig
@@ -269,7 +269,7 @@ test "completion - union" {
 }
 
 test "completion - enum" {
-    // TODO: Fix this test
+    // TODO: Fix
     return error.SkipZigTest;
     // try testCompletion(
     //     \\const E = enum {
diff --git a/tests/lsp_features/semantic_tokens.zig b/tests/lsp_features/semantic_tokens.zig
index 2d5a7d4..113589e 100644
--- a/tests/lsp_features/semantic_tokens.zig
+++ b/tests/lsp_features/semantic_tokens.zig
@@ -13,14 +13,11 @@ test "semantic tokens - empty" {
 }
 
 test "semantic tokens" {
-    // TODO: Fix this test
-    return error.SkipZigTest;
-
-    // try testSemanticTokens(
-    //     \\const std = @import("std");
-    // ,
-    //     &.{ 0, 0, 5, 7, 0, 0, 6, 3, 0, 33, 0, 4, 1, 11, 0, 0, 2, 7, 12, 0, 0, 8, 5, 9, 0 },
-    // );
+    try testSemanticTokens(
+        \\const std = @import("std");
+    ,
+        &.{ 0, 0, 5, 7, 0, 0, 6, 3, 0, 33, 0, 4, 1, 11, 0, 0, 2, 7, 12, 0, 0, 8, 5, 9, 0 },
+    );
 
     // TODO more tests
 }

From 887539ed1aa84ee6f583156c7e239b974bcf1c31 Mon Sep 17 00:00:00 2001
From: Joseph Stahl <1269177+josephst@users.noreply.github.com>
Date: Sun, 4 Dec 2022 16:44:22 -0500
Subject: [PATCH 19/22] Allocator.resize() does not adjust size of string
 allocated for URI to file path conversion (#806)

* fix missing backslash

* fix: zls escaping colon to %3A on URIs

ZLS escapes a colon char ":" as "%3A" when encoding file paths to URIs
When decoding, need to make the target string 2 character shorter
to compensate for length decrease when replacing %3A with :

* add new failing test because of resize()

* revert changes to %3A handling - problem seems to be with allocator.resize

* switch to realloc

* Fix test failures, revert errdefer->defer

* platform-specific URI tests

URI parsing is highly platform-specific
run Unix-style (file:///home/main.zig) on non-Windows test runners,
run Windows-style (file://c%3A/main.zig) on Windows test runners
---
 src/uri.zig           |  4 ++--
 tests/utility/uri.zig | 53 +++++++++++++++++++++++++++++++++++++------
 2 files changed, 48 insertions(+), 9 deletions(-)

diff --git a/src/uri.zig b/src/uri.zig
index 95ce9a9..a1064d8 100644
--- a/src/uri.zig
+++ b/src/uri.zig
@@ -101,7 +101,7 @@ pub fn parse(allocator: std.mem.Allocator, str: []const u8) ![]u8 {
     if (str.len < 7 or !std.mem.eql(u8, "file://", str[0..7])) return error.UriBadScheme;
 
     var uri = try allocator.alloc(u8, str.len - (if (std.fs.path.sep == '\\') 8 else 7));
-    defer allocator.free(uri);
+    errdefer allocator.free(uri);
 
     const path = if (std.fs.path.sep == '\\') str[8..] else str[7..];
 
@@ -125,5 +125,5 @@ pub fn parse(allocator: std.mem.Allocator, str: []const u8) ![]u8 {
         i -= 1;
     }
 
-    return try allocator.dupe(u8, uri[0..i]);
+    return allocator.realloc(uri, i);
 }
diff --git a/tests/utility/uri.zig b/tests/utility/uri.zig
index 4aeb3b4..a1a494c 100644
--- a/tests/utility/uri.zig
+++ b/tests/utility/uri.zig
@@ -1,16 +1,55 @@
 const std = @import("std");
+const builtin = @import("builtin");
 const zls = @import("zls");
 
 const URI = zls.URI;
 
 const allocator = std.testing.allocator;
 
-test "uri - pathRelative" {
-    const join1 = try URI.pathRelative(allocator, "file://project/zig", "/src/main+.zig");
-    defer allocator.free(join1);
-    try std.testing.expectEqualStrings("file://project/zig/src/main%2B.zig", join1);
+test "uri - parse (Windows)" {
+    if (builtin.os.tag == .windows) {
+        const parseWin = try URI.parse(allocator, "file:///c%3A/main.zig");
+        defer allocator.free(parseWin);
+        try std.testing.expectEqualStrings("c:\\main.zig", parseWin);
 
-    const join2 = try URI.pathRelative(allocator, "file://project/zig/wow", "../]src]/]main.zig");
+        const parseWin2 = try URI.parse(allocator, "file:///c%3A/main%2B.zig");
+        defer allocator.free(parseWin2);
+        try std.testing.expectEqualStrings("c:\\main+.zig", parseWin2);
+    }
+}
+
+test "uri - parse (Unix-style)" {
+    if (builtin.os.tag != .windows) {
+        const parseUnix = try URI.parse(allocator, "file:///home/main.zig");
+        defer allocator.free(parseUnix);
+        try std.testing.expectEqualStrings("/home/main.zig", parseUnix);
+
+        const parseUnix2 = try URI.parse(allocator, "file:///home/main%2B.zig");
+        defer allocator.free(parseUnix2);
+        try std.testing.expectEqualStrings("/home/main+.zig", parseUnix2);
+    }
+}
+
+test "uri - fromPath" {
+    if (builtin.os.tag == .windows) {
+        const fromPathWin = try URI.fromPath(allocator, "c:\\main.zig");
+        defer allocator.free(fromPathWin);
+        try std.testing.expectEqualStrings("file:///c%3A/main.zig", fromPathWin);
+    }
+
+    if (builtin.os.tag != .windows) {
+        const fromPathUnix = try URI.fromPath(allocator, "/home/main.zig");
+        defer allocator.free(fromPathUnix);
+        try std.testing.expectEqualStrings("file:///home/main.zig", fromPathUnix);
+    }
+}
+
+test "uri - pathRelative" {
+    const join1 = try URI.pathRelative(allocator, "file:///project/zig", "/src/main+.zig");
+    defer allocator.free(join1);
+    try std.testing.expectEqualStrings("file:///project/zig/src/main%2B.zig", join1);
+
+    const join2 = try URI.pathRelative(allocator, "file:///project/zig/wow", "../]src]/]main.zig");
     defer allocator.free(join2);
-    try std.testing.expectEqualStrings("file://project/zig/%5Dsrc%5D/%5Dmain.zig", join2);
-}
\ No newline at end of file
+    try std.testing.expectEqualStrings("file:///project/zig/%5Dsrc%5D/%5Dmain.zig", join2);
+}

From 1e99692d5c670c483e1eaf2cd8710fe1c99272ff Mon Sep 17 00:00:00 2001
From: Auguste Rame <19855629+SuperAuguste@users.noreply.github.com>
Date: Wed, 7 Dec 2022 11:39:46 -0500
Subject: [PATCH 20/22] Enable stage2 (#810)

---
 build.zig                                        |  2 --
 tests/language_features/comptime_interpreter.zig | 16 ++++++++--------
 tests/lsp_features/selection_range.zig           |  2 +-
 3 files changed, 9 insertions(+), 11 deletions(-)

diff --git a/build.zig b/build.zig
index e04a158..1007ad0 100644
--- a/build.zig
+++ b/build.zig
@@ -13,7 +13,6 @@ pub fn build(b: *std.build.Builder) !void {
 
     const mode = b.standardReleaseOptions();
     const exe = b.addExecutable("zls", "src/main.zig");
-    exe.use_stage1 = true;
     const exe_options = b.addOptions();
     exe.addOptions("build_options", exe_options);
 
@@ -134,7 +133,6 @@ pub fn build(b: *std.build.Builder) !void {
         });
     }
 
-    tests.use_stage1 = true;
     tests.addPackage(.{ .name = "zls", .source = .{ .path = "src/zls.zig" }, .dependencies = exe.packages.items });
     tests.setBuildMode(.Debug);
     tests.setTarget(target);
diff --git a/tests/language_features/comptime_interpreter.zig b/tests/language_features/comptime_interpreter.zig
index ae9311e..cc42b3d 100644
--- a/tests/language_features/comptime_interpreter.zig
+++ b/tests/language_features/comptime_interpreter.zig
@@ -32,18 +32,18 @@ test "ComptimeInterpreter - basic test" {
 
     _ = try interpreter.interpret(0, null, .{});
 
-    var bool_type = try interpreter.createType(std.math.maxInt(std.zig.Ast.Node.Index), .{ .@"bool" = .{} });
+    var bool_type = try interpreter.createType(std.math.maxInt(std.zig.Ast.Node.Index), .{ .bool = {} });
     var arg_false = ComptimeInterpreter.Value{
         .interpreter = &interpreter,
         .node_idx = std.math.maxInt(std.zig.Ast.Node.Index),
-        .@"type" = bool_type,
-        .value_data = try interpreter.createValueData(.{ .@"bool" = false }),
+        .type = bool_type,
+        .value_data = try interpreter.createValueData(.{ .bool = false }),
     };
     var arg_true = ComptimeInterpreter.Value{
         .interpreter = &interpreter,
         .node_idx = std.math.maxInt(std.zig.Ast.Node.Index),
-        .@"type" = bool_type,
-        .value_data = try interpreter.createValueData(.{ .@"bool" = true }),
+        .type = bool_type,
+        .value_data = try interpreter.createValueData(.{ .bool = true }),
     };
 
     const rmt = interpreter.root_type.?.getTypeInfo().@"struct".scope.declarations.get("ReturnMyType").?;
@@ -57,8 +57,8 @@ test "ComptimeInterpreter - basic test" {
     }, .{});
     defer call_with_true.scope.deinit();
 
-    try std.testing.expectFmt("u69", "{any}", .{interpreter.formatTypeInfo(call_with_false.result.value.value_data.@"type".getTypeInfo())});
-    try std.testing.expectFmt("u8", "{any}", .{interpreter.formatTypeInfo(call_with_true.result.value.value_data.@"type".getTypeInfo())});
+    try std.testing.expectFmt("u69", "{any}", .{interpreter.formatTypeInfo(call_with_false.result.value.value_data.type.getTypeInfo())});
+    try std.testing.expectFmt("u8", "{any}", .{interpreter.formatTypeInfo(call_with_true.result.value.value_data.type.getTypeInfo())});
 }
 
 test "ComptimeInterpreter - struct" {
@@ -92,5 +92,5 @@ test "ComptimeInterpreter - struct" {
     const z = try interpreter.call(null, rmt.node_idx, &.{}, .{});
     defer z.scope.deinit();
 
-    try std.testing.expectFmt("struct {slay: bool, var abc: comptime_int = 123, }", "{any}", .{interpreter.formatTypeInfo(z.result.value.value_data.@"type".getTypeInfo())});
+    try std.testing.expectFmt("struct {slay: bool, var abc: comptime_int = 123, }", "{any}", .{interpreter.formatTypeInfo(z.result.value.value_data.type.getTypeInfo())});
 }
diff --git a/tests/lsp_features/selection_range.zig b/tests/lsp_features/selection_range.zig
index 9eb7c5c..0b92d28 100644
--- a/tests/lsp_features/selection_range.zig
+++ b/tests/lsp_features/selection_range.zig
@@ -47,7 +47,7 @@ fn testSelectionRange(source: []const u8, want: []const []const u8) !void {
 
     const request = requests.SelectionRange{ .params = .{
         .textDocument = .{ .uri = test_uri },
-        .positions = &.{position},
+        .positions = &[_]types.Position{position},
     } };
 
     const response = try ctx.requestGetResponse(?[]SelectionRange, "textDocument/selectionRange", request);

From ddf3ef1389e9f7c056e77ef808d6a746b8adbfc9 Mon Sep 17 00:00:00 2001
From: nullptrdevs <16590917+nullptrdevs@users.noreply.github.com>
Date: Wed, 7 Dec 2022 17:12:27 -0800
Subject: [PATCH 21/22] main ci: upload an artifact per arch (#809)

* main ci: upload an artifact per arch

* main ci: do deploy only if 'zigtools' is the owner
---
 .github/workflows/main.yml | 56 ++++++++++++++++++++++++++++++++------
 1 file changed, 47 insertions(+), 9 deletions(-)

diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index 0607ced..4f9a76e 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -53,21 +53,59 @@ jobs:
             fi
             sed -e '1,5d' < README.md > artifacts/${target}/README.md
             cp LICENSE artifacts/${target}/
-            cd artifacts/${target}/
-            tar cfa ${target}.tar.zst *.md bin/*
-            mv ${target}.tar.zst ../
-            cd ../..
           done
 
-      - name: Upload artifacts
+      - name: Upload x86_64-windows artifact
         if: ${{ matrix.os == 'ubuntu-latest' }}
-        uses: actions/upload-artifact@v2
+        uses: actions/upload-artifact@v3
         with:
-          name: builds
-          path: artifacts/*.tar.zst
+          name: zls-x86_64-windows
+          path: artifacts/x86_64-windows/
+
+      - name: Upload x86_64-linux artifact
+        if: ${{ matrix.os == 'ubuntu-latest' }}
+        uses: actions/upload-artifact@v3
+        with:
+          name: zls-x86_64-linux
+          path: artifacts/x86_64-linux/
+
+      - name: Upload x86_64-macos artifact
+        if: ${{ matrix.os == 'ubuntu-latest' }}
+        uses: actions/upload-artifact@v3
+        with:
+          name: zls-x86_64-macos
+          path: artifacts/x86_64-macos/
+
+      - name: Upload x86-windows artifact
+        if: ${{ matrix.os == 'ubuntu-latest' }}
+        uses: actions/upload-artifact@v3
+        with:
+          name: zls-x86-windows
+          path: artifacts/x86-windows/
+
+      - name: Upload x86-linux artifact
+        if: ${{ matrix.os == 'ubuntu-latest' }}
+        uses: actions/upload-artifact@v3
+        with:
+          name: zls-x86-linux
+          path: artifacts/x86-linux/
+
+      - name: Upload aarch64-linux artifact
+        if: ${{ matrix.os == 'ubuntu-latest' }}
+        uses: actions/upload-artifact@v3
+        with:
+          name: zls-aarch64-linux
+          path: artifacts/aarch64-linux/
+
+      - name: Upload aarch64-macos artifact
+        if: ${{ matrix.os == 'ubuntu-latest' }}
+        uses: actions/upload-artifact@v3
+        with:
+          name: zls-aarch64-macos
+          path: artifacts/aarch64-macos/
 
       - name: Beam to Felix
-        if: ${{ matrix.os == 'ubuntu-latest' && github.ref == 'refs/heads/master' }}
+        if: ${{ matrix.os == 'ubuntu-latest' && github.ref == 'refs/heads/master' && github.repository_owner == 'zigtools' }}
         uses: easingthemes/ssh-deploy@v2.1.1
         env:
           SSH_PRIVATE_KEY: ${{ secrets.SERVER_SSH_PRIVKEY }}

From 9e658cdbb6d1d29b047a8698e062205bc341586d Mon Sep 17 00:00:00 2001
From: Lee Cannon <leecannon@leecannon.xyz>
Date: Thu, 8 Dec 2022 19:32:50 +0000
Subject: [PATCH 22/22] update TracyAllocator for new Allocator changes (#812)

* update TracyAllocator for new Allocator changes

* Add build with Tracy to CI to catch regressions

* disable Tracy CI step on macos
---
 .github/workflows/main.yml |  6 +++++-
 src/tracy.zig              | 38 ++++++++++++++++++++++++--------------
 2 files changed, 29 insertions(+), 15 deletions(-)

diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index 4f9a76e..21f7ebd 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -22,7 +22,7 @@ jobs:
         with:
           fetch-depth: 0
           submodules: true
-      - uses: goto-bus-stop/setup-zig@v1
+      - uses: goto-bus-stop/setup-zig@v2
         with:
           version: master
 
@@ -32,6 +32,10 @@ jobs:
       - name: Build
         run: zig build
 
+      - name: Build with Tracy
+        if: ${{ matrix.os != 'macos-latest' }}
+        run: zig build -Denable_tracy -Denable_tracy_allocation
+
       - name: Run Tests
         run: zig build test
 
diff --git a/src/tracy.zig b/src/tracy.zig
index 07553bc..f933edd 100644
--- a/src/tracy.zig
+++ b/src/tracy.zig
@@ -146,44 +146,54 @@ pub fn TracyAllocator(comptime name: ?[:0]const u8) type {
         }
 
         pub fn allocator(self: *Self) std.mem.Allocator {
-            return std.mem.Allocator.init(self, allocFn, resizeFn, freeFn);
+            return .{
+                .ptr = self,
+                .vtable = &.{
+                    .alloc = allocFn,
+                    .resize = resizeFn,
+                    .free = freeFn,
+                },
+            };
         }
 
-        fn allocFn(self: *Self, len: usize, ptr_align: u29, len_align: u29, ret_addr: usize) std.mem.Allocator.Error![]u8 {
-            const result = self.parent_allocator.rawAlloc(len, ptr_align, len_align, ret_addr);
+        fn allocFn(ptr: *anyopaque, len: usize, ptr_align: u8, ret_addr: usize) ?[*]u8 {
+            const self = @ptrCast(*Self, @alignCast(@alignOf(Self), ptr));
+            const result = self.parent_allocator.rawAlloc(len, ptr_align, ret_addr);
             if (result) |data| {
-                if (data.len != 0) {
+                if (len != 0) {
                     if (name) |n| {
-                        allocNamed(data.ptr, data.len, n);
+                        allocNamed(data, len, n);
                     } else {
-                        alloc(data.ptr, data.len);
+                        alloc(data, len);
                     }
                 }
-            } else |_| {
+            } else {
                 messageColor("allocation failed", 0xFF0000);
             }
             return result;
         }
 
-        fn resizeFn(self: *Self, buf: []u8, buf_align: u29, new_len: usize, len_align: u29, ret_addr: usize) ?usize {
-            if (self.parent_allocator.rawResize(buf, buf_align, new_len, len_align, ret_addr)) |resized_len| {
+        fn resizeFn(ptr: *anyopaque, buf: []u8, buf_align: u8, new_len: usize, ret_addr: usize) bool {
+            const self = @ptrCast(*Self, @alignCast(@alignOf(Self), ptr));
+            if (self.parent_allocator.rawResize(buf, buf_align, new_len, ret_addr)) {
                 if (name) |n| {
                     freeNamed(buf.ptr, n);
-                    allocNamed(buf.ptr, resized_len, n);
+                    allocNamed(buf.ptr, new_len, n);
                 } else {
                     free(buf.ptr);
-                    alloc(buf.ptr, resized_len);
+                    alloc(buf.ptr, new_len);
                 }
 
-                return resized_len;
+                return true;
             }
 
             // during normal operation the compiler hits this case thousands of times due to this
             // emitting messages for it is both slow and causes clutter
-            return null;
+            return false;
         }
 
-        fn freeFn(self: *Self, buf: []u8, buf_align: u29, ret_addr: usize) void {
+        fn freeFn(ptr: *anyopaque, buf: []u8, buf_align: u8, ret_addr: usize) void {
+            const self = @ptrCast(*Self, @alignCast(@alignOf(Self), ptr));
             self.parent_allocator.rawFree(buf, buf_align, ret_addr);
             // this condition is to handle free being called on an empty slice that was never even allocated
             // example case: `std.process.getSelfExeSharedLibPaths` can return `&[_][:0]u8{}`