Initial diagnostic sketch

Author: CAD97

.editorconfig

@@ -0,0 +1,6 @@
+root = true
+
+[*]
+end_of_line = lf
+insert_final_newline = true
+charset = utf-8

.gitignore

@@ -0,0 +1,2 @@
+/target
+Cargo.lock

Cargo.toml

@@ -0,0 +1,4 @@
+[workspace]
+members = [
+    "crates/retort",
+]

crates/retort/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "retort"
+version = "0.1.0"
+edition = "2018"
+
+authors = [
+    "Brendan Zabarauskas <[email protected]>",
+    "Christopher Durham <[email protected]>",
+    "Yehuda Katz <[email protected]>",
+    "Zibi Braniecki <[email protected]>",
+]
+
+[dependencies]
+lsp-types = "0.61.0"

crates/retort/examples/rustc.rs

@@ -0,0 +1,56 @@
+use {
+    lsp_types::{Location, Position, Range as LSPRange},
+    retort::{diagnostic::*, lsp},
+    std::ops::Range,
+};
+
+fn main() {
+    let source = include_str!("rustc_source.txt");
+
+    let position = |i: usize| -> Position {
+        let nl = (&source[..i]).rfind('\n').map(|i| i + 1).unwrap_or(0);
+        Position {
+            line: (&source[..nl]).chars().filter(|&c| c == '\n').count() as u64,
+            character: (&source[nl..i])
+                .chars()
+                .map(|c| c.len_utf16())
+                .sum::<usize>() as u64,
+        }
+    };
+
+    let diagnostic = Diagnostic::build()
+        .primary(
+            Annotation::build()
+                .span(50..777)
+                .message("mismatched types")
+                .build(),
+        )
+        .code("E0308")
+        .level(Level::Err)
+        .secondary(
+            Annotation::build()
+                .span(55..69)
+                .message("expected `Option<String>` because of return type")
+                .build(),
+        )
+        .secondary(
+            Annotation::build()
+                .span(76..775)
+                .message("expected enum `std::option::Option`, found ()")
+                .build(),
+        )
+        .build();
+
+    let out = lsp::render(
+        Some(diagnostic),
+        Some("retort rustc example".to_string()),
+        |range: Range<usize>| {
+            Location::new(
+                "example:rustc_source.txt".parse().unwrap(),
+                LSPRange::new(position(range.start), position(range.end)),
+            )
+        },
+    );
+
+    println!("{:#?}", out);
+}

crates/retort/examples/rustc_source.txt

@@ -0,0 +1,73 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+) -> Option<String> {
+    for ann in annotations {
+        match (ann.range.0, ann.range.1) {
+            (None, None) => continue,
+            (Some(start), Some(end)) if start > end_index => continue,
+            (Some(start), Some(end)) if start >= start_index => {
+                let label = if let Some(ref label) = ann.label {
+                    format!(" {}", label)
+                } else {
+                    String::from("")
+                };
+
+                return Some(format!(
+                    "{}{}{}",
+                    " ".repeat(start - start_index),
+                    "^".repeat(end - start),
+                    label
+                ));
+            }
+            _ => continue,
+        }
+    }
+}

crates/retort/src/diagnostic/builders.rs

