2016-04-20 13:52:31 -05:00
|
|
|
// Code for annotating snippets.
|
|
|
|
|
2019-02-06 12:53:01 -06:00
|
|
|
use crate::Level;
|
2016-04-20 13:52:31 -05:00
|
|
|
|
2016-07-11 15:02:03 -05:00
|
|
|
#[derive(Clone, Debug, PartialOrd, Ord, PartialEq, Eq)]
|
|
|
|
pub struct Line {
|
|
|
|
pub line_index: usize,
|
|
|
|
pub annotations: Vec<Annotation>,
|
2016-04-20 13:52:31 -05:00
|
|
|
}
|
|
|
|
|
2016-11-23 01:32:16 -06:00
|
|
|
#[derive(Clone, Debug, PartialOrd, Ord, PartialEq, Eq)]
|
|
|
|
pub struct MultilineAnnotation {
|
|
|
|
pub depth: usize,
|
|
|
|
pub line_start: usize,
|
|
|
|
pub line_end: usize,
|
|
|
|
pub start_col: usize,
|
|
|
|
pub end_col: usize,
|
|
|
|
pub is_primary: bool,
|
|
|
|
pub label: Option<String>,
|
2019-03-28 22:19:50 -05:00
|
|
|
pub overlaps_exactly: bool,
|
2016-11-23 01:32:16 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
impl MultilineAnnotation {
|
|
|
|
pub fn increase_depth(&mut self) {
|
|
|
|
self.depth += 1;
|
|
|
|
}
|
|
|
|
|
2019-03-27 21:26:47 -05:00
|
|
|
/// Compare two `MultilineAnnotation`s considering only the `Span` they cover.
|
|
|
|
pub fn same_span(&self, other: &MultilineAnnotation) -> bool {
|
2019-12-22 16:42:04 -06:00
|
|
|
self.line_start == other.line_start
|
|
|
|
&& self.line_end == other.line_end
|
|
|
|
&& self.start_col == other.start_col
|
|
|
|
&& self.end_col == other.end_col
|
2019-03-27 21:26:47 -05:00
|
|
|
}
|
|
|
|
|
2016-11-23 01:32:16 -06:00
|
|
|
pub fn as_start(&self) -> Annotation {
|
|
|
|
Annotation {
|
|
|
|
start_col: self.start_col,
|
|
|
|
end_col: self.start_col + 1,
|
|
|
|
is_primary: self.is_primary,
|
2017-04-14 18:38:10 -05:00
|
|
|
label: None,
|
2019-12-22 16:42:04 -06:00
|
|
|
annotation_type: AnnotationType::MultilineStart(self.depth),
|
2016-11-23 01:32:16 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn as_end(&self) -> Annotation {
|
|
|
|
Annotation {
|
2017-11-17 06:13:02 -06:00
|
|
|
start_col: self.end_col.saturating_sub(1),
|
2016-11-23 01:32:16 -06:00
|
|
|
end_col: self.end_col,
|
|
|
|
is_primary: self.is_primary,
|
2017-04-14 18:38:10 -05:00
|
|
|
label: self.label.clone(),
|
2019-12-22 16:42:04 -06:00
|
|
|
annotation_type: AnnotationType::MultilineEnd(self.depth),
|
2016-11-23 01:32:16 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn as_line(&self) -> Annotation {
|
|
|
|
Annotation {
|
|
|
|
start_col: 0,
|
|
|
|
end_col: 0,
|
|
|
|
is_primary: self.is_primary,
|
|
|
|
label: None,
|
2019-12-22 16:42:04 -06:00
|
|
|
annotation_type: AnnotationType::MultilineLine(self.depth),
|
2016-11-23 01:32:16 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-10-23 19:22:06 -05:00
|
|
|
#[derive(Clone, Debug, PartialOrd, Ord, PartialEq, Eq)]
|
|
|
|
pub enum AnnotationType {
|
|
|
|
/// Annotation under a single line of code
|
|
|
|
Singleline,
|
|
|
|
|
|
|
|
/// Annotation enclosing the first and last character of a multiline span
|
2016-11-23 01:32:16 -06:00
|
|
|
Multiline(MultilineAnnotation),
|
2016-10-23 19:22:06 -05:00
|
|
|
|
|
|
|
// The Multiline type above is replaced with the following three in order
|
|
|
|
// to reuse the current label drawing code.
|
|
|
|
//
|
|
|
|
// Each of these corresponds to one part of the following diagram:
|
|
|
|
//
|
|
|
|
// x | foo(1 + bar(x,
|
2017-04-14 18:38:10 -05:00
|
|
|
// | _________^ < MultilineStart
|
|
|
|
// x | | y), < MultilineLine
|
|
|
|
// | |______________^ label < MultilineEnd
|
2016-10-23 19:22:06 -05:00
|
|
|
// x | z);
|
|
|
|
/// Annotation marking the first character of a fully shown multiline span
|
|
|
|
MultilineStart(usize),
|
|
|
|
/// Annotation marking the last character of a fully shown multiline span
|
|
|
|
MultilineEnd(usize),
|
|
|
|
/// Line at the left enclosing the lines of a fully shown multiline span
|
2017-04-06 14:18:18 -05:00
|
|
|
// Just a placeholder for the drawing algorithm, to know that it shouldn't skip the first 4
|
|
|
|
// and last 2 lines of code. The actual line is drawn in `emit_message_default` and not in
|
|
|
|
// `draw_multiline_line`.
|
2016-10-23 19:22:06 -05:00
|
|
|
MultilineLine(usize),
|
|
|
|
}
|
|
|
|
|
2016-05-02 12:05:14 -05:00
|
|
|
#[derive(Clone, Debug, PartialOrd, Ord, PartialEq, Eq)]
|
2016-07-11 15:02:03 -05:00
|
|
|
pub struct Annotation {
|
2016-04-20 13:52:31 -05:00
|
|
|
/// Start column, 0-based indexing -- counting *characters*, not
|
|
|
|
/// utf-8 bytes. Note that it is important that this field goes
|
|
|
|
/// first, so that when we sort, we sort orderings by start
|
|
|
|
/// column.
|
2016-07-11 15:02:03 -05:00
|
|
|
pub start_col: usize,
|
2016-04-20 13:52:31 -05:00
|
|
|
|
2016-04-26 11:33:38 -05:00
|
|
|
/// End column within the line (exclusive)
|
2016-07-11 15:02:03 -05:00
|
|
|
pub end_col: usize,
|
2016-04-20 13:52:31 -05:00
|
|
|
|
|
|
|
/// Is this annotation derived from primary span
|
2016-07-11 15:02:03 -05:00
|
|
|
pub is_primary: bool,
|
2016-04-20 13:52:31 -05:00
|
|
|
|
|
|
|
/// Optional label to display adjacent to the annotation.
|
2016-07-11 15:02:03 -05:00
|
|
|
pub label: Option<String>,
|
2016-10-23 19:22:06 -05:00
|
|
|
|
|
|
|
/// Is this a single line, multiline or multiline span minimized down to a
|
|
|
|
/// smaller span.
|
|
|
|
pub annotation_type: AnnotationType,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Annotation {
|
2017-08-15 14:45:21 -05:00
|
|
|
/// Whether this annotation is a vertical line placeholder.
|
2017-01-20 20:57:21 -06:00
|
|
|
pub fn is_line(&self) -> bool {
|
2020-09-18 12:11:06 -05:00
|
|
|
matches!(self.annotation_type, AnnotationType::MultilineLine(_))
|
2017-01-20 20:57:21 -06:00
|
|
|
}
|
|
|
|
|
2016-10-23 19:22:06 -05:00
|
|
|
pub fn is_multiline(&self) -> bool {
|
2020-09-18 12:11:06 -05:00
|
|
|
matches!(self.annotation_type,
|
2019-12-22 16:42:04 -06:00
|
|
|
AnnotationType::Multiline(_)
|
|
|
|
| AnnotationType::MultilineStart(_)
|
|
|
|
| AnnotationType::MultilineLine(_)
|
2020-09-18 12:11:06 -05:00
|
|
|
| AnnotationType::MultilineEnd(_))
|
2016-10-23 19:22:06 -05:00
|
|
|
}
|
|
|
|
|
2017-01-20 20:57:21 -06:00
|
|
|
pub fn len(&self) -> usize {
|
|
|
|
// Account for usize underflows
|
|
|
|
if self.end_col > self.start_col {
|
|
|
|
self.end_col - self.start_col
|
|
|
|
} else {
|
|
|
|
self.start_col - self.end_col
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn has_label(&self) -> bool {
|
|
|
|
if let Some(ref label) = self.label {
|
|
|
|
// Consider labels with no text as effectively not being there
|
|
|
|
// to avoid weird output with unnecessary vertical lines, like:
|
|
|
|
//
|
|
|
|
// X | fn foo(x: u32) {
|
|
|
|
// | -------^------
|
|
|
|
// | | |
|
|
|
|
// | |
|
|
|
|
// |
|
|
|
|
//
|
|
|
|
// Note that this would be the complete output users would see.
|
2020-02-28 07:20:33 -06:00
|
|
|
!label.is_empty()
|
2017-01-20 20:57:21 -06:00
|
|
|
} else {
|
|
|
|
false
|
|
|
|
}
|
|
|
|
}
|
2017-04-14 18:38:10 -05:00
|
|
|
|
|
|
|
pub fn takes_space(&self) -> bool {
|
|
|
|
// Multiline annotations always have to keep vertical space.
|
2020-10-26 20:02:48 -05:00
|
|
|
matches!(self.annotation_type, AnnotationType::MultilineStart(_) | AnnotationType::MultilineEnd(_))
|
2017-04-14 18:38:10 -05:00
|
|
|
}
|
2016-04-20 13:52:31 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
#[derive(Debug)]
|
|
|
|
pub struct StyledString {
|
|
|
|
pub text: String,
|
|
|
|
pub style: Style,
|
|
|
|
}
|
|
|
|
|
2020-06-11 09:49:57 -05:00
|
|
|
#[derive(Copy, Clone, Debug, PartialEq, Hash, Encodable, Decodable)]
|
2016-04-20 13:52:31 -05:00
|
|
|
pub enum Style {
|
2018-06-10 21:43:28 -05:00
|
|
|
MainHeaderMsg,
|
2016-07-11 15:02:03 -05:00
|
|
|
HeaderMsg,
|
2016-04-20 13:52:31 -05:00
|
|
|
LineAndColumn,
|
|
|
|
LineNumber,
|
|
|
|
Quotation,
|
|
|
|
UnderlinePrimary,
|
|
|
|
UnderlineSecondary,
|
|
|
|
LabelPrimary,
|
|
|
|
LabelSecondary,
|
|
|
|
NoStyle,
|
2016-07-11 15:02:03 -05:00
|
|
|
Level(Level),
|
2017-01-11 15:55:41 -06:00
|
|
|
Highlight,
|
2016-10-18 12:43:02 -05:00
|
|
|
}
|