wdl-analysis 0.23.0

Analysis of Workflow Description Language (WDL) documents.
Documentation 
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

//! Validation of known rule names.

use std::collections::HashSet;

use rowan::Direction;
use wdl_ast::AstToken;
use wdl_ast::Comment;
use wdl_ast::Directive;
use wdl_grammar::Diagnostic;
use wdl_grammar::Severity;
use wdl_grammar::Span;
use wdl_grammar::SupportedVersion;
use wdl_grammar::SyntaxElement;

use crate::Diagnostics;
use crate::Document;
use crate::KnownRulesRule;
use crate::VisitReason;
use crate::Visitor;
use crate::find_nearest_rule;

/// Creates an "unknown rule" diagnostic.
fn unknown_rule(id: &str, nearest_rule: Option<String>, span: Span) -> Diagnostic {
    let mut diagnostic = Diagnostic::note(format!("unknown rule `{id}`"))
        .with_rule(KnownRulesRule::ID)
        .with_label("cannot make an exception for this rule", span);

    if let Some(nearest_rule) = nearest_rule {
        diagnostic = diagnostic.with_fix(format!("did you mean `{nearest_rule}`?"));
    } else {
        diagnostic = diagnostic.with_fix("remove the unknown rule from the exception list");
    }

    diagnostic
}

/// Detects unknown rules within lint directives.
pub(crate) struct KnownRules {
    /// All rules known to the validator.
    known_rules: HashSet<String>,
    /// The severity of the diagnostic.
    severity: Option<Severity>,
}

impl KnownRules {
    /// Creates a new instance of the `KnownRules` rule.
    pub fn new(known_rules: HashSet<String>) -> Self {
        Self {
            known_rules,
            severity: None,
        }
    }

    /// Gets the set of known rules.
    pub fn known_rules(&self) -> &HashSet<String> {
        &self.known_rules
    }
}

impl Extend<String> for KnownRules {
    fn extend<T: IntoIterator<Item = String>>(&mut self, iter: T) {
        self.known_rules.extend(iter);
    }
}

impl Visitor for KnownRules {
    fn reset(&mut self) {
        let Self {
            severity,
            known_rules: _,
        } = self;

        *severity = None;
    }

    fn document(
        &mut self,
        _: &mut Diagnostics,
        visit_reason: VisitReason,
        doc: &Document,
        _: SupportedVersion,
    ) {
        if visit_reason != VisitReason::Enter {
            return;
        }

        self.severity = doc.config().diagnostics_config().known_rules;
    }

    fn comment(&mut self, diagnostics: &mut Diagnostics, comment: &Comment) {
        if self.severity.is_none() {
            return;
        }

        let Some(Directive::Except(except)) = comment.directive() else {
            return;
        };

        for rule in except {
            if self.known_rules.contains(&rule.name) {
                continue;
            }

            let diagnostic = unknown_rule(
                &rule.name,
                find_nearest_rule(self.known_rules.iter().map(String::as_str), &rule.name),
                rule.span,
            );

            if let Some(target) = comment
                .inner()
                .siblings_with_tokens(Direction::Next)
                .find_map(|sibling| {
                    if let SyntaxElement::Node(node) = sibling {
                        Some(node)
                    } else {
                        None
                    }
                })
            {
                diagnostics.exceptable_add(diagnostic, &target, &KnownRulesRule::EXCEPTABLE_NODES);
            } else {
                diagnostics.add(diagnostic);
            }
        }
    }
}