nu-lint 1.3.0

Linter for Nu shell scripts that helpfully suggests improvements
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

use nu_protocol::ast::{Expr, Expression, ListItem, RecordItem};

use super::{extract_record_from_expr, get_labels_value, has_field};
use crate::{
    LintLevel,
    ast::call::CallExt,
    context::LintContext,
    rule::{DetectFix, Rule},
    violation::Detection,
};

/// Check if a label record has 'text' but is missing 'span'
fn label_missing_span(record: &[RecordItem], context: &LintContext) -> bool {
    let has_text = has_field(record, "text", context);
    let has_span = has_field(record, "span", context);
    log::trace!("label_missing_span: has_text={has_text}, has_span={has_span}");
    has_text && !has_span
}

const fn list_item_expr(item: &ListItem) -> &Expression {
    match item {
        ListItem::Item(e) | ListItem::Spread(_, e) => e,
    }
}

/// Extract label records from labels expression (handles both single record and
/// list)
fn extract_labels_missing_span<'a>(
    labels_expr: &'a Expression,
    context: &LintContext,
) -> Vec<&'a Expression> {
    log::trace!("extract_labels_missing_span: expr = {:?}", labels_expr.expr);

    // Handle FullCellPath wrapping by extracting the head expression
    let effective_expr = match &labels_expr.expr {
        Expr::FullCellPath(full_cell_path) if full_cell_path.tail.is_empty() => {
            log::trace!("Unwrapping FullCellPath to get head expression");
            &full_cell_path.head
        }
        _ => labels_expr,
    };

    match &effective_expr.expr {
        // Single label record: labels: { text: "...", span: ... }
        Expr::Record(record) => {
            log::trace!("Found Record with {} items", record.len());
            let missing = label_missing_span(record, context);
            log::trace!("label_missing_span returned {missing}");
            if missing {
                vec![effective_expr]
            } else {
                vec![]
            }
        }
        // List of labels: labels: [{ text: "..." }, ...]
        Expr::List(items) => {
            log::trace!("Found List with {} items", items.len());
            items
                .iter()
                .filter(|item| {
                    extract_record_from_expr(list_item_expr(item))
                        .is_some_and(|record| label_missing_span(record, context))
                })
                .map(list_item_expr)
                .collect()
        }
        other => {
            log::trace!("Found other expr type: {other:?}");
            vec![]
        }
    }
}

struct AddSpanToLabel;

impl DetectFix for AddSpanToLabel {
    type FixInput<'a> = ();

    fn id(&self) -> &'static str {
        "add_span_to_label"
    }

    fn short_description(&self) -> &'static str {
        "labels should include 'span' to highlight error location in user code"
    }

    fn source_link(&self) -> Option<&'static str> {
        Some("https://www.nushell.sh/book/creating_errors.html")
    }

    fn level(&self) -> LintLevel {
        LintLevel::Hint
    }

    fn detect<'a>(&self, context: &'a LintContext) -> Vec<(Detection, Self::FixInput<'a>)> {
        log::trace!("add_span_to_label detect() called");
        Self::no_fix(context.detect(|expr, ctx| {
            let Expr::Call(call) = &expr.expr else {
                return vec![];
            };

            if call.get_call_name(ctx) != "error make" {
                return vec![];
            }
            log::trace!("Found error make call");

            let Some(error_record) = call
                .get_first_positional_arg()
                .and_then(extract_record_from_expr)
            else {
                log::trace!("No error record found");
                return vec![];
            };
            log::trace!("Found error record with {} items", error_record.len());

            let Some(labels_expr) = get_labels_value(error_record, ctx) else {
                log::trace!("No labels field found");
                return vec![];
            };
            log::trace!("Found labels field");

            let labels_missing_span = extract_labels_missing_span(labels_expr, ctx);
            log::trace!("labels_missing_span count = {}", labels_missing_span.len());
            if labels_missing_span.is_empty() {
                log::trace!("No labels missing span, returning empty");
                return vec![];
            }
            log::trace!("Found {} labels missing span", labels_missing_span.len());

            labels_missing_span
                .into_iter()
                .map(|label_expr| {
                    Detection::from_global_span(
                        "label has 'text' but is missing 'span' to highlight error location",
                        label_expr.span,
                    )
                    .with_primary_label("missing span")
                })
                .collect()
        }))
    }
}

pub static RULE: &dyn Rule = &AddSpanToLabel;

#[cfg(test)]
mod detect_bad;
#[cfg(test)]
mod ignore_good;