move hover doc comments to the bottom (#2302)

If the every line in the doc comment is empty or starts with a space, one space characters will be trimmed from the beginning of every line.

Author: darkdarcool

src/analysis.zig

@@ -131,14 +131,27 @@ pub fn collectDocComments(allocator: std.mem.Allocator, tree: Ast, doc_comments:
     var lines: std.ArrayListUnmanaged([]const u8) = .empty;
     defer lines.deinit(allocator);
 
+    var lines_start_with_space = true;
+
     var curr_line_tok = doc_comments;
     while (true) : (curr_line_tok += 1) {
         const comm = tree.tokenTag(curr_line_tok);
         if ((container_doc and comm == .container_doc_comment) or (!container_doc and comm == .doc_comment)) {
-            try lines.append(allocator, tree.tokenSlice(curr_line_tok)[3..]);
+            const line = tree.tokenSlice(curr_line_tok)[3..];
+            if (line.len > 1 and line[0] != ' ') lines_start_with_space = false;
+            try lines.append(allocator, line);
         } else break;
     }
 
+    // If all of the lines that aren't empty start with a space, remove the first space
+    if (lines_start_with_space) {
+        for (lines.items, 0..) |line, i| {
+            if (line.len > 1 and line[0] == ' ') {
+                lines.items[i] = line[1..];
+            }
+        }
+    }
+
     return try std.mem.join(allocator, "\n", lines.items);
 }
 

src/features/hover.zig

@@ -128,8 +128,6 @@ fn hoverSymbolResolved(
     var hover_text: std.ArrayListUnmanaged(u8) = .empty;
     const writer = hover_text.writer(arena);
     if (markup_kind == .markdown) {
-        for (doc_strings) |doc|
-            try writer.print("{s}\n\n", .{doc});
         try writer.print("```zig\n{s}\n```\n```zig\n({s})\n```", .{ def_str, resolved_type_str });
         if (referenced_types.len > 0)
             try writer.print("\n\n" ++ "Go to ", .{});
@@ -141,11 +139,17 @@ fn hoverSymbolResolved(
             try writer.print("[{s}]({s}#L{d})", .{ ref.str, ref.handle.uri, line });
         }
     } else {
-        for (doc_strings) |doc|
-            try writer.print("{s}\n\n", .{doc});
         try writer.print("{s}\n({s})", .{ def_str, resolved_type_str });
     }
 
+    if (doc_strings.len > 0) {
+        try writer.writeAll("\n\n");
+        for (doc_strings, 0..) |doc, i| {
+            try writer.writeAll(doc);
+            if (i != doc_strings.len - 1) try writer.writeAll("\n\n");
+        }
+    }
+
     return hover_text.items;
 }
 

tests/lsp_features/completion.zig

@@ -3167,9 +3167,9 @@ test "top-level doc comment" {
             .kind = .Struct,
             .detail = "type",
             .documentation =
-            \\ A
+            \\A
             \\
-            \\ B
+            \\B
             ,
         },
     });

tests/lsp_features/hover.zig

@@ -274,8 +274,6 @@ test "struct" {
         \\    };
         \\};
     ,
-        \\ Foo doc comment
-        \\
         \\```zig
         \\const FooStruct = struct {
         \\    bar: u32,
@@ -286,6 +284,8 @@ test "struct" {
         \\```zig
         \\(type)
         \\```
+        \\
+        \\Foo doc comment
     );
     try testHover(
         \\const Edge<cursor>Cases = struct {
@@ -691,14 +691,14 @@ test "function parameter" {
         \\    return a;
         \\}
     ,
-        \\ hello world
-        \\
         \\```zig
         \\a: u32
         \\```
         \\```zig
         \\(u32)
         \\```
+        \\
+        \\hello world
     );
 }
 
@@ -748,23 +748,23 @@ test "either types" {
         \\const either = if (undefined) A else B;
         \\const bar = either.<cursor>T;
     ,
-        \\small type
-        \\
         \\```zig
         \\const T = u32
         \\```
         \\```zig
         \\(type)
         \\```
         \\
-        \\large type
+        \\small type
         \\
         \\```zig
         \\const T = u64
         \\```
         \\```zig
         \\(type)
         \\```
+        \\
+        \\large type
     );
     try testHoverWithOptions(
         \\const A = struct {
@@ -778,15 +778,15 @@ test "either types" {
         \\const either = if (undefined) A else B;
         \\const bar = either.<cursor>T;
     ,
-        \\small type
-        \\
         \\const T = u32
         \\(type)
         \\
-        \\large type
+        \\small type
         \\
         \\const T = u64
         \\(type)
+        \\
+        \\large type
     , .{ .markup_kind = .plaintext });
 }
 
@@ -795,14 +795,14 @@ test "var decl comments" {
         \\///this is a comment
         \\const f<cursor>oo = 0 + 0;
     ,
-        \\this is a comment
-        \\
         \\```zig
         \\const foo = 0 + 0
         \\```
         \\```zig
         \\(comptime_int)
         \\```
+        \\
+        \\this is a comment
     );
 }
 
@@ -931,16 +931,16 @@ test "combine doc comments of declaration and definition" {
         \\    const baz = struct {};
         \\};
     ,
-        \\ Foo
-        \\
-        \\ Bar
-        \\
         \\```zig
         \\const baz = struct
         \\```
         \\```zig
         \\(type)
         \\```
+        \\
+        \\Foo
+        \\
+        \\Bar
     );
     try testHoverWithOptions(
         \\/// Foo
@@ -950,12 +950,12 @@ test "combine doc comments of declaration and definition" {
         \\    const baz = struct {};
         \\};
     ,
-        \\ Foo
-        \\
-        \\ Bar
-        \\
         \\const baz = struct
         \\(type)
+        \\
+        \\Foo
+        \\
+        \\Bar
     , .{ .markup_kind = .plaintext });
 }
 
@@ -966,16 +966,16 @@ test "top-level doc comment" {
         \\/// A
         \\const S<cursor>elf = @This();
     ,
-        \\ A
-        \\
-        \\ B
-        \\
         \\```zig
         \\const Self = @This()
         \\```
         \\```zig
         \\(type)
         \\```
+        \\
+        \\A
+        \\
+        \\B
     );
 }