feat(diagnostic): integrate annotate-snippets crate

crates/mun/src/main.rs

@@ -2,11 +2,12 @@
 extern crate failure;
 
 use std::cell::RefCell;
+use std::env;
 use std::rc::Rc;
 use std::time::Duration;
 
 use clap::{App, AppSettings, Arg, ArgMatches, SubCommand};
-use mun_compiler::{Config, PathOrInline, Target};
+use mun_compiler::{Config, DisplayColor, PathOrInline, Target};
 use mun_runtime::{invoke_fn, ReturnTypeReflection, Runtime, RuntimeBuilder};
 
 fn main() -> Result<(), failure::Error> {
@@ -40,6 +41,13 @@ fn main() -> Result<(), failure::Error> {
                         .takes_value(true)
                         .help("target triple for which code is compiled"),
                 )
+                .arg(
+                    Arg::with_name("color")
+                        .long("color")
+                        .takes_value(true)
+                        .possible_values(&["enable", "auto", "disable"])
+                        .help("color text in terminal"),
+                )
                 .about("Compiles a local Mun file into a module"),
         )
         .subcommand(
@@ -136,6 +144,17 @@ fn compiler_options(matches: &ArgMatches) -> Result<mun_compiler::CompilerOption
         _ => return Err(format_err!("Only optimization levels 0-3 are supported")),
     };
 
+    let display_color = matches
+        .value_of("color")
+        .map(ToOwned::to_owned)
+        .or_else(|| env::var("MUN_TERMINAL_COLOR").ok())
+        .map(|value| match value.as_str() {
+            "disable" => DisplayColor::Disable,
+            "enable" => DisplayColor::Enable,
+            _ => DisplayColor::Auto,
+        })
+        .unwrap_or(DisplayColor::Auto);
+
     Ok(mun_compiler::CompilerOptions {
         input: PathOrInline::Path(matches.value_of("INPUT").unwrap().into()), // Safe because its a required arg
         config: Config {
@@ -144,6 +163,7 @@ fn compiler_options(matches: &ArgMatches) -> Result<mun_compiler::CompilerOption
                 .map_or_else(Target::host_target, Target::search)?,
             optimization_lvl,
             out_dir: None,
+            display_color,
         },
     })
 }

crates/mun_compiler/Cargo.toml

@@ -10,10 +10,13 @@ description = "Binary compilation functionality for Mun"
 
 [dependencies]
 failure = "0.1.7"
-
 mun_codegen = { path="../mun_codegen" }
 mun_syntax = { path="../mun_syntax" }
-mun_errors = { path="../mun_errors" }
 mun_hir = {path="../mun_hir"}
 mun_target = {path="../mun_target"}
-termcolor = "1.0.5"
+annotate-snippets = { version = "0.6.1", features = ["color"] }
+unicode-segmentation = "1.6.0"
+ansi_term = "0.12.1"
+
+[dev-dependencies]
+insta = "0.13.1"

crates/mun_compiler/src/annotate.rs

