vhdl_lang 0.41.0

VHDL Language Frontend
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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this file,
// You can obtain one at http://mozilla.org/MPL/2.0/.
//
// Copyright (c) 2019, Olof Kraigher olof.kraigher@gmail.com

mod assignment_typecheck;
mod association_formal;
mod circular_dependencies;
mod context_clause;
mod deferred_constant;
mod homographs;
mod implicit;
mod incomplete_type;
mod incremental_analysis;
mod package_instance;
mod protected_type;
mod resolves_design_units;
mod resolves_names;
mod resolves_type_mark;
mod sensitivity_list;
mod subprogram_arguments;
mod typecheck_expression;
mod util;
mod visibility;

use std::cell::RefCell;

pub use self::util::*;
use crate::ast::UnitId;
pub use crate::data::Diagnostic;
use crate::data::DiagnosticHandler;
pub use crate::syntax::test::*;

use super::analyze::AnalyzeContext;
use super::named_entity::*;
use super::region::*;
use super::DesignRoot;
use super::EntRef;

pub(super) struct TestSetup<'a> {
    builder: RefCell<LibraryBuilder>,
    root: DesignRoot,
    arena: Arena,
    pub scope: Scope<'a>,
}

impl<'a> TestSetup<'a> {
    pub fn new() -> Self {
        let builder = LibraryBuilder::new();
        let (mut root, _) = builder.get_analyzed_root();
        root.ensure_library(root.symbol_utf8("libname"));
        let arena = Arena::new(ArenaId::default());

        Self {
            arena,
            root,
            builder: RefCell::new(builder),
            scope: Scope::new(Region::default()),
        }
    }

    pub fn ctx(&'a self) -> AnalyzeContext<'a> {
        let ctx = AnalyzeContext::new(
            &self.root,
            &UnitId::package(
                &self.root.symbol_utf8("libname"),
                &self.root.symbol_utf8("dummy"),
            ),
            &self.arena,
        );
        ctx.add_implicit_context_clause(&self.scope).unwrap();
        ctx
    }

    pub fn snippet(&self, code: &str) -> Code {
        self.builder.borrow_mut().snippet(code)
    }

    pub fn declarative_part(&'a self, code: &str) -> Code {
        let code = self.snippet(code);
        self.ctx()
            .analyze_declarative_part(
                &self.scope,
                code.declarative_part().as_mut(),
                &mut NoDiagnostics,
            )
            .unwrap();
        code
    }

    pub fn lookup(&'a self, sym: &str) -> EntRef<'a> {
        // We cheat and create a source pos as the lookup method requires it
        let designator = self.snippet(sym).designator();

        self.scope
            .lookup(&designator.pos, &designator.item)
            .unwrap()
            .into_non_overloaded()
            .unwrap()
    }

    pub fn lookup_overloaded(&'a self, code: Code) -> OverloadedEnt<'a> {
        let des = code.designator();

        if let NamedEntities::Overloaded(overloaded) =
            self.scope.lookup(&des.pos, &des.item).unwrap()
        {
            overloaded
                .entities()
                .find(|ent| ent.decl_pos() == Some(&code.pos()))
                .unwrap()
        } else {
            panic!("Expected overloaded name");
        }
    }

    pub fn lookup_type(&'a self, sym: &str) -> TypeEnt<'a> {
        TypeEnt::from_any(self.lookup(sym)).unwrap()
    }
}

pub struct NoDiagnostics;

impl DiagnosticHandler for NoDiagnostics {
    fn push(&mut self, diagnostic: crate::Diagnostic) {
        panic!("{}", diagnostic.show())
    }
}