summaryrefslogtreecommitdiff
path: root/src/locations.zig
diff options
context:
space:
mode:
Diffstat (limited to 'src/locations.zig')
-rw-r--r--src/locations.zig179
1 files changed, 176 insertions, 3 deletions
diff --git a/src/locations.zig b/src/locations.zig
index 7755f6fd..745393e5 100644
--- a/src/locations.zig
+++ b/src/locations.zig
@@ -16,6 +16,8 @@ pub fn isContextLine(line: []const u8) bool {
pub const Row = struct {
kind: enum { match, context, preview },
declaration: bool = false,
+ mark_occurrence: bool = true,
+ source_column: usize = 0,
path: []u8,
at: look.Spot,
location_end: usize,
@@ -34,7 +36,7 @@ pub fn freeRows(gpa: std.mem.Allocator, rows: []Row) void {
pub fn equalRows(a: []const Row, b: []const Row) bool {
if (a.len != b.len) return false;
for (a, b) |left, right| {
- if (left.kind != right.kind or left.declaration != right.declaration or !std.meta.eql(left.at, right.at) or
+ if (left.kind != right.kind or left.declaration != right.declaration or left.mark_occurrence != right.mark_occurrence or left.source_column != right.source_column or !std.meta.eql(left.at, right.at) or
left.location_end != right.location_end or left.code_start != right.code_start or
!std.mem.eql(u8, left.path, right.path) or !std.mem.eql(u8, left.colors, right.colors)) return false;
}
@@ -119,7 +121,8 @@ pub fn parse(line: []const u8) Parsed {
return parseRaw(line);
}
-fn parseRaw(line: []const u8) Parsed {
+/// Native producer rows have one separator byte before untouched source.
+pub fn parseRaw(line: []const u8) Parsed {
var at: usize = 1;
while (at < line.len) : (at += 1) {
if (line[at] != ':' or at + 1 == line.len or !std.ascii.isDigit(line[at + 1])) continue;
@@ -148,6 +151,8 @@ const Pending = struct {
original: ?usize,
hidden: bool = false,
declaration: bool = false,
+ mark_occurrence: bool = true,
+ source_column: usize = 0,
depth: usize = 0,
colors: []const u8 = &.{},
@@ -174,6 +179,174 @@ pub fn sourceText(p: *pardes.Pardes, arena: std.mem.Allocator, dir: []const u8,
return .{ .path = lexical, .bytes = arena.dupe(u8, bytes) catch return null };
}
+/// Byte boundary after the guides in a call tree, independent of source indentation.
+pub fn treePrefix(line: []const u8) struct { end: usize, branch: bool } {
+ var at: usize = 0;
+ while (at < line.len) {
+ for ([_][]const u8{ "╰──┬ ", "├──╮ ", "╰──╮ ", "├─── ", "╰─── ", "├──┬ ", "└──┬ ", "└─── " }) |branch| {
+ if (std.mem.startsWith(u8, line[at..], branch)) return .{ .end = at + branch.len, .branch = true };
+ }
+ if (std.mem.startsWith(u8, line[at..], "├─ ") or std.mem.startsWith(u8, line[at..], "└─ ") or std.mem.startsWith(u8, line[at..], "╰─ "))
+ return .{ .end = at + "└─ ".len, .branch = false };
+ if (std.mem.startsWith(u8, line[at..], "│")) {
+ at += "│".len;
+ } else if (line[at] == ' ') {
+ at += 1;
+ } else break;
+ }
+ return .{ .end = at, .branch = false };
+}
+
+/// The same tree columns carried across a soft-wrapped display row. This is
+/// presentation only: source bytes and Look addresses remain untouched.
+pub fn treeContinuation(line: []const u8, buffer: []u8, max_cells: usize) []const u8 {
+ const prefix = line[0..treePrefix(line).end];
+ var out: std.Io.Writer = .fixed(buffer);
+ var it = (std.unicode.Utf8View.init(prefix) catch return "").iterator();
+ var cells: usize = 0;
+ var end: usize = 0;
+ while (it.nextCodepoint()) |cp| {
+ if (cells >= max_cells) break;
+ out.writeAll(if (cp == '│' or cp == '├' or cp == '┬' or cp == '╮') "│" else " ") catch break;
+ cells += 1;
+ if (cp != ' ') end = out.buffered().len;
+ }
+ if (end == 0) return "";
+ // Keep one cell between the continuation and the wrapped source text.
+ if (end < out.buffered().len) end += 1;
+ return out.buffered()[0..end];
+}
+
+/// Enrich caller nodes on the UI thread, using the same source/declaration cache
+/// as LocationsContext. The LSP worker only supplies relationships and addresses.
+pub fn formatCallstack(p: *pardes.Pardes, dir: []const u8, input: []const u8) !Result {
+ const arena = p.scratch.allocator();
+ var out: std.Io.Writer.Allocating = .init(p.gpa);
+ errdefer out.deinit();
+ var rows: std.ArrayList(Row) = .empty;
+ errdefer {
+ for (rows.items) |row| {
+ p.gpa.free(row.path);
+ p.gpa.free(row.colors);
+ }
+ rows.deinit(p.gpa);
+ }
+ const stacked = p.settings.callstack_layout == .stacked;
+ var sources: std.StringHashMap(?Source) = .init(arena);
+ var lines = std.mem.splitScalar(u8, std.mem.trimEnd(u8, input, "\n"), '\n');
+ while (lines.next()) |raw| {
+ const mark = @import("lsp/lsp.zig").callstack_match;
+ const focus = std.mem.startsWith(u8, raw, mark);
+ const line = if (focus) raw[mark.len..] else raw;
+ const prefix = treePrefix(line);
+ const target = parseRaw(line[prefix.end..]);
+ if (target.at.line == 0) {
+ try out.writer.print("{s}\n", .{line});
+ try appendMetadata(p.gpa, &rows, .{ .path = "", .at = .{}, .label = "", .code = "", .original = null }, .context, 0, line.len, false);
+ continue;
+ }
+ const entry = try sources.getOrPut(target.path);
+ if (!entry.found_existing) entry.value_ptr.* = sourceText(p, arena, dir, target.path);
+ const source = entry.value_ptr.*;
+ var cached: Cache.Hit = .{ .analysis = .{} };
+ defer cached.deinit(p.tree_sitter_gpa);
+ if (source) |text| cached = p.locations_cache.get(p.tree_sitter_gpa, text.path, text.bytes, true, true) catch .{ .analysis = .{} };
+ var code = line[prefix.end + target.code_start ..];
+ var colors: []const u8 = &.{};
+ var source_row = target.at.line - 1;
+ if (source) |text| {
+ const row = target.at.line - 1;
+ if (prefix.branch) {
+ // Choose the innermost header containing the server's name range.
+ var chosen: ?syntax.ContextDeclaration = null;
+ for (cached.analysis.declarations) |declaration| {
+ if (declaration.start_line <= row and row <= declaration.header_end_line) {
+ if (chosen == null or declaration.end_byte - declaration.start_byte < chosen.?.end_byte - chosen.?.start_byte)
+ chosen = declaration;
+ }
+ }
+ if (chosen) |header| {
+ code = text.bytes[header.start_byte..header.header_end_byte];
+ source_row = header.start_line;
+ } else {
+ const fallback = @import("modal.zig").lineSlice(text.bytes, row);
+ if (fallback.len > 0) code = fallback;
+ }
+ }
+ {
+ const offset = @import("modal.zig").lineStartOffset(text.bytes, source_row);
+ if (offset + code.len <= cached.analysis.colors.len and
+ std.mem.eql(u8, code, text.bytes[offset..][0..code.len]))
+ colors = cached.analysis.colors[offset..][0..code.len];
+ }
+ }
+ const recursion = prefix.branch and std.mem.endsWith(u8, line, " ↻ recursion");
+ const first_line = code[0 .. std.mem.indexOfScalar(u8, code, '\n') orelse code.len];
+ const source_indent = if (stacked) first_line.len - std.mem.trimStart(u8, first_line, " \t").len else 0;
+ if (stacked) {
+ const end = prefix.end + target.end;
+ try out.writer.print("{s}\n", .{line[0..end]});
+ try appendMetadata(p.gpa, &rows, .{ .path = target.path, .at = target.at, .label = "", .code = "", .original = null, .mark_occurrence = false }, .match, end, end, false);
+ }
+ var header_lines = std.mem.splitScalar(u8, code, '\n');
+ var first = true;
+ var color_offset: usize = 0;
+ while (header_lines.next()) |code_line| {
+ const start = out.written().len;
+ if (stacked) {
+ var guide_buf: [1024]u8 = undefined;
+ const guide = treeContinuation(line, &guide_buf, std.math.maxInt(usize));
+ try out.writer.writeAll(guide);
+ const width = pardes.panes.File.displayWidth(line[0..prefix.end]);
+ try out.writer.splatByteAll(' ', width -| pardes.panes.File.displayWidth(guide));
+ } else if (first) {
+ try out.writer.writeAll(line[0 .. prefix.end + target.end]);
+ try out.writer.writeByte(' ');
+ } else {
+ const branch_start = prefix.end - "└──┬ ".len;
+ try out.writer.writeAll(line[0..branch_start]);
+ try out.writer.writeAll(if (std.mem.startsWith(u8, line[branch_start..], "├")) "│ " else " ");
+ try out.writer.writeAll(if (std.mem.endsWith(u8, line[0..prefix.end], "┬ ") or std.mem.endsWith(u8, line[0..prefix.end], "╮ ")) "│ " else " ");
+ try out.writer.splatByteAll(' ', pardes.panes.File.displayWidth(line[prefix.end..][0..target.end]) + 1);
+ }
+ const code_start = out.written().len - start;
+ const trim = @min(source_indent, code_line.len - std.mem.trimStart(u8, code_line, " \t").len);
+ try out.writer.writeAll(code_line[trim..]);
+ const recursion_note = recursion and first and !std.mem.endsWith(u8, code_line, " ↻ recursion");
+ if (recursion_note) try out.writer.writeAll(" ↻ recursion");
+ try out.writer.writeByte('\n');
+ try appendMetadata(p.gpa, &rows, .{
+ .path = target.path,
+ .at = if (first) target.at else .{ .line = source_row + 1 },
+ .label = "",
+ .code = code_line[trim..],
+ .source_column = trim,
+ .original = null,
+ .mark_occurrence = focus and !prefix.branch,
+ .colors = if (colors.len >= color_offset + code_line.len) colors[color_offset + trim ..][0 .. code_line.len - trim] else &.{},
+ }, if (first) (if (stacked) .preview else .match) else .context, if (first and !stacked) prefix.end + target.end else 0, code_start, true);
+ // Recursion notes are prose, outside the source snapshot.
+ if (recursion_note) {
+ const added = " ↻ recursion".len;
+ const row = &rows.items[rows.items.len - 1];
+ if (row.colors.len > 0) {
+ const expanded = try p.gpa.alloc(u8, row.colors.len + added);
+ @memcpy(expanded[0..row.colors.len], row.colors);
+ @memset(expanded[row.colors.len..], 0);
+ p.gpa.free(row.colors);
+ row.colors = expanded;
+ }
+ }
+ color_offset += code_line.len + 1;
+ source_row += 1;
+ first = false;
+ }
+ }
+ const owned_rows = try rows.toOwnedSlice(p.gpa);
+ errdefer freeRows(p.gpa, owned_rows);
+ return .{ .content = try out.toOwnedSlice(), .rows = owned_rows, .anchor = null };
+}
+
/// Inputs are sorted results. Expand each source group, merge context with
/// matches, then align groups of eight matches. All temporary source data
/// stays in the caller's scratch arena; returned text and rows are owned.
@@ -334,7 +507,7 @@ fn appendMetadata(gpa: std.mem.Allocator, rows: *std.ArrayList(Row), pending: Pe
errdefer gpa.free(path);
const colors = try gpa.dupe(u8, if (source) pending.colors else &.{});
errdefer gpa.free(colors);
- try rows.append(gpa, .{ .kind = kind, .declaration = pending.declaration, .path = path, .at = pending.at, .location_end = location_end, .code_start = code_start, .colors = colors });
+ try rows.append(gpa, .{ .kind = kind, .declaration = pending.declaration, .mark_occurrence = pending.mark_occurrence, .source_column = pending.source_column, .path = path, .at = pending.at, .location_end = location_end, .code_start = code_start, .colors = colors });
}
const alignment_entries = 8;