131 lines
4.3 KiB
Zig
131 lines
4.3 KiB
Zig
const std = @import("std");
|
|
const Span = @import("ast.zig").Span;
|
|
|
|
pub const Level = enum {
|
|
err,
|
|
warn,
|
|
note,
|
|
};
|
|
|
|
pub const SourceLoc = struct {
|
|
line: u32,
|
|
col: u32,
|
|
|
|
pub fn compute(source: []const u8, byte_offset: u32) SourceLoc {
|
|
var line: u32 = 1;
|
|
var col: u32 = 1;
|
|
const end = @min(byte_offset, @as(u32, @intCast(source.len)));
|
|
for (source[0..end]) |c| {
|
|
if (c == '\n') {
|
|
line += 1;
|
|
col = 1;
|
|
} else {
|
|
col += 1;
|
|
}
|
|
}
|
|
return .{ .line = line, .col = col };
|
|
}
|
|
};
|
|
|
|
pub const Diagnostic = struct {
|
|
level: Level,
|
|
message: []const u8,
|
|
span: ?Span,
|
|
source_file: ?[]const u8 = null,
|
|
};
|
|
|
|
pub const DiagnosticList = struct {
|
|
items: std.ArrayList(Diagnostic) = .empty,
|
|
allocator: std.mem.Allocator,
|
|
source: []const u8,
|
|
file_name: []const u8,
|
|
current_source_file: ?[]const u8 = null,
|
|
import_sources: ?*const std.StringHashMap([:0]const u8) = null,
|
|
|
|
pub fn init(allocator: std.mem.Allocator, source: []const u8, file_name: []const u8) DiagnosticList {
|
|
return .{
|
|
.allocator = allocator,
|
|
.source = source,
|
|
.file_name = file_name,
|
|
};
|
|
}
|
|
|
|
pub fn deinit(self: *DiagnosticList) void {
|
|
self.items.deinit(self.allocator);
|
|
}
|
|
|
|
pub fn add(self: *DiagnosticList, level: Level, message: []const u8, span: ?Span) void {
|
|
// Deduplicate: skip if same level+span+message already exists
|
|
for (self.items.items) |d| {
|
|
if (d.level == level and std.mem.eql(u8, d.message, message)) {
|
|
const a = d.span orelse continue;
|
|
const b = span orelse continue;
|
|
if (a.start == b.start and a.end == b.end) return;
|
|
}
|
|
}
|
|
self.items.append(self.allocator, .{
|
|
.level = level,
|
|
.message = message,
|
|
.span = span,
|
|
.source_file = self.current_source_file,
|
|
}) catch {};
|
|
}
|
|
|
|
pub fn addFmt(self: *DiagnosticList, level: Level, span: ?Span, comptime fmt: []const u8, args: anytype) void {
|
|
const message = std.fmt.allocPrint(self.allocator, fmt, args) catch "diagnostic format error";
|
|
self.add(level, message, span);
|
|
}
|
|
|
|
pub fn hasErrors(self: *const DiagnosticList) bool {
|
|
for (self.items.items) |d| {
|
|
if (d.level == .err) return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
fn resolveSourceAndFile(self: *const DiagnosticList, d: Diagnostic) struct { source: []const u8, file_name: []const u8 } {
|
|
if (d.source_file) |sf| {
|
|
if (self.import_sources) |is| {
|
|
if (is.get(sf)) |src| {
|
|
return .{ .source = src, .file_name = sf };
|
|
}
|
|
}
|
|
}
|
|
return .{ .source = self.source, .file_name = self.file_name };
|
|
}
|
|
|
|
pub fn render(self: *const DiagnosticList, writer: anytype) !void {
|
|
for (self.items.items) |d| {
|
|
const level_str = switch (d.level) {
|
|
.err => "error",
|
|
.warn => "warning",
|
|
.note => "note",
|
|
};
|
|
if (d.span) |span| {
|
|
const resolved = self.resolveSourceAndFile(d);
|
|
const loc = SourceLoc.compute(resolved.source, span.start);
|
|
try writer.print("{s}:{d}:{d}: {s}: {s}\n", .{ resolved.file_name, loc.line, loc.col, level_str, d.message });
|
|
} else {
|
|
try writer.print("{s}: {s}: {s}\n", .{ self.file_name, level_str, d.message });
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn renderDebug(self: *const DiagnosticList) void {
|
|
for (self.items.items) |d| {
|
|
const level_str = switch (d.level) {
|
|
.err => "error",
|
|
.warn => "warning",
|
|
.note => "note",
|
|
};
|
|
if (d.span) |span| {
|
|
const resolved = self.resolveSourceAndFile(d);
|
|
const loc = SourceLoc.compute(resolved.source, span.start);
|
|
std.debug.print("{s}:{d}:{d}: {s}: {s}\n", .{ resolved.file_name, loc.line, loc.col, level_str, d.message });
|
|
} else {
|
|
std.debug.print("{s}: {s}: {s}\n", .{ self.file_name, level_str, d.message });
|
|
}
|
|
}
|
|
}
|
|
};
|