@@ -0,0 +1,216 @@
+//! This module provides builders for integrating the [`annotate-snippets`] crate with Mun.
+//!
+//! [`annotate-snippets`]: https://docs.rs/annotate-snippets/0.6.1/annotate_snippets/
+
+use annotate_snippets::snippet::{Annotation, AnnotationType, Slice, Snippet, SourceAnnotation};
+use mun_hir::line_index::LineIndex;
+
+use unicode_segmentation::UnicodeSegmentation;
+
+pub struct SnippetBuilder {
+    snippet: Snippet,
+}
+
+impl Default for SnippetBuilder {
+    fn default() -> Self {
+        SnippetBuilder {
+            snippet: Snippet {
+                title: None,
+                footer: vec![],
+                slices: vec![],
+            },
+        }
+    }
+}
+
+impl SnippetBuilder {
+    pub fn new() -> SnippetBuilder {
+        SnippetBuilder::default()
+    }
+    pub fn title(mut self, title: Annotation) -> SnippetBuilder {
+        self.snippet.title = Some(title);
+        self
+    }
+    pub fn footer(mut self, footer: Annotation) -> SnippetBuilder {
+        self.snippet.footer.push(footer);
+        self
+    }
+    pub fn slice(mut self, slice: Slice) -> SnippetBuilder {
+        self.snippet.slices.push(slice);
+        self
+    }
+    pub fn build(self) -> Snippet {
+        self.snippet
+    }
+}
+
+pub struct SliceBuilder {
+    slice: Slice,
+}
+
+impl SliceBuilder {
+    pub fn new(fold: bool) -> SliceBuilder {
+        SliceBuilder {
+            slice: Slice {
+                source: String::new(),
+                line_start: 0,
+                origin: None,
+                annotations: Vec::new(),
+                fold,
+            },
+        }
+    }
+
+    pub fn origin(mut self, relative_file_path: &str) -> SliceBuilder {
+        self.slice.origin = Some(relative_file_path.to_string());
+        self
+    }
+
+    pub fn source_annotation(
+        mut self,
+        range: (usize, usize),
+        label: &str,
+        source_annotation_type: AnnotationType,
+    ) -> SliceBuilder {
+        self.slice.annotations.push(SourceAnnotation {
+            range,
+            label: label.to_string(),
+            annotation_type: source_annotation_type,
+        });
+        self
+    }
+
+    pub fn build(mut self, source_text: &str, line_index: &LineIndex) -> Slice {
+        // Variable for storing the first and last line of the used source code
+        let mut fl_lines: Option<(u32, u32)> = None;
+
+        // Find the range of lines that include all highlighted segments
+        for annotation in &self.slice.annotations {
+            if let Some(range) = fl_lines {
+                fl_lines = Some((
+                    line_index
+                        .line_col(range.0.into())
+                        .line
+                        .min(line_index.line_col((annotation.range.0 as u32).into()).line),
+                    line_index
+                        .line_col(range.1.into())
+                        .line
+                        .max(line_index.line_col((annotation.range.1 as u32).into()).line),
+                ));
+            } else {
+                fl_lines = Some((
+                    line_index.line_col((annotation.range.0 as u32).into()).line,
+                    line_index.line_col((annotation.range.1 as u32).into()).line,
+                ));
+            }
+        }
+
+        if let Some(fl_lines) = fl_lines {
+            self.slice.line_start = fl_lines.0 as usize + 1;
+            let first_line_offset = line_index.line_offset(fl_lines.0);
+
+            // Extract the required range of lines
+            self.slice.source = line_index
+                .text_part(fl_lines.0, fl_lines.1, source_text, source_text.len())
+                .unwrap()
+                .to_string();
+
+            // Convert annotation ranges based on the cropped region, indexable by unicode
+            // graphemes (required for aligned annotations)
+            let convertor_function = |source: &String, annotation_range_border: usize| {
+                UnicodeSegmentation::graphemes(
+                &source[0..(annotation_range_border - first_line_offset)],
+                true).count()
+                // this addend is a fix for annotate-snippets issue number 24
+                + (line_index.line_col((annotation_range_border as u32).into()).line
+                    - fl_lines.0) as usize
+            };
+            for annotation in self.slice.annotations.iter_mut() {
+                annotation.range = (
+                    convertor_function(&self.slice.source, annotation.range.0),
+                    convertor_function(&self.slice.source, annotation.range.1),
+                );
+            }
+        }
+        self.slice
+    }
+}
+
+pub struct AnnotationBuilder {
+    annotation: Annotation,
+}
+
+impl AnnotationBuilder {
+    pub fn new(annotation_type: AnnotationType) -> AnnotationBuilder {
+        AnnotationBuilder {
+            annotation: Annotation {
+                id: None,
+                label: None,
+                annotation_type,
+            },
+        }
+    }
+
+    pub fn id(mut self, id: &str) -> AnnotationBuilder {
+        self.annotation.id = Some(id.to_string());
+        self
+    }
+
+    pub fn label(mut self, label: &str) -> AnnotationBuilder {
+        self.annotation.label = Some(label.to_string());
+        self
+    }
+
+    pub fn build(self) -> Annotation {
+        self.annotation
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn annotation_builder_snapshot() {
+        insta::assert_debug_snapshot!(AnnotationBuilder::new(AnnotationType::Note)
+            .id("1")
+            .label("test annotation")
+            .build());
+    }
+    #[test]
+    fn slice_builder_snapshot() {
+        let source_code = "fn foo():float{\n48\n}";
+        let line_index: LineIndex = LineIndex::new(source_code);
+
+        insta::assert_debug_snapshot!(SliceBuilder::new(true)
+            .origin("/tmp/usr/test.mun")
+            .source_annotation((14, 20), "test source annotation", AnnotationType::Note)
+            .build(source_code, &line_index));
+    }
+    #[test]
+    fn snippet_builder_snapshot() {
+        let source_code = "fn foo():float{\n48\n}\n\nfn bar():bool{\n23\n}";
+        let line_index: LineIndex = LineIndex::new(source_code);
+
+        insta::assert_debug_snapshot!(SnippetBuilder::new()
+            .title(
+                AnnotationBuilder::new(AnnotationType::Note)
+                    .id("1")
+                    .label("test annotation")
+                    .build()
+            )
+            .footer(
+                AnnotationBuilder::new(AnnotationType::Warning)
+                    .id("2")
+                    .label("test annotation")
+                    .build()
+            )
+            .slice(
+                SliceBuilder::new(true)
+                    .origin("/tmp/usr/test.mun")
+                    .source_annotation((14, 20), "test source annotation", AnnotationType::Note,)
+                    .source_annotation((35, 41), "test source annotation", AnnotationType::Error,)
+                    .build(source_code, &line_index)
+            )
+            .build());
+    }
+}