boseiju/lexer/tokens/intermediates/
english_keywords.rs

1#[derive(idris_derive::Idris)]
2#[derive(serde::Serialize, serde::Deserialize)]
3#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
4pub enum EnglishKeyword {
5    A {
6        #[cfg(feature = "spanned_tree")]
7        span: crate::ability_tree::span::TreeSpan,
8    },
9    Additional {
10        #[cfg(feature = "spanned_tree")]
11        span: crate::ability_tree::span::TreeSpan,
12    },
13    Already {
14        #[cfg(feature = "spanned_tree")]
15        span: crate::ability_tree::span::TreeSpan,
16    },
17    After {
18        #[cfg(feature = "spanned_tree")]
19        span: crate::ability_tree::span::TreeSpan,
20    },
21    Among {
22        #[cfg(feature = "spanned_tree")]
23        span: crate::ability_tree::span::TreeSpan,
24    },
25    An {
26        #[cfg(feature = "spanned_tree")]
27        span: crate::ability_tree::span::TreeSpan,
28    },
29    And {
30        #[cfg(feature = "spanned_tree")]
31        span: crate::ability_tree::span::TreeSpan,
32    },
33    AndOr {
34        #[cfg(feature = "spanned_tree")]
35        span: crate::ability_tree::span::TreeSpan,
36    },
37    Another {
38        #[cfg(feature = "spanned_tree")]
39        span: crate::ability_tree::span::TreeSpan,
40    },
41    Any {
42        #[cfg(feature = "spanned_tree")]
43        span: crate::ability_tree::span::TreeSpan,
44    },
45    /* Fixme: perhaps an ambiguous token ? both a "is" and a possessive */
46    ApostropheS {
47        #[cfg(feature = "spanned_tree")]
48        span: crate::ability_tree::span::TreeSpan,
49    },
50    Are {
51        #[cfg(feature = "spanned_tree")]
52        span: crate::ability_tree::span::TreeSpan,
53    },
54    As {
55        #[cfg(feature = "spanned_tree")]
56        span: crate::ability_tree::span::TreeSpan,
57    },
58    AsLongAs {
59        #[cfg(feature = "spanned_tree")]
60        span: crate::ability_tree::span::TreeSpan,
61    },
62    AsThough {
63        #[cfg(feature = "spanned_tree")]
64        span: crate::ability_tree::span::TreeSpan,
65    },
66    At {
67        #[cfg(feature = "spanned_tree")]
68        span: crate::ability_tree::span::TreeSpan,
69    },
70    Back {
71        #[cfg(feature = "spanned_tree")]
72        span: crate::ability_tree::span::TreeSpan,
73    },
74    Be {
75        #[cfg(feature = "spanned_tree")]
76        span: crate::ability_tree::span::TreeSpan,
77    },
78    Become {
79        #[cfg(feature = "spanned_tree")]
80        span: crate::ability_tree::span::TreeSpan,
81    },
82    Beginning {
83        #[cfg(feature = "spanned_tree")]
84        span: crate::ability_tree::span::TreeSpan,
85    },
86    Bottom {
87        #[cfg(feature = "spanned_tree")]
88        span: crate::ability_tree::span::TreeSpan,
89    },
90    By {
91        #[cfg(feature = "spanned_tree")]
92        span: crate::ability_tree::span::TreeSpan,
93    },
94    Can {
95        #[cfg(feature = "spanned_tree")]
96        span: crate::ability_tree::span::TreeSpan,
97    },
98    Cant {
99        #[cfg(feature = "spanned_tree")]
100        span: crate::ability_tree::span::TreeSpan,
101    },
102    Cause {
103        #[cfg(feature = "spanned_tree")]
104        span: crate::ability_tree::span::TreeSpan,
105    },
106    Chosen {
107        #[cfg(feature = "spanned_tree")]
108        span: crate::ability_tree::span::TreeSpan,
109    },
110    Control {
111        #[cfg(feature = "spanned_tree")]
112        span: crate::ability_tree::span::TreeSpan,
113    },
114    Copy {
115        #[cfg(feature = "spanned_tree")]
116        span: crate::ability_tree::span::TreeSpan,
117    },
118    Divided {
119        #[cfg(feature = "spanned_tree")]
120        span: crate::ability_tree::span::TreeSpan,
121    },
122    During {
123        #[cfg(feature = "spanned_tree")]
124        span: crate::ability_tree::span::TreeSpan,
125    },
126    Do {
127        #[cfg(feature = "spanned_tree")]
128        span: crate::ability_tree::span::TreeSpan,
129    },
130    Dont {
131        #[cfg(feature = "spanned_tree")]
132        span: crate::ability_tree::span::TreeSpan,
133    },
134    Equal {
135        #[cfg(feature = "spanned_tree")]
136        span: crate::ability_tree::span::TreeSpan,
137    },
138    Everyting {
139        #[cfg(feature = "spanned_tree")]
140        span: crate::ability_tree::span::TreeSpan,
141    },
142    Except {
143        #[cfg(feature = "spanned_tree")]
144        span: crate::ability_tree::span::TreeSpan,
145    },
146    First {
147        #[cfg(feature = "spanned_tree")]
148        span: crate::ability_tree::span::TreeSpan,
149    },
150    For {
151        #[cfg(feature = "spanned_tree")]
152        span: crate::ability_tree::span::TreeSpan,
153    },
154    From {
155        #[cfg(feature = "spanned_tree")]
156        span: crate::ability_tree::span::TreeSpan,
157    },
158    Have {
159        #[cfg(feature = "spanned_tree")]
160        span: crate::ability_tree::span::TreeSpan,
161    },
162    Into {
163        #[cfg(feature = "spanned_tree")]
164        span: crate::ability_tree::span::TreeSpan,
165    },
166    If {
167        #[cfg(feature = "spanned_tree")]
168        span: crate::ability_tree::span::TreeSpan,
169    },
170    IfAble {
171        #[cfg(feature = "spanned_tree")]
172        span: crate::ability_tree::span::TreeSpan,
173    },
174    In {
175        #[cfg(feature = "spanned_tree")]
176        span: crate::ability_tree::span::TreeSpan,
177    },
178    InAdditionTo {
179        #[cfg(feature = "spanned_tree")]
180        span: crate::ability_tree::span::TreeSpan,
181    },
182    Instead {
183        #[cfg(feature = "spanned_tree")]
184        span: crate::ability_tree::span::TreeSpan,
185    },
186    Is {
187        #[cfg(feature = "spanned_tree")]
188        span: crate::ability_tree::span::TreeSpan,
189    },
190    Isnt {
191        #[cfg(feature = "spanned_tree")]
192        span: crate::ability_tree::span::TreeSpan,
193    },
194    It {
195        #[cfg(feature = "spanned_tree")]
196        span: crate::ability_tree::span::TreeSpan,
197    },
198    Its {
199        #[cfg(feature = "spanned_tree")]
200        span: crate::ability_tree::span::TreeSpan,
201    },
202    Kind {
203        #[cfg(feature = "spanned_tree")]
204        span: crate::ability_tree::span::TreeSpan,
205    },
206    Less {
207        #[cfg(feature = "spanned_tree")]
208        span: crate::ability_tree::span::TreeSpan,
209    },
210    May {
211        #[cfg(feature = "spanned_tree")]
212        span: crate::ability_tree::span::TreeSpan,
213    },
214    Must {
215        #[cfg(feature = "spanned_tree")]
216        span: crate::ability_tree::span::TreeSpan,
217    },
218    More {
219        #[cfg(feature = "spanned_tree")]
220        span: crate::ability_tree::span::TreeSpan,
221    },
222    Named {
223        #[cfg(feature = "spanned_tree")]
224        span: crate::ability_tree::span::TreeSpan,
225    },
226    Next {
227        #[cfg(feature = "spanned_tree")]
228        span: crate::ability_tree::span::TreeSpan,
229    },
230    New {
231        #[cfg(feature = "spanned_tree")]
232        span: crate::ability_tree::span::TreeSpan,
233    },
234    No {
235        #[cfg(feature = "spanned_tree")]
236        span: crate::ability_tree::span::TreeSpan,
237    },
238    Not {
239        #[cfg(feature = "spanned_tree")]
240        span: crate::ability_tree::span::TreeSpan,
241    },
242    Of {
243        #[cfg(feature = "spanned_tree")]
244        span: crate::ability_tree::span::TreeSpan,
245    },
246    On {
247        #[cfg(feature = "spanned_tree")]
248        span: crate::ability_tree::span::TreeSpan,
249    },
250    Once {
251        #[cfg(feature = "spanned_tree")]
252        span: crate::ability_tree::span::TreeSpan,
253    },
254    Only {
255        #[cfg(feature = "spanned_tree")]
256        span: crate::ability_tree::span::TreeSpan,
257    },
258    Onto {
259        #[cfg(feature = "spanned_tree")]
260        span: crate::ability_tree::span::TreeSpan,
261    },
262    Or {
263        #[cfg(feature = "spanned_tree")]
264        span: crate::ability_tree::span::TreeSpan,
265    },
266    Other {
267        #[cfg(feature = "spanned_tree")]
268        span: crate::ability_tree::span::TreeSpan,
269    },
270    Otherwise {
271        #[cfg(feature = "spanned_tree")]
272        span: crate::ability_tree::span::TreeSpan,
273    },
274    RatherThan {
275        #[cfg(feature = "spanned_tree")]
276        span: crate::ability_tree::span::TreeSpan,
277    },
278    Random {
279        #[cfg(feature = "spanned_tree")]
280        span: crate::ability_tree::span::TreeSpan,
281    },
282    Same {
283        #[cfg(feature = "spanned_tree")]
284        span: crate::ability_tree::span::TreeSpan,
285    },
286    Second {
287        #[cfg(feature = "spanned_tree")]
288        span: crate::ability_tree::span::TreeSpan,
289    },
290    Than {
291        #[cfg(feature = "spanned_tree")]
292        span: crate::ability_tree::span::TreeSpan,
293    },
294    That {
295        #[cfg(feature = "spanned_tree")]
296        span: crate::ability_tree::span::TreeSpan,
297    },
298    The {
299        #[cfg(feature = "spanned_tree")]
300        span: crate::ability_tree::span::TreeSpan,
301    },
302    TheRest {
303        #[cfg(feature = "spanned_tree")]
304        span: crate::ability_tree::span::TreeSpan,
305    },
306    Them {
307        #[cfg(feature = "spanned_tree")]
308        span: crate::ability_tree::span::TreeSpan,
309    },
310    Then {
311        #[cfg(feature = "spanned_tree")]
312        span: crate::ability_tree::span::TreeSpan,
313    },
314    Their {
315        #[cfg(feature = "spanned_tree")]
316        span: crate::ability_tree::span::TreeSpan,
317    },
318    There {
319        #[cfg(feature = "spanned_tree")]
320        span: crate::ability_tree::span::TreeSpan,
321    },
322    They {
323        #[cfg(feature = "spanned_tree")]
324        span: crate::ability_tree::span::TreeSpan,
325    },
326    This {
327        #[cfg(feature = "spanned_tree")]
328        span: crate::ability_tree::span::TreeSpan,
329    },
330    ThisWay {
331        #[cfg(feature = "spanned_tree")]
332        span: crate::ability_tree::span::TreeSpan,
333    },
334    Those {
335        #[cfg(feature = "spanned_tree")]
336        span: crate::ability_tree::span::TreeSpan,
337    },
338    To {
339        #[cfg(feature = "spanned_tree")]
340        span: crate::ability_tree::span::TreeSpan,
341    },
342    Top {
343        #[cfg(feature = "spanned_tree")]
344        span: crate::ability_tree::span::TreeSpan,
345    },
346    Twice {
347        #[cfg(feature = "spanned_tree")]
348        span: crate::ability_tree::span::TreeSpan,
349    },
350    Types {
351        #[cfg(feature = "spanned_tree")]
352        span: crate::ability_tree::span::TreeSpan,
353    },
354    Unless {
355        #[cfg(feature = "spanned_tree")]
356        span: crate::ability_tree::span::TreeSpan,
357    },
358    Until {
359        #[cfg(feature = "spanned_tree")]
360        span: crate::ability_tree::span::TreeSpan,
361    },
362    When {
363        #[cfg(feature = "spanned_tree")]
364        span: crate::ability_tree::span::TreeSpan,
365    },
366    Whenever {
367        #[cfg(feature = "spanned_tree")]
368        span: crate::ability_tree::span::TreeSpan,
369    },
370    Where {
371        #[cfg(feature = "spanned_tree")]
372        span: crate::ability_tree::span::TreeSpan,
373    },
374    With {
375        #[cfg(feature = "spanned_tree")]
376        span: crate::ability_tree::span::TreeSpan,
377    },
378    Without {
379        #[cfg(feature = "spanned_tree")]
380        span: crate::ability_tree::span::TreeSpan,
381    },
382    Would {
383        #[cfg(feature = "spanned_tree")]
384        span: crate::ability_tree::span::TreeSpan,
385    },
386}
387
388#[cfg(feature = "spanned_tree")]
389impl EnglishKeyword {
390    pub fn span(&self) -> crate::ability_tree::span::TreeSpan {
391        match self {
392            Self::A { span } => *span,
393            Self::Additional { span } => *span,
394            Self::Already { span } => *span,
395            Self::After { span } => *span,
396            Self::Among { span } => *span,
397            Self::An { span } => *span,
398            Self::And { span } => *span,
399            Self::AndOr { span } => *span,
400            Self::Another { span } => *span,
401            Self::Any { span } => *span,
402            Self::ApostropheS { span } => *span,
403            Self::Are { span } => *span,
404            Self::As { span } => *span,
405            Self::AsLongAs { span } => *span,
406            Self::AsThough { span } => *span,
407            Self::At { span } => *span,
408            Self::Back { span } => *span,
409            Self::Be { span } => *span,
410            Self::Become { span } => *span,
411            Self::Beginning { span } => *span,
412            Self::Bottom { span } => *span,
413            Self::By { span } => *span,
414            Self::Can { span } => *span,
415            Self::Cant { span } => *span,
416            Self::Cause { span } => *span,
417            Self::Chosen { span } => *span,
418            Self::Control { span } => *span,
419            Self::Copy { span } => *span,
420            Self::Divided { span } => *span,
421            Self::During { span } => *span,
422            Self::Do { span } => *span,
423            Self::Dont { span } => *span,
424            Self::Equal { span } => *span,
425            Self::Everyting { span } => *span,
426            Self::Except { span } => *span,
427            Self::First { span } => *span,
428            Self::For { span } => *span,
429            Self::From { span } => *span,
430            Self::Have { span } => *span,
431            Self::Into { span } => *span,
432            Self::If { span } => *span,
433            Self::IfAble { span } => *span,
434            Self::In { span } => *span,
435            Self::InAdditionTo { span } => *span,
436            Self::Instead { span } => *span,
437            Self::Is { span } => *span,
438            Self::Isnt { span } => *span,
439            Self::It { span } => *span,
440            Self::Its { span } => *span,
441            Self::Kind { span } => *span,
442            Self::Less { span } => *span,
443            Self::May { span } => *span,
444            Self::Must { span } => *span,
445            Self::More { span } => *span,
446            Self::Named { span } => *span,
447            Self::Next { span } => *span,
448            Self::New { span } => *span,
449            Self::No { span } => *span,
450            Self::Not { span } => *span,
451            Self::Of { span } => *span,
452            Self::On { span } => *span,
453            Self::Once { span } => *span,
454            Self::Only { span } => *span,
455            Self::Onto { span } => *span,
456            Self::Or { span } => *span,
457            Self::Other { span } => *span,
458            Self::Otherwise { span } => *span,
459            Self::RatherThan { span } => *span,
460            Self::Random { span } => *span,
461            Self::Same { span } => *span,
462            Self::Second { span } => *span,
463            Self::Than { span } => *span,
464            Self::That { span } => *span,
465            Self::The { span } => *span,
466            Self::Their { span } => *span,
467            Self::TheRest { span } => *span,
468            Self::Them { span } => *span,
469            Self::Then { span } => *span,
470            Self::There { span } => *span,
471            Self::They { span } => *span,
472            Self::This { span } => *span,
473            Self::ThisWay { span } => *span,
474            Self::Those { span } => *span,
475            Self::To { span } => *span,
476            Self::Top { span } => *span,
477            Self::Twice { span } => *span,
478            Self::Types { span } => *span,
479            Self::Unless { span } => *span,
480            Self::Until { span } => *span,
481            Self::When { span } => *span,
482            Self::Whenever { span } => *span,
483            Self::Where { span } => *span,
484            Self::With { span } => *span,
485            Self::Without { span } => *span,
486            Self::Would { span } => *span,
487        }
488    }
489}
490
491impl EnglishKeyword {
492    pub fn try_from_span(span: &crate::lexer::Span) -> Option<Self> {
493        match span.text {
494            "a" => Some(Self::A {
495                #[cfg(feature = "spanned_tree")]
496                span: span.into(),
497            }),
498            "additional" => Some(Self::Additional {
499                #[cfg(feature = "spanned_tree")]
500                span: span.into(),
501            }),
502            "already" => Some(Self::Already {
503                #[cfg(feature = "spanned_tree")]
504                span: span.into(),
505            }),
506            "after" => Some(Self::After {
507                #[cfg(feature = "spanned_tree")]
508                span: span.into(),
509            }),
510            "among" => Some(Self::Among {
511                #[cfg(feature = "spanned_tree")]
512                span: span.into(),
513            }),
514            "an" => Some(Self::An {
515                #[cfg(feature = "spanned_tree")]
516                span: span.into(),
517            }),
518            "and" => Some(Self::And {
519                #[cfg(feature = "spanned_tree")]
520                span: span.into(),
521            }),
522            "and/or" => Some(Self::AndOr {
523                #[cfg(feature = "spanned_tree")]
524                span: span.into(),
525            }),
526            "another" => Some(Self::Another {
527                #[cfg(feature = "spanned_tree")]
528                span: span.into(),
529            }),
530            "any" => Some(Self::Any {
531                #[cfg(feature = "spanned_tree")]
532                span: span.into(),
533            }),
534            "'s" => Some(Self::ApostropheS {
535                #[cfg(feature = "spanned_tree")]
536                span: span.into(),
537            }),
538            "as" => Some(Self::As {
539                #[cfg(feature = "spanned_tree")]
540                span: span.into(),
541            }),
542            "as long as" => Some(Self::As {
543                #[cfg(feature = "spanned_tree")]
544                span: span.into(),
545            }),
546            "as though" => Some(Self::AsThough {
547                #[cfg(feature = "spanned_tree")]
548                span: span.into(),
549            }),
550            "at" => Some(Self::At {
551                #[cfg(feature = "spanned_tree")]
552                span: span.into(),
553            }),
554            "are" => Some(Self::Are {
555                #[cfg(feature = "spanned_tree")]
556                span: span.into(),
557            }),
558            "back" => Some(Self::Back {
559                #[cfg(feature = "spanned_tree")]
560                span: span.into(),
561            }),
562            "be" => Some(Self::Be {
563                #[cfg(feature = "spanned_tree")]
564                span: span.into(),
565            }),
566            "become" | "becomes" => Some(Self::Become {
567                #[cfg(feature = "spanned_tree")]
568                span: span.into(),
569            }),
570            "beginning" => Some(Self::Beginning {
571                #[cfg(feature = "spanned_tree")]
572                span: span.into(),
573            }),
574            "bottom" => Some(Self::Bottom {
575                #[cfg(feature = "spanned_tree")]
576                span: span.into(),
577            }),
578            "by" => Some(Self::By {
579                #[cfg(feature = "spanned_tree")]
580                span: span.into(),
581            }),
582            "can" => Some(Self::Can {
583                #[cfg(feature = "spanned_tree")]
584                span: span.into(),
585            }),
586            "can't" => Some(Self::Cant {
587                #[cfg(feature = "spanned_tree")]
588                span: span.into(),
589            }),
590            "cause" | "causes" => Some(Self::Cause {
591                #[cfg(feature = "spanned_tree")]
592                span: span.into(),
593            }),
594            "chosen" => Some(Self::Chosen {
595                #[cfg(feature = "spanned_tree")]
596                span: span.into(),
597            }),
598            "control" | "controls" => Some(Self::Control {
599                #[cfg(feature = "spanned_tree")]
600                span: span.into(),
601            }),
602            "copy" => Some(Self::Copy {
603                #[cfg(feature = "spanned_tree")]
604                span: span.into(),
605            }),
606            "divided" => Some(Self::Divided {
607                #[cfg(feature = "spanned_tree")]
608                span: span.into(),
609            }),
610            "during" => Some(Self::During {
611                #[cfg(feature = "spanned_tree")]
612                span: span.into(),
613            }),
614            "do" | "does" => Some(Self::Do {
615                #[cfg(feature = "spanned_tree")]
616                span: span.into(),
617            }),
618            "don't" | "doesn't" => Some(Self::Dont {
619                #[cfg(feature = "spanned_tree")]
620                span: span.into(),
621            }),
622            "equal" => Some(Self::Equal {
623                #[cfg(feature = "spanned_tree")]
624                span: span.into(),
625            }),
626            "everything" => Some(Self::Everyting {
627                #[cfg(feature = "spanned_tree")]
628                span: span.into(),
629            }),
630            "except" => Some(Self::Except {
631                #[cfg(feature = "spanned_tree")]
632                span: span.into(),
633            }),
634            "first" => Some(Self::First {
635                #[cfg(feature = "spanned_tree")]
636                span: span.into(),
637            }),
638            "from" => Some(Self::From {
639                #[cfg(feature = "spanned_tree")]
640                span: span.into(),
641            }),
642            "for" => Some(Self::For {
643                #[cfg(feature = "spanned_tree")]
644                span: span.into(),
645            }),
646            "has" | "had" | "have" | "'ve" => Some(Self::Have {
647                #[cfg(feature = "spanned_tree")]
648                span: span.into(),
649            }),
650            "into" => Some(Self::Into {
651                #[cfg(feature = "spanned_tree")]
652                span: span.into(),
653            }),
654            "if" => Some(Self::If {
655                #[cfg(feature = "spanned_tree")]
656                span: span.into(),
657            }),
658            "if able" => Some(Self::IfAble {
659                #[cfg(feature = "spanned_tree")]
660                span: span.into(),
661            }),
662            "in" => Some(Self::In {
663                #[cfg(feature = "spanned_tree")]
664                span: span.into(),
665            }),
666            "in addition to" => Some(Self::InAdditionTo {
667                #[cfg(feature = "spanned_tree")]
668                span: span.into(),
669            }),
670            "instead" => Some(Self::Instead {
671                #[cfg(feature = "spanned_tree")]
672                span: span.into(),
673            }),
674            "is" | "was" => Some(Self::Is {
675                #[cfg(feature = "spanned_tree")]
676                span: span.into(),
677            }),
678            "isn't" | "wasn't" => Some(Self::Isnt {
679                #[cfg(feature = "spanned_tree")]
680                span: span.into(),
681            }),
682            "it" => Some(Self::It {
683                #[cfg(feature = "spanned_tree")]
684                span: span.into(),
685            }),
686            "its" => Some(Self::Its {
687                #[cfg(feature = "spanned_tree")]
688                span: span.into(),
689            }),
690            "kind" => Some(Self::Kind {
691                #[cfg(feature = "spanned_tree")]
692                span: span.into(),
693            }),
694            "less" => Some(Self::Less {
695                #[cfg(feature = "spanned_tree")]
696                span: span.into(),
697            }),
698            "may" => Some(Self::May {
699                #[cfg(feature = "spanned_tree")]
700                span: span.into(),
701            }),
702            "must" => Some(Self::Must {
703                #[cfg(feature = "spanned_tree")]
704                span: span.into(),
705            }),
706            "more" => Some(Self::More {
707                #[cfg(feature = "spanned_tree")]
708                span: span.into(),
709            }),
710            "named" => Some(Self::Named {
711                #[cfg(feature = "spanned_tree")]
712                span: span.into(),
713            }),
714            "next" => Some(Self::Next {
715                #[cfg(feature = "spanned_tree")]
716                span: span.into(),
717            }),
718            "new" => Some(Self::Next {
719                #[cfg(feature = "spanned_tree")]
720                span: span.into(),
721            }),
722            "no" => Some(Self::No {
723                #[cfg(feature = "spanned_tree")]
724                span: span.into(),
725            }),
726            "not" => Some(Self::No {
727                #[cfg(feature = "spanned_tree")]
728                span: span.into(),
729            }),
730            "of" => Some(Self::Of {
731                #[cfg(feature = "spanned_tree")]
732                span: span.into(),
733            }),
734            "on" => Some(Self::On {
735                #[cfg(feature = "spanned_tree")]
736                span: span.into(),
737            }),
738            "once" => Some(Self::Once {
739                #[cfg(feature = "spanned_tree")]
740                span: span.into(),
741            }),
742            "only" => Some(Self::Only {
743                #[cfg(feature = "spanned_tree")]
744                span: span.into(),
745            }),
746            "onto" => Some(Self::Onto {
747                #[cfg(feature = "spanned_tree")]
748                span: span.into(),
749            }),
750            "or" => Some(Self::Or {
751                #[cfg(feature = "spanned_tree")]
752                span: span.into(),
753            }),
754            "other" => Some(Self::Other {
755                #[cfg(feature = "spanned_tree")]
756                span: span.into(),
757            }),
758            "otherwise" => Some(Self::Otherwise {
759                #[cfg(feature = "spanned_tree")]
760                span: span.into(),
761            }),
762            "rather than" => Some(Self::RatherThan {
763                #[cfg(feature = "spanned_tree")]
764                span: span.into(),
765            }),
766            "random" => Some(Self::RatherThan {
767                #[cfg(feature = "spanned_tree")]
768                span: span.into(),
769            }),
770            "same" => Some(Self::Same {
771                #[cfg(feature = "spanned_tree")]
772                span: span.into(),
773            }),
774            "second" => Some(Self::Second {
775                #[cfg(feature = "spanned_tree")]
776                span: span.into(),
777            }),
778            "than" => Some(Self::Than {
779                #[cfg(feature = "spanned_tree")]
780                span: span.into(),
781            }),
782            "that" => Some(Self::That {
783                #[cfg(feature = "spanned_tree")]
784                span: span.into(),
785            }),
786            "the" => Some(Self::The {
787                #[cfg(feature = "spanned_tree")]
788                span: span.into(),
789            }),
790            "their" => Some(Self::Their {
791                #[cfg(feature = "spanned_tree")]
792                span: span.into(),
793            }),
794            "the rest" => Some(Self::TheRest {
795                #[cfg(feature = "spanned_tree")]
796                span: span.into(),
797            }),
798            "them" => Some(Self::Them {
799                #[cfg(feature = "spanned_tree")]
800                span: span.into(),
801            }),
802            "then" => Some(Self::Then {
803                #[cfg(feature = "spanned_tree")]
804                span: span.into(),
805            }),
806            "there" => Some(Self::There {
807                #[cfg(feature = "spanned_tree")]
808                span: span.into(),
809            }),
810            "they" => Some(Self::They {
811                #[cfg(feature = "spanned_tree")]
812                span: span.into(),
813            }),
814            "this" => Some(Self::This {
815                #[cfg(feature = "spanned_tree")]
816                span: span.into(),
817            }),
818            "this way" => Some(Self::ThisWay {
819                #[cfg(feature = "spanned_tree")]
820                span: span.into(),
821            }),
822            "those" => Some(Self::Those {
823                #[cfg(feature = "spanned_tree")]
824                span: span.into(),
825            }),
826            "to" => Some(Self::To {
827                #[cfg(feature = "spanned_tree")]
828                span: span.into(),
829            }),
830            "top" => Some(Self::Top {
831                #[cfg(feature = "spanned_tree")]
832                span: span.into(),
833            }),
834            "twice" => Some(Self::Twice {
835                #[cfg(feature = "spanned_tree")]
836                span: span.into(),
837            }),
838            "types" => Some(Self::Types {
839                #[cfg(feature = "spanned_tree")]
840                span: span.into(),
841            }),
842            "unless" => Some(Self::Unless {
843                #[cfg(feature = "spanned_tree")]
844                span: span.into(),
845            }),
846            "until" => Some(Self::Until {
847                #[cfg(feature = "spanned_tree")]
848                span: span.into(),
849            }),
850            "when" => Some(Self::When {
851                #[cfg(feature = "spanned_tree")]
852                span: span.into(),
853            }),
854            "whenever" => Some(Self::Whenever {
855                #[cfg(feature = "spanned_tree")]
856                span: span.into(),
857            }),
858            "where" => Some(Self::Where {
859                #[cfg(feature = "spanned_tree")]
860                span: span.into(),
861            }),
862            "with" => Some(Self::With {
863                #[cfg(feature = "spanned_tree")]
864                span: span.into(),
865            }),
866            "without" => Some(Self::Without {
867                #[cfg(feature = "spanned_tree")]
868                span: span.into(),
869            }),
870            "would" => Some(Self::Would {
871                #[cfg(feature = "spanned_tree")]
872                span: span.into(),
873            }),
874            _ => None,
875        }
876    }
877}
boseiju/lexer/tokens/intermediates/english_keywords.rs

boseiju/lexer/tokens/intermediates/
english_keywords.rs
