Struct libslide::linter::stmt::redundant_nesting::RedundantNestingLinter

pub struct RedundantNestingLinter<'a> {
    source: &'a str,
    diagnostics: Vec<Diagnostic>,
}

Fields

source: &'a str

diagnostics: Vec<Diagnostic>

Implementations

impl<'a> RedundantNestingLinter<'a>

pub fn new(source: &'a str) -> Self

impl<'a> RedundantNestingLinter<'a>

fn visit_nesting(&mut self, expr: &'a RcExpr, span: Span)

Trait Implementations

impl<'a> DiagnosticRecord for RedundantNestingLinter<'a>

The redundant nesting lint detects redundant nesting of expressions in parantheses or brackets.

For example, the following nestings are redundant and can be reduced to a single nesting:

((1))     -> (1)
[[1]]     -> [1]
([[(1)]]) -> (1)

Redundant nestings are difficult to read and may be misleading, as generally a single nesting is expected to host an expression for precedence or clarity reasons.

const CODE: &'static str

Diagnostic code.

const EXPLANATION: &'static str

Detailed diagnostic explanation.

impl<'a> LintRule<'a, StmtList> for RedundantNestingLinter<'a>

fn lint(stmt_list: &StmtList, source: &'a str) -> Vec<Diagnostic>

Lints a grammar given the original source code of the program.

impl<'a> StmtVisitor<'a> for RedundantNestingLinter<'a>

fn visit_parend(&mut self, expr: &'a RcExpr, span: Span)

Visits a parenthesized expression.

fn visit_bracketed(&mut self, expr: &'a RcExpr, span: Span)

Visits a bracketed expression.

fn visit_stmt_list(&mut self, stmt_list: &'a StmtList)

Visits a statement list.

fn visit_stmt(&mut self, stmt: &'a Stmt)

Visits a statement.

fn visit_stmt_kind(&mut self, stmt_kind: &'a StmtKind)

Visits a specific statement kind.

fn visit_asgn(&mut self, asgn: &'a Assignment)

Visits an assignment.

fn visit_asgn_op(&mut self, _asgn_op: &'a AssignmentOp)

Visits an assignment operator.

fn visit_expr(&mut self, expr: &'a RcExpr)

Visits an expression.

fn visit_const(&mut self, _konst: &'a f64, _span: Span)

Visits a constant.

fn visit_var(&mut self, _var: &'a InternedStr, _span: Span)

Visits a variable.

fn visit_binary_op(&mut self, _op: BinaryOperator)

Visits a binary operator.

fn visit_binary(&mut self, expr: &'a BinaryExpr<RcExpr>, span: Span)

Visits a binary expression.

fn visit_unary_op(&mut self, _op: UnaryOperator)

Visits a unary operator.

fn visit_unary(&mut self, expr: &'a UnaryExpr<RcExpr>, span: Span)

Visits a unary expression.