oak-go 0.0.11

High-performance incremental Go parser for the oak ecosystem with flexible configuration, supporting concurrent programming and cloud-native development.
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
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225

#![doc = include_str!("readme.md")]
use core::range::Range;

use std::{boxed::Box, string::String, vec::Vec};

/// Strongly typed AST root for the Go language.
#[derive(Debug, PartialEq, Clone)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct GoRoot {
    /// The package name declared in the source file.
    pub package: Option<String>,
    /// The list of import declarations.
    pub imports: Vec<Import>,
    /// The list of top-level declarations.
    pub declarations: Vec<Declaration>,
}

/// Represents an import declaration in Go source code.
#[derive(Debug, PartialEq, Clone)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct Import {
    /// The import path as a string.
    pub path: String,
    /// An optional alias for the import.
    pub alias: Option<String>,
    /// The source span of the import declaration.
    #[cfg_attr(feature = "serde", serde(with = "oak_core::serde_range"))]
    pub span: Range<usize>,
}

/// Represents a top-level declaration in Go source code.
#[derive(Debug, PartialEq, Clone)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum Declaration {
    /// A function declaration.
    Function(Function),
    /// A variable declaration.
    Variable(Variable),
    /// A type declaration.
    Type(TypeDecl),
    /// A constant declaration.
    Const(Const),
}

/// Represents a function declaration in Go source code.
#[derive(Debug, PartialEq, Clone)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct Function {
    /// The function name.
    pub name: String,
    /// The optional receiver for methods.
    pub receiver: Option<Parameter>,
    /// The list of parameters.
    pub params: Vec<Parameter>,
    /// The list of return type names.
    pub return_types: Vec<String>,
    /// The function body block.
    pub body: Block,
    /// The source span of the function declaration.
    #[cfg_attr(feature = "serde", serde(with = "oak_core::serde_range"))]
    pub span: Range<usize>,
}

/// Represents a parameter in a function declaration.
#[derive(Debug, PartialEq, Clone)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct Parameter {
    /// The parameter name.
    pub name: String,
    /// The parameter type name.
    pub param_type: String,
    /// The source span of the parameter.
    #[cfg_attr(feature = "serde", serde(with = "oak_core::serde_range"))]
    pub span: Range<usize>,
}

/// Represents a block of statements in Go source code.
#[derive(Debug, PartialEq, Clone)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct Block {
    /// The list of statements in the block.
    pub statements: Vec<Statement>,
    /// The source span of the block.
    #[cfg_attr(feature = "serde", serde(with = "oak_core::serde_range"))]
    pub span: Range<usize>,
}

/// Represents a statement in Go source code.
#[derive(Debug, PartialEq, Clone)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum Statement {
    /// An expression statement.
    Expression(Expression),
    /// An assignment statement.
    Assignment {
        /// The target variable names.
        targets: Vec<String>,
        /// The assigned values.
        values: Vec<Expression>,
        /// The source span of the assignment.
        #[cfg_attr(feature = "serde", serde(with = "oak_core::serde_range"))]
        span: Range<usize>,
    },
    /// A return statement.
    Return {
        /// The values being returned.
        values: Vec<Expression>,
        /// The source span of the return statement.
        #[cfg_attr(feature = "serde", serde(with = "oak_core::serde_range"))]
        span: Range<usize>,
    },
    /// An if statement.
    If {
        /// The condition expression.
        condition: Expression,
        /// The then block.
        then_block: Block,
        /// The optional else block.
        else_block: Option<Block>,
        /// The source span of the if statement.
        #[cfg_attr(feature = "serde", serde(with = "oak_core::serde_range"))]
        span: Range<usize>,
    },
    /// A for statement.
    For {
        /// The optional initialization statement.
        init: Option<Box<Statement>>,
        /// The optional condition expression.
        condition: Option<Expression>,
        /// The optional post iteration statement.
        post: Option<Box<Statement>>,
        /// The loop body block.
        body: Block,
        /// The source span of the for statement.
        #[cfg_attr(feature = "serde", serde(with = "oak_core::serde_range"))]
        span: Range<usize>,
    },
}

/// Represents an expression in Go source code.
#[derive(Debug, PartialEq, Clone)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum Expression {
    /// An identifier expression.
    Identifier {
        /// The identifier name.
        name: String,
        /// The source span of the identifier.
        #[cfg_attr(feature = "serde", serde(with = "oak_core::serde_range"))]
        span: Range<usize>,
    },
    /// A literal expression.
    Literal {
        /// The literal value as a string.
        value: String,
        /// The source span of the literal.
        #[cfg_attr(feature = "serde", serde(with = "oak_core::serde_range"))]
        span: Range<usize>,
    },
    /// A binary expression.
    Binary {
        /// The left operand.
        left: Box<Expression>,
        /// The operator.
        op: String,
        /// The right operand.
        right: Box<Expression>,
        /// The source span of the binary expression.
        #[cfg_attr(feature = "serde", serde(with = "oak_core::serde_range"))]
        span: Range<usize>,
    },
    /// A function call expression.
    Call {
        /// The function being called.
        func: Box<Expression>,
        /// The arguments passed to the function.
        args: Vec<Expression>,
        /// The source span of the call expression.
        #[cfg_attr(feature = "serde", serde(with = "oak_core::serde_range"))]
        span: Range<usize>,
    },
}

/// Represents a variable declaration in Go source code.
#[derive(Debug, PartialEq, Clone)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct Variable {
    /// The variable name.
    pub name: String,
    /// The optional type annotation.
    pub var_type: Option<String>,
    /// The optional initial value.
    pub value: Option<Expression>,
    /// The source span of the variable declaration.
    #[cfg_attr(feature = "serde", serde(with = "oak_core::serde_range"))]
    pub span: Range<usize>,
}

/// Represents a type declaration in Go source code.
#[derive(Debug, PartialEq, Clone)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct TypeDecl {
    /// The type name.
    pub name: String,
    /// The type definition as a string.
    pub definition: String,
    /// The source span of the type declaration.
    #[cfg_attr(feature = "serde", serde(with = "oak_core::serde_range"))]
    pub span: Range<usize>,
}

/// Represents a constant declaration in Go source code.
#[derive(Debug, PartialEq, Clone)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct Const {
    /// The constant name.
    pub name: String,
    /// The optional type annotation.
    pub const_type: Option<String>,
    /// The constant value.
    pub value: Expression,
    /// The source span of the constant declaration.
    #[cfg_attr(feature = "serde", serde(with = "oak_core::serde_range"))]
    pub span: Range<usize>,
}