oak-ada 0.0.11

High-performance incremental Ada parser for the oak ecosystem with flexible configuration, emphasizing safety and reliability.
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
130
131
132
133
134
135
136

#![doc = include_str!("readme.md")]
/// Root node of the Ada syntax tree.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct AdaRoot {
    /// Items in this Ada file.
    pub items: Vec<AdaItem>,
}

impl AdaRoot {
    /// Creates a new Ada root node.
    pub fn new(items: Vec<AdaItem>) -> Self {
        Self { items }
    }

    /// Returns all top-level items in this Ada file.
    pub fn items(&self) -> &[AdaItem] {
        &self.items
    }
}

/// Item in an Ada file (package, procedure, function, etc.).
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum AdaItem {
    /// Package declaration.
    Package(AdaPackage),
    /// Procedure declaration.
    Procedure(AdaProcedure),
    /// Function declaration.
    Function(AdaFunction),
    /// Type declaration.
    Type(AdaTypeDeclaration),
    /// Variable declaration.
    Variable(AdaVariableDeclaration),
}

/// Ada package declaration.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct AdaPackage {
    /// Package name.
    pub name: String,
}

impl AdaPackage {
    /// Creates a new package declaration.
    pub fn new(name: String) -> Self {
        Self { name }
    }
}

/// Ada procedure declaration.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct AdaProcedure {
    /// Procedure name.
    pub name: String,
    /// Parameter list.
    pub parameters: Vec<AdaParameter>,
}

impl AdaProcedure {
    /// Creates a new procedure declaration.
    pub fn new(name: String, parameters: Vec<AdaParameter>) -> Self {
        Self { name, parameters }
    }
}

/// Ada function declaration.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct AdaFunction {
    /// Function name.
    pub name: String,
    /// Parameter list.
    pub parameters: Vec<AdaParameter>,
    /// Return type.
    pub return_type: String,
}

impl AdaFunction {
    /// Creates a new function declaration.
    pub fn new(name: String, parameters: Vec<AdaParameter>, return_type: String) -> Self {
        Self { name, parameters, return_type }
    }
}

/// Ada parameter.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct AdaParameter {
    /// Parameter name.
    pub name: String,
    /// Parameter type.
    pub param_type: String,
}

impl AdaParameter {
    /// Creates a new parameter.
    pub fn new(name: String, param_type: String) -> Self {
        Self { name, param_type }
    }
}

/// Ada type declaration.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct AdaTypeDeclaration {
    /// Type name.
    pub name: String,
    /// Type definition.
    pub type_def: String,
}

impl AdaTypeDeclaration {
    /// Creates a new type declaration.
    pub fn new(name: String, type_def: String) -> Self {
        Self { name, type_def }
    }
}

/// Ada variable declaration.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct AdaVariableDeclaration {
    /// Variable name.
    pub name: String,
    /// Variable type.
    pub var_type: String,
}

impl AdaVariableDeclaration {
    /// Creates a new variable declaration.
    pub fn new(name: String, var_type: String) -> Self {
        Self { name, var_type }
    }
}

impl Default for AdaRoot {
    fn default() -> Self {
        Self::new(Vec::new())
    }
}