oak_delphi/kind/
mod.rs

1use oak_core::{ElementType, Token, TokenType, UniversalElementRole, UniversalTokenRole};
2use serde::{Deserialize, Serialize};
3
4/// Token type for Delphi language syntax
5pub type DelphiToken = Token<DelphiSyntaxKind>;
6
7/// Syntax kinds for Delphi programming language
8#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
9pub enum DelphiSyntaxKind {
10    /// Root node of the syntax tree
11    Root,
12    // Basic tokens
13    Identifier,
14    String,
15    Number,
16    Float,
17    Whitespace,
18    Newline,
19
20    // Delphi keywords
21    Program,
22    Unit,
23    Interface,
24    Implementation,
25    Uses,
26    Type,
27    Var,
28    Const,
29    Function,
30    Procedure,
31    Begin,
32    End,
33    If,
34    Then,
35    Else,
36    While,
37    Do,
38    For,
39    To,
40    Downto,
41    Repeat,
42    Until,
43    Case,
44    Of,
45    With,
46    Try,
47    Except,
48    Finally,
49    Raise,
50    Class,
51    Object,
52    Record,
53    Array,
54    Set,
55    File,
56    Packed,
57    String_,
58    Integer,
59    Real,
60    Boolean,
61    Char,
62    Pointer,
63    Nil,
64    True_,
65    False_,
66    And_,
67    Or_,
68    Not_,
69    Div,
70    Mod,
71    In_,
72    Is_,
73    As_,
74
75    // Operators
76    Plus,
77    Minus,
78    Star,
79    Slash,
80    Equal,
81    NotEqual,
82    Less,
83    Greater,
84    LessEqual,
85    GreaterEqual,
86    Assign,
87    Dot,
88    DotDot,
89    Caret,
90    At,
91
92    // Separators
93    LeftParen,
94    RightParen,
95    LeftBracket,
96    RightBracket,
97    Semicolon,
98    Comma,
99    Colon,
100
101    // Comments
102    Comment,
103    LineComment,
104    BlockComment,
105
106    // Special
107    Error,
108    Eof,
109}
110
111impl DelphiSyntaxKind {
112    /// Returns true if this syntax kind is a Delphi keyword
113    pub fn is_keyword(&self) -> bool {
114        matches!(
115            self,
116            Self::Program
117                | Self::Unit
118                | Self::Interface
119                | Self::Implementation
120                | Self::Uses
121                | Self::Type
122                | Self::Var
123                | Self::Const
124                | Self::Function
125                | Self::Procedure
126                | Self::Begin
127                | Self::End
128                | Self::If
129                | Self::Then
130                | Self::Else
131                | Self::While
132                | Self::Do
133                | Self::For
134                | Self::To
135                | Self::Downto
136                | Self::Repeat
137                | Self::Until
138                | Self::Case
139                | Self::Of
140                | Self::With
141                | Self::Try
142                | Self::Except
143                | Self::Finally
144                | Self::Raise
145                | Self::Class
146                | Self::Object
147                | Self::Record
148                | Self::Array
149                | Self::Set
150                | Self::File
151                | Self::Packed
152                | Self::String_
153                | Self::Integer
154                | Self::Real
155                | Self::Boolean
156                | Self::Char
157                | Self::Pointer
158                | Self::Nil
159                | Self::True_
160                | Self::False_
161                | Self::And_
162                | Self::Or_
163                | Self::Not_
164                | Self::Div
165                | Self::Mod
166                | Self::In_
167                | Self::Is_
168                | Self::As_
169        )
170    }
171}
172
173impl TokenType for DelphiSyntaxKind {
174    const END_OF_STREAM: Self = Self::Eof;
175    type Role = UniversalTokenRole;
176
177    fn role(&self) -> Self::Role {
178        match self {
179            Self::Whitespace => UniversalTokenRole::Whitespace,
180            Self::Newline => UniversalTokenRole::Whitespace,
181            Self::Identifier => UniversalTokenRole::Name,
182            Self::String | Self::Number | Self::Float | Self::True_ | Self::False_ | Self::Nil => UniversalTokenRole::Literal,
183            kind if kind.is_keyword() => UniversalTokenRole::Keyword,
184            Self::Plus | Self::Minus | Self::Star | Self::Slash | Self::Equal | Self::NotEqual | Self::Less | Self::Greater | Self::LessEqual | Self::GreaterEqual | Self::Assign | Self::Dot | Self::DotDot | Self::Caret | Self::At => {
185                UniversalTokenRole::Operator
186            }
187            Self::LeftParen | Self::RightParen | Self::LeftBracket | Self::RightBracket | Self::Semicolon | Self::Comma | Self::Colon => UniversalTokenRole::Punctuation,
188            Self::Comment | Self::LineComment | Self::BlockComment => UniversalTokenRole::Comment,
189            Self::Error => UniversalTokenRole::Error,
190            Self::Eof => UniversalTokenRole::None,
191            _ => UniversalTokenRole::None,
192        }
193    }
194}
195
196impl ElementType for DelphiSyntaxKind {
197    type Role = UniversalElementRole;
198
199    fn role(&self) -> Self::Role {
200        match self {
201            Self::Root => UniversalElementRole::Root,
202            _ => UniversalElementRole::None,
203        }
204    }
205}