semantic-analyzer 0.4.6

Semantic analyzer library for compilers written in Rust for semantic analysis of programming languages AST
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

use crate::utils::SemanticTest;
use semantic_analyzer::ast::{self, CodeLocation, GetLocation, Ident};
use semantic_analyzer::types::error::StateErrorKind;
use semantic_analyzer::types::semantic::SemanticStackContext;

mod utils;

#[test]
fn function_transform_ast() {
    let fn_name = ast::FunctionName::new(Ident::new("fn1"));
    assert_eq!(fn_name.location(), CodeLocation::new(1, 0));
    assert_eq!(fn_name.to_string(), "fn1");
}

#[test]
fn function_declaration_without_body() {
    let mut t = SemanticTest::new();
    let fn_name = ast::FunctionName::new(Ident::new("fn1"));
    let fn_statement = ast::FunctionStatement::new(
        fn_name.clone(),
        vec![],
        ast::Type::Primitive(ast::PrimitiveTypes::I8),
        vec![],
    );
    t.state.function_declaration(&fn_statement);
    assert!(t.is_empty_error());
    assert!(t.state.global.functions.contains_key(&fn_name.into()));
    let state = t.state.global.context.clone().get();
    assert_eq!(state.len(), 1);
    assert_eq!(
        state[0],
        SemanticStackContext::FunctionDeclaration {
            fn_decl: fn_statement.clone().into()
        }
    );

    t.state.function_declaration(&fn_statement);
    assert!(t.check_errors_len(1), "Errors: {:?}", t.state.errors.len());
    assert!(
        t.check_error(StateErrorKind::FunctionAlreadyExist),
        "Errors: {:?}",
        t.state.errors[0]
    );
}

#[test]
fn function_declaration_wrong_type() {
    let mut t = SemanticTest::new();
    let fn_name = ast::FunctionName::new(Ident::new("fn2"));

    let type_decl = ast::StructTypes {
        name: Ident::new("type1"),
        attributes: vec![],
    };

    let fn_statement = ast::FunctionStatement::new(
        fn_name.clone(),
        vec![ast::FunctionParameter {
            name: ast::ParameterName::new(Ident::new("x")),
            parameter_type: ast::Type::Primitive(ast::PrimitiveTypes::I64),
        }],
        ast::Type::Struct(type_decl.clone()),
        vec![],
    );
    t.state.function_declaration(&fn_statement);
    assert!(t.check_errors_len(1), "Errors: {:?}", t.state.errors.len());
    assert!(
        t.check_error(StateErrorKind::TypeNotFound),
        "Errors: {:?}",
        t.state.errors[0]
    );

    assert!(!t
        .state
        .global
        .functions
        .contains_key(&fn_name.clone().into()));
    let state = t.state.global.context.clone().get();
    assert_eq!(state.len(), 0);

    let fn_statement2 = ast::FunctionStatement::new(
        fn_statement.name,
        vec![ast::FunctionParameter {
            name: ast::ParameterName::new(Ident::new("x")),
            parameter_type: ast::Type::Struct(type_decl.clone()),
        }],
        ast::Type::Primitive(ast::PrimitiveTypes::I64),
        fn_statement.body,
    );
    t.state.function_declaration(&fn_statement2);
    assert!(t.check_errors_len(2), "Errors: {:?}", t.state.errors.len());
    assert!(t.check_error_index(1, StateErrorKind::TypeNotFound));
    t.clean_errors();

    t.state.types(&type_decl);
    assert!(t.is_empty_error());
    t.state.function_declaration(&fn_statement2);
    assert!(t.is_empty_error());
    assert!(t.state.global.functions.contains_key(&fn_name.into()));
    let state = t.state.global.context.clone().get();
    assert_eq!(state.len(), 2);
    assert_eq!(
        state[1],
        SemanticStackContext::FunctionDeclaration {
            fn_decl: fn_statement2.into()
        }
    );
}