slicec 0.3.3

The Slice parser and other core components for Slice compilers.
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

// Copyright (c) ZeroC, Inc.

use crate::test_helpers::*;
use slicec::diagnostics::{Diagnostic, Error};
use slicec::grammar::*;
use slicec::slice_file::Span;

#[test]
fn supports_single_inheritance() {
    // Arrange
    let slice = "
        mode = Slice1
        module Test
        class I {}

        class J : I {}
    ";

    // Act
    let ast = parse_for_ast(slice);

    // Assert
    let class_i_def = ast.find_element::<Class>("Test::I").unwrap();
    let class_j_def = ast.find_element::<Class>("Test::J").unwrap();

    assert!(class_i_def.base_class().is_none());
    assert!(class_j_def.base_class().is_some());
    assert_eq!(
        class_j_def.base_class().unwrap().module_scoped_identifier(),
        class_i_def.module_scoped_identifier(),
    );
}

#[test]
fn does_not_support_multiple_inheritance() {
    // Arrange
    let slice = "
        mode = Slice1
        module Test

        class I {}

        class J {}

        class K : I, J {}
    ";

    // Act
    let diagnostics = parse_for_diagnostics(slice);

    // Assert
    let expected = Diagnostic::new(Error::Syntax {
        message: "expected '{', but found ','".to_owned(),
    })
    .set_span(&Span::new((9, 20).into(), (9, 21).into(), "string-0"));

    check_diagnostics(diagnostics, [expected]);
}

#[test]
fn field_shadowing_is_disallowed() {
    // Arrange
    let slice = "
        mode = Slice1
        module Test

        class I {
            i: int32
        }
        class J : I {
            i: int32
        }
    ";

    // Act
    let diagnostics = parse_for_diagnostics(slice);

    // Assert
    let expected = Diagnostic::new(Error::Shadows {
        identifier: "i".to_owned(),
    })
    .add_note("'i' was previously defined here", None);

    check_diagnostics(diagnostics, [expected]);
}

#[test]
fn inherits_correct_fields() {
    // Arrange
    let slice = "
        mode = Slice1
        module Test

        class A {
            a: int32
        }
        class B : A {
            b: string
        }
        class C : B {
            c: float64
        }
    ";

    // Act
    let ast = parse_for_ast(slice);

    // Assert
    let class_a_def = ast.find_element::<Class>("Test::A").unwrap();
    let class_b_def = ast.find_element::<Class>("Test::B").unwrap();
    let class_c_def = ast.find_element::<Class>("Test::C").unwrap();

    assert_eq!(class_a_def.fields().len(), 1);
    assert_eq!(class_a_def.all_fields().len(), 1);
    assert_eq!(class_a_def.all_fields()[0].identifier(), "a");

    assert_eq!(class_b_def.fields().len(), 1);
    assert_eq!(class_b_def.all_fields().len(), 2);
    assert_eq!(class_b_def.all_fields()[0].identifier(), "a");
    assert_eq!(class_b_def.all_fields()[1].identifier(), "b");

    assert_eq!(class_c_def.fields().len(), 1);
    assert_eq!(class_c_def.all_fields().len(), 3);
    assert_eq!(class_c_def.all_fields()[0].identifier(), "a");
    assert_eq!(class_c_def.all_fields()[1].identifier(), "b");
    assert_eq!(class_c_def.all_fields()[2].identifier(), "c");
}