@@ -0,0 +1,98 @@
+use super::*;
+use std::{fmt::Display, mem};
+
+impl<Span: crate::Span> Diagnostic<Span> {
+    pub fn build() -> DiagnosticBuilder<Span> {
+        DiagnosticBuilder {
+            primary: None,
+            code: None,
+            secondary: vec![],
+            level: None,
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct DiagnosticBuilder<Span> {
+    primary: Option<Annotation<Span>>,
+    code: Option<String>,
+    secondary: Vec<Annotation<Span>>,
+    level: Option<Level>,
+}
+
+impl<Span: crate::Span> DiagnosticBuilder<Span> {
+    pub fn primary(&mut self, annotation: Annotation<Span>) -> &mut Self {
+        self.primary = Some(annotation);
+        self
+    }
+
+    pub fn code(&mut self, code: impl Display) -> &mut Self {
+        self.code = Some(code.to_string());
+        self
+    }
+
+    pub fn secondary(&mut self, annotation: Annotation<Span>) -> &mut Self {
+        self.secondary.push(annotation);
+        self
+    }
+
+    pub fn level(&mut self, level: Level) -> &mut Self {
+        self.level = Some(level);
+        self
+    }
+
+    pub fn build(&mut self) -> Diagnostic<Span> {
+        let mut swindle = vec![];
+        mem::swap(&mut swindle, &mut self.secondary);
+        Diagnostic {
+            primary: self
+                .primary
+                .take()
+                .expect("incomplete `Diagnostic` without `primary`"),
+            code: self.code.take(),
+            secondary: swindle,
+            level: self.level.take(),
+            non_exhaustive: (),
+        }
+    }
+}
+
+impl<Span: crate::Span> Annotation<Span> {
+    pub fn build() -> AnnotationBuilder<Span> {
+        AnnotationBuilder {
+            span: None,
+            message: String::new(),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct AnnotationBuilder<Span> {
+    span: Option<Span>,
+    message: String,
+}
+
+impl<Span: crate::Span> AnnotationBuilder<Span> {
+    pub fn span(&mut self, span: impl Into<Span>) -> &mut Self {
+        self.span = Some(span.into());
+        self
+    }
+
+    pub fn message(&mut self, message: impl Display) -> &mut Self {
+        self.message = message.to_string();
+        self
+    }
+
+    pub fn build(&mut self) -> Annotation<Span> {
+        let mut swizzle = String::new();
+        mem::swap(&mut swizzle, &mut self.message);
+        Annotation {
+            span: self
+                .span
+                .take()
+                .expect("incomplete `Annotation` without `span`"),
+            message: swizzle,
+            non_exhaustive: (),
+        }
+    }
+}

crates/retort/src/diagnostic/mod.rs

@@ -0,0 +1,37 @@
+mod builders;
+pub use builders::*;
+
+// Note on LSP conversion:
+//   range: primary.span.range
+//   severity: level
+//   code: code
+//   source: (give to the renderer)
+//   message: primary.message
+//   related_information: secondary
+//     location.uri: span.origin
+//     location.range: span.range
+//     message: message
+
+#[derive(Debug, Clone)]
+pub struct Diagnostic<Span> {
+    pub primary: Annotation<Span>,
+    pub code: Option<String>,
+    pub secondary: Vec<Annotation<Span>>,
+    pub level: Option<Level>,
+    non_exhaustive: (),
+}
+
+#[derive(Debug, Clone)]
+pub struct Annotation<Span> {
+    pub span: Span,
+    pub message: String,
+    non_exhaustive: (),
+}
+
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
+pub enum Level {
+    Err,
+    Warn,
+    Info,
+    Hint,
+}

crates/retort/src/lib.rs

@@ -0,0 +1,37 @@
+use {
+    std::{fmt, ops::Range},
+};
+
+pub mod diagnostic;
+pub mod lsp;
+
+pub trait Span: fmt::Debug + Clone {
+    type SourceHandle: Clone;
+    type Index: Copy;
+
+    fn start(&self) -> Self::Index;
+    fn end(&self) -> Self::Index;
+    fn new(&self, start: Self::Index, end: Self::Index) -> Self;
+    fn resource(&self) -> Option<&Self::SourceHandle>;
+}
+
+impl Span for Range<usize> {
+    type SourceHandle = &'static str;
+    type Index = usize;
+
+    fn start(&self) -> usize {
+        self.start
+    }
+
+    fn end(&self) -> usize {
+        self.end
+    }
+
+    fn new(&self, start: usize, end: usize) -> Self {
+        start..end
+    }
+
+    fn resource(&self) -> Option<&Self::SourceHandle> {
+        Some(&"example:")
+    }
+}

crates/retort/src/lsp.rs

@@ -0,0 +1,55 @@
+use {
+    crate::{diagnostic::*, Span as _},
+    lsp_types::{
+        Diagnostic as LSPDiagnostic, DiagnosticRelatedInformation, DiagnosticSeverity,
+        NumberOrString, PublishDiagnosticsParams, Url,
+    },
+    std::{borrow::Borrow, collections::HashMap},
+};
+
+impl Level {
+    fn as_lsp(self) -> DiagnosticSeverity {
+        match self {
+            Level::Err => DiagnosticSeverity::Error,
+            Level::Warn => DiagnosticSeverity::Warning,
+            Level::Info => DiagnosticSeverity::Information,
+            Level::Hint => DiagnosticSeverity::Hint,
+        }
+    }
+}
+
+pub fn render<Span: crate::Span>(
+    diagnostics: impl IntoIterator<Item = Diagnostic<Span>>,
+    source: Option<String>,
+    mut span_resolver: impl FnMut(Span) -> lsp_types::Location,
+) -> Vec<PublishDiagnosticsParams>
+where
+    Span::SourceHandle: Borrow<str>,
+{
+    let mut out: HashMap<Url, Vec<LSPDiagnostic>> = HashMap::new();
+
+    for diagnostic in diagnostics {
+        let location = span_resolver(diagnostic.primary.span);
+        out.entry(location.uri).or_default().push(LSPDiagnostic {
+            range: location.range,
+            severity: diagnostic.level.map(Level::as_lsp),
+            code: diagnostic.code.map(NumberOrString::String),
+            source: source.clone(),
+            message: diagnostic.primary.message,
+            related_information: Some(
+                diagnostic
+                    .secondary
+                    .into_iter()
+                    .map(|diagnostic| DiagnosticRelatedInformation {
+                        location: span_resolver(diagnostic.span),
+                        message: diagnostic.message,
+                    })
+                    .collect(),
+            ),
+        })
+    }
+
+    out.into_iter()
+        .map(|(uri, diagnostics)| PublishDiagnosticsParams { uri, diagnostics })
+        .collect()
+}