lwb_parser/parser/syntax_file/ast/
from_pairs.rs

1#![allow(unused)]
2#![allow(non_snake_case)]
3#![allow(non_camel_case_types)]
4#![allow(clippy::all)]
5// |==========================================================|
6// |      WARNING: THIS FILE IS AUTOMATICALLY GENERATED.      |
7// |      CHANGES TO IT WILL BE DELETED WHEN REGENERATED.     |
8// | IN GENERAL, THIS FILE SHOULD NOT BE MODIFIED IN ANY WAY. |
9// |==========================================================|
10use super::prelude::*;
11impl<M: AstInfo> FromPairs<M> for Program<M> {
12    fn from_pairs<G: GenerateAstInfo<Result = M>>(pair: &ParsePairSort, generator: &mut G) -> Self {
13        assert!(
14            vec!["program"].contains(&pair.sort),
15            "{} not in {:?}",
16            pair.sort,
17            vec!["program"]
18        );
19        let info = generator.generate(&pair);
20        Self(
21            info,
22            if let ParsePairExpression::List(_, ref l) = pair.constructor_value {
23                l . iter () . map (| x | if let ParsePairExpression :: Sort (_ , ref s) = x { SortOrMeta :: from_pairs (s , generator) } else { unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "program") ; }) . collect ()
24            } else {
25                unreachable!(
26                    "expected different parse pair expression in pair to ast conversion of {}",
27                    "program"
28                );
29            },
30        )
31    }
32}
33impl<M: AstInfo> FromPairs<M> for SortOrMeta<M> {
34    fn from_pairs<G: GenerateAstInfo<Result = M>>(pair: &ParsePairSort, generator: &mut G) -> Self {
35        assert!(
36            vec!["sort-or-meta"].contains(&pair.sort),
37            "{} not in {:?}",
38            pair.sort,
39            vec!["sort-or-meta"]
40        );
41        let info = generator.generate(&pair);
42        match pair.constructor_name {
43            "meta" => {
44                Self::Meta(
45                    info,
46                    if let ParsePairExpression::Sort(_, ref s) = pair.constructor_value {
47                        Meta::from_pairs(s, generator)
48                    } else {
49                        unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "sort-or-meta");
50                    },
51                )
52            }
53            "sort" => {
54                Self::Sort(
55                    info,
56                    if let ParsePairExpression::Sort(_, ref s) = pair.constructor_value {
57                        Sort::from_pairs(s, generator)
58                    } else {
59                        unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "sort-or-meta");
60                    },
61                )
62            }
63            a => unreachable!("{}", a),
64        }
65    }
66}
67impl<M: AstInfo> FromPairs<M> for Meta<M> {
68    fn from_pairs<G: GenerateAstInfo<Result = M>>(pair: &ParsePairSort, generator: &mut G) -> Self {
69        assert!(
70            vec!["meta"].contains(&pair.sort),
71            "{} not in {:?}",
72            pair.sort,
73            vec!["meta"]
74        );
75        let info = generator.generate(&pair);
76        if let ParsePairExpression::List(_, ref l) = pair.constructor_value {
77            Self(
78                info,
79                if let ParsePairExpression::Sort(_, ref s) = l[2usize] {
80                    Identifier::from_pairs(s, generator)
81                } else {
82                    unreachable!(
83                        "expected different parse pair expression in pair to ast conversion of {}",
84                        "meta"
85                    );
86                },
87            )
88        } else {
89            unreachable!(
90                "expected different parse pair expression in pair to ast conversion of {}",
91                "meta"
92            );
93        }
94    }
95}
96impl<M: AstInfo> FromPairs<M> for Sort<M> {
97    fn from_pairs<G: GenerateAstInfo<Result = M>>(pair: &ParsePairSort, generator: &mut G) -> Self {
98        assert!(
99            vec!["sort"].contains(&pair.sort),
100            "{} not in {:?}",
101            pair.sort,
102            vec!["sort"]
103        );
104        let info = generator.generate(&pair);
105        match pair.constructor_name {
106            "sort-documented" => {
107                if let ParsePairExpression::List(_, ref l) = pair.constructor_value {
108                    Self::SortDocumented(
109                        info,
110                        if let ParsePairExpression::List(_, ref l) = l[0usize] {
111                            l . iter () . map (| x | if let ParsePairExpression :: Sort (_ , ref s) = x { DocComment :: from_pairs (s , generator) } else { unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "sort") ; }) . collect ()
112                        } else {
113                            unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "sort");
114                        },
115                        if let ParsePairExpression::Sort(_, ref s) = l[1usize] {
116                            Box::new(Sort::from_pairs(s, generator))
117                        } else {
118                            unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "sort");
119                        },
120                    )
121                } else {
122                    unreachable!(
123                        "expected different parse pair expression in pair to ast conversion of {}",
124                        "sort"
125                    );
126                }
127            }
128            "sort" => {
129                if let ParsePairExpression::List(_, ref l) = pair.constructor_value {
130                    Self::Sort(
131                        info,
132                        if let ParsePairExpression::Sort(_, ref s) = l[0usize] {
133                            Identifier::from_pairs(s, generator)
134                        } else {
135                            unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "sort");
136                        },
137                        if let ParsePairExpression::List(_, ref l) = l[2usize] {
138                            l . first () . map (| x | if let ParsePairExpression :: Sort (_ , ref s) = x { AnnotationList :: from_pairs (s , generator) } else { unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "sort") ; })
139                        } else {
140                            unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "sort");
141                        },
142                        if let ParsePairExpression::List(_, ref l) = l[4usize] {
143                            l . iter () . map (| x | if let ParsePairExpression :: Sort (_ , ref s) = x { Constructor :: from_pairs (s , generator) } else { unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "sort") ; }) . collect ()
144                        } else {
145                            unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "sort");
146                        },
147                    )
148                } else {
149                    unreachable!(
150                        "expected different parse pair expression in pair to ast conversion of {}",
151                        "sort"
152                    );
153                }
154            }
155            "sort-single" => {
156                if let ParsePairExpression::List(_, ref l) = pair.constructor_value {
157                    Self::SortSingle(
158                        info,
159                        if let ParsePairExpression::Sort(_, ref s) = l[0usize] {
160                            Identifier::from_pairs(s, generator)
161                        } else {
162                            unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "sort");
163                        },
164                        if let ParsePairExpression::List(_, ref l) = l[2usize] {
165                            l . iter () . map (| x | if let ParsePairExpression :: Sort (_ , ref s) = x { Expression :: from_pairs (s , generator) } else { unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "sort") ; }) . collect ()
166                        } else {
167                            unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "sort");
168                        },
169                        if let ParsePairExpression::List(_, ref l) = l[4usize] {
170                            l . first () . map (| x | if let ParsePairExpression :: Sort (_ , ref s) = x { AnnotationList :: from_pairs (s , generator) } else { unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "sort") ; })
171                        } else {
172                            unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "sort");
173                        },
174                    )
175                } else {
176                    unreachable!(
177                        "expected different parse pair expression in pair to ast conversion of {}",
178                        "sort"
179                    );
180                }
181            }
182            a => unreachable!("{}", a),
183        }
184    }
185}
186impl<M: AstInfo> FromPairs<M> for Identifier<M> {
187    fn from_pairs<G: GenerateAstInfo<Result = M>>(pair: &ParsePairSort, generator: &mut G) -> Self {
188        assert!(
189            vec!["identifier"].contains(&pair.sort),
190            "{} not in {:?}",
191            pair.sort,
192            vec!["identifier"]
193        );
194        let info = generator.generate(&pair);
195        return Self(info, pair.constructor_value.span().as_str().to_string());
196    }
197}
198impl<M: AstInfo> FromPairs<M> for DocComment<M> {
199    fn from_pairs<G: GenerateAstInfo<Result = M>>(pair: &ParsePairSort, generator: &mut G) -> Self {
200        assert!(
201            vec!["doc-comment"].contains(&pair.sort),
202            "{} not in {:?}",
203            pair.sort,
204            vec!["doc-comment"]
205        );
206        let info = generator.generate(&pair);
207        return Self(info, pair.constructor_value.span().as_str().to_string());
208    }
209}
210impl<M: AstInfo> FromPairs<M> for AnnotationList<M> {
211    fn from_pairs<G: GenerateAstInfo<Result = M>>(pair: &ParsePairSort, generator: &mut G) -> Self {
212        assert!(
213            vec!["annotation-list"].contains(&pair.sort),
214            "{} not in {:?}",
215            pair.sort,
216            vec!["annotation-list"]
217        );
218        let info = generator.generate(&pair);
219        if let ParsePairExpression::List(_, ref l) = pair.constructor_value {
220            Self(
221                info,
222                if let ParsePairExpression::List(_, ref l) = l[1usize] {
223                    l . iter () . map (| x | if let ParsePairExpression :: Sort (_ , ref s) = x { Annotation :: from_pairs (s , generator) } else { unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "annotation-list") ; }) . collect ()
224                } else {
225                    unreachable!(
226                        "expected different parse pair expression in pair to ast conversion of {}",
227                        "annotation-list"
228                    );
229                },
230            )
231        } else {
232            unreachable!(
233                "expected different parse pair expression in pair to ast conversion of {}",
234                "annotation-list"
235            );
236        }
237    }
238}
239impl<M: AstInfo> FromPairs<M> for Constructor<M> {
240    fn from_pairs<G: GenerateAstInfo<Result = M>>(pair: &ParsePairSort, generator: &mut G) -> Self {
241        assert!(
242            vec!["constructor"].contains(&pair.sort),
243            "{} not in {:?}",
244            pair.sort,
245            vec!["constructor"]
246        );
247        let info = generator.generate(&pair);
248        match pair.constructor_name {
249            "constructor-documented" => {
250                if let ParsePairExpression::List(_, ref l) = pair.constructor_value {
251                    Self::ConstructorDocumented(
252                        info,
253                        if let ParsePairExpression::List(_, ref l) = l[0usize] {
254                            l . iter () . map (| x | if let ParsePairExpression :: Sort (_ , ref s) = x { DocComment :: from_pairs (s , generator) } else { unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "constructor") ; }) . collect ()
255                        } else {
256                            unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "constructor");
257                        },
258                        if let ParsePairExpression::Sort(_, ref s) = l[1usize] {
259                            Box::new(Constructor::from_pairs(s, generator))
260                        } else {
261                            unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "constructor");
262                        },
263                    )
264                } else {
265                    unreachable!(
266                        "expected different parse pair expression in pair to ast conversion of {}",
267                        "constructor"
268                    );
269                }
270            }
271            "constructor" => {
272                if let ParsePairExpression::List(_, ref l) = pair.constructor_value {
273                    Self::Constructor(
274                        info,
275                        if let ParsePairExpression::Sort(_, ref s) = l[1usize] {
276                            Identifier::from_pairs(s, generator)
277                        } else {
278                            unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "constructor");
279                        },
280                        if let ParsePairExpression::List(_, ref l) = l[3usize] {
281                            l . iter () . map (| x | if let ParsePairExpression :: Sort (_ , ref s) = x { Expression :: from_pairs (s , generator) } else { unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "constructor") ; }) . collect ()
282                        } else {
283                            unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "constructor");
284                        },
285                        if let ParsePairExpression::List(_, ref l) = l[5usize] {
286                            l . first () . map (| x | if let ParsePairExpression :: Sort (_ , ref s) = x { AnnotationList :: from_pairs (s , generator) } else { unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "constructor") ; })
287                        } else {
288                            unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "constructor");
289                        },
290                    )
291                } else {
292                    unreachable!(
293                        "expected different parse pair expression in pair to ast conversion of {}",
294                        "constructor"
295                    );
296                }
297            }
298            "constructor-bare" => {
299                if let ParsePairExpression::List(_, ref l) = pair.constructor_value {
300                    Self::ConstructorBare(
301                        info,
302                        if let ParsePairExpression::Sort(_, ref s) = l[1usize] {
303                            Identifier::from_pairs(s, generator)
304                        } else {
305                            unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "constructor");
306                        },
307                        if let ParsePairExpression::List(_, ref l) = l[3usize] {
308                            l . first () . map (| x | if let ParsePairExpression :: Sort (_ , ref s) = x { AnnotationList :: from_pairs (s , generator) } else { unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "constructor") ; })
309                        } else {
310                            unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "constructor");
311                        },
312                    )
313                } else {
314                    unreachable!(
315                        "expected different parse pair expression in pair to ast conversion of {}",
316                        "constructor"
317                    );
318                }
319            }
320            a => unreachable!("{}", a),
321        }
322    }
323}
324impl<M: AstInfo> FromPairs<M> for Expression<M> {
325    fn from_pairs<G: GenerateAstInfo<Result = M>>(pair: &ParsePairSort, generator: &mut G) -> Self {
326        assert!(
327            vec!["atom", "expression"].contains(&pair.sort),
328            "{} not in {:?}",
329            pair.sort,
330            vec!["atom", "expression"]
331        );
332        let info = generator.generate(&pair);
333        match pair.constructor_name {
334            "star" => {
335                if let ParsePairExpression::List(_, ref l) = pair.constructor_value {
336                    Self::Star(
337                        info,
338                        if let ParsePairExpression::Sort(_, ref s) = l[0usize] {
339                            Box::new(Expression::from_pairs(s, generator))
340                        } else {
341                            unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "expression");
342                        },
343                    )
344                } else {
345                    unreachable!(
346                        "expected different parse pair expression in pair to ast conversion of {}",
347                        "expression"
348                    );
349                }
350            }
351            "plus" => {
352                if let ParsePairExpression::List(_, ref l) = pair.constructor_value {
353                    Self::Plus(
354                        info,
355                        if let ParsePairExpression::Sort(_, ref s) = l[0usize] {
356                            Box::new(Expression::from_pairs(s, generator))
357                        } else {
358                            unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "expression");
359                        },
360                    )
361                } else {
362                    unreachable!(
363                        "expected different parse pair expression in pair to ast conversion of {}",
364                        "expression"
365                    );
366                }
367            }
368            "maybe" => {
369                if let ParsePairExpression::List(_, ref l) = pair.constructor_value {
370                    Self::Maybe(
371                        info,
372                        if let ParsePairExpression::Sort(_, ref s) = l[0usize] {
373                            Box::new(Expression::from_pairs(s, generator))
374                        } else {
375                            unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "expression");
376                        },
377                    )
378                } else {
379                    unreachable!(
380                        "expected different parse pair expression in pair to ast conversion of {}",
381                        "expression"
382                    );
383                }
384            }
385            "repeat-exact" => {
386                if let ParsePairExpression::List(_, ref l) = pair.constructor_value {
387                    Self::RepeatExact(
388                        info,
389                        if let ParsePairExpression::Sort(_, ref s) = l[0usize] {
390                            Box::new(Expression::from_pairs(s, generator))
391                        } else {
392                            unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "expression");
393                        },
394                        if let ParsePairExpression::Sort(_, ref s) = l[2usize] {
395                            Number::from_pairs(s, generator)
396                        } else {
397                            unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "expression");
398                        },
399                    )
400                } else {
401                    unreachable!(
402                        "expected different parse pair expression in pair to ast conversion of {}",
403                        "expression"
404                    );
405                }
406            }
407            "repeat-range" => {
408                if let ParsePairExpression::List(_, ref l) = pair.constructor_value {
409                    Self::RepeatRange(
410                        info,
411                        if let ParsePairExpression::Sort(_, ref s) = l[0usize] {
412                            Box::new(Expression::from_pairs(s, generator))
413                        } else {
414                            unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "expression");
415                        },
416                        if let ParsePairExpression::Sort(_, ref s) = l[2usize] {
417                            Number::from_pairs(s, generator)
418                        } else {
419                            unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "expression");
420                        },
421                        if let ParsePairExpression::Sort(_, ref s) = l[4usize] {
422                            Number::from_pairs(s, generator)
423                        } else {
424                            unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "expression");
425                        },
426                    )
427                } else {
428                    unreachable!(
429                        "expected different parse pair expression in pair to ast conversion of {}",
430                        "expression"
431                    );
432                }
433            }
434            "repeat-lower" => {
435                if let ParsePairExpression::List(_, ref l) = pair.constructor_value {
436                    Self::RepeatLower(
437                        info,
438                        if let ParsePairExpression::Sort(_, ref s) = l[0usize] {
439                            Box::new(Expression::from_pairs(s, generator))
440                        } else {
441                            unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "expression");
442                        },
443                        if let ParsePairExpression::Sort(_, ref s) = l[2usize] {
444                            Number::from_pairs(s, generator)
445                        } else {
446                            unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "expression");
447                        },
448                    )
449                } else {
450                    unreachable!(
451                        "expected different parse pair expression in pair to ast conversion of {}",
452                        "expression"
453                    );
454                }
455            }
456            "delimited" => {
457                if let ParsePairExpression::List(_, ref l) = pair.constructor_value {
458                    Self::Delimited(
459                        info,
460                        if let ParsePairExpression::Sort(_, ref s) = l[2usize] {
461                            Box::new(Expression::from_pairs(s, generator))
462                        } else {
463                            unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "expression");
464                        },
465                        if let ParsePairExpression::Sort(_, ref s) = l[4usize] {
466                            Box::new(Expression::from_pairs(s, generator))
467                        } else {
468                            unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "expression");
469                        },
470                        if let ParsePairExpression::Sort(_, ref s) = l[6usize] {
471                            DelimitedBound::from_pairs(s, generator)
472                        } else {
473                            unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "expression");
474                        },
475                        if let ParsePairExpression::List(_, ref l) = l[7usize] {
476                            l.first().is_some()
477                        } else {
478                            unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "expression");
479                        },
480                    )
481                } else {
482                    unreachable!(
483                        "expected different parse pair expression in pair to ast conversion of {}",
484                        "expression"
485                    );
486                }
487            }
488            "atom" => {
489                *if let ParsePairExpression::Sort(_, ref s) = pair.constructor_value {
490                    Box::new(Expression::from_pairs(s, generator))
491                } else {
492                    unreachable!(
493                        "expected different parse pair expression in pair to ast conversion of {}",
494                        "expression"
495                    );
496                }
497            }
498            "literal" => {
499                Self::Literal(
500                    info,
501                    if let ParsePairExpression::Sort(_, ref s) = pair.constructor_value {
502                        String::from_pairs(s, generator)
503                    } else {
504                        unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "expression");
505                    },
506                )
507            }
508            "paren" => {
509                if let ParsePairExpression::List(_, ref l) = pair.constructor_value {
510                    Self::Paren(
511                        info,
512                        if let ParsePairExpression::List(_, ref l) = l[1usize] {
513                            l . iter () . map (| x | if let ParsePairExpression :: Sort (_ , ref s) = x { Box :: new (Expression :: from_pairs (s , generator)) } else { unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "expression") ; }) . collect ()
514                        } else {
515                            unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "expression");
516                        },
517                    )
518                } else {
519                    unreachable!(
520                        "expected different parse pair expression in pair to ast conversion of {}",
521                        "expression"
522                    );
523                }
524            }
525            "labelled" => {
526                if let ParsePairExpression::List(_, ref l) = pair.constructor_value {
527                    Self::Labelled(
528                        info,
529                        if let ParsePairExpression::Sort(_, ref s) = l[0usize] {
530                            Identifier::from_pairs(s, generator)
531                        } else {
532                            unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "expression");
533                        },
534                        if let ParsePairExpression::Sort(_, ref s) = l[2usize] {
535                            Box::new(Expression::from_pairs(s, generator))
536                        } else {
537                            unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "expression");
538                        },
539                    )
540                } else {
541                    unreachable!(
542                        "expected different parse pair expression in pair to ast conversion of {}",
543                        "expression"
544                    );
545                }
546            }
547            "sort" => {
548                Self::Sort(
549                    info,
550                    if let ParsePairExpression::Sort(_, ref s) = pair.constructor_value {
551                        Identifier::from_pairs(s, generator)
552                    } else {
553                        unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "expression");
554                    },
555                )
556            }
557            "class" => {
558                Self::Class(
559                    info,
560                    if let ParsePairExpression::Sort(_, ref s) = pair.constructor_value {
561                        CharacterClass::from_pairs(s, generator)
562                    } else {
563                        unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "expression");
564                    },
565                )
566            }
567            a => unreachable!("{}", a),
568        }
569    }
570}
571impl<M: AstInfo> FromPairs<M> for Annotation<M> {
572    fn from_pairs<G: GenerateAstInfo<Result = M>>(pair: &ParsePairSort, generator: &mut G) -> Self {
573        assert!(
574            vec!["annotation"].contains(&pair.sort),
575            "{} not in {:?}",
576            pair.sort,
577            vec!["annotation"]
578        );
579        let info = generator.generate(&pair);
580        match pair.constructor_name {
581            "injection" => Self::Injection(info),
582            "no-pretty-print" => Self::NoPrettyPrint(info),
583            "single-string" => Self::SingleString(info),
584            "no-layout" => Self::NoLayout(info),
585            "hidden" => Self::Hidden(info),
586            "error" => {
587                if let ParsePairExpression::List(_, ref l) = pair.constructor_value {
588                    Self::Error(
589                        info,
590                        if let ParsePairExpression::Sort(_, ref s) = l[2usize] {
591                            String::from_pairs(s, generator)
592                        } else {
593                            unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "annotation");
594                        },
595                    )
596                } else {
597                    unreachable!(
598                        "expected different parse pair expression in pair to ast conversion of {}",
599                        "annotation"
600                    );
601                }
602            }
603            "part-of" => {
604                if let ParsePairExpression::List(_, ref l) = pair.constructor_value {
605                    Self::PartOf(
606                        info,
607                        if let ParsePairExpression::Sort(_, ref s) = l[2usize] {
608                            Identifier::from_pairs(s, generator)
609                        } else {
610                            unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "annotation");
611                        },
612                    )
613                } else {
614                    unreachable!(
615                        "expected different parse pair expression in pair to ast conversion of {}",
616                        "annotation"
617                    );
618                }
619            }
620            a => unreachable!("{}", a),
621        }
622    }
623}
624impl<M: AstInfo> FromPairs<M> for Number<M> {
625    fn from_pairs<G: GenerateAstInfo<Result = M>>(pair: &ParsePairSort, generator: &mut G) -> Self {
626        assert!(
627            vec!["number"].contains(&pair.sort),
628            "{} not in {:?}",
629            pair.sort,
630            vec!["number"]
631        );
632        let info = generator.generate(&pair);
633        return Self(info, pair.constructor_value.span().as_str().to_string());
634    }
635}
636impl<M: AstInfo> FromPairs<M> for DelimitedBound<M> {
637    fn from_pairs<G: GenerateAstInfo<Result = M>>(pair: &ParsePairSort, generator: &mut G) -> Self {
638        assert!(
639            vec!["delimited-bound"].contains(&pair.sort),
640            "{} not in {:?}",
641            pair.sort,
642            vec!["delimited-bound"]
643        );
644        let info = generator.generate(&pair);
645        match pair.constructor_name {
646            "num-num" => {
647                if let ParsePairExpression::List(_, ref l) = pair.constructor_value {
648                    Self::NumNum(
649                        info,
650                        if let ParsePairExpression::Sort(_, ref s) = l[0usize] {
651                            Number::from_pairs(s, generator)
652                        } else {
653                            unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "delimited-bound");
654                        },
655                        if let ParsePairExpression::Sort(_, ref s) = l[2usize] {
656                            Number::from_pairs(s, generator)
657                        } else {
658                            unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "delimited-bound");
659                        },
660                    )
661                } else {
662                    unreachable!(
663                        "expected different parse pair expression in pair to ast conversion of {}",
664                        "delimited-bound"
665                    );
666                }
667            }
668            "num-inf" => {
669                if let ParsePairExpression::List(_, ref l) = pair.constructor_value {
670                    Self::NumInf(
671                        info,
672                        if let ParsePairExpression::Sort(_, ref s) = l[0usize] {
673                            Number::from_pairs(s, generator)
674                        } else {
675                            unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "delimited-bound");
676                        },
677                    )
678                } else {
679                    unreachable!(
680                        "expected different parse pair expression in pair to ast conversion of {}",
681                        "delimited-bound"
682                    );
683                }
684            }
685            "num" => {
686                Self::Num(
687                    info,
688                    if let ParsePairExpression::Sort(_, ref s) = pair.constructor_value {
689                        Number::from_pairs(s, generator)
690                    } else {
691                        unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "delimited-bound");
692                    },
693                )
694            }
695            "star" => Self::Star(info),
696            "plus" => Self::Plus(info),
697            a => unreachable!("{}", a),
698        }
699    }
700}
701impl<M: AstInfo> FromPairs<M> for String<M> {
702    fn from_pairs<G: GenerateAstInfo<Result = M>>(pair: &ParsePairSort, generator: &mut G) -> Self {
703        assert!(
704            vec!["string"].contains(&pair.sort),
705            "{} not in {:?}",
706            pair.sort,
707            vec!["string"]
708        );
709        let info = generator.generate(&pair);
710        match pair.constructor_name {
711            "single" => {
712                if let ParsePairExpression::List(_, ref l) = pair.constructor_value {
713                    Self::Single(
714                        info,
715                        if let ParsePairExpression::List(_, ref l) = l[1usize] {
716                            l . iter () . map (| x | if let ParsePairExpression :: Sort (_ , ref s) = x { StringChar :: from_pairs (s , generator) } else { unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "string") ; }) . collect ()
717                        } else {
718                            unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "string");
719                        },
720                    )
721                } else {
722                    unreachable!(
723                        "expected different parse pair expression in pair to ast conversion of {}",
724                        "string"
725                    );
726                }
727            }
728            "double" => {
729                if let ParsePairExpression::List(_, ref l) = pair.constructor_value {
730                    Self::Double(
731                        info,
732                        if let ParsePairExpression::List(_, ref l) = l[1usize] {
733                            l . iter () . map (| x | if let ParsePairExpression :: Sort (_ , ref s) = x { StringChar :: from_pairs (s , generator) } else { unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "string") ; }) . collect ()
734                        } else {
735                            unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "string");
736                        },
737                    )
738                } else {
739                    unreachable!(
740                        "expected different parse pair expression in pair to ast conversion of {}",
741                        "string"
742                    );
743                }
744            }
745            a => unreachable!("{}", a),
746        }
747    }
748}
749impl<M: AstInfo> FromPairs<M> for CharacterClass<M> {
750    fn from_pairs<G: GenerateAstInfo<Result = M>>(pair: &ParsePairSort, generator: &mut G) -> Self {
751        assert!(
752            vec!["character-class"].contains(&pair.sort),
753            "{} not in {:?}",
754            pair.sort,
755            vec!["character-class"]
756        );
757        let info = generator.generate(&pair);
758        if let ParsePairExpression::List(_, ref l) = pair.constructor_value {
759            Self(
760                info,
761                if let ParsePairExpression::List(_, ref l) = l[1usize] {
762                    l.first().is_some()
763                } else {
764                    unreachable!(
765                        "expected different parse pair expression in pair to ast conversion of {}",
766                        "character-class"
767                    );
768                },
769                if let ParsePairExpression::List(_, ref l) = l[2usize] {
770                    l . iter () . map (| x | if let ParsePairExpression :: Sort (_ , ref s) = x { CharacterClassItem :: from_pairs (s , generator) } else { unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "character-class") ; }) . collect ()
771                } else {
772                    unreachable!(
773                        "expected different parse pair expression in pair to ast conversion of {}",
774                        "character-class"
775                    );
776                },
777            )
778        } else {
779            unreachable!(
780                "expected different parse pair expression in pair to ast conversion of {}",
781                "character-class"
782            );
783        }
784    }
785}
786impl<M: AstInfo> FromPairs<M> for StringChar<M> {
787    fn from_pairs<G: GenerateAstInfo<Result = M>>(pair: &ParsePairSort, generator: &mut G) -> Self {
788        assert!(
789            vec!["string-char"].contains(&pair.sort),
790            "{} not in {:?}",
791            pair.sort,
792            vec!["string-char"]
793        );
794        let info = generator.generate(&pair);
795        match pair.constructor_name {
796            "escaped" => {
797                if let ParsePairExpression::List(_, ref l) = pair.constructor_value {
798                    Self::Escaped(
799                        info,
800                        if let ParsePairExpression::Empty(ref span) = l[1usize] {
801                            span.as_str().to_string()
802                        } else {
803                            unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "string-char");
804                        },
805                    )
806                } else {
807                    unreachable!(
808                        "expected different parse pair expression in pair to ast conversion of {}",
809                        "string-char"
810                    );
811                }
812            }
813            "normal" => {
814                Self::Normal(
815                    info,
816                    if let ParsePairExpression::Empty(ref span) = pair.constructor_value {
817                        span.as_str().to_string()
818                    } else {
819                        unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "string-char");
820                    },
821                )
822            }
823            a => unreachable!("{}", a),
824        }
825    }
826}
827impl<M: AstInfo> FromPairs<M> for CharacterClassItem<M> {
828    fn from_pairs<G: GenerateAstInfo<Result = M>>(pair: &ParsePairSort, generator: &mut G) -> Self {
829        assert!(
830            vec!["character-class-item"].contains(&pair.sort),
831            "{} not in {:?}",
832            pair.sort,
833            vec!["character-class-item"]
834        );
835        let info = generator.generate(&pair);
836        match pair.constructor_name {
837            "range" => {
838                if let ParsePairExpression::List(_, ref l) = pair.constructor_value {
839                    Self::Range(
840                        info,
841                        if let ParsePairExpression::Sort(_, ref s) = l[0usize] {
842                            EscapeClosingBracket::from_pairs(s, generator)
843                        } else {
844                            unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "character-class-item");
845                        },
846                        if let ParsePairExpression::Sort(_, ref s) = l[2usize] {
847                            EscapeClosingBracket::from_pairs(s, generator)
848                        } else {
849                            unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "character-class-item");
850                        },
851                    )
852                } else {
853                    unreachable!(
854                        "expected different parse pair expression in pair to ast conversion of {}",
855                        "character-class-item"
856                    );
857                }
858            }
859            "single-char" => {
860                Self::SingleChar(
861                    info,
862                    if let ParsePairExpression::Sort(_, ref s) = pair.constructor_value {
863                        EscapeClosingBracket::from_pairs(s, generator)
864                    } else {
865                        unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "character-class-item");
866                    },
867                )
868            }
869            a => unreachable!("{}", a),
870        }
871    }
872}
873impl<M: AstInfo> FromPairs<M> for EscapeClosingBracket<M> {
874    fn from_pairs<G: GenerateAstInfo<Result = M>>(pair: &ParsePairSort, generator: &mut G) -> Self {
875        assert!(
876            vec!["escape-closing-bracket"].contains(&pair.sort),
877            "{} not in {:?}",
878            pair.sort,
879            vec!["escape-closing-bracket"]
880        );
881        let info = generator.generate(&pair);
882        match pair.constructor_name {
883            "escaped" => {
884                if let ParsePairExpression::List(_, ref l) = pair.constructor_value {
885                    Self::Escaped(
886                        info,
887                        if let ParsePairExpression::Empty(ref span) = l[1usize] {
888                            span.as_str().to_string()
889                        } else {
890                            unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "escape-closing-bracket");
891                        },
892                    )
893                } else {
894                    unreachable!(
895                        "expected different parse pair expression in pair to ast conversion of {}",
896                        "escape-closing-bracket"
897                    );
898                }
899            }
900            "unescaped" => {
901                Self::Unescaped(
902                    info,
903                    if let ParsePairExpression::Empty(ref span) = pair.constructor_value {
904                        span.as_str().to_string()
905                    } else {
906                        unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "escape-closing-bracket");
907                    },
908                )
909            }
910            a => unreachable!("{}", a),
911        }
912    }
913}
914impl<M: AstInfo> FromPairs<M> for Layout<M> {
915    fn from_pairs<G: GenerateAstInfo<Result = M>>(pair: &ParsePairSort, generator: &mut G) -> Self {
916        assert!(
917            vec!["layout"].contains(&pair.sort),
918            "{} not in {:?}",
919            pair.sort,
920            vec!["layout"]
921        );
922        let info = generator.generate(&pair);
923        match pair.constructor_name {
924            "simple" => {
925                Self::Simple(
926                    info,
927                    if let ParsePairExpression::Empty(ref span) = pair.constructor_value {
928                        span.as_str().to_string()
929                    } else {
930                        unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "layout");
931                    },
932                )
933            }
934            "comment" => {
935                if let ParsePairExpression::List(_, ref l) = pair.constructor_value {
936                    Self::Comment(
937                        info,
938                        if let ParsePairExpression::List(_, ref l) = l[1usize] {
939                            l . iter () . map (| x | if let ParsePairExpression :: Empty (ref span) = x { span . as_str () . to_string () } else { unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "layout") ; }) . collect ()
940                        } else {
941                            unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "layout");
942                        },
943                    )
944                } else {
945                    unreachable!(
946                        "expected different parse pair expression in pair to ast conversion of {}",
947                        "layout"
948                    );
949                }
950            }
951            a => unreachable!("{}", a),
952        }
953    }
954}
lwb_parser/parser/syntax_file/ast/from_pairs.rs

lwb_parser/parser/syntax_file/ast/
from_pairs.rs
