masmlint 0.1.1

A linter for Miden Assembly
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

use std::sync::Arc;

use miden_assembly::{
    SourceFile, Span,
    ast::{Block, Export, Form, Instruction, Op},
    testing::TestContext,
};
use miette::{Context, Result};

use crate::{LintError, errors::LinterError};

pub struct Linter {
    lints: Vec<Box<dyn EarlyLintPass>>,
    errors: Vec<LintError>,
}

impl Linter {
    pub fn new(lints: Vec<Box<dyn EarlyLintPass>>) -> Self {
        Self { lints, errors: Vec::new() }
    }

    pub fn lint(&mut self, source: Arc<SourceFile>) -> Result<()> {
        self.early_lint(Arc::clone(&source))
    }

    pub fn finish(mut self) -> Result<(), LinterError> {
        let errors = core::mem::take(&mut self.errors);

        if errors.is_empty() {
            Ok(())
        } else {
            Err(LinterError::new_lints(errors))
        }
    }

    fn early_lint(&mut self, source_file: Arc<SourceFile>) -> Result<()> {
        // This is abusing the miden-assembly testing feature to be able to parse the forms,
        // but there is no other public API to get the forms, unfortunately.
        let forms = TestContext::new()
            .parse_forms(Arc::clone(&source_file))
            .context("failed to parse forms")?;

        let errors = core::mem::take(&mut self.errors);

        let mut early_ctx = EarlyContext { errors, source_file };

        for form in forms {
            let Form::Procedure(Export::Procedure(proc)) = form else {
                continue;
            };

            early_ctx.lint_block(proc.body(), self.lints.as_mut_slice());
        }

        // Put the errors back into the field.
        core::mem::swap(&mut early_ctx.errors, &mut self.errors);

        Ok(())
    }
}

pub struct EarlyContext {
    errors: Vec<LintError>,
    source_file: Arc<SourceFile>,
}

impl EarlyContext {
    fn lint_block(&mut self, block: &Block, lints: &mut [Box<dyn EarlyLintPass>]) {
        for lint in lints.iter_mut() {
            lint.block_changed(block);
        }

        for op in block.iter() {
            match op {
                Op::If { then_blk, else_blk, .. } => {
                    self.lint_block(then_blk, lints);
                    self.lint_block(else_blk, lints);
                },
                Op::While { body, .. } => {
                    self.lint_block(body, lints);
                },
                Op::Repeat { body, .. } => {
                    self.lint_block(body, lints);
                },
                Op::Inst(instr) => {
                    for lint in lints.iter_mut() {
                        lint.lint_instruction(self, instr);
                    }
                },
            }
        }
    }

    pub fn push_error(&mut self, error: LintError) {
        self.errors.push(error);
    }

    pub fn source_file(&self) -> Arc<SourceFile> {
        Arc::clone(&self.source_file)
    }
}

pub trait EarlyLintPass {
    fn lint_instruction(&mut self, early_ctx: &mut EarlyContext, instruction: &Span<Instruction>);
    fn block_changed(&mut self, _block: &Block) {}
}