veryl-analyzer 0.22.0

A modern hardware description language
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

pub mod check_attribute;
pub mod check_embed_include;
pub mod check_identifier;
pub mod check_statement;
pub mod check_unsafe;
pub mod create_literal_table;
pub mod create_symbol_table;
use check_attribute::*;
use check_embed_include::*;
use check_identifier::*;
use check_statement::*;
use check_unsafe::*;
use create_literal_table::*;
use create_symbol_table::*;

use crate::analyzer_error::AnalyzerError;
use veryl_metadata::{Build, Lint};
use veryl_parser::resource_table::StrId;
use veryl_parser::veryl_walker::Handler;

pub struct Pass1Handlers {
    check_attribute: CheckAttribute,
    check_embed_include: CheckEmbedInclude,
    check_identifier: CheckIdentifier,
    check_statement: CheckStatement,
    check_unsafe: CheckUnsafe,
    create_literal_table: CreateLiteralTable,
    create_symbol_table: CreateSymbolTable,
}

impl Pass1Handlers {
    pub fn new(
        build_opt: &Build,
        lint_opt: &Lint,
        is_dependency: bool,
        project_name: StrId,
    ) -> Self {
        Self {
            check_attribute: CheckAttribute::new(lint_opt, is_dependency, project_name),
            check_embed_include: CheckEmbedInclude::new(),
            check_identifier: CheckIdentifier::new(lint_opt, is_dependency),
            check_statement: CheckStatement::new(),
            check_unsafe: CheckUnsafe::new(),
            create_literal_table: CreateLiteralTable::new(),
            create_symbol_table: CreateSymbolTable::new(build_opt, project_name),
        }
    }

    pub fn get_handlers(&mut self) -> Vec<&mut dyn Handler> {
        vec![
            &mut self.check_attribute as &mut dyn Handler,
            &mut self.check_embed_include as &mut dyn Handler,
            &mut self.check_identifier as &mut dyn Handler,
            &mut self.check_statement as &mut dyn Handler,
            &mut self.check_unsafe as &mut dyn Handler,
            &mut self.create_literal_table as &mut dyn Handler,
            &mut self.create_symbol_table as &mut dyn Handler,
        ]
    }

    pub fn get_errors(&mut self) -> Vec<AnalyzerError> {
        let mut ret = Vec::new();
        ret.append(&mut self.check_attribute.errors);
        ret.append(&mut self.check_embed_include.errors);
        ret.append(&mut self.check_identifier.errors);
        ret.append(&mut self.check_statement.errors);
        ret.append(&mut self.check_unsafe.errors);
        ret.append(&mut self.create_literal_table.errors);
        ret.append(&mut self.create_symbol_table.errors);
        ret
    }
}