oak_ruby/parser/
element_type.rs

1use oak_core::{ElementType, UniversalElementRole};
2use std::fmt;
3
4/// Element types for Ruby.
5#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
6#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
7#[repr(u8)]
8pub enum RubyElementType {
9    /// An identifier.
10    Identifier,
11    /// A global variable (e.g., `$stdout`).
12    GlobalVariable,
13    /// An instance variable (e.g., `@name`).
14    InstanceVariable,
15    /// A class variable (e.g., `@@name`).
16    ClassVariable,
17    /// A constant (e.g., `MATH`).
18    Constant,
19    /// An integer literal.
20    IntegerLiteral,
21    /// A float literal.
22    FloatLiteral,
23    /// A string literal.
24    StringLiteral,
25    /// A general literal.
26    Literal,
27    /// A symbol (e.g., `:name`).
28    Symbol,
29    /// A regular expression literal.
30    RegexLiteral,
31
32    /// The `if` keyword.
33    If,
34    /// The `unless` keyword.
35    Unless,
36    /// The `elsif` keyword.
37    Elsif,
38    /// The `else` keyword.
39    Else,
40    /// The `case` keyword.
41    Case,
42    /// The `when` keyword.
43    When,
44    /// The `then` keyword.
45    Then,
46    /// The `for` keyword.
47    For,
48    /// The `while` keyword.
49    While,
50    /// The `until` keyword.
51    Until,
52    /// The `break` keyword.
53    Break,
54    /// The `next` keyword.
55    Next,
56    /// The `redo` keyword.
57    Redo,
58    /// The `retry` keyword.
59    Retry,
60    /// The `return` keyword.
61    Return,
62    /// The `yield` keyword.
63    Yield,
64    /// The `def` keyword.
65    Def,
66    /// The `class` keyword.
67    Class,
68    /// The `module` keyword.
69    Module,
70    /// The `end` keyword.
71    End,
72    /// The `lambda` keyword.
73    Lambda,
74    /// The `proc` keyword.
75    Proc,
76    /// The `begin` keyword.
77    Begin,
78    /// The `rescue` keyword.
79    Rescue,
80    /// The `ensure` keyword.
81    Ensure,
82    /// The `raise` keyword.
83    Raise,
84    /// The `require` keyword.
85    Require,
86    /// The `load` keyword.
87    Load,
88    /// The `include` keyword.
89    Include,
90    /// The `extend` keyword.
91    Extend,
92    /// The `prepend` keyword.
93    Prepend,
94    /// The `and` keyword.
95    And,
96    /// The `or` keyword.
97    Or,
98    /// The `not` keyword.
99    Not,
100    /// The `in` keyword.
101    In,
102    /// The `true` keyword.
103    True,
104    /// The `false` keyword.
105    False,
106    /// The `nil` keyword.
107    Nil,
108    /// The `super` keyword.
109    Super,
110    /// The `self` keyword.
111    Self_,
112    /// The `alias` keyword.
113    Alias,
114    /// The `undef` keyword.
115    Undef,
116    /// The `defined?` keyword.
117    Defined,
118    /// The `do` keyword.
119    Do,
120
121    /// Plus operator `+`.
122    Plus,
123    /// Minus operator `-`.
124    Minus,
125    /// Multiply operator `*`.
126    Multiply,
127    /// Divide operator `/`.
128    Divide,
129    /// Modulo operator `%`.
130    Modulo,
131    /// Power operator `**`.
132    Power,
133    /// Equality operator `==`.
134    EqualEqual,
135    /// Inequality operator `!=`.
136    NotEqual,
137    /// Less than operator `<`.
138    Less,
139    /// Greater than operator `>`.
140    Greater,
141    /// Less than or equal operator `<=`.
142    LessEqual,
143    /// Greater than or equal operator `>=`.
144    GreaterEqual,
145    /// Case equality operator `===`.
146    EqualEqualEqual,
147    /// Spaceship operator `<=>`.
148    Spaceship,
149    /// Assignment operator `=`.
150    Assign,
151    /// Plus assignment operator `+=`.
152    PlusAssign,
153    /// Minus assignment operator `-=`.
154    MinusAssign,
155    /// Multiply assignment operator `*=`.
156    MultiplyAssign,
157    /// Divide assignment operator `/=`.
158    DivideAssign,
159    /// Modulo assignment operator `%=`.
160    ModuloAssign,
161    /// Power assignment operator `**=`.
162    PowerAssign,
163    /// Bitwise AND operator `&`.
164    BitAnd,
165    /// Bitwise OR operator `|`.
166    BitOr,
167    /// Bitwise XOR operator `^`.
168    Xor,
169    /// Logical NOT operator `!`.
170    LogicalNot,
171    /// Bitwise NOT operator `~`.
172    Tilde,
173    /// Left shift operator `<<`.
174    LeftShift,
175    /// Right shift operator `>>`.
176    RightShift,
177    /// AND assignment operator `&=`.
178    AndAssign,
179    /// OR assignment operator `|=`.
180    OrAssign,
181    /// XOR assignment operator `^=`.
182    XorAssign,
183    /// Left shift assignment operator `<<=`.
184    LeftShiftAssign,
185    /// Right shift assignment operator `>>=`.
186    RightShiftAssign,
187    /// Logical AND operator `&&`.
188    AndAnd,
189    /// Logical OR operator `||`.
190    OrOr,
191    /// OR OR assignment operator `||=`.
192    OrOrAssign,
193    /// AND AND assignment operator `&&=`.
194    AndAndAssign,
195    /// Question mark `?`.
196    Question,
197    /// Range operator `..`.
198    DotDot,
199    /// Range operator `...`.
200    DotDotDot,
201    /// Match operator `=~`.
202    Match,
203    /// Not match operator `!~`.
204    NotMatch,
205
206    /// Left parenthesis `(`.
207    LeftParen,
208    /// Right parenthesis `)`.
209    RightParen,
210    /// Left bracket `[`.
211    LeftBracket,
212    /// Right bracket `]`.
213    RightBracket,
214    /// Left brace `{`.
215    LeftBrace,
216    /// Right brace `}`.
217    RightBrace,
218    /// Comma `,`.
219    Comma,
220    /// Colon `:`.
221    Colon,
222    /// Semicolon `;`.
223    Semicolon,
224    /// Dot `.`.
225    Dot,
226    /// Double colon `::`.
227    DoubleColon,
228    /// At symbol `@`.
229    At,
230    /// Dollar sign `$`.
231    Dollar,
232
233    /// Whitespace.
234    Whitespace,
235    /// Newline.
236    Newline,
237    /// Comment.
238    Comment,
239    /// End of file.
240    Eof,
241    /// Invalid token.
242    Invalid,
243    /// Root element.
244    Root,
245    /// A binary expression.
246    BinaryExpression,
247    /// A unary expression.
248    UnaryExpression,
249    /// A literal expression.
250    LiteralExpression,
251    /// A parenthesized expression.
252    ParenExpression,
253    /// A parenthesized expression (alternative).
254    ParenthesizedExpression,
255    /// A method definition.
256    MethodDefinition,
257    /// A class definition.
258    ClassDefinition,
259    /// A module definition.
260    ModuleDefinition,
261    /// An if statement.
262    IfStatement,
263    /// A while statement.
264    WhileStatement,
265    /// An unless statement.
266    UnlessStatement,
267    /// An until statement.
268    UntilStatement,
269    /// A for statement.
270    ForStatement,
271    /// A case statement.
272    CaseStatement,
273    /// A when clause.
274    WhenClause,
275    /// A begin statement.
276    BeginStatement,
277    /// A rescue clause.
278    RescueClause,
279    /// An ensure clause.
280    EnsureClause,
281    /// A return statement.
282    ReturnStatement,
283    /// An if expression.
284    IfExpression,
285    /// A call expression.
286    CallExpression,
287    /// A member access expression.
288    MemberAccess,
289    /// A parameter list.
290    ParameterList,
291    /// An argument list.
292    ArgumentList,
293    /// An error element.
294    Error,
295    /// Equal operator `=`.
296    Equal,
297}
298
299impl RubyElementType {
300    /// Returns true if the element is ignored (whitespace, newline, or comment).
301    pub fn is_ignored(&self) -> bool {
302        matches!(self, Self::Whitespace | Self::Newline | Self::Comment)
303    }
304
305    /// Returns true if the element is a keyword.
306    pub fn is_keyword(&self) -> bool {
307        matches!(
308            self,
309            Self::If
310                | Self::Unless
311                | Self::Elsif
312                | Self::Else
313                | Self::Case
314                | Self::When
315                | Self::Then
316                | Self::For
317                | Self::While
318                | Self::Until
319                | Self::Break
320                | Self::Next
321                | Self::Redo
322                | Self::Retry
323                | Self::Return
324                | Self::Yield
325                | Self::Def
326                | Self::Class
327                | Self::Module
328                | Self::End
329                | Self::Lambda
330                | Self::Proc
331                | Self::Begin
332                | Self::Rescue
333                | Self::Ensure
334                | Self::Raise
335                | Self::Require
336                | Self::Load
337                | Self::Include
338                | Self::Extend
339                | Self::Prepend
340                | Self::And
341                | Self::Or
342                | Self::Not
343                | Self::In
344                | Self::True
345                | Self::False
346                | Self::Nil
347                | Self::Super
348                | Self::Self_
349                | Self::Alias
350                | Self::Undef
351                | Self::Defined
352                | Self::Do
353        )
354    }
355}
356
357impl fmt::Display for RubyElementType {
358    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
359        let name = match self {
360            Self::Identifier => "Identifier",
361            Self::GlobalVariable => "GlobalVariable",
362            Self::InstanceVariable => "InstanceVariable",
363            Self::ClassVariable => "ClassVariable",
364            Self::Constant => "Constant",
365            Self::IntegerLiteral => "IntegerLiteral",
366            Self::FloatLiteral => "FloatLiteral",
367            Self::StringLiteral => "StringLiteral",
368            Self::Literal => "Literal",
369            Self::Symbol => "Symbol",
370            Self::RegexLiteral => "RegexLiteral",
371
372            Self::If => "If",
373            Self::Unless => "Unless",
374            Self::Elsif => "Elsif",
375            Self::Else => "Else",
376            Self::Case => "Case",
377            Self::When => "When",
378            Self::Then => "Then",
379            Self::For => "For",
380            Self::While => "While",
381            Self::Until => "Until",
382            Self::Break => "Break",
383            Self::Next => "Next",
384            Self::Redo => "Redo",
385            Self::Retry => "Retry",
386            Self::Return => "Return",
387            Self::Yield => "Yield",
388            Self::Def => "Def",
389            Self::Class => "Class",
390            Self::Module => "Module",
391            Self::End => "End",
392            Self::Lambda => "Lambda",
393            Self::Proc => "Proc",
394            Self::Begin => "Begin",
395            Self::Rescue => "Rescue",
396            Self::Ensure => "Ensure",
397            Self::Raise => "Raise",
398            Self::Require => "Require",
399            Self::Load => "Load",
400            Self::Include => "Include",
401            Self::Extend => "Extend",
402            Self::Prepend => "Prepend",
403            Self::And => "And",
404            Self::Or => "Or",
405            Self::Not => "Not",
406            Self::In => "In",
407            Self::True => "True",
408            Self::False => "False",
409            Self::Nil => "Nil",
410            Self::Super => "Super",
411            Self::Self_ => "Self",
412            Self::Alias => "Alias",
413            Self::Undef => "Undef",
414            Self::Defined => "Defined",
415            Self::Do => "Do",
416
417            Self::Plus => "Plus",
418            Self::Minus => "Minus",
419            Self::Multiply => "Multiply",
420            Self::Divide => "Divide",
421            Self::Modulo => "Modulo",
422            Self::Power => "Power",
423            Self::EqualEqual => "EqualEqual",
424            Self::NotEqual => "NotEqual",
425            Self::Less => "Less",
426            Self::Greater => "Greater",
427            Self::LessEqual => "LessEqual",
428            Self::GreaterEqual => "GreaterEqual",
429            Self::EqualEqualEqual => "EqualEqualEqual",
430            Self::Spaceship => "Spaceship",
431            Self::Assign => "Assign",
432            Self::PlusAssign => "PlusAssign",
433            Self::MinusAssign => "MinusAssign",
434            Self::MultiplyAssign => "MultiplyAssign",
435            Self::DivideAssign => "DivideAssign",
436            Self::ModuloAssign => "ModuloAssign",
437            Self::PowerAssign => "PowerAssign",
438            Self::BitAnd => "BitAnd",
439            Self::BitOr => "BitOr",
440            Self::Xor => "Xor",
441            Self::LogicalNot => "LogicalNot",
442            Self::Tilde => "Tilde",
443            Self::LeftShift => "LeftShift",
444            Self::RightShift => "RightShift",
445            Self::AndAssign => "AndAssign",
446            Self::OrAssign => "OrAssign",
447            Self::XorAssign => "XorAssign",
448            Self::LeftShiftAssign => "LeftShiftAssign",
449            Self::RightShiftAssign => "RightShiftAssign",
450            Self::AndAnd => "AndAnd",
451            Self::OrOr => "OrOr",
452            Self::OrOrAssign => "OrOrAssign",
453            Self::AndAndAssign => "AndAndAssign",
454            Self::Question => "Question",
455            Self::DotDot => "DotDot",
456            Self::DotDotDot => "DotDotDot",
457            Self::Match => "Match",
458            Self::NotMatch => "NotMatch",
459
460            Self::LeftParen => "LeftParen",
461            Self::RightParen => "RightParen",
462            Self::LeftBracket => "LeftBracket",
463            Self::RightBracket => "RightBracket",
464            Self::LeftBrace => "LeftBrace",
465            Self::RightBrace => "RightBrace",
466            Self::Comma => "Comma",
467            Self::Colon => "Colon",
468            Self::Semicolon => "Semicolon",
469            Self::Dot => "Dot",
470            Self::DoubleColon => "DoubleColon",
471            Self::At => "At",
472            Self::Dollar => "Dollar",
473
474            Self::Whitespace => "Whitespace",
475            Self::Newline => "Newline",
476            Self::Comment => "Comment",
477            Self::Eof => "Eof",
478            Self::Invalid => "Invalid",
479            Self::Root => "Root",
480            Self::BinaryExpression => "BinaryExpression",
481            Self::UnaryExpression => "UnaryExpression",
482            Self::LiteralExpression => "LiteralExpression",
483            Self::ParenExpression => "ParenExpression",
484            Self::ParenthesizedExpression => "ParenthesizedExpression",
485            Self::MethodDefinition => "MethodDefinition",
486            Self::ClassDefinition => "ClassDefinition",
487            Self::ModuleDefinition => "ModuleDefinition",
488            Self::IfStatement => "IfStatement",
489            Self::WhileStatement => "WhileStatement",
490            Self::UnlessStatement => "UnlessStatement",
491            Self::UntilStatement => "UntilStatement",
492            Self::ForStatement => "ForStatement",
493            Self::CaseStatement => "CaseStatement",
494            Self::WhenClause => "WhenClause",
495            Self::BeginStatement => "BeginStatement",
496            Self::RescueClause => "RescueClause",
497            Self::EnsureClause => "EnsureClause",
498            Self::ReturnStatement => "ReturnStatement",
499            Self::IfExpression => "IfExpression",
500            Self::CallExpression => "CallExpression",
501            Self::MemberAccess => "MemberAccess",
502            Self::ParameterList => "ParameterList",
503            Self::ArgumentList => "ArgumentList",
504            Self::Error => "Error",
505            Self::Equal => "Equal",
506        };
507        write!(f, "{}", name)
508    }
509}
510
511impl ElementType for RubyElementType {
512    type Role = UniversalElementRole;
513
514    fn role(&self) -> Self::Role {
515        match self {
516            _ => UniversalElementRole::None,
517        }
518    }
519}
520
521impl From<crate::lexer::token_type::RubyTokenType> for RubyElementType {
522    fn from(token: crate::lexer::token_type::RubyTokenType) -> Self {
523        unsafe { std::mem::transmute(token) }
524    }
525}
oak_ruby/parser/element_type.rs

oak_ruby/parser/
element_type.rs
