summaryrefslogtreecommitdiff
path: root/src/locations.zig
diff options
context:
space:
mode:
authorGabriel Schneider <[email protected]>2026-10-22 09:50:43 -0300
committerGabriel Schneider <[email protected]>2026-10-22 10:03:24 -0300
commita8b457a306a4442975210bcac3f04b56513c61c3 (patch)
tree6e2026ecb15da2fb919a0202f5d8b38e3b36a595 /src/locations.zig
parenta8a1499bdffffc5b6919e24ec957e92fabaf003b (diff)
parent7e9d2c4169245072265b483ffaa6aa05f23f08d3 (diff)
downloadpardes-a8b457a306a4442975210bcac3f04b56513c61c3.tar.gz
pardes-a8b457a306a4442975210bcac3f04b56513c61c3.zip
Merge: Def/Refs, the diff viewer, Helix n/N, Callstack, Zig 0.17, Window mode and the terminal cwd fix onto 0.24
The docs keep both sides: 0.24's Ctrl-i fallbacks and typed ls with this line's Window mode, raw Esc and Helix n/N wording. The CHANGELOG's unreleased entries go above 0.24, Def/Refs and the context rows among them. cheatsheet-a4.pdf rendered again; .scratch/ ignored. Co-Authored-By: Claude Opus 5.5 <[email protected]>
Diffstat (limited to 'src/locations.zig')
-rw-r--r--src/locations.zig207
1 files changed, 192 insertions, 15 deletions
diff --git a/src/locations.zig b/src/locations.zig
index 6a604907..2828566d 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 = &.{},
@@ -159,7 +164,9 @@ const Pending = struct {
const Source = struct { path: []const u8, bytes: []const u8 };
-fn sourceText(p: *pardes.Pardes, arena: std.mem.Allocator, dir: []const u8, path: []const u8) ?Source {
+/// A file's text as a look from `dir` finds it: an open pane's, unsaved
+/// edits and all, else the disk's. Null for a PDF or one not there.
+pub fn sourceText(p: *pardes.Pardes, arena: std.mem.Allocator, dir: []const u8, path: []const u8) ?Source {
if (std.ascii.eqlIgnoreCase(std.fs.path.extension(path), ".pdf")) return null;
const lexical = std.fs.path.resolvePosix(arena, &.{ dir, path }) catch return null;
var pathbuf: [4096]u8 = undefined;
@@ -172,6 +179,174 @@ fn sourceText(p: *pardes.Pardes, arena: std.mem.Allocator, dir: []const u8, path
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.
@@ -332,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;
@@ -412,12 +587,13 @@ pub const Config = struct {
const key = token[0..colon];
const value = token[colon + 1 ..];
var found = false;
- inline for (@typeInfo(Config).@"struct".fields) |field| {
- if (std.mem.eql(u8, key, field.name)) {
- @field(result, field.name) = switch (@typeInfo(field.type)) {
+ const info = @typeInfo(Config).@"struct";
+ inline for (info.field_names, info.field_types) |name, T| {
+ if (std.mem.eql(u8, key, name)) {
+ @field(result, name) = switch (@typeInfo(T)) {
.bool => if (std.mem.eql(u8, value, "on")) true else if (std.mem.eql(u8, value, "off")) false else return error.ExpectedOnOrOff,
- .int => std.fmt.parseInt(field.type, value, 10) catch return error.InvalidContext,
- .@"enum" => std.meta.stringToEnum(field.type, value) orelse return error.InvalidLayout,
+ .int => std.fmt.parseInt(T, value, 10) catch return error.InvalidContext,
+ .@"enum" => std.meta.stringToEnum(T, value) orelse return error.InvalidLayout,
else => @compileError("unsupported location setting type"),
};
found = true;
@@ -429,11 +605,12 @@ pub const Config = struct {
}
pub fn write(config: Config, writer: *std.Io.Writer) !void {
- inline for (@typeInfo(Config).@"struct".fields, 0..) |field, index| {
+ const info = @typeInfo(Config).@"struct";
+ inline for (info.field_names, info.field_types, 0..) |name, T, index| {
if (index > 0) try writer.writeByte(' ');
- try writer.writeAll(field.name ++ ":");
- const value = @field(config, field.name);
- switch (@typeInfo(field.type)) {
+ try writer.writeAll(name ++ ":");
+ const value = @field(config, name);
+ switch (@typeInfo(T)) {
.bool => try writer.writeAll(if (value) "on" else "off"),
.int => try writer.print("{d}", .{value}),
.@"enum" => try writer.writeAll(@tagName(value)),
@@ -634,11 +811,11 @@ test "locations cache bounds memory and entries and evicts least recently used"
try std.testing.expectEqual(@as(usize, 2), cache.len);
try std.testing.expect(cache.bytes <= 40);
try std.testing.expectEqualStrings("b.unknown", cache.entries[0].path);
- try std.testing.expectError(error.SourceTooLarge, cache.getBounded(gpa, "large.unknown", "x" ** 41, false, false, 40));
+ try std.testing.expectError(error.SourceTooLarge, cache.getBounded(gpa, "large.unknown", &@as([41]u8, @splat('x')), false, false, 40));
try std.testing.expectEqual(@as(usize, 2), cache.len);
if (syntax.supportsPath("large.zig")) {
const before = cache.analyses;
- try std.testing.expectError(error.SourceTooLarge, cache.getBounded(gpa, "large.zig", "x" ** 25, true, true, 40));
+ try std.testing.expectError(error.SourceTooLarge, cache.getBounded(gpa, "large.zig", &@as([25]u8, @splat('x')), true, true, 40));
try std.testing.expectEqual(before, cache.analyses);
}
cache.deinit(gpa);