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

use crate::analyzer_error::{AnalyzerError, InvalidPortDefaultValueKind};
use crate::conv::{Affiliation, Context};
use crate::ir::{self, Comptime, IrResult, VarKind};
use veryl_parser::token_range::TokenRange;
use veryl_parser::veryl_grammar_trait::*;

pub fn check_port_default_value(
    context: &mut Context,
    value: &PortDeclarationItem,
    comptime: &IrResult<(Comptime, ir::Expression)>,
    kind: VarKind,
    expr: &Expression,
) {
    let token: TokenRange = if let PortDeclarationItemGroup::PortTypeConcrete(x) =
        value.port_declaration_item_group.as_ref()
        && let Some(x) = &x.port_type_concrete.port_type_concrete_opt0
    {
        x.port_default_value.as_ref().into()
    } else {
        return;
    };

    if let Ok((comptime, _)) = comptime
        && !comptime.is_global
    {
        context.insert_error(AnalyzerError::invalid_port_default_value(
            InvalidPortDefaultValueKind::NotGlobal,
            &token,
        ));
    }
    // For now, port default value is allowed for module only.
    // https://github.com/veryl-lang/veryl/issues/1178#issuecomment-2568996379
    if context.is_affiliated(Affiliation::Function) {
        context.insert_error(AnalyzerError::invalid_port_default_value(
            InvalidPortDefaultValueKind::InFunction,
            &token,
        ));
    }
    match kind {
        VarKind::Input => (),
        VarKind::Output => {
            if !expr.is_anonymous_expression() {
                context.insert_error(AnalyzerError::invalid_port_default_value(
                    InvalidPortDefaultValueKind::NonAnonymousInOutput,
                    &token,
                ));
            }
        }
        _ => {
            context.insert_error(AnalyzerError::invalid_port_default_value(
                InvalidPortDefaultValueKind::InvalidDirection(kind.to_string()),
                &token,
            ));
        }
    }
}

pub fn check_port_direction(context: &mut Context, value: &PortDeclarationItem) {
    if let PortDeclarationItemGroup::PortTypeConcrete(x) =
        value.port_declaration_item_group.as_ref()
    {
        let x = x.port_type_concrete.as_ref();
        let direction = x.direction.as_ref();
        check_direction(context, direction);

        if let Direction::Inout(_) = direction {
            let r#type = &x.array_type;
            let is_tri = r#type
                .scalar_type
                .scalar_type_list
                .iter()
                .any(|x| matches!(x.type_modifier.as_ref(), TypeModifier::Tri(_)));

            if !is_tri {
                context.insert_error(AnalyzerError::missing_tri(&r#type.as_ref().into()));
            }
        }
    }
}

pub fn check_direction(context: &mut Context, value: &Direction) {
    match value {
        Direction::Modport(x) => {
            let valid = context.is_affiliated(Affiliation::Module)
                | context.is_affiliated(Affiliation::Function)
                | context.is_affiliated(Affiliation::ProtoModule);
            if !valid {
                context.insert_error(AnalyzerError::invalid_direction(
                    "modport",
                    &x.modport.modport_token.token.into(),
                ));
            }
        }
        Direction::Import(x) => {
            let valid = context.is_affiliated(Affiliation::Modport);
            if !valid {
                context.insert_error(AnalyzerError::invalid_direction(
                    "import",
                    &x.import.import_token.token.into(),
                ));
            }
        }
        _ => (),
    }
}