Use ariadne

#1323

Author: neunenak

justfile

@@ -12,7 +12,7 @@ export JUST_LOG := log
 watch +args='test':
   cargo watch --clear --exec '{{ args }}'
 
-[group: 'test']
+[group('test', 'bogus extra argument')]
 test:
   cargo test --all
 

src/compile_error.rs

@@ -19,6 +19,102 @@ impl<'src> CompileError<'src> {
   }
 }
 
+pub(crate) fn render_compile_error(error: &CompileError) {
+  use ariadne::{Label, Report, ReportKind, Source};
+
+  let token = error.token;
+  let source = Source::from(token.src);
+
+  let start = token.offset;
+  let end = token.offset + token.length;
+
+  let path = format!("{}", token.path.display());
+  let label = Label::new((&path, start..end));
+
+  let report = Report::build(ReportKind::Error, &path, start);
+
+  let report = match &*error.kind  {
+      CompileErrorKind::AttributeArgumentCountMismatch { attribute, found, min, max } => {
+
+          let label_msg = format!("Found {found} {}", Count("argument", *found));
+
+          let note = if min == max {
+              format!("`{attribute}` takes {min} {}", Count("argument", *min))
+          } else {
+              format!("`{attribute}` takes between {min} and {max} arguments")
+          };
+
+          report
+              .with_code(1)
+              .with_message("Attribute argument count mismatch")
+              .with_label(label.with_message(label_msg))
+              .with_note(note)
+              .finish()
+      },
+      _ => {
+
+          let message = format!("{error}");
+          report
+              .with_message(message)
+              .with_label(label)
+              .finish()
+      }
+      /*
+      CompileErrorKind::BacktickShebang => todo!(),
+      CompileErrorKind::CircularRecipeDependency { recipe, circle } => todo!(),
+      CompileErrorKind::CircularVariableDependency { variable, circle } => todo!(),
+      CompileErrorKind::DependencyArgumentCountMismatch { dependency, found, min, max } => todo!(),
+      CompileErrorKind::Redefinition { first, first_type, name, second_type } => todo!(),
+      CompileErrorKind::DuplicateAttribute { attribute, first } => todo!(),
+      CompileErrorKind::DuplicateParameter { recipe, parameter } => todo!(),
+      CompileErrorKind::DuplicateSet { setting, first } => todo!(),
+      CompileErrorKind::DuplicateVariable { variable } => todo!(),
+      CompileErrorKind::DuplicateUnexport { variable } => todo!(),
+      CompileErrorKind::ExpectedKeyword { expected, found } => todo!(),
+      CompileErrorKind::ExportUnexported { variable } => todo!(),
+      CompileErrorKind::ExtraLeadingWhitespace => todo!(),
+      CompileErrorKind::ExtraneousAttributes { count } => todo!(),
+      CompileErrorKind::FunctionArgumentCountMismatch { function, found, expected } => todo!(),
+      CompileErrorKind::Include => todo!(),
+      CompileErrorKind::InconsistentLeadingWhitespace { expected, found } => todo!(),
+      CompileErrorKind::Internal { message } => todo!(),
+      CompileErrorKind::InvalidAttribute { item_kind, item_name, attribute } => todo!(),
+      CompileErrorKind::InvalidEscapeSequence { character } => todo!(),
+      CompileErrorKind::MismatchedClosingDelimiter { close, open, open_line } => todo!(),
+      CompileErrorKind::MixedLeadingWhitespace { whitespace } => todo!(),
+      CompileErrorKind::ParameterFollowsVariadicParameter { parameter } => todo!(),
+      CompileErrorKind::ParsingRecursionDepthExceeded => todo!(),
+      CompileErrorKind::RequiredParameterFollowsDefaultParameter { parameter } => todo!(),
+      CompileErrorKind::ShebangAndScriptAttribute { recipe } => todo!(),
+      CompileErrorKind::ShellExpansion { err } => todo!(),
+      CompileErrorKind::UndefinedVariable { variable } => todo!(),
+      CompileErrorKind::UnexpectedCharacter { expected } => todo!(),
+      CompileErrorKind::UnexpectedClosingDelimiter { close } => todo!(),
+      CompileErrorKind::UnexpectedEndOfToken { expected } => todo!(),
+      CompileErrorKind::UnexpectedToken { expected, found } => todo!(),
+      CompileErrorKind::UnicodeEscapeCharacter { character } => todo!(),
+      CompileErrorKind::UnicodeEscapeDelimiter { character } => todo!(),
+      CompileErrorKind::UnicodeEscapeEmpty => todo!(),
+      CompileErrorKind::UnicodeEscapeLength { hex } => todo!(),
+      CompileErrorKind::UnicodeEscapeRange { hex } => todo!(),
+      CompileErrorKind::UnicodeEscapeUnterminated => todo!(),
+      CompileErrorKind::UnknownAliasTarget { alias, target } => todo!(),
+      CompileErrorKind::UnknownAttribute { attribute } => todo!(),
+      CompileErrorKind::UnknownDependency { recipe, unknown } => todo!(),
+      CompileErrorKind::UnknownFunction { function } => todo!(),
+      CompileErrorKind::UnknownSetting { setting } => todo!(),
+      CompileErrorKind::UnknownStartOfToken => todo!(),
+      CompileErrorKind::UnpairedCarriageReturn => todo!(),
+      CompileErrorKind::UnterminatedBacktick => todo!(),
+      CompileErrorKind::UnterminatedInterpolation => todo!(),
+      CompileErrorKind::UnterminatedString => todo!(),
+      */
+  };
+
+  report.eprint((&path, source))
+      .unwrap();
+}
+
 fn capitalize(s: &str) -> String {
   let mut chars = s.chars();
   match chars.next() {

src/error.rs

@@ -504,6 +504,13 @@ impl<'src> ColorDisplay for Error<'src> {
   }
 }
 
+pub(crate) fn render_error(error: &Error, color: Color) {
+  match error {
+    Error::Compile { compile_error } => compile_error::render_compile_error(compile_error),
+    _ => eprintln!("{}", error.color_display(color.stderr())),
+  }
+}
+
 fn format_cmd(binary: &OsString, arguments: &Vec<OsString>) -> String {
   iter::once(binary)
     .chain(arguments)

src/run.rs

@@ -29,7 +29,7 @@ pub fn run(args: impl Iterator<Item = impl Into<OsString> + Clone>) -> Result<()
     })
     .map_err(|error| {
       if !verbosity.quiet() && error.print_message() {
-        eprintln!("{}", error.color_display(color.stderr()));
+        crate::error::render_error(&error, color);
       }
       error.code().unwrap_or(EXIT_FAILURE)
     })