Struct libslide::linter::stmt::homogenous_assignment::HomogenousAssignmentLinter

pub struct HomogenousAssignmentLinter<'a> {
    source: &'a str,
    asgn_op: Option<AssignmentOp>,
    diagnostics: Vec<Diagnostic>,
}

Fields

source: &'a str

asgn_op: Option<AssignmentOp>

The assignment op kind we expect to see across the program, set to the first assignment op we see.

diagnostics: Vec<Diagnostic>

Implementations

impl<'a> HomogenousAssignmentLinter<'a>

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

Trait Implementations

impl<'a> DiagnosticRecord for HomogenousAssignmentLinter<'a>

The homogenous assignment lint detects and warns on mixed use of assignment operators.

For example, the following program uses both the equality and assign-define operators to assign variables:

a = 1
b := 1

This can be misleading or confusing, as these two operators are syntactically different (and semantically different in canonical mathematics notation), but are treated the same in slide.

For this reason, it is suggested that exclusively = or := are used for assignments in slide programs.

const CODE: &'static str

Diagnostic code.

const EXPLANATION: &'static str

Detailed diagnostic explanation.

impl<'a> LintRule<'a, StmtList> for HomogenousAssignmentLinter<'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 HomogenousAssignmentLinter<'a>

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

Visits an assignment operator.

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_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.

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.