lib_ruby_parser/
parse_value.rs

1use alloc_from_pool::PoolValue;
2
3use crate::builder::{ArgsType, PKwLabel};
4use crate::context::Context;
5use crate::str_term::StrTerm;
6use crate::Node;
7use crate::Token;
8
9impl From<ParseValue> for Node {
10    fn from(value: ParseValue) -> Node {
11        match value {
12            ParseValue::Node(value) => *value,
13            other => unreachable!("expected Node, got {:?}", other),
14        }
15    }
16}
17
18#[allow(non_snake_case)]
19pub(crate) mod BoxedNode {
20    use super::{Node, ParseValue};
21
22    pub(crate) fn from(value: ParseValue) -> Box<Node> {
23        match value {
24            ParseValue::Node(value) => value,
25            other => unreachable!("expected BoxedNode, got {:?}", other),
26        }
27    }
28}
29
30impl Token {
31    pub(crate) fn from(value: ParseValue) -> PoolValue<Token> {
32        match value {
33            ParseValue::Token(value) => value,
34            other => unreachable!("expected Token, got {:?}", other),
35        }
36    }
37}
38
39#[derive(Debug, Clone)]
40pub(crate) struct TokenWithContext {
41    pub(crate) token: PoolValue<Token>,
42    pub(crate) ctx: Context,
43}
44
45impl TokenWithContext {
46    pub(crate) fn from(value: ParseValue) -> Self {
47        match value {
48            ParseValue::TokenWithContext(value) => *value,
49            other => unreachable!("expected TokenWithContext, got {:?}", other),
50        }
51    }
52}
53
54impl Context {
55    pub(crate) fn from(value: ParseValue) -> Self {
56        match value {
57            ParseValue::Context(ctx) => ctx,
58            other => unreachable!("expected Context, got {:?}", other),
59        }
60    }
61}
62
63#[allow(non_snake_case)]
64pub(crate) mod NodeList {
65    use super::{Node, ParseValue};
66
67    pub(crate) fn from(value: ParseValue) -> Vec<Node> {
68        match value {
69            ParseValue::NodeList(value) => *value,
70            other => unreachable!("expected NodeList, got {:?}", other),
71        }
72    }
73}
74
75#[allow(non_snake_case)]
76#[allow(clippy::box_collection)]
77pub(crate) mod BoxedNodeList {
78    use super::{Node, ParseValue};
79
80    pub(crate) fn from(value: ParseValue) -> Box<Vec<Node>> {
81        match value {
82            ParseValue::NodeList(value) => value,
83            other => unreachable!("expected NodeList, got {:?}", other),
84        }
85    }
86}
87
88#[allow(non_snake_case)]
89pub(crate) mod Bool {
90    use super::ParseValue;
91
92    pub(crate) fn from(value: ParseValue) -> bool {
93        match value {
94            ParseValue::Bool(value) => value,
95            other => unreachable!("expected Bool, got {:?}", other),
96        }
97    }
98}
99
100#[allow(non_snake_case)]
101pub(crate) mod MaybeStrTerm {
102    use super::{ParseValue, StrTerm};
103
104    pub(crate) fn from(value: ParseValue) -> Option<Box<StrTerm>> {
105        match value {
106            ParseValue::MaybeStrTerm(value) => value,
107            other => unreachable!("expected MaybeStrTerm, got {:?}", other),
108        }
109    }
110}
111
112#[allow(non_snake_case)]
113pub(crate) mod Num {
114    use super::ParseValue;
115
116    pub(crate) fn from(value: ParseValue) -> i32 {
117        match value {
118            ParseValue::Num(value) => value,
119            other => unreachable!("expected Num, got {:?}", other),
120        }
121    }
122}
123
124#[derive(Debug, Clone)]
125pub(crate) struct Superclass {
126    pub(crate) lt_t: Option<PoolValue<Token>>,
127    pub(crate) value: Option<Box<Node>>,
128}
129impl Superclass {
130    pub(crate) fn from(value: ParseValue) -> Superclass {
131        match value {
132            ParseValue::Superclass(value) => *value,
133            other => unreachable!("expected Superclass, got {:?}", other),
134        }
135    }
136}
137
138#[derive(Debug, Clone)]
139pub(crate) struct Ensure {
140    pub(crate) ensure_t: PoolValue<Token>,
141    pub(crate) body: Option<Box<Node>>,
142}
143#[allow(non_snake_case)]
144pub(crate) mod OptEnsure {
145    use super::{Ensure, ParseValue};
146
147    pub(crate) fn from(value: ParseValue) -> Option<Ensure> {
148        match value {
149            ParseValue::OptEnsure(value) => value.map(|v| *v),
150            other => unreachable!("expected OptEnsure, got {:?}", other),
151        }
152    }
153}
154
155#[derive(Debug, Clone)]
156pub(crate) struct Else {
157    pub(crate) else_t: PoolValue<Token>,
158    pub(crate) body: Option<Box<Node>>,
159}
160#[allow(non_snake_case)]
161pub(crate) mod OptElse {
162    use super::{Else, ParseValue};
163
164    pub(crate) fn from(value: ParseValue) -> Option<Else> {
165        match value {
166            ParseValue::OptElse(value) => value.map(|v| *v),
167            other => unreachable!("expected OptElse, got {:?}", other),
168        }
169    }
170}
171
172#[derive(Debug, Clone)]
173pub(crate) struct ExcVar {
174    pub(crate) assoc_t: Option<PoolValue<Token>>,
175    pub(crate) exc_var: Option<Box<Node>>,
176}
177impl ExcVar {
178    pub(crate) fn from(value: ParseValue) -> ExcVar {
179        match value {
180            ParseValue::ExcVar(value) => *value,
181            other => unreachable!("expected ExcVar, got {:?}", other),
182        }
183    }
184}
185
186#[derive(Debug, Clone)]
187pub(crate) struct IfTail {
188    pub(crate) keyword_t: Option<PoolValue<Token>>,
189    pub(crate) body: Option<Box<Node>>,
190}
191impl IfTail {
192    pub(crate) fn from(value: ParseValue) -> IfTail {
193        match value {
194            ParseValue::IfTail(value) => *value,
195            other => unreachable!("expected IfTail, got {:?}", other),
196        }
197    }
198}
199
200#[derive(Debug, Clone)]
201pub(crate) struct ExprValueDo {
202    pub(crate) value: Box<Node>,
203    pub(crate) do_t: PoolValue<Token>,
204}
205impl ExprValueDo {
206    pub(crate) fn from(value: ParseValue) -> ExprValueDo {
207        match value {
208            ParseValue::ExprValueDo(value) => *value,
209            other => unreachable!("expected ExprValueDo, got {:?}", other),
210        }
211    }
212}
213
214impl PKwLabel {
215    pub(crate) fn from(value: ParseValue) -> PKwLabel {
216        match value {
217            ParseValue::PKwLabel(value) => *value,
218            other => unreachable!("expected PKwLabel, got {:?}", other),
219        }
220    }
221}
222
223#[derive(Debug, Clone)]
224pub(crate) struct BraceBody {
225    pub(crate) args_type: ArgsType,
226    pub(crate) body: Option<Box<Node>>,
227}
228impl BraceBody {
229    pub(crate) fn from(value: ParseValue) -> BraceBody {
230        match value {
231            ParseValue::BraceBody(value) => *value,
232            other => unreachable!("expected BraceBody, got {:?}", other),
233        }
234    }
235}
236
237#[derive(Debug, Clone)]
238pub(crate) struct CmdBraceBlock {
239    pub(crate) begin_t: PoolValue<Token>,
240    pub(crate) args_type: ArgsType,
241    pub(crate) body: Option<Box<Node>>,
242    pub(crate) end_t: PoolValue<Token>,
243}
244impl CmdBraceBlock {
245    pub(crate) fn from(value: ParseValue) -> CmdBraceBlock {
246        match value {
247            ParseValue::CmdBraceBlock(value) => *value,
248            other => unreachable!("expected CmdBraceBlock, got {:?}", other),
249        }
250    }
251}
252
253#[derive(Debug, Clone)]
254pub(crate) struct ParenArgs {
255    pub(crate) begin_t: PoolValue<Token>,
256    pub(crate) args: Vec<Node>,
257    pub(crate) end_t: PoolValue<Token>,
258}
259impl ParenArgs {
260    pub(crate) fn from(value: ParseValue) -> ParenArgs {
261        match value {
262            ParseValue::ParenArgs(value) => *value,
263            other => unreachable!("expected ParenArgs, got {:?}", other),
264        }
265    }
266}
267
268#[derive(Debug, Clone)]
269pub(crate) struct OptParenArgs {
270    pub(crate) begin_t: Option<PoolValue<Token>>,
271    pub(crate) args: Vec<Node>,
272    pub(crate) end_t: Option<PoolValue<Token>>,
273}
274impl OptParenArgs {
275    pub(crate) fn from(value: ParseValue) -> OptParenArgs {
276        match value {
277            ParseValue::OptParenArgs(value) => *value,
278            other => unreachable!("expected OptParenArgs, got {:?}", other),
279        }
280    }
281}
282
283#[derive(Debug, Clone)]
284pub(crate) struct BeginBlock {
285    pub(crate) begin_t: PoolValue<Token>,
286    pub(crate) body: Option<Box<Node>>,
287    pub(crate) end_t: PoolValue<Token>,
288}
289impl BeginBlock {
290    pub(crate) fn from(value: ParseValue) -> BeginBlock {
291        match value {
292            ParseValue::BeginBlock(value) => *value,
293            other => unreachable!("expected BeginBlock, got {:?}", other),
294        }
295    }
296}
297
298#[derive(Debug, Clone)]
299pub(crate) struct LambdaBody {
300    pub(crate) begin_t: PoolValue<Token>,
301    pub(crate) body: Option<Box<Node>>,
302    pub(crate) end_t: PoolValue<Token>,
303}
304impl LambdaBody {
305    pub(crate) fn from(value: ParseValue) -> LambdaBody {
306        match value {
307            ParseValue::LambdaBody(value) => *value,
308            other => unreachable!("expected LambdaBody, got {:?}", other),
309        }
310    }
311}
312
313#[derive(Debug, Clone)]
314pub(crate) struct DoBlock {
315    pub(crate) begin_t: PoolValue<Token>,
316    pub(crate) args_type: ArgsType,
317    pub(crate) body: Option<Box<Node>>,
318    pub(crate) end_t: PoolValue<Token>,
319}
320impl DoBlock {
321    pub(crate) fn from(value: ParseValue) -> DoBlock {
322        match value {
323            ParseValue::DoBlock(value) => *value,
324            other => unreachable!("expected DoBlock, got {:?}", other),
325        }
326    }
327}
328
329#[derive(Debug, Clone)]
330pub(crate) struct BraceBlock {
331    pub(crate) begin_t: PoolValue<Token>,
332    pub(crate) args_type: ArgsType,
333    pub(crate) body: Option<Box<Node>>,
334    pub(crate) end_t: PoolValue<Token>,
335}
336impl BraceBlock {
337    pub(crate) fn from(value: ParseValue) -> BraceBlock {
338        match value {
339            ParseValue::BraceBlock(value) => *value,
340            other => unreachable!("expected BraceBlock, got {:?}", other),
341        }
342    }
343}
344
345#[derive(Debug, Clone)]
346pub(crate) struct DefsHead {
347    pub(crate) def_t: PoolValue<Token>,
348    pub(crate) definee: Box<Node>,
349    pub(crate) dot_t: PoolValue<Token>,
350    pub(crate) name_t: TokenWithContext,
351}
352impl DefsHead {
353    pub(crate) fn from(value: ParseValue) -> DefsHead {
354        match value {
355            ParseValue::DefsHead(value) => *value,
356            other => unreachable!("expected DefsHead, got {:?}", other),
357        }
358    }
359}
360
361#[derive(Debug, Clone)]
362pub(crate) struct DefnHead {
363    pub(crate) def_t: PoolValue<Token>,
364    pub(crate) name_t: TokenWithContext,
365}
366impl DefnHead {
367    pub(crate) fn from(value: ParseValue) -> DefnHead {
368        match value {
369            ParseValue::DefnHead(value) => *value,
370            other => unreachable!("expected DefnHead, got {:?}", other),
371        }
372    }
373}
374
375#[derive(Debug, Clone)]
376pub(crate) struct Cases {
377    pub(crate) when_bodies: Vec<Node>,
378    pub(crate) opt_else: Option<Else>,
379}
380impl Cases {
381    pub(crate) fn from(value: ParseValue) -> Cases {
382        match value {
383            ParseValue::Cases(value) => *value,
384            other => unreachable!("expected Cases, got {:?}", other),
385        }
386    }
387}
388
389#[derive(Debug, Clone)]
390pub(crate) struct CaseBody {
391    pub(crate) when_bodies: Vec<Node>,
392    pub(crate) opt_else: Option<Else>,
393}
394impl CaseBody {
395    pub(crate) fn from(value: ParseValue) -> CaseBody {
396        match value {
397            ParseValue::CaseBody(value) => *value,
398            other => unreachable!("expected CaseBody, got {:?}", other),
399        }
400    }
401}
402
403#[derive(Debug, Clone)]
404pub(crate) struct PCases {
405    pub(crate) in_bodies: Vec<Node>,
406    pub(crate) opt_else: Option<Else>,
407}
408impl PCases {
409    pub(crate) fn from(value: ParseValue) -> PCases {
410        match value {
411            ParseValue::PCases(value) => *value,
412            other => unreachable!("expected PCases, got {:?}", other),
413        }
414    }
415}
416
417#[derive(Debug, Clone)]
418pub(crate) struct PCaseBody {
419    pub(crate) in_bodies: Vec<Node>,
420    pub(crate) opt_else: Option<Else>,
421}
422impl PCaseBody {
423    pub(crate) fn from(value: ParseValue) -> PCaseBody {
424        match value {
425            ParseValue::PCaseBody(value) => *value,
426            other => unreachable!("expected PCaseBody, got {:?}", other),
427        }
428    }
429}
430
431#[allow(non_snake_case)]
432pub(crate) mod MaybeNode {
433    use super::{Node, ParseValue};
434
435    pub(crate) fn from(value: ParseValue) -> Option<Node> {
436        match value {
437            ParseValue::MaybeNode(maybe_node) => maybe_node.map(|node| *node),
438            other => unreachable!("expected MaybeNode, got {:?}", other),
439        }
440    }
441}
442
443#[allow(non_snake_case)]
444pub(crate) mod MaybeBoxedNode {
445    use super::{Node, ParseValue};
446
447    pub(crate) fn from(value: ParseValue) -> Option<Box<Node>> {
448        match value {
449            ParseValue::MaybeNode(value) => value,
450            other => unreachable!("expected MaybeNode, got {:?}", other),
451        }
452    }
453}
454
455#[derive(Debug, Clone)]
456pub(crate) struct DoBody {
457    pub(crate) args_type: ArgsType,
458    pub(crate) body: Option<Box<Node>>,
459}
460impl DoBody {
461    pub(crate) fn from(value: ParseValue) -> DoBody {
462        match value {
463            ParseValue::DoBody(value) => *value,
464            other => unreachable!("expected DoBody, got {:?}", other),
465        }
466    }
467}
468
469#[derive(Debug, Clone)]
470pub(crate) struct PTopExpr {
471    pub(crate) pattern: Box<Node>,
472    pub(crate) guard: Option<Box<Node>>,
473}
474impl PTopExpr {
475    pub(crate) fn from(value: ParseValue) -> PTopExpr {
476        match value {
477            ParseValue::PTopExpr(value) => *value,
478            other => unreachable!("expected PTopExpr, got {:?}", other),
479        }
480    }
481}
482
483#[derive(Debug, Clone)]
484pub(crate) struct MatchPatternWithTrailingComma {
485    pub(crate) elements: Vec<Node>,
486    pub(crate) trailing_comma: Option<PoolValue<Token>>,
487}
488impl MatchPatternWithTrailingComma {
489    pub(crate) fn from(value: ParseValue) -> Self {
490        match value {
491            ParseValue::MatchPatternWithTrailingComma(value) => *value,
492            other => unreachable!("expected MatchPatternWithTrailingComma, got {:?}", other),
493        }
494    }
495}
496
497#[derive(Debug, Clone)]
498pub(crate) struct NoKwRest {
499    pub(crate) kwrest_mark: PoolValue<Token>,
500    pub(crate) k_nil: PoolValue<Token>,
501}
502impl NoKwRest {
503    pub(crate) fn from(value: ParseValue) -> Self {
504        match value {
505            ParseValue::NoKwRest(value) => *value,
506            other => unreachable!("expected NoKwRest, got {:?}", other),
507        }
508    }
509}
510
511#[allow(clippy::box_collection)]
512#[derive(Clone, Debug)]
513pub(crate) enum ParseValue {
514    Stolen,
515    Uninitialized,
516    None,
517    Token(PoolValue<Token>),
518    TokenWithContext(Box<TokenWithContext>),
519    Context(Context),
520    Node(Box<Node>),
521    NodeList(Box<Vec<Node>>),
522    Bool(bool),
523    MaybeStrTerm(Option<Box<StrTerm>>),
524    Num(i32),
525
526    /* For custom superclass rule */
527    Superclass(Box<Superclass>),
528
529    /* For custom opt_ensure rule */
530    OptEnsure(Option<Box<Ensure>>),
531
532    /* For custom opt_else rule */
533    OptElse(Option<Box<Else>>),
534
535    /* For custom exc_var rule */
536    ExcVar(Box<ExcVar>),
537
538    /* For custom if_tail rule */
539    IfTail(Box<IfTail>),
540
541    /* For custom expr_value_do rule */
542    ExprValueDo(Box<ExprValueDo>),
543
544    /* For custom p_kw_label rule */
545    PKwLabel(Box<PKwLabel>),
546
547    /* For custom brace_body rule */
548    BraceBody(Box<BraceBody>),
549
550    /* For custom cmd_brace_block rule */
551    CmdBraceBlock(Box<CmdBraceBlock>),
552
553    /* For custom paren_args rule  */
554    ParenArgs(Box<ParenArgs>),
555
556    /* For custom opt_paren_args rule  */
557    OptParenArgs(Box<OptParenArgs>),
558
559    /* For custom lambda_body rule  */
560    LambdaBody(Box<LambdaBody>),
561
562    /* For custom do_block rule  */
563    DoBlock(Box<DoBlock>),
564
565    /* For custom brace_block rule  */
566    BraceBlock(Box<BraceBlock>),
567
568    /* For custom defs_head rule */
569    DefsHead(Box<DefsHead>),
570
571    /* For custom defn_head rule */
572    DefnHead(Box<DefnHead>),
573
574    /* For custom begin_block rule  */
575    BeginBlock(Box<BeginBlock>),
576
577    /* For custom cases rule */
578    Cases(Box<Cases>),
579
580    /* For custom case_body rule */
581    CaseBody(Box<CaseBody>),
582
583    /* For custom p_cases rule */
584    PCases(Box<PCases>),
585
586    /* For custom p_case_body rule */
587    PCaseBody(Box<PCaseBody>),
588
589    /* For custom compstmt rule */
590    MaybeNode(Option<Box<Node>>),
591
592    /* For custom do_body rule */
593    DoBody(Box<DoBody>),
594
595    /* For custom p_top_expr rule */
596    PTopExpr(Box<PTopExpr>),
597
598    /* For pattern matching patterns with trailing comma */
599    MatchPatternWithTrailingComma(Box<MatchPatternWithTrailingComma>),
600
601    /* For p_kwnorest and f_no_kwarg rules */
602    NoKwRest(Box<NoKwRest>),
603}
604
605impl ParseValue {
606    // rust-bison-skeleton contract
607    pub(crate) fn from_token(token: PoolValue<Token>) -> Self {
608        Self::Token(token)
609    }
610    pub(crate) fn new_uninitialized() -> Self {
611        Self::Uninitialized
612    }
613    pub(crate) fn is_uninitialized(&self) -> bool {
614        matches!(self, Self::Uninitialized)
615    }
616
617    pub(crate) fn new_superclass(value: Superclass) -> Self {
618        Self::Superclass(Box::new(value))
619    }
620    pub(crate) fn new_opt_ensure(value: Option<Ensure>) -> Self {
621        Self::OptEnsure(value.map(Box::new))
622    }
623    pub(crate) fn new_opt_else(value: Option<Else>) -> Self {
624        Self::OptElse(value.map(Box::new))
625    }
626    pub(crate) fn new_exc_var(value: ExcVar) -> Self {
627        Self::ExcVar(Box::new(value))
628    }
629    pub(crate) fn new_if_tail(value: IfTail) -> Self {
630        Self::IfTail(Box::new(value))
631    }
632    pub(crate) fn new_expr_value_do(value: ExprValueDo) -> Self {
633        Self::ExprValueDo(Box::new(value))
634    }
635    pub(crate) fn new_p_kw_label(value: PKwLabel) -> Self {
636        Self::PKwLabel(Box::new(value))
637    }
638    pub(crate) fn new_brace_body(value: BraceBody) -> Self {
639        Self::BraceBody(Box::new(value))
640    }
641    pub(crate) fn new_cmd_brace_block(value: CmdBraceBlock) -> Self {
642        Self::CmdBraceBlock(Box::new(value))
643    }
644    pub(crate) fn new_paren_args(value: ParenArgs) -> Self {
645        Self::ParenArgs(Box::new(value))
646    }
647    pub(crate) fn new_opt_paren_args(value: OptParenArgs) -> Self {
648        Self::OptParenArgs(Box::new(value))
649    }
650    pub(crate) fn new_lambda_body(value: LambdaBody) -> Self {
651        Self::LambdaBody(Box::new(value))
652    }
653    pub(crate) fn new_do_block(value: DoBlock) -> Self {
654        Self::DoBlock(Box::new(value))
655    }
656    pub(crate) fn new_brace_block(value: BraceBlock) -> Self {
657        Self::BraceBlock(Box::new(value))
658    }
659    pub(crate) fn new_defs_head(value: DefsHead) -> Self {
660        Self::DefsHead(Box::new(value))
661    }
662    pub(crate) fn new_defn_head(value: DefnHead) -> Self {
663        Self::DefnHead(Box::new(value))
664    }
665    pub(crate) fn new_begin_block(value: BeginBlock) -> Self {
666        Self::BeginBlock(Box::new(value))
667    }
668    pub(crate) fn new_cases(value: Cases) -> Self {
669        Self::Cases(Box::new(value))
670    }
671    pub(crate) fn new_case_body(value: CaseBody) -> Self {
672        Self::CaseBody(Box::new(value))
673    }
674    pub(crate) fn new_p_cases(value: PCases) -> Self {
675        Self::PCases(Box::new(value))
676    }
677    pub(crate) fn new_p_case_body(value: PCaseBody) -> Self {
678        Self::PCaseBody(Box::new(value))
679    }
680    pub(crate) fn new_do_body(value: DoBody) -> Self {
681        Self::DoBody(Box::new(value))
682    }
683    pub(crate) fn new_p_top_expr(value: PTopExpr) -> Self {
684        Self::PTopExpr(Box::new(value))
685    }
686    pub(crate) fn new_match_pattern_with_trailing_comma(
687        value: MatchPatternWithTrailingComma,
688    ) -> Self {
689        Self::MatchPatternWithTrailingComma(Box::new(value))
690    }
691    pub(crate) fn new_no_kw_rest(value: NoKwRest) -> Self {
692        Self::NoKwRest(Box::new(value))
693    }
694}
695
696impl Default for ParseValue {
697    fn default() -> Self {
698        Self::Stolen
699    }
700}
lib_ruby_parser/parse_value.rs

lib_ruby_parser/
parse_value.rs
