1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174

//! A simple builder for facilitating the creation of diagnostics

use crate::{Diagnostic, RuleResult, SyntaxNode};
use codespan_reporting::diagnostic::{Label, Severity};
use rslint_parser::{SyntaxElement, SyntaxNodeExt, SyntaxToken, TextRange};
use std::ops::Range;

/// A simple builder for creating codespan diagnostics sequentially
#[derive(Debug, Clone)]
pub struct DiagnosticBuilder(Diagnostic, usize);

impl DiagnosticBuilder {
    /// Create a new builder with a severity of error
    pub fn error(file_id: usize, code: impl Into<String>, message: impl Into<String>) -> Self {
        Self(
            Diagnostic {
                code: Some(code.into()),
                message: message.into(),
                severity: Severity::Error,
                labels: vec![],
                notes: vec![],
            },
            file_id,
        )
    }

    /// Create a new builder with a severity of warning
    pub fn warning(file_id: usize, code: impl Into<String>, message: impl Into<String>) -> Self {
        Self(
            Diagnostic {
                code: Some(code.into()),
                message: message.into(),
                severity: Severity::Warning,
                labels: vec![],
                notes: vec![],
            },
            file_id,
        )
    }

    /// Create a new builder with a severity of note
    pub fn note_diagnostic(
        file_id: usize,
        code: impl Into<String>,
        message: impl Into<String>,
    ) -> Self {
        Self(
            Diagnostic {
                code: Some(code.into()),
                message: message.into(),
                severity: Severity::Note,
                labels: vec![],
                notes: vec![],
            },
            file_id,
        )
    }

    /// Change the severity of this diagnostic
    pub fn severity(mut self, severity: Severity) -> Self {
        self.0.severity = severity;
        self
    }

    /// Add a primary label to the diagnostic
    pub fn primary(mut self, range: impl Span, message: impl AsRef<str>) -> Self {
        self.0.labels.append(&mut vec![
            Label::primary(self.1, range.as_range()).with_message(message.as_ref())
        ]);
        self
    }

    /// Add a secondary label to this diagnostic
    pub fn secondary(mut self, range: impl Span, message: impl AsRef<str>) -> Self {
        self.0.labels.append(&mut vec![
            Label::secondary(self.1, range.as_range()).with_message(message.as_ref())
        ]);
        self
    }

    /// Add a note message to the bottom of the diagnostic (usually a `Help:` or `Note:` message)
    pub fn note(mut self, message: impl AsRef<str>) -> Self {
        self.0.notes.append(&mut vec![message.as_ref().to_owned()]);
        self
    }

    pub fn finish(self) -> Diagnostic {
        self.0
    }
}

impl From<DiagnosticBuilder> for Diagnostic {
    fn from(builder: DiagnosticBuilder) -> Diagnostic {
        builder.0
    }
}

impl From<DiagnosticBuilder> for RuleResult {
    fn from(builder: DiagnosticBuilder) -> RuleResult {
        RuleResult {
            diagnostics: vec![builder.into()],
        }
    }
}

impl From<DiagnosticBuilder> for Option<RuleResult> {
    fn from(builder: DiagnosticBuilder) -> Option<RuleResult> {
        Some(RuleResult {
            diagnostics: vec![builder.into()],
        })
    }
}

/// A value which can be used as the range inside of a diagnostic.
///
/// This is essentially a hack to allow us to use SyntaxElement, SyntaxNode, etc directly
pub trait Span {
    fn as_range(&self) -> Range<usize>;
}

impl<T: Span> Span for &T {
    fn as_range(&self) -> Range<usize> {
        (*self).as_range()
    }
}

impl<T: Span> Span for &mut T {
    fn as_range(&self) -> Range<usize> {
        (**self).as_range()
    }
}

impl<T: Clone> Span for Range<T>
where
    T: Into<usize>,
{
    fn as_range(&self) -> Range<usize> {
        self.start.clone().into()..self.end.clone().into()
    }
}

impl Span for SyntaxNode {
    fn as_range(&self) -> Range<usize> {
        self.trimmed_range().into()
    }
}

impl Span for SyntaxToken {
    fn as_range(&self) -> Range<usize> {
        self.text_range().into()
    }
}

impl Span for SyntaxElement {
    fn as_range(&self) -> Range<usize> {
        match self {
            SyntaxElement::Node(n) => n.trimmed_range(),
            SyntaxElement::Token(t) => t.text_range(),
        }
        .into()
    }
}

impl<FileId: Clone> Span for Label<FileId> {
    fn as_range(&self) -> Range<usize> {
        self.range.clone()
    }
}

impl Span for TextRange {
    fn as_range(&self) -> Range<usize> {
        self.clone().into()
    }
}