wdl-lint 0.26.0

Lint rules for 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
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

//! A lint rule for import placements.

use wdl_analysis::Diagnostics;
use wdl_analysis::Example;
use wdl_analysis::LabeledSnippet;
use wdl_analysis::VisitReason;
use wdl_analysis::Visitor;
use wdl_ast::AstNode;
use wdl_ast::Diagnostic;
use wdl_ast::Span;
use wdl_ast::SyntaxKind;
use wdl_ast::v1::ImportStatement;
use wdl_ast::v1::StructDefinition;
use wdl_ast::v1::TaskDefinition;
use wdl_ast::v1::WorkflowDefinition;

use crate::Rule;
use crate::Tag;
use crate::TagSet;

/// The identifier for the import placement rule.
const ID: &str = "ImportPlacement";

/// Creates a "misplaced import" diagnostic.
fn misplaced_import(span: Span) -> Diagnostic {
    Diagnostic::warning("misplaced import")
        .with_rule(ID)
        .with_highlight(span)
        .with_fix(
            "move this import so that it comes after the version statement but before any \
             document items",
        )
}

/// Detects incorrect import placements.
#[derive(Default, Debug, Clone, Copy)]
pub struct ImportPlacementRule {
    /// Whether or not an import statement is considered invalid.
    invalid: bool,
}

impl Rule for ImportPlacementRule {
    fn id(&self) -> &'static str {
        ID
    }

    fn description(&self) -> &'static str {
        "Ensures that imports are placed between the version statement and any document items."
    }

    fn explanation(&self) -> &'static str {
        "All import statements should follow the WDL version declaration with one empty line \
         between the version and the first import statement."
    }

    fn examples(&self) -> &'static [Example] {
        &[Example {
            negative: LabeledSnippet {
                label: None,
                snippet: r#"version 1.2

workflow example {
}

import "example2.wdl"
"#,
            },
            revised: Some(LabeledSnippet {
                label: None,
                snippet: r#"version 1.2

import "example2.wdl"

workflow example {
}
"#,
            }),
        }]
    }

    fn tags(&self) -> TagSet {
        TagSet::new(&[Tag::Clarity])
    }

    fn exceptable_nodes(&self) -> Option<&'static [wdl_ast::SyntaxKind]> {
        Some(&[
            SyntaxKind::VersionStatementNode,
            SyntaxKind::ImportStatementNode,
        ])
    }

    fn related_rules(&self) -> &'static [&'static str] {
        &[]
    }
}

impl Visitor for ImportPlacementRule {
    fn reset(&mut self) {
        *self = Self::default();
    }

    fn import_statement(
        &mut self,
        diagnostics: &mut Diagnostics,
        reason: VisitReason,
        stmt: &ImportStatement,
    ) {
        if reason == VisitReason::Exit {
            return;
        }

        if self.invalid {
            diagnostics.exceptable_add(
                misplaced_import(stmt.span()),
                stmt.inner(),
                &self.exceptable_nodes(),
            );
        }
    }

    fn struct_definition(
        &mut self,
        _: &mut Diagnostics,
        reason: VisitReason,
        _: &StructDefinition,
    ) {
        if reason == VisitReason::Exit {
            return;
        }

        // Saw an item other than an import, imports are no longer valid
        self.invalid = true;
    }

    fn task_definition(&mut self, _: &mut Diagnostics, reason: VisitReason, _: &TaskDefinition) {
        if reason == VisitReason::Exit {
            return;
        }

        // Saw an item other than an import, imports are no longer valid
        self.invalid = true;
    }

    fn workflow_definition(
        &mut self,
        _: &mut Diagnostics,
        reason: VisitReason,
        _: &WorkflowDefinition,
    ) {
        if reason == VisitReason::Exit {
            return;
        }

        // Saw an item other than an import, imports are no longer valid
        self.invalid = true;
    }
}