summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/errors/merge_error.rs31
-rw-r--r--src/lib.rs3
-rw-r--r--src/reports/mod.rs73
-rw-r--r--src/reports/source_hierarchy.rs22
-rw-r--r--src/reports/source_symbols.rs6
-rw-r--r--src/reports/unused_symbols.rs4
6 files changed, 71 insertions, 68 deletions
diff --git a/src/errors/merge_error.rs b/src/errors/merge_error.rs
index 89f55a2..01cbcba 100644
--- a/src/errors/merge_error.rs
+++ b/src/errors/merge_error.rs
@@ -1,8 +1,5 @@
use crate::*;
-use ansi::*;
-use log::error;
-
use std::collections::HashSet;
@@ -14,15 +11,19 @@ pub struct MergeError<'a> {
impl MergeError<'_> {
pub fn report(&self) {
- error!("A cyclic dependency was found between the following files:");
+ let message = "A cyclic dependency was found between the following files:";
+ let mut details = InkedString::new();
for id in &self.cyclic_unit_ids {
let unit = &self.resolver.source_units[*id];
let path = &unit.source_unit.path();
match unit.source_unit.name() {
- Some(name) =>
- eprintln!("{name}{NORMAL}{DIM} ({path}){NORMAL}"),
- None =>
- eprintln!("{path}"),
+ Some(name) => {
+ details.push(ink!("{name}"));
+ details.push(ink!(" ({path})\n").dim());
+ }
+ None => {
+ details.push(ink!("{path}\n"));
+ }
};
// Print each parent involved in the dependency cycle.
for parent_id in &unit.parent_ids {
@@ -30,10 +31,13 @@ impl MergeError<'_> {
let parent_unit = &self.resolver.source_units[*parent_id];
let parent_path = &parent_unit.source_unit.path();
match parent_unit.source_unit.name() {
- Some(parent_name) =>
- eprintln!(" => {parent_name} {DIM}({parent_path}){NORMAL}"),
- None =>
- eprintln!(" => {parent_path}"),
+ Some(parent_name) => {
+ details.push(ink!(" => {parent_name}"));
+ details.push(ink!(" ({parent_path})\n").dim());
+ }
+ None => {
+ details.push(ink!(" => {parent_path}\n"));
+ }
};
// Report all referenced symbols that are defined by this parent.
let mut reported_definition_ids = HashSet::new();
@@ -42,12 +46,13 @@ impl MergeError<'_> {
if reported_definition_ids.insert(reference.definition) {
let definition = &self.resolver.definitions[reference.definition];
if definition.tracked.source_id == *parent_id {
- eprintln!(" {:?}", definition.tracked.symbol);
+ details.push(ink!(" {:?}\n", definition.tracked.symbol));
}
}
}
}
}
}
+ log_error(message, Some(details));
}
}
diff --git a/src/lib.rs b/src/lib.rs
index 6c076d5..4754663 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -12,3 +12,6 @@ pub use types::*;
pub type ParseFn = fn(&str, Option<&Path>) -> Option<Vec<Symbol>>;
pub type PushFn = fn(&mut String, &SourceFile);
+
+use log::*;
+use inked::*;
diff --git a/src/reports/mod.rs b/src/reports/mod.rs
index bbddba9..9fc5e27 100644
--- a/src/reports/mod.rs
+++ b/src/reports/mod.rs
@@ -10,53 +10,52 @@ pub use unused_symbols::*;
use crate::*;
-pub use log::LogLevel;
-pub use ansi::*;
-
pub fn report_source_issue(level: LogLevel, context: &Context, message: &str) {
- let mut reporter = SourceIssueReporter::new(context, message, level);
+ let mut reporter = SourceIssueReporter::new(context, level);
reporter.format_source_span(context.source);
- let string = reporter.output;
+ let details = reporter.details;
// Print the completed message.
match level {
- LogLevel::Info => log::info!( "{string}"),
- LogLevel::Warn => log::warn!( "{string}"),
- LogLevel::Error => log::error!("{string}"),
- LogLevel::Fatal => log::fatal!("{string}"),
+ LogLevel::Info => log_info(message, Some(details)),
+ LogLevel::Warn => log_warn(message, Some(details)),
+ LogLevel::Error => log_error(message, Some(details)),
+ LogLevel::Fatal => log_fatal(message, Some(details)),
}
}
struct SourceIssueReporter<'a> {
context: &'a Context<'a>,
- output: String,
+ details: InkedString,
level: LogLevel,
digits: usize,
}
impl<'a> SourceIssueReporter<'a> {
- pub fn new(context: &'a Context<'a>, message: &str, level: LogLevel) -> Self {
- let output = format!("{message}\n");
+ pub fn new(context: &'a Context<'a>, level: LogLevel) -> Self {
+ let details = InkedString::new();
let digits = get_end_line_number(context.source).to_string().len();
- Self { context, level, output, digits }
+ Self { context, level, details, digits }
}
pub fn format_source_span(&mut self, source: &SourceSpan) {
let colour = match self.level {
- LogLevel::Info => BLUE,
- LogLevel::Warn => YELLOW,
- LogLevel::Error => RED,
- LogLevel::Fatal => RED,
+ LogLevel::Info => Colour::Blue,
+ LogLevel::Warn => Colour::Yellow,
+ LogLevel::Error => Colour::Red,
+ LogLevel::Fatal => Colour::Red,
};
// Print location line.
- self.output.push_str(NORMAL);
let arrow = "-->";
+ let w = self.digits + 3;
+ self.details.push(ink!("{arrow:>w$} ").blue());
let location = source.location();
- self.push(&format!("{BLUE}{arrow:>w$}{NORMAL} {location}\n", w=self.digits+3));
+ self.details.push(ink!("{location}\n"));
+ // Print each source line.
let line_count = location.end.line - location.start.line + 1;
for line_i in 0..line_count {
let merged_i = source.in_merged.start.line + line_i;
@@ -74,25 +73,30 @@ impl<'a> SourceIssueReporter<'a> {
};
// Print source code line.
- self.push(&format!("{BLUE} {line_num:>w$} | {NORMAL}", line_num=location_i+1, w=self.digits));
+ let line_num = location_i + 1;
+ let w = self.digits;
+ self.details.push(ink!(" {line_num:>w$} | ").blue());
+ let mut line_colour = None;
for (i, c) in source_line.chars().enumerate() {
- if i == left { self.output.push_str(colour) }
- if i == right { self.output.push_str(NORMAL) }
- self.output.push(c);
+ if i == left { line_colour = Some(colour) }
+ if i == right { line_colour = None }
+ self.details.push(ink!("{c}").set_colour(line_colour));
}
- self.output.push_str(NORMAL);
- self.output.push('\n');
+ self.details.push(ink!("\n"));
// Print an underline on the final line.
if line_i + 1 == line_count {
// Print source code underline.
let space = " ";
- self.push(&format!("{BLUE} {space:>w$} | {NORMAL}", w=self.digits));
- for _ in 0..left { self.output.push_str(" "); }
- self.output.push_str(colour);
- for _ in left..right { self.output.push_str("^"); }
- self.output.push_str(NORMAL);
- self.output.push('\n');
+ let w = self.digits;
+ self.details.push(ink!(" {space:>w$} | ").blue());
+ for _ in 0..left {
+ self.details.push(ink!(" "));
+ }
+ for _ in left..right {
+ self.details.push(ink!("^").set_colour(Some(colour)));
+ }
+ self.details.push(ink!("\n"));
}
}
@@ -100,13 +104,6 @@ impl<'a> SourceIssueReporter<'a> {
if let Some(child) = &source.child {
self.format_source_span(&child);
}
-
- // Remove the trailing new-line.
- self.output.pop();
- }
-
- fn push(&mut self, string: &str) {
- self.output.push_str(&string);
}
}
diff --git a/src/reports/source_hierarchy.rs b/src/reports/source_hierarchy.rs
index 2e88a77..f391785 100644
--- a/src/reports/source_hierarchy.rs
+++ b/src/reports/source_hierarchy.rs
@@ -7,7 +7,7 @@ pub struct SourceHierarchy<'a> {
impl<'a> SourceHierarchy<'a> {
pub fn report(&self) {
- eprintln!(".");
+ ink!(".").eprintln();
let len = self.resolver.root_unit_ids.len();
for (i, id) in self.resolver.root_unit_ids.iter().enumerate() {
let end = i + 1 == len;
@@ -19,29 +19,29 @@ impl<'a> SourceHierarchy<'a> {
// A level entry is true if all entries in that level have been printed.
for level in &levels {
match level {
- false => eprint!("│ "),
- true => eprint!(" "),
+ false => ink!("│ ").eprint(),
+ true => ink!(" ").eprint(),
}
}
// The end value is true if all siblings of this entry have been printed.
match end {
- false => eprint!("├── "),
- true => eprint!("└── "),
+ false => ink!("├── ").eprint(),
+ true => ink!("└── ").eprint(),
}
let unit = &self.resolver.source_units[id];
let path_str = &unit.source_unit.main.path.as_os_str().to_string_lossy();
if let Some(name_str) = unit.source_unit.name() {
- eprint!("{name_str}{BLUE}");
- if unit.source_unit.head.is_some() { eprint!(" +head") }
- if unit.source_unit.tail.is_some() { eprint!(" +tail") }
+ ink!("{name_str}").eprint();
+ if unit.source_unit.head.is_some() { ink!(" +head").blue().eprint() }
+ if unit.source_unit.tail.is_some() { ink!(" +tail").blue().eprint() }
let mut unresolved = 0;
for symbol in &self.resolver.unresolved {
if symbol.source_id == id { unresolved += 1; }
}
- if unresolved > 0 { eprint!("{RED} ({unresolved})"); }
- eprintln!("{NORMAL} {DIM}({path_str}){NORMAL}");
+ if unresolved > 0 { ink!(" ({unresolved})").red().eprint(); }
+ ink!(" ({path_str})").dim().eprintln();
} else {
- eprintln!("{path_str}");
+ ink!("{path_str}").eprintln();
}
levels.push(end);
let len = unit.child_ids.len();
diff --git a/src/reports/source_symbols.rs b/src/reports/source_symbols.rs
index 976660f..a042f1c 100644
--- a/src/reports/source_symbols.rs
+++ b/src/reports/source_symbols.rs
@@ -9,7 +9,7 @@ impl<'a> SourceSymbols<'a> {
pub fn report(&self) {
for definition in &self.resolver.definitions {
let message = format!(
- "Definition '{BOLD}{:?}{NORMAL}' (resolves {})",
+ "Definition '{:?}' (resolves {})",
definition.tracked.symbol, definition.references.len());
let context = definition.tracked.context(self.resolver);
report_source_issue(LogLevel::Info, &context, &message);
@@ -18,7 +18,7 @@ impl<'a> SourceSymbols<'a> {
for reference in &self.resolver.resolved {
let definition = &self.resolver.definitions[reference.definition];
let message = format!(
- "Resolved reference '{BOLD}{:?}{NORMAL}' (defined by {:?})",
+ "Resolved reference '{:?}' (defined by {:?})",
reference.tracked.symbol, definition.tracked.symbol);
let context = reference.tracked.context(self.resolver);
report_source_issue(LogLevel::Info, &context, &message);
@@ -26,7 +26,7 @@ impl<'a> SourceSymbols<'a> {
for reference in &self.resolver.unresolved {
let message = format!(
- "Unresolved reference '{BOLD}{:?}{NORMAL}'", reference.symbol);
+ "Unresolved reference '{:?}'", reference.symbol);
let context = reference.context(self.resolver);
report_source_issue(LogLevel::Warn, &context, &message);
}
diff --git a/src/reports/unused_symbols.rs b/src/reports/unused_symbols.rs
index 7cd3596..90cb7d1 100644
--- a/src/reports/unused_symbols.rs
+++ b/src/reports/unused_symbols.rs
@@ -9,9 +9,7 @@ impl<'a> UnusedSymbols<'a> {
pub fn report(&self) {
for definition in &self.resolver.definitions {
if definition.references.is_empty() {
- let message = format!(
- "Unused definition '{BOLD}{:?}{NORMAL}'",
- definition.tracked.symbol);
+ let message = format!("Unused definition '{:?}'", definition.tracked.symbol);
let context = definition.tracked.context(self.resolver);
report_source_issue(LogLevel::Warn, &context, &message);
}
generated by cgit v1.2.3-70-g09d2 (git 2.49.0) at 2025-04-29 17:12:46 +0000