rework code action test fn to take code action kind, fix string literal code action handlers

Author: WillLillis

src/Server.zig

@@ -321,7 +321,7 @@ fn showMessage(
     }
 }
 
-fn initAnalyser(server: *Server, handle: ?*DocumentStore.Handle) Analyser {
+pub fn initAnalyser(server: *Server, handle: ?*DocumentStore.Handle) Analyser {
     return Analyser.init(
         server.allocator,
         &server.document_store,

src/features/code_actions.zig

@@ -388,25 +388,45 @@ fn handleStringLiteralToMultiline(builder: *Builder, actions: *std.ArrayListUnma
     const str_tok_idx = offsets.sourceIndexToTokenIndex(builder.handle.tree, loc.start);
     if (tokens.items(.tag)[str_tok_idx] != .string_literal) return;
     const token_src = builder.handle.tree.tokenSlice(str_tok_idx);
-    const str_conts = token_src[1 .. token_src.len - 1]; // Omit leading and trailing '"'
     const edit_loc_start = builder.handle.tree.tokenLocation(tokens.items(.start)[str_tok_idx], str_tok_idx).line_start;
 
-    var multiline = std.ArrayList(u8).init(builder.arena);
-    const writer = multiline.writer();
+    var parsed = std.ArrayList(u8).init(builder.arena);
+    defer parsed.deinit();
+    const writer = parsed.writer();
 
-    if (builder.handle.tree.tokensOnSameLine(str_tok_idx -| 1, str_tok_idx)) {
-        try writer.writeByte('\n');
+    switch (try std.zig.string_literal.parseWrite(writer, token_src)) {
+        .failure => return,
+        .success => {},
     }
+    // carriage returns are not allowed in multiline string literals
+    if (std.mem.containsAtLeast(u8, parsed.items, 1, "\r")) return;
 
-    var iter = std.mem.splitSequence(u8, str_conts, "\\n");
-    while (iter.next()) |line| {
-        try writer.print("\\\\{s}\n", .{line});
-    }
+    const next_token = @min(str_tok_idx + 1, builder.handle.tree.tokens.len - 1);
+    const leading_nl = builder.handle.tree.tokensOnSameLine(str_tok_idx -| 1, str_tok_idx);
+    const trailing_nl = builder.handle.tree.tokensOnSameLine(str_tok_idx, @intCast(next_token));
+
+    const len = blk: {
+        var tot: usize = 0;
+        if (leading_nl) tot += 1;
+        tot += std.mem.replacementSize(u8, writer.context.items, "\n", "\n\\\\") + "\\\\".len;
+        if (trailing_nl) tot += 1;
+
+        break :blk tot;
+    };
+    var buf = try std.ArrayList(u8).initCapacity(builder.arena, len);
+    errdefer buf.deinit();
 
-    // remove trailing newline in cases where it's not needed
-    if (str_tok_idx + 1 < tokens.len and !builder.handle.tree.tokensOnSameLine(str_tok_idx, str_tok_idx + 1)) {
-        _ = multiline.pop();
+    var start_idx: usize = 0;
+    if (leading_nl) {
+        buf.appendAssumeCapacity('\n');
+        start_idx += 1;
     }
+    buf.appendSliceAssumeCapacity("\\\\");
+    start_idx += 2;
+    try if (trailing_nl) buf.resize(len - 1) else buf.resize(len);
+
+    _ = std.mem.replace(u8, parsed.items, "\n", "\n\\\\", buf.items[start_idx..]);
+    if (trailing_nl) buf.appendAssumeCapacity('\n');
 
     try actions.append(builder.arena, .{
         .title = "string literal to multiline string",
@@ -418,7 +438,7 @@ fn handleStringLiteralToMultiline(builder: *Builder, actions: *std.ArrayListUnma
                     .start = edit_loc_start,
                     .end = edit_loc_start + token_src.len,
                 },
-                multiline.items,
+                buf.items,
             ),
         }),
     });
@@ -430,15 +450,18 @@ fn handleMultilineStringToLiteral(builder: *Builder, actions: *std.ArrayListUnma
 
     var multiline_tok_idx = offsets.sourceIndexToTokenIndex(builder.handle.tree, loc.start);
     if (token_tags[multiline_tok_idx] != .multiline_string_literal_line) return;
+    multiline_tok_idx -|= 1;
 
     // walk up to the first multiline string literal
     const start_tok_idx = blk: {
-        while (multiline_tok_idx > 0) : (multiline_tok_idx -= 1) {
+        while (true) : (multiline_tok_idx -|= 1) {
             if (token_tags[multiline_tok_idx] != .multiline_string_literal_line) {
                 break :blk multiline_tok_idx + 1;
+            } else if (multiline_tok_idx == 0) {
+                break :blk multiline_tok_idx;
             }
         }
-        break :blk multiline_tok_idx;
+        unreachable;
     };
 
     var str_literal = std.ArrayList(u8).init(builder.arena);
@@ -464,16 +487,14 @@ fn handleMultilineStringToLiteral(builder: *Builder, actions: *std.ArrayListUnma
             try writer.writeAll("\\n");
         }
         const line = builder.handle.tree.tokenSlice(curr_tok_idx);
-        const end = if (line[line.len - 1] == '\n')
-            line.len - 1
-        else
-            line.len;
-        try writer.writeAll(line[2..end]); // Omit the leading '\\', trailing '\n' (if it's there)
+        std.debug.assert(line.len >= 2);
+        const end = if (line[line.len - 1] == '\n') line.len - 1 else line.len;
+        // Omit the leading "\\", trailing '\n' (if it's there)
+        try std.zig.stringEscape(line[2..end], "", .{}, writer);
         edit_loc_end = builder.handle.tree.tokenLocation(token_starts[curr_tok_idx], curr_tok_idx).line_end;
     }
 
     try writer.writeByte('\"');
-
     // bring up the semicolon from the next line, if it's there
     if (curr_tok_idx < token_tags.len and token_tags[curr_tok_idx] == .semicolon) {
         try writer.writeByte(';');
@@ -705,7 +726,7 @@ const DiagnosticKind = union(enum) {
     }
 };
 
-const UserActionKind = union(enum) {
+pub const UserActionKind = union(enum) {
     str_kind_conv: StrCat,
 
     const StrCat = enum {

tests/lsp_features/code_actions.zig

@@ -364,7 +364,7 @@ test "ignore autofix comment whitespace" {
 }
 
 test "string literal to multiline string literal" {
-    try testUserCodeAction(
+    try testUserCodeAction(.{ .str_kind_conv = .@"string literal to multiline string" },
         \\const foo = <cursor>"line one\nline two\nline three";
     ,
         \\const foo = 
@@ -373,15 +373,15 @@ test "string literal to multiline string literal" {
         \\\\line three
         \\;
     );
-    try testUserCodeAction(
+    try testUserCodeAction(.{ .str_kind_conv = .@"string literal to multiline string" },
         \\const foo = "Hello, <cursor>World!\n";
     ,
         \\const foo = 
         \\\\Hello, World!
         \\\\
         \\;
     );
-    try testUserCodeAction(
+    try testUserCodeAction(.{ .str_kind_conv = .@"string literal to multiline string" },
         \\std.debug.print(<cursor>"Hi\nHey\nHello\n", .{});
     ,
         \\std.debug.print(
@@ -391,18 +391,44 @@ test "string literal to multiline string literal" {
         \\\\
         \\, .{});
     );
-    try testUserCodeAction(
+    try testUserCodeAction(.{ .str_kind_conv = .@"string literal to multiline string" },
         \\const blank = <cursor>""
         \\;
     ,
         \\const blank = 
         \\\\
         \\;
     );
+    try testUserCodeAction(.{ .str_kind_conv = .@"string literal to multiline string" },
+        \\for (0..42) |idx| {
+        \\    std.debug.print("{}: {}\n<cursor>", .{ idx, my_foos[idx] });
+        \\}
+    ,
+        \\for (0..42) |idx| {
+        \\    std.debug.print(
+        \\\\{}: {}
+        \\\\
+        \\, .{ idx, my_foos[idx] });
+        \\}
+    );
+    try testUserCodeAction(.{ .str_kind_conv = .@"string literal to multiline string" },
+        \\const s1 = <cursor>"\t";
+    ,
+        \\const s1 = 
+        \\\\	
+        \\;
+    );
+    try testUserCodeAction(.{ .str_kind_conv = .@"string literal to multiline string" },
+        \\const s1 = <cursor>"pre text\tpost text";
+    ,
+        \\const s1 = 
+        \\\\pre text	post text
+        \\;
+    );
 }
 
 test "multiline string literal to string literal" {
-    try testUserCodeAction(
+    try testUserCodeAction(.{ .str_kind_conv = .@"multiline string to string literal" },
         \\const bleh =
         \\    \\hello
         \\    \\world<cursor>
@@ -415,7 +441,7 @@ test "multiline string literal to string literal" {
         \\    \\oh?
         \\;
     );
-    try testUserCodeAction(
+    try testUserCodeAction(.{ .str_kind_conv = .@"multiline string to string literal" },
         \\std.debug.print(
         \\\\Hi<cursor>
         \\\\Hey
@@ -427,7 +453,7 @@ test "multiline string literal to string literal" {
         \\"Hi\nHey\nHello\n"
         \\, .{});
     );
-    try testUserCodeAction(
+    try testUserCodeAction(.{ .str_kind_conv = .@"multiline string to string literal" },
         \\const nums =
         \\    \\123
         \\    \\456<cursor>
@@ -436,17 +462,19 @@ test "multiline string literal to string literal" {
     ,
         \\const nums = "123\n456\n789";
     );
-    try testUserCodeAction(
-        \\for (0..42) |idx| {
-        \\    std.debug.print("{}: {}\n<cursor>", .{ idx, my_foos[idx] });
-        \\}
+    try testUserCodeAction(.{ .str_kind_conv = .@"multiline string to string literal" },
+        \\const s3 =
+        \\  <cursor>\\"
+        \\;
     ,
-        \\for (0..42) |idx| {
-        \\    std.debug.print(
-        \\\\{}: {}
-        \\\\
-        \\, .{ idx, my_foos[idx] });
-        \\}
+        \\const s3 = "\"";
+    );
+    try testUserCodeAction(.{ .str_kind_conv = .@"multiline string to string literal" },
+        \\const s3 =
+        \\  <cursor>\\\
+        \\;
+    ,
+        \\const s3 = "\\";
     );
 }
 
@@ -503,7 +531,7 @@ fn testAutofixOptions(before: []const u8, after: []const u8, want_zir: bool) !vo
     try std.testing.expectEqualStrings(after, handle.tree.source);
 }
 
-fn testUserCodeAction(source: []const u8, expected: []const u8) !void {
+fn testUserCodeAction(action_kind: zls.code_actions.UserActionKind, source: []const u8, expected: []const u8) !void {
     var ctx = try Context.init();
     defer ctx.deinit();
 
@@ -514,7 +542,6 @@ fn testUserCodeAction(source: []const u8, expected: []const u8) !void {
     const uri = try ctx.addDocument(text);
     const handle = ctx.server.document_store.getHandle(uri).?;
     const pos = offsets.indexToPosition(text, cursor_idx, ctx.server.offset_encoding);
-
     const params = types.CodeActionParams{
         .textDocument = .{ .uri = uri },
         .range = .{
@@ -524,29 +551,26 @@ fn testUserCodeAction(source: []const u8, expected: []const u8) !void {
         .context = .{ .diagnostics = &[_]zls.types.Diagnostic{} },
     };
 
-    @setEvalBranchQuota(5000);
-    const response = try ctx.server.sendRequestSync(ctx.arena.allocator(), "textDocument/codeAction", params) orelse {
-        std.debug.print("Server returned `null` as the result\n", .{});
-        return error.InvalidResponse;
+    var analyser = ctx.server.initAnalyser(handle);
+    defer analyser.deinit();
+    var builder = zls.code_actions.Builder{
+        .arena = ctx.arena.allocator(),
+        .analyser = &analyser,
+        .handle = handle,
+        .offset_encoding = ctx.server.offset_encoding,
     };
+    var actions = std.ArrayListUnmanaged(types.CodeAction){};
 
-    var text_edits: std.ArrayListUnmanaged(types.TextEdit) = .{};
-    defer text_edits.deinit(allocator);
-
-    for (response) |action| {
-        const code_action = action.CodeAction;
-        if (code_action.kind.? == .@"source.fixAll") continue;
-        const workspace_edit = code_action.edit.?;
-        const changes = workspace_edit.changes.?.map;
-        try std.testing.expectEqual(@as(usize, 1), changes.count());
-        try std.testing.expect(changes.contains(uri));
-
-        try text_edits.appendSlice(allocator, changes.get(uri).?);
-    }
+    try builder.addCodeAction(action_kind, params, &actions);
+    try std.testing.expect(actions.items.len == 1);
+    const code_action = actions.items[0];
+    const workspace_edit = code_action.edit.?;
+    const changes = workspace_edit.changes.?.map;
+    try std.testing.expectEqual(@as(usize, 1), changes.count());
+    try std.testing.expect(changes.contains(uri));
 
-    const actual = try zls.diff.applyTextEdits(allocator, text, text_edits.items, ctx.server.offset_encoding);
+    const actual = try zls.diff.applyTextEdits(allocator, text, changes.get(uri).?, ctx.server.offset_encoding);
     defer allocator.free(actual);
     try ctx.server.document_store.refreshDocument(uri, try allocator.dupeZ(u8, actual));
-
     try std.testing.expectEqualStrings(expected, handle.tree.source);
 }