veryl-analyzer 0.20.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

use crate::analyzer_error::AnalyzerError;
use crate::conv::Context;
use crate::symbol::{SymbolId, SymbolKind};
use crate::symbol_table;
use veryl_parser::veryl_grammar_trait::*;
use veryl_parser::veryl_token::Token;

fn check_path(
    context: &mut Context,
    full_path: &mut Vec<SymbolId>,
    check_dot_separator: bool,
    separator_token: &Token,
) {
    let preceed_symbol = if let Some(symbol_id) = full_path.pop() {
        symbol_table::get(symbol_id).unwrap()
    } else {
        return;
    };
    let this_symbol = if let Some(symbol_id) = full_path.last() {
        symbol_table::get(*symbol_id).unwrap()
    } else {
        // length of `full_path` may be shorter than length of actual path
        // if the type of the preceed symbol is defined in the SV namespace.
        return;
    };
    let expect_dot_separator = if let SymbolKind::Function(_) = this_symbol.kind {
        matches!(
            preceed_symbol.kind,
            SymbolKind::Instance(_) // member function of interface
        )
    } else {
        matches!(
            this_symbol.kind,
            SymbolKind::Variable(_) // member variable of instance
            | SymbolKind::StructMember(_)
            | SymbolKind::UnionMember(_)
            | SymbolKind::Modport(_)
            | SymbolKind::ModportVariableMember(_)
            | SymbolKind::ModportFunctionMember(_)
        )
    };

    if expect_dot_separator != check_dot_separator {
        context.insert_error(AnalyzerError::wrong_seperator(
            &separator_token.to_string(),
            &separator_token.into(),
        ));
    }
}

pub fn check_separator(context: &mut Context, value: &ExpressionIdentifier) {
    if let Ok(symbol) = symbol_table::resolve(value) {
        let mut full_path: Vec<_> = symbol.full_path.into_iter().rev().collect();

        for x in &value.scoped_identifier.scoped_identifier_list {
            check_path(
                context,
                &mut full_path,
                false,
                &x.colon_colon.colon_colon_token.token,
            );
        }

        for x in &value.expression_identifier_list0 {
            check_path(context, &mut full_path, true, &x.dot.dot_token.token);
        }
    }
}