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
|
mod lints;
mod make;
pub use lints::LINTS;
use rnix::{SyntaxElement, SyntaxKind, TextRange};
use std::{default::Default, convert::Into};
/// Report generated by a lint
#[derive(Debug, Default)]
pub struct Report {
/// General information about this lint and where it applies.
pub note: &'static str,
/// An error code to uniquely identify this lint
pub code: u32,
/// Collection of diagnostics raised by this lint
pub diagnostics: Vec<Diagnostic>,
}
impl Report {
/// Construct a report. Do not invoke manually, see `lint` macro
pub fn new(note: &'static str, code: u32) -> Self {
Self {
note,
code,
..Default::default()
}
}
/// Add a diagnostic to this report
pub fn diagnostic(mut self, at: TextRange, message: String) -> Self {
self.diagnostics.push(Diagnostic::new(at, message));
self
}
/// Add a diagnostic with a fix to this report
pub fn suggest(mut self, at: TextRange, message: String, suggestion: Suggestion) -> Self {
self.diagnostics.push(Diagnostic::suggest(at, message, suggestion));
self
}
}
/// Mapping from a bytespan to an error message.
/// Can optionally suggest a fix.
#[derive(Debug)]
pub struct Diagnostic {
pub at: TextRange,
pub message: String,
pub suggestion: Option<Suggestion>,
}
impl Diagnostic {
/// Construct a diagnostic.
pub fn new(at: TextRange, message: String) -> Self {
Self { at, message, suggestion: None }
}
/// Construct a diagnostic with a fix.
pub fn suggest(at: TextRange, message: String, suggestion: Suggestion) -> Self {
Self { at, message, suggestion: Some(suggestion) }
}
}
/// Suggested fix for a diagnostic, the fix is provided as a syntax element.
/// Look at `make.rs` to construct fixes.
#[derive(Debug)]
pub struct Suggestion {
pub at: TextRange,
pub fix: SyntaxElement,
}
impl Suggestion {
/// Construct a suggestion.
pub fn new<E: Into<SyntaxElement>>(at: TextRange, fix: E) -> Self {
Self {
at,
fix: fix.into()
}
}
}
/// Lint logic is defined via this trait. Do not implement manually,
/// look at the `lint` attribute macro instead for implementing rules
pub trait Rule {
fn validate(&self, node: &SyntaxElement) -> Option<Report>;
}
/// Contains information about the lint itself. Do not implement manually,
/// look at the `lint` attribute macro instead for implementing rules
pub trait Metadata {
fn name() -> &'static str where Self: Sized;
fn note() -> &'static str where Self: Sized;
fn code() -> u32 where Self: Sized;
fn report() -> Report where Self: Sized;
fn match_with(&self, with: &SyntaxKind) -> bool;
fn match_kind(&self) -> SyntaxKind;
}
/// Combines Rule and Metadata, do not implement manually, this is derived by
/// the `lint` macro.
pub trait Lint: Metadata + Rule + Send + Sync {}
/// Helper utility to take lints from modules and insert them into a map for efficient
/// access. Mapping is from a SyntaxKind to a list of lints that apply on that Kind.
///
/// See `lints.rs` for usage.
#[macro_export]
macro_rules! lint_map {
($($s:ident),*,) => {
lint_map!($($s),*);
};
($($s:ident),*) => {
use ::std::collections::HashMap;
use ::rnix::SyntaxKind;
$(
mod $s;
)*
::lazy_static::lazy_static! {
pub static ref LINTS: HashMap<SyntaxKind, Vec<&'static Box<dyn $crate::Lint>>> = {
let mut map = HashMap::new();
$(
{
let temp_lint = &*$s::LINT;
let temp_match = temp_lint.match_kind();
map.entry(temp_match)
.and_modify(|v: &mut Vec<_>| v.push(temp_lint))
.or_insert_with(|| vec![temp_lint]);
}
)*
map
};
}
}
}
|
