decent_synquote_alternative/
parser.rs

1use proc_macro2::token_stream::IntoIter;
2use proc_macro2::{Delimiter, Ident, Literal, Punct, Spacing, Span, TokenStream, TokenTree};
3
4#[macro_export]
5macro_rules! join_ts {
6    ($iter:expr) => {
7        {
8            #[allow(unused_mut)]
9            let mut tb = TokenBuilder::new();
10            for part in $iter {
11                tb.extend(part);
12            }
13            tb.end()
14        }
15    };
16    ($iter:expr, separator: $sep:expr) => {
17        {
18            #[allow(unused_mut)]
19            let mut tb = TokenBuilder::new();
20            let mut add_sep = false;
21            for part in $iter {
22                if add_sep {
23                    $sep.add_to(&mut tb);
24                }
25                tb.extend(part);
26                add_sep = true;
27            }
28            tb.end()
29        }
30    };
31    ($iter:expr, $part_pat:pat, $($part:expr) *) => {
32        {
33            #[allow(unused_mut)]
34            let mut tb = TokenBuilder::new();
35            for $part_pat in $iter {
36                extend_ts!(&mut tb,
37                    $($part) *
38                );
39            }
40            tb.end()
41        }
42    };
43    ($iter:expr, $part_pat:pat, $($part:expr) *, separator: $sep:expr) => {
44        {
45            #[allow(unused_mut)]
46            let mut tb = TokenBuilder::new();
47            let mut add_sep = false;
48            for $part_pat in $iter {
49                if add_sep {
50                    $sep.add_to(&mut tb);
51                }
52                extend_ts!(&mut tb,
53                    $($part) *
54                );
55                add_sep = true;
56            }
57            tb.end()
58        }
59    };
60}
61
62#[macro_export]
63macro_rules! extend_ts {
64    ($tb:expr, $($part:expr) *) => {
65        {
66            $(
67                $part.add_to($tb);
68            )*
69        }
70    };
71}
72
73#[macro_export]
74macro_rules! ts {
75    ($($part:expr) *) => {
76        {
77            #[allow(unused_mut)]
78            let mut tb = TokenBuilder::new();
79            $(
80                $part.add_to(&mut tb);
81            )*
82            tb.end()
83        }
84    };
85}
86
87#[macro_export]
88macro_rules! ident {
89    ($($x:expr) *) => {{
90        let mut s = String::new();
91        $(
92            s.push_str(&$x.to_string());
93        )*
94        Ident::new(&s, Span::call_site())
95    }};
96}
97
98use crate::token_builder::*;
99
100pub struct TokenParser {
101    backtracked: Option<Box<TokenParser>>,
102    iter_stack: Vec<IntoIter>,
103    current: Option<TokenTree>,
104}
105
106fn token_tree_as_punct(tt: &TokenTree, what: char) -> Option<Punct> {
107    if let TokenTree::Punct(p) = tt {
108        if p.as_char() == what {
109            Some(p.clone())
110        } else {
111            None
112        }
113    } else {
114        None
115    }
116}
117
118fn token_tree_as_ident(tt: &TokenTree, what: &str) -> Option<Ident> {
119    if let TokenTree::Ident(i) = tt {
120        if i.to_string() == what {
121            Some(i.clone())
122        } else {
123            None
124        }
125    } else {
126        None
127    }
128}
129
130#[derive(Clone, Copy)]
131pub enum StructKind {
132    Struct,
133    Tuple,
134}
135impl StructKind {
136    pub fn open(&self) -> &'static str {
137        match self {
138            StructKind::Struct => "{",
139            StructKind::Tuple => "(",
140        }
141    }
142    pub fn close(&self) -> &str {
143        match self {
144            StructKind::Struct => "}",
145            StructKind::Tuple => ")",
146        }
147    }
148}
149
150#[derive(Clone)]
151pub enum StructFieldIdentifier {
152    Named(Ident),
153    Position(usize),
154}
155impl Default for StructFieldIdentifier {
156    fn default() -> Self {
157        Self::Position(0)
158    }
159}
160
161#[derive(Clone)]
162pub struct Struct {
163    pub attributes: Vec<TokenStream>,
164    pub visibility: TokenStream,
165    pub ident: Ident,
166    pub generics: Generics,
167    pub kind: Option<StructKind>,
168    pub where_clause: Option<WhereClause>,
169    pub struct_fields: Vec<StructField>,
170}
171#[derive(Clone)]
172pub struct StructField {
173    pub attributes: Vec<TokenStream>,
174    pub visibility: TokenStream,
175    pub identifier: StructFieldIdentifier,
176    pub ty: Ty,
177}
178impl StructField {
179    pub fn access(&self) -> TokenStream {
180        match &self.identifier {
181            StructFieldIdentifier::Named(x) => ts!(x),
182            StructFieldIdentifier::Position(i) => ts!(i),
183        }
184    }
185
186    pub fn safe_ident(&self) -> Ident {
187        match &self.identifier {
188            StructFieldIdentifier::Named(x) => x.clone(),
189            StructFieldIdentifier::Position(i) => ident!("_" i),
190        }
191    }
192    pub fn expr_field(&self, rhs: TokenStream) -> TokenStream {
193        match &self.identifier {
194            StructFieldIdentifier::Named(x) => ts!(x ":" rhs),
195            StructFieldIdentifier::Position(_) => rhs,
196        }
197    }
198}
199#[derive(Clone)]
200pub struct Enum {
201    pub attributes: Vec<TokenStream>,
202    pub visibility: TokenStream,
203    pub ident: Ident,
204    pub generics: Generics,
205    pub where_clause: Option<WhereClause>,
206    pub items: Vec<EnumItem>,
207}
208#[derive(Clone)]
209pub struct EnumItem {
210    pub attributes: Vec<TokenStream>,
211    pub ident: Ident,
212    pub data: Option<EnumItemData>,
213}
214impl EnumItem {
215    pub fn get_struct_data(&self) -> Option<(StructKind, &[StructField])> {
216        match &self.data {
217            None | Some(EnumItemData::Discriminant(_)) => None,
218            Some(EnumItemData::Struct(kind, fields)) => Some((*kind, fields)),
219        }
220    }
221
222    pub fn pattern_match(&self, enum_ident: &Ident, binding_append: Option<Ident>) -> TokenStream {
223        match &self.data {
224            Some(EnumItemData::Struct(kind, fields)) => ts!(
225                enum_ident "::" self.ident
226                kind.open()
227                    join_ts!(fields.iter(), field,
228                        match &field.identifier {
229                            StructFieldIdentifier::Named(x) => {
230                                ts!(x ":")
231                            }
232                            StructFieldIdentifier::Position(_) => {
233                                ts!("")
234                            }
235                        }
236                        if let Some(binding_append) = &binding_append {
237                            ident!(field.safe_ident() binding_append)
238                        } else {
239                            field.safe_ident()
240                        }
241                    , separator: ",")
242                kind.close()
243            ),
244            None | Some(EnumItemData::Discriminant(_)) => ts!(enum_ident "::" self.ident),
245        }
246    }
247}
248#[derive(Clone)]
249pub enum EnumItemData {
250    Discriminant(TokenTree),
251    Struct(StructKind, Vec<StructField>),
252}
253#[derive(Clone)]
254pub struct LifetimeParam {
255    pub ident: TokenStream,
256    pub bounds: Option<TokenStream>,
257}
258#[derive(Clone, Default)]
259pub struct TypeParam {
260    pub attributes: Vec<TokenStream>,
261    pub type_ident: TokenStream,
262    pub bounds: Option<TokenStream>,
263    pub equal_ty: Option<Ty>,
264}
265#[derive(Clone, Default)]
266pub struct Generics {
267    pub lifetime_params: Vec<LifetimeParam>,
268    pub type_params: Vec<TypeParam>,
269}
270#[derive(Clone)]
271pub struct WhereClauseItem {
272    pub for_lifetimes: Option<TokenStream>,
273    pub lhs: TokenStream,
274    pub rhs: TokenStream,
275}
276#[derive(Clone, Default)]
277pub struct WhereClause {
278    pub items: Vec<WhereClauseItem>,
279}
280#[derive(Clone)]
281pub struct Function {
282    pub attributes: Vec<TokenStream>,
283    pub visibility: TokenStream,
284    pub ident: Ident,
285    pub qualifiers: FunctionQualifiers,
286    pub generics: Generics,
287    pub parameters: Vec<FunctionParameter>,
288    pub return_ty: Option<Ty>,
289    pub where_clause: Option<WhereClause>,
290}
291#[derive(Clone, Default)]
292pub struct FunctionQualifiers {
293    pub async_or_const: Option<AsyncOrConst>,
294    pub unsafe_: bool,
295    pub extern_abi: Option<TokenStream>,
296}
297#[derive(Clone)]
298pub enum AsyncOrConst {
299    Async,
300    Const,
301}
302#[derive(Clone)]
303pub struct FunctionParameter {
304    pub attributes: Vec<TokenStream>,
305    pub pattern: TokenStream,
306    pub ty: Ty,
307}
308#[derive(Clone)]
309pub struct RefTy {
310    pub mutable: bool,
311    pub lifetime: Option<TokenStream>,
312    pub rest: Ty,
313}
314#[derive(Clone)]
315pub struct Ty {
316    pub stream: TokenStream,
317    pub kind: TyKind,
318}
319#[derive(Clone)]
320pub enum TyKind {
321    Ref(Box<RefTy>),
322    Other,
323}
324
325impl TokenBuilderExtend for Ty {
326    fn add_to(&self, tb: &mut TokenBuilder) {
327        self.stream.add_to(tb)
328    }
329}
330
331impl TokenBuilderExtend for AsyncOrConst {
332    fn add_to(&self, tb: &mut TokenBuilder) {
333        match self {
334            AsyncOrConst::Async => tb.extend(&ident!("async")),
335            AsyncOrConst::Const => tb.extend(&ident!("const")),
336        }
337    }
338}
339impl TokenBuilderExtend for FunctionParameter {
340    fn add_to(&self, tb: &mut TokenBuilder) {
341        extend_ts!(tb,
342            self.attributes self.pattern ":" self.ty
343        )
344    }
345}
346impl TokenBuilderExtend for FunctionQualifiers {
347    fn add_to(&self, tb: &mut TokenBuilder) {
348        extend_ts!(tb,
349            self.async_or_const if self.unsafe_ { ts!("unsafe") } else { ts!() } self.extern_abi
350        )
351    }
352}
353impl TokenBuilderExtend for Function {
354    fn add_to(&self, tb: &mut TokenBuilder) {
355        extend_ts!(tb,
356            self.attributes self.visibility self.qualifiers
357                "fn" self.ident self.generics "(" self.parameters ")"
358                if let Some(return_ty) = &self.return_ty {
359                    ts!("->" return_ty)
360                } else {
361                    ts!()
362                }
363                self.where_clause
364        )
365    }
366}
367
368impl Generics {
369    pub fn mutating_type_params(&self, mutate: impl Fn(&mut TypeParam)) -> Self {
370        let mut cloned = self.clone();
371        for lt in cloned.type_params.iter_mut() {
372            mutate(lt)
373        }
374        cloned
375    }
376}
377impl TokenBuilderExtend for Enum {
378    fn add_to(&self, tb: &mut TokenBuilder) {
379        extend_ts!(tb,
380            self.visibility "enum" self.ident self.generics self.where_clause
381            "{"
382            join_ts!(&self.items, item,
383                item.attributes item.ident
384                match &item.data {
385                    Some(EnumItemData::Struct(kind, fields)) => {
386                        ts!(
387                            kind.open()
388                            join_ts!(fields, separator: ",")
389                            kind.close()
390                        )
391                    }
392                    Some(EnumItemData::Discriminant(discriminant)) => {
393                        ts!("=" discriminant)
394                    }
395                    None => {
396                        ts!()
397                    }
398                }
399            , separator: ",")
400            "}"
401        )
402    }
403}
404impl TokenBuilderExtend for Struct {
405    fn add_to(&self, tb: &mut TokenBuilder) {
406        let (first_where_clause_slot, second_where_clause_slot) = if matches!(self.kind, Some(StructKind::Struct)) {
407            (ts!(self.where_clause), ts!())
408        } else {
409            (ts!(), ts!(self.where_clause))
410        };
411
412        extend_ts!(tb,
413            self.visibility "struct" self.ident self.generics
414            first_where_clause_slot
415            self.kind.as_ref().map(|k| k.open())
416            join_ts!(&self.struct_fields, separator: ",")
417            self.kind.as_ref().map(|k| k.close())
418            second_where_clause_slot
419            match self.kind {
420                Some(StructKind::Tuple) | None => ";",
421                _ => ""
422            }
423        )
424    }
425}
426impl TokenBuilderExtend for StructField {
427    fn add_to(&self, tb: &mut TokenBuilder) {
428        extend_ts!(tb,
429            self.attributes
430            self.visibility
431            match &self.identifier {
432                StructFieldIdentifier::Named(x) => ts!(x ":"),
433                StructFieldIdentifier::Position(_) => ts!()
434            }
435            self.ty
436        )
437    }
438}
439impl TokenBuilderExtend for LifetimeParam {
440    fn add_to(&self, tb: &mut TokenBuilder) {
441        extend_ts!(tb,
442            self.ident
443            self.bounds.as_ref().map(|x| ts!(":" x))
444        )
445    }
446}
447impl TokenBuilderExtend for TypeParam {
448    fn add_to(&self, tb: &mut TokenBuilder) {
449        extend_ts!(tb,
450            self.attributes
451            self.type_ident
452            self.bounds.as_ref().map(|x| ts!(":" x))
453            self.equal_ty.as_ref().map(|x| ts!("=" x))
454        )
455    }
456}
457impl TokenBuilderExtend for Generics {
458    fn add_to(&self, tb: &mut TokenBuilder) {
459        if self.lifetime_params.is_empty() && self.type_params.is_empty() {
460        } else {
461            extend_ts!(tb,
462                "<"
463                join_ts!(&self.lifetime_params, separator: ",")
464                if !self.lifetime_params.is_empty() { ts!(",") } else { ts!() }
465                join_ts!(&self.type_params, separator: ",")
466                ">"
467            )
468        }
469    }
470}
471impl Generics {
472    pub fn removing_eq_type(&self) -> Self {
473        let mut new = self.clone();
474        for type_param in new.type_params.iter_mut() {
475            type_param.equal_ty = None;
476        }
477        new
478    }
479    pub fn removing_bounds_and_eq_type(&self) -> Self {
480        let mut new = self.clone();
481        for lifetime_param in new.lifetime_params.iter_mut() {
482            lifetime_param.bounds = None;
483        }
484        for type_param in new.type_params.iter_mut() {
485            type_param.bounds = None;
486            type_param.equal_ty = None;
487        }
488        new
489    }
490}
491impl TokenBuilderExtend for WhereClauseItem {
492    fn add_to(&self, tb: &mut TokenBuilder) {
493        extend_ts!(tb,
494            self.for_lifetimes self.lhs ":" self.rhs
495        )
496    }
497}
498impl TokenBuilderExtend for WhereClause {
499    fn add_to(&self, tb: &mut TokenBuilder) {
500        extend_ts!(tb,
501            "where"
502            join_ts!(&self.items, separator: ",")
503        )
504    }
505}
506
507impl WhereClause {
508    pub fn add_clause_items(&mut self, items: TokenStream) {
509        let mut parser = TokenParser::new(items);
510        let mut items = Vec::new();
511        while let Some(clause_item) = parser.eat_where_clause_item() {
512            items.push(clause_item);
513            if let Some(_) = parser.eat_punct(',') {
514                continue;
515            } else {
516                break;
517            }
518        }
519        self.items.extend(items);
520    }
521}
522
523impl TokenParser {
524    pub fn eat_function(&mut self) -> Option<Function> {
525        let mut attributes = Vec::new();
526        while let Some(attribute) = self.eat_outer_attribute() {
527            attributes.push(attribute);
528        }
529        let visibility = self.eat_visibility();
530        let async_or_const = if self.eat_ident("async").is_some() {
531            Some(AsyncOrConst::Async)
532        } else if self.eat_ident("const").is_some() {
533            Some(AsyncOrConst::Const)
534        } else {
535            None
536        };
537        let unsafe_ = self.eat_ident("unsafe").is_some();
538        let extern_abi = if let Some(extern_) = self.eat_ident("extern") {
539            if let Some(literal) = self.eat_literal() {
540                Some(ts!(extern_ literal))
541            } else {
542                return None;
543            }
544        } else {
545            None
546        };
547        if self.eat_ident("fn").is_some() {
548            if let Some(ident) = self.eat_any_ident() {
549                let generics = self.eat_generics();
550                if let Some(TokenTree::Group(content)) = self.eat_group(Delimiter::Parenthesis) {
551                    let mut content_parser = TokenParser::new(content.stream());
552                    let mut parameters = Vec::new();
553                    while let Some(parameter) = content_parser.eat_function_parameter() {
554                        parameters.push(parameter);
555                        let _ = content_parser.eat_punct(',');
556                    }
557                    let return_ty = if self.eat_punct('-').is_some() {
558                        if self.eat_punct('>').is_some() {
559                            if let Some(return_ty) = self.eat_type() {
560                                Some(return_ty)
561                            } else {
562                                return None;
563                            }
564                        } else {
565                            return None;
566                        }
567                    } else {
568                        None
569                    };
570                    let where_clause = self.eat_where_clause();
571                    return Some(Function {
572                        attributes,
573                        visibility,
574                        ident,
575                        generics,
576                        qualifiers: FunctionQualifiers {
577                            async_or_const,
578                            unsafe_,
579                            extern_abi,
580                        },
581                        parameters,
582                        return_ty,
583                        where_clause,
584                    });
585                }
586            }
587        }
588        return None;
589    }
590
591    pub fn eat_function_parameter(&mut self) -> Option<FunctionParameter> {
592        let mut attributes = Vec::new();
593        while let Some(attribute) = self.eat_outer_attribute() {
594            attributes.push(attribute);
595        }
596        let mut pattern = TokenBuilder::new();
597        let mut empty_pattern = true;
598        while let Some(tt) = self.advance_if(|tt| match tt {
599            TokenTree::Punct(p) => {
600                if p.as_char() != ':' {
601                    Some(tt.clone())
602                } else {
603                    None
604                }
605            }
606            _ => Some(tt.clone()),
607        }) {
608            empty_pattern = false;
609            pattern.extend_tree(tt);
610        }
611        if empty_pattern {
612            return None;
613        }
614        self.eat_punct(':').unwrap();
615
616        if let Some(ty) = self.eat_type() {
617            Some(FunctionParameter {
618                attributes,
619                pattern: pattern.end(),
620                ty,
621            })
622        } else {
623            return None;
624        }
625    }
626
627    pub fn new(start: TokenStream) -> Self {
628        let mut ret = Self {
629            backtracked: None,
630            iter_stack: vec![start.into_iter()],
631            current: None,
632        };
633        ret.advance();
634        ret
635    }
636
637    pub fn backtrack(&mut self, ts: TokenStream) {
638        if !ts.is_empty() {
639            if let Some(backtracked) = &mut self.backtracked {
640                backtracked.backtrack(ts)
641            } else {
642                self.backtracked = Some(Box::new(TokenParser::new(ts)));
643            }
644        }
645    }
646
647    pub fn peek(&mut self) -> Option<&TokenTree> {
648        if let Some(backtracked) = &mut self.backtracked {
649            backtracked.peek()
650        } else {
651            self.current.as_ref()
652        }
653    }
654
655    pub fn advance(&mut self) {
656        if let Some(backtracked) = &mut self.backtracked {
657            backtracked.advance();
658            if backtracked.peek().is_none() {
659                self.backtracked = None;
660            }
661            return;
662        }
663        let last = self.iter_stack.last_mut().unwrap();
664        let value = last.next();
665
666        if let Some(tok) = value {
667            self.current = Some(tok);
668        } else {
669            self.current = None;
670        }
671    }
672
673    pub fn advance_if<T>(&mut self, cond: impl FnOnce(&TokenTree) -> Option<T>) -> Option<T> {
674        let value = self.peek();
675        if let Some(tok) = value {
676            if let Some(value) = cond(tok) {
677                self.advance();
678                Some(value)
679            } else {
680                None
681            }
682        } else {
683            None
684        }
685    }
686
687    pub fn open_delim(&mut self, delim: Delimiter) -> bool {
688        let iter = if let Some(TokenTree::Group(group)) = self.peek() {
689            if group.delimiter() == delim {
690                Some(group.stream().into_iter())
691            } else {
692                None
693            }
694        } else {
695            None
696        };
697
698        if let Some(iter) = iter {
699            self.iter_stack.push(iter);
700            self.advance();
701            true
702        } else {
703            false
704        }
705    }
706
707    pub fn open_brace(&mut self) -> bool {
708        self.open_delim(Delimiter::Brace)
709    }
710
711    pub fn open_paren(&mut self) -> bool {
712        self.open_delim(Delimiter::Parenthesis)
713    }
714
715    //
716    // pub fn open_bracket(&mut self) -> bool {
717    //     self.open_delim(Delimiter::Bracket)
718    // }
719
720    pub fn is_eot(&mut self) -> bool {
721        if self.current.is_none() && self.iter_stack.len() != 0 {
722            return true;
723        } else {
724            return false;
725        }
726    }
727
728    pub fn eat_eot(&mut self) -> bool {
729        // current is None
730        if self.is_eot() {
731            self.iter_stack.pop();
732            if self.iter_stack.len() != 0 {
733                self.advance()
734            }
735            return true;
736        }
737        return false;
738    }
739
740    pub fn eat_ident(&mut self, what: &str) -> Option<Ident> {
741        self.advance_if(|tt| token_tree_as_ident(tt, what))
742    }
743
744    //
745    // pub fn is_punct(&mut self, what: char) -> bool {
746    //     // check if our punct is multichar.
747    //     if let Some(tt) = self.peek() {
748    //         token_tree_as_punct(tt, what).is_some()
749    //     } else {
750    //         return false;
751    //     }
752    // }
753
754    pub fn eat_punct_with_spacing(&mut self, what: char, spacing: Spacing) -> Option<Punct> {
755        self.advance_if(|tt| {
756            if let TokenTree::Punct(p) = tt {
757                if p.as_char() == what && p.spacing() == spacing {
758                    Some(p.clone())
759                } else {
760                    None
761                }
762            } else {
763                None
764            }
765        })
766    }
767
768    pub fn eat_punct(&mut self, what: char) -> Option<Punct> {
769        self.advance_if(|tt| token_tree_as_punct(tt, what))
770    }
771
772    pub fn eat_any_ident(&mut self) -> Option<Ident> {
773        self.advance_if(|tt| {
774            if let TokenTree::Ident(id) = tt {
775                Some(id.clone())
776            } else {
777                None
778            }
779        })
780    }
781
782    pub fn eat_literal(&mut self) -> Option<Literal> {
783        self.advance_if(|tt| {
784            if let TokenTree::Literal(l) = tt {
785                Some(l.clone())
786            } else {
787                None
788            }
789        })
790    }
791
792    pub fn eat_type_bound_where_clause_item(&mut self) -> Option<WhereClauseItem> {
793        let for_lifetimes = self.eat_for_lifetimes();
794        if let Some(ty) = self.eat_type() {
795            let lhs = ty;
796            if let Some(_) = self.eat_punct(':') {
797                let mut rhs = TokenBuilder::new();
798                if let Some(typbs) = self.eat_type_param_bounds() {
799                    rhs.stream(typbs);
800                }
801                let rhs = rhs.end();
802                return Some(WhereClauseItem {
803                    for_lifetimes,
804                    lhs: lhs.stream,
805                    rhs,
806                });
807            }
808        }
809        None
810    }
811
812    pub fn eat_lifetime_bounds(&mut self) -> Option<TokenStream> {
813        let mut tb = TokenBuilder::new();
814        while let Some(lt) = self.eat_lifetime() {
815            tb.stream(lt);
816            if let Some(plus) = self.eat_punct('+') {
817                tb.extend(&plus);
818                continue;
819            } else {
820                break;
821            }
822        }
823        Some(tb.end())
824    }
825
826    pub fn eat_lifetime_where_clause_item(&mut self) -> Option<WhereClauseItem> {
827        if let Some(lt) = self.eat_lifetime() {
828            let lhs = lt;
829            if let Some(_) = self.eat_punct(':') {
830                if let Some(lt_bounds) = self.eat_lifetime_bounds() {
831                    let rhs = lt_bounds;
832
833                    return Some(WhereClauseItem {
834                        for_lifetimes: None,
835                        lhs,
836                        rhs,
837                    });
838                }
839            }
840        }
841        None
842    }
843
844    pub fn eat_where_clause_item(&mut self) -> Option<WhereClauseItem> {
845        self.eat_lifetime_where_clause_item()
846            .or_else(|| self.eat_type_bound_where_clause_item())
847    }
848
849    pub fn eat_where_clause(&mut self) -> Option<WhereClause> {
850        if let Some(_) = self.eat_ident("where") {
851            let mut items = Vec::new();
852            while let Some(clause_item) = self.eat_where_clause_item() {
853                items.push(clause_item);
854                if let Some(_) = self.eat_punct(',') {
855                    continue;
856                } else {
857                    break;
858                }
859            }
860            Some(WhereClause { items })
861        } else {
862            None
863        }
864    }
865
866    pub fn eat_struct(&mut self) -> Option<Struct> {
867        let mut attributes = Vec::new();
868        while let Some(attr) = self.eat_outer_attribute() {
869            attributes.push(attr);
870        }
871        let visibility = self.eat_visibility();
872        if let Some(_) = self.eat_ident("struct") {
873            if let Some(ident) = self.eat_any_ident() {
874                let generics = self.eat_generics();
875                if self.open_paren() {
876                    let struct_fields = self.eat_tuple_fields();
877
878                    if self.eat_eot() {
879                        let where_clause = self.eat_where_clause();
880                        if let Some(_) = self.eat_punct(';') {
881                            return Some(Struct {
882                                attributes,
883                                visibility,
884                                ident,
885                                generics,
886                                kind: Some(StructKind::Tuple),
887                                where_clause,
888                                struct_fields,
889                            });
890                        }
891                    }
892                } else {
893                    // struct struct or empty struct
894                    let where_clause = self.eat_where_clause();
895                    if self.open_brace() {
896                        let struct_fields = self.eat_struct_fields();
897
898                        if self.eat_eot() {
899                            return Some(Struct {
900                                attributes,
901                                visibility,
902                                ident,
903                                generics,
904                                kind: Some(StructKind::Struct),
905                                where_clause,
906                                struct_fields,
907                            });
908                        }
909                    } else {
910                        return Some(Struct {
911                            attributes,
912                            visibility,
913                            ident,
914                            generics,
915                            kind: None,
916                            where_clause,
917                            struct_fields: vec![],
918                        });
919                    }
920                }
921            }
922        }
923        self.backtrack(visibility);
924        None
925    }
926
927    pub fn eat_enum_item(&mut self) -> Option<EnumItem> {
928        let mut attributes = Vec::new();
929        while let Some(attr) = self.eat_outer_attribute() {
930            attributes.push(attr);
931        }
932        let _ = self.eat_visibility();
933
934        if let Some(ident) = self.eat_any_ident() {
935            if self.open_paren() {
936                let struct_fields = self.eat_tuple_fields();
937                self.eat_eot();
938                Some(EnumItem {
939                    attributes,
940                    ident,
941                    data: Some(EnumItemData::Struct(StructKind::Tuple, struct_fields)),
942                })
943            } else if self.open_brace() {
944                let struct_fields = self.eat_struct_fields();
945                self.eat_eot();
946                Some(EnumItem {
947                    attributes,
948                    ident,
949                    data: Some(EnumItemData::Struct(StructKind::Struct, struct_fields)),
950                })
951            } else if let Some(_) = self.eat_punct('=') {
952                let expr: Option<TokenTree> = self
953                    .eat_literal()
954                    .map(TokenTree::Literal)
955                    .or_else(|| self.eat_any_ident().map(TokenTree::Ident))
956                    .or_else(|| self.eat_group(Delimiter::Brace))
957                    .into();
958                if let Some(expr) = expr {
959                    Some(EnumItem {
960                        attributes,
961                        ident,
962                        data: Some(EnumItemData::Discriminant(expr)),
963                    })
964                } else {
965                    // self.backtrack(tb.end());
966                    None
967                }
968            } else {
969                Some(EnumItem {
970                    attributes,
971                    ident,
972                    data: None,
973                })
974            }
975        } else {
976            // self.backtrack(tb.end());
977            None
978        }
979    }
980
981    pub fn eat_enumeration(&mut self) -> Option<Enum> {
982        let mut attributes = Vec::new();
983        while let Some(attr) = self.eat_outer_attribute() {
984            attributes.push(attr);
985        }
986        let visibility = self.eat_visibility();
987
988        if let Some(_) = self.eat_ident("enum") {
989            if let Some(ident) = self.eat_any_ident() {
990                let generics = self.eat_generics();
991                let where_clause = self.eat_where_clause();
992                if self.open_brace() {
993                    let mut items = Vec::new();
994                    while let Some(item) = self.eat_enum_item() {
995                        items.push(item);
996                        if let Some(_) = self.eat_punct(',') {
997                        } else {
998                            break;
999                        }
1000                    }
1001                    if self.eat_eot() {
1002                        return Some(Enum {
1003                            attributes,
1004                            visibility,
1005                            ident,
1006                            generics,
1007                            where_clause,
1008                            items,
1009                        });
1010                    }
1011                }
1012            }
1013        }
1014        self.backtrack(visibility);
1015        return None;
1016    }
1017
1018    pub fn eat_lifetime_param(&mut self) -> Option<LifetimeParam> {
1019        let mut attributes = Vec::new();
1020        while let Some(outer_attribute) = self.eat_outer_attribute() {
1021            attributes.push(outer_attribute);
1022        }
1023        if let Some(ident) = self.eat_lifetime_or_label() {
1024            if let Some(_) = self.eat_punct(':') {
1025                if let Some(bounds) = self.eat_lifetime_bounds() {
1026                    Some(LifetimeParam {
1027                        ident,
1028                        bounds: Some(bounds),
1029                    })
1030                } else {
1031                    // self.backtrack(tb.end());
1032                    None
1033                }
1034            } else {
1035                Some(LifetimeParam { ident, bounds: None })
1036            }
1037        } else {
1038            // self.backtrack(tb.end());
1039            return None;
1040        }
1041    }
1042
1043    pub fn eat_type_param(&mut self) -> Option<TypeParam> {
1044        let mut attributes = Vec::new();
1045        while let Some(attr) = self.eat_outer_attribute() {
1046            attributes.push(attr);
1047        }
1048        if let Some(ident) = self.eat_any_ident() {
1049            let bounds = if let Some(_) = self.eat_punct(':') {
1050                if let Some(bounds) = self.eat_type_param_bounds() {
1051                    Some(bounds)
1052                } else {
1053                    // self.backtrack(tb.end());
1054                    return None;
1055                }
1056            } else {
1057                None
1058            };
1059            let equal_ty = if let Some(_) = self.eat_punct('=') {
1060                if let Some(ty) = self.eat_type() {
1061                    Some(ty)
1062                } else {
1063                    // self.backtrack(tb.end());
1064                    return None;
1065                }
1066            } else {
1067                None
1068            };
1069            Some(TypeParam {
1070                attributes,
1071                type_ident: TokenTree::Ident(ident).into(),
1072                bounds,
1073                equal_ty,
1074            })
1075        } else {
1076            // self.backtrack(tb.end());
1077            None
1078        }
1079    }
1080
1081    pub fn eat_generics(&mut self) -> Generics {
1082        if let Some(_) = self.eat_punct('<') {
1083            let mut lifetime_params = Vec::new();
1084            while let Some(lt_param) = self.eat_lifetime_param() {
1085                lifetime_params.push(lt_param);
1086                if let Some(_) = self.eat_punct(',') {}
1087            }
1088            let mut type_params = Vec::new();
1089            while let Some(ty_param) = self.eat_type_param() {
1090                type_params.push(ty_param);
1091                if let Some(_) = self.eat_punct(',') {
1092                } else {
1093                    break;
1094                }
1095            }
1096
1097            if let Some(_) = self.eat_punct('>') {
1098                return Generics {
1099                    lifetime_params,
1100                    type_params,
1101                };
1102            }
1103        }
1104        Generics {
1105            lifetime_params: Vec::new(),
1106            type_params: Vec::new(),
1107        }
1108    }
1109
1110    pub fn eat_tuple_fields(&mut self) -> Vec<StructField> {
1111        let mut i = 0;
1112        if let Some(field) = self.eat_tuple_field(i) {
1113            i += 1;
1114            let mut fields = Vec::new();
1115            fields.push(field);
1116            while let Some(_) = self.eat_punct(',') {
1117                if let Some(field) = self.eat_tuple_field(i) {
1118                    i += 1;
1119                    fields.push(field);
1120                } else {
1121                    break;
1122                }
1123            }
1124            fields
1125        } else {
1126            Vec::new()
1127        }
1128    }
1129
1130    pub fn eat_tuple_field(&mut self, i: usize) -> Option<StructField> {
1131        let mut attributes = Vec::new();
1132        while let Some(attribute) = self.eat_outer_attribute() {
1133            attributes.push(attribute);
1134        }
1135        let visibility = self.eat_visibility();
1136        if let Some(ty) = self.eat_type() {
1137            Some(StructField {
1138                attributes,
1139                visibility,
1140                identifier: StructFieldIdentifier::Position(i),
1141                ty,
1142            })
1143        } else {
1144            // self.backtrack(tb.end());
1145            None
1146        }
1147    }
1148
1149    pub fn eat_struct_fields(&mut self) -> Vec<StructField> {
1150        let mut fields = Vec::new();
1151        while let Some(field) = self.eat_struct_field() {
1152            fields.push(field);
1153            if let Some(_) = self.eat_punct(',') {
1154            } else {
1155                break;
1156            }
1157        }
1158        fields
1159    }
1160
1161    pub fn eat_struct_field(&mut self) -> Option<StructField> {
1162        let mut attributes = vec![];
1163        while let Some(outer_attribute) = self.eat_outer_attribute() {
1164            attributes.push(outer_attribute.clone());
1165        }
1166        let visibility = self.eat_visibility();
1167        if let Some(identifier) = self.eat_any_ident() {
1168            let _ = self.eat_punct(':');
1169            if let Some(ty) = self.eat_type() {
1170                Some(StructField {
1171                    attributes,
1172                    visibility,
1173                    identifier: StructFieldIdentifier::Named(identifier),
1174                    ty,
1175                })
1176            } else {
1177                // self.backtrack(tb.end());
1178                None
1179            }
1180        } else {
1181            // self.backtrack(tb.end());
1182            None
1183        }
1184    }
1185
1186    pub fn eat_group_angle_bracket(&mut self) -> Option<TokenStream> {
1187        let mut tb = TokenBuilder::new();
1188        // if we have a <, keep running and keep a < stack
1189
1190        if let Some(ob) = self.eat_punct('<') {
1191            tb.extend_tree(ob);
1192            let mut stack = 1;
1193            // keep eating things till we are at stack 0 for a ">"
1194            while stack > 0 {
1195                if let Some(start_arrow) = self.eat_punct_with_spacing('-', Spacing::Joint) {
1196                    tb.extend_tree(start_arrow);
1197                    if let Some(end_arrow) = self.eat_punct('>') {
1198                        tb.extend_tree(end_arrow);
1199                    }
1200                }
1201                if let Some(ob) = self.eat_punct('<') {
1202                    tb.extend_tree(ob);
1203                    stack += 1;
1204                }
1205                if let Some(cb) = self.eat_punct('>') {
1206                    tb.extend_tree(cb);
1207                    stack -= 1;
1208                } else if self.eat_eot() {
1209                    // shits broken
1210                    return None;
1211                } else {
1212                    // store info here in generics struct
1213                    if let Some(current) = self.peek() {
1214                        tb.extend_tree(current.clone());
1215                    }
1216                    self.advance();
1217                }
1218            }
1219            return Some(tb.end());
1220        } else {
1221            return None;
1222        }
1223    }
1224
1225    // same as lifetime_token because I don't distinguish between ident and keywords
1226    pub fn eat_lifetime_or_label(&mut self) -> Option<TokenStream> {
1227        let mut tb = TokenBuilder::new();
1228        if let Some(ap) = self.eat_punct('\'') {
1229            tb.extend_tree(ap);
1230            if let Some(lifetime) = self.eat_any_ident() {
1231                tb.extend_tree(lifetime);
1232            } else {
1233                // self.backtrack(tb.end());
1234                return None;
1235            }
1236            Some(tb.end())
1237        } else {
1238            None
1239        }
1240    }
1241
1242    pub fn eat_lifetime(&mut self) -> Option<TokenStream> {
1243        self.eat_lifetime_or_label().or_else(|| {
1244            let mut tb = TokenBuilder::new();
1245            if let Some(ap) = self.eat_punct_with_spacing('\'', Spacing::Joint) {
1246                tb.extend_tree(ap);
1247                if let Some(anon) = self.eat_punct_with_spacing('_', Spacing::Alone) {
1248                    tb.extend_tree(anon);
1249                } else {
1250                    // self.backtrack(tb.end());
1251                    return None;
1252                }
1253                Some(tb.end())
1254            } else {
1255                None
1256            }
1257        })
1258    }
1259
1260    pub fn eat_double_colon(&mut self) -> Option<TokenStream> {
1261        if let Some(c1) = self.eat_punct_with_spacing(':', Spacing::Joint) {
1262            let mut tb = TokenBuilder::new();
1263            tb.extend_tree(c1);
1264            if let Some(c2) = self.eat_punct_with_spacing(':', Spacing::Alone) {
1265                tb.extend_tree(c2);
1266                Some(tb.end())
1267            } else {
1268                self.backtrack(tb.end());
1269                None
1270            }
1271        } else {
1272            None
1273        }
1274    }
1275
1276    pub fn eat_fn_arrow(&mut self) -> Option<TokenStream> {
1277        if let Some(c1) = self.eat_punct_with_spacing('-', Spacing::Joint) {
1278            let mut tb = TokenBuilder::new();
1279            tb.extend_tree(c1);
1280            if let Some(c2) = self.eat_punct_with_spacing('>', Spacing::Alone) {
1281                tb.extend_tree(c2);
1282                Some(tb.end())
1283            } else {
1284                // self.backtrack(tb.end());
1285                None
1286            }
1287        } else {
1288            None
1289        }
1290    }
1291
1292    pub fn eat_type_path_segment(&mut self) -> Option<TokenStream> {
1293        let mut tb = TokenBuilder::new();
1294        if let Some(ident) = self.eat_any_ident() {
1295            tb.extend_tree(ident);
1296            let mut colons_tb = TokenBuilder::new();
1297            if let Some(colons) = self.eat_double_colon() {
1298                colons_tb.stream(colons);
1299            }
1300            if let Some(generic) = self.eat_group_angle_bracket() {
1301                tb.stream(colons_tb.end());
1302                tb.stream(generic);
1303            } else if let Some(fn_args) = self.eat_group(Delimiter::Parenthesis) {
1304                tb.stream(colons_tb.end());
1305                tb.extend_tree(fn_args);
1306                if let Some(arrow) = self.eat_fn_arrow() {
1307                    tb.stream(arrow);
1308                    if let Some(ty) = self.eat_type() {
1309                        tb.stream(ty.stream);
1310                    } else {
1311                        // self.backtrack(tb.end());
1312                        return None;
1313                    }
1314                }
1315            } else {
1316                self.backtrack(colons_tb.end());
1317            }
1318            Some(tb.end())
1319        } else {
1320            None
1321        }
1322    }
1323
1324    pub fn eat_type_path(&mut self) -> Option<TokenStream> {
1325        let mut tb = TokenBuilder::new();
1326        if let Some(colons) = self.eat_double_colon() {
1327            tb.stream(colons);
1328        }
1329        if let Some(segment) = self.eat_type_path_segment() {
1330            tb.stream(segment);
1331        } else {
1332            //self.backtrack(tb.end());
1333            return None;
1334        }
1335        while let Some(colons) = self.eat_double_colon() {
1336            tb.stream(colons);
1337            if let Some(segment) = self.eat_type_path_segment() {
1338                tb.stream(segment);
1339            } else {
1340                //self.backtrack(tb.end());
1341                return None;
1342            }
1343        }
1344        Some(tb.end())
1345    }
1346
1347    pub fn eat_raw_pointer_type(&mut self) -> Option<TokenStream> {
1348        if let Some(star) = self.eat_punct('*') {
1349            let mut tb = TokenBuilder::new();
1350            tb.extend_tree(star);
1351            if let Some(ident) = self.eat_ident("cont").or_else(|| self.eat_ident("mut")) {
1352                tb.extend_tree(ident);
1353                if let Some(ty) = self.eat_type_no_bounds() {
1354                    tb.stream(ty.stream);
1355                    Some(tb.end())
1356                } else {
1357                    // self.backtrack(tb.end());
1358                    return None;
1359                }
1360            } else {
1361                // self.backtrack(tb.end());
1362                return None;
1363            }
1364        } else {
1365            None
1366        }
1367    }
1368
1369    pub fn eat_qualified_path_in_type(&mut self) -> Option<TokenStream> {
1370        // qualified path type
1371        let mut tb = TokenBuilder::new();
1372        if let Some(qtp) = self.eat_group_angle_bracket() {
1373            tb.stream(qtp);
1374
1375            if let Some(colons) = self.eat_double_colon() {
1376                tb.stream(colons);
1377                if let Some(tps) = self.eat_type_path_segment() {
1378                    tb.stream(tps);
1379
1380                    while let Some(colons) = self.eat_double_colon() {
1381                        tb.stream(colons);
1382                        if let Some(tps) = self.eat_type_path_segment() {
1383                            tb.stream(tps);
1384                        } else {
1385                            // self.backtrack(tb.end());
1386                            return None;
1387                        }
1388                    }
1389                    Some(tb.end())
1390                } else {
1391                    // self.backtrack(tb.end());
1392                    None
1393                }
1394            } else {
1395                // self.backtrack(tb.end());
1396                None
1397            }
1398        } else {
1399            None
1400        }
1401    }
1402
1403    pub fn eat_for_lifetimes(&mut self) -> Option<TokenStream> {
1404        let mut tb = TokenBuilder::new();
1405
1406        if let Some(for_ident) = self.eat_ident("for") {
1407            tb.extend_tree(for_ident);
1408            if let Some(lifetime_params) = self.eat_group_angle_bracket() {
1409                tb.stream(lifetime_params);
1410                Some(tb.end())
1411            } else {
1412                // self.backtrack(tb.end());
1413                None
1414            }
1415        } else {
1416            None
1417        }
1418    }
1419
1420    pub fn eat_outer_attribute(&mut self) -> Option<TokenStream> {
1421        let nbr_sign = self.eat_punct('#')?;
1422        if let Some(content) = self.eat_group(Delimiter::Bracket) {
1423            let mut tb = TokenBuilder::new();
1424            tb.extend_tree(nbr_sign);
1425            tb.extend_tree(content);
1426            Some(tb.end())
1427        } else {
1428            None
1429        }
1430    }
1431
1432    pub fn eat_simple_path(&mut self) -> Option<TokenStream> {
1433        let mut tb = TokenBuilder::new();
1434        if let Some(db) = self.eat_double_colon() {
1435            tb.stream(db);
1436        }
1437        if let Some(sps) = self.eat_any_ident() {
1438            // simple path segment, except $crate
1439            tb.extend_tree(sps);
1440            while let Some(db) = self.eat_double_colon() {
1441                if let Some(sps) = self.eat_any_ident() {
1442                    // simple path segment, except $crate
1443                    tb.stream(db);
1444                    tb.extend_tree(sps);
1445                } else {
1446                    // self.backtrack(tb.end());
1447                    return None;
1448                }
1449            }
1450            Some(tb.end())
1451        } else {
1452            // self.backtrack(tb.end());
1453            None
1454        }
1455    }
1456
1457    pub fn eat_macro_invocation(&mut self) -> Option<TokenStream> {
1458        if let Some(sp) = self.eat_simple_path() {
1459            let mut tb = TokenBuilder::new();
1460            tb.stream(sp);
1461            if let Some(tree) = self.eat_any_group() {
1462                tb.extend_tree(tree);
1463                Some(tb.end())
1464            } else {
1465                // self.backtrack(tb.end());
1466                None
1467            }
1468        } else {
1469            None
1470        }
1471    }
1472
1473    // TODO: check for backtracking correctness
1474    pub fn eat_trait_bound(&mut self) -> Option<TokenStream> {
1475        if let Some(g) = self.eat_group(Delimiter::Parenthesis) {
1476            let mut tb = TokenBuilder::new();
1477            tb.extend_tree(g);
1478            Some(tb.end())
1479        } else {
1480            let q = self.eat_punct('?');
1481            let for_lt = self.eat_for_lifetimes();
1482
1483            let mut tb = TokenBuilder::new();
1484
1485            if let Some(tp) = self.eat_type_path() {
1486                if let Some(q) = q {
1487                    tb.extend_tree(q);
1488                }
1489                if let Some(for_lt) = for_lt {
1490                    tb.stream(for_lt);
1491                }
1492                tb.stream(tp);
1493
1494                Some(tb.end())
1495            } else {
1496                // self.backtrack(tb.end());
1497                return None;
1498            }
1499        }
1500    }
1501
1502    pub fn eat_trait_object_type_one_bound(&mut self) -> Option<TokenStream> {
1503        let mut tb = TokenBuilder::new();
1504        if let Some(dyn_ident) = self.eat_ident("dyn") {
1505            tb.extend_tree(dyn_ident);
1506        }
1507        if let Some(trait_bound) = self.eat_trait_bound() {
1508            tb.stream(trait_bound);
1509            Some(tb.end())
1510        } else {
1511            // self.backtrack(tb.end());
1512            None
1513        }
1514    }
1515
1516    pub fn eat_impl_trait_type_one_bound(&mut self) -> Option<TokenStream> {
1517        if let Some(impl_ident) = self.eat_ident("impl") {
1518            let mut tb = TokenBuilder::new();
1519            if let Some(trait_bound) = self.eat_trait_bound() {
1520                tb.extend_tree(impl_ident);
1521                tb.stream(trait_bound);
1522                Some(tb.end())
1523            } else {
1524                // self.backtrack(tb.end());
1525                None
1526            }
1527        } else {
1528            None
1529        }
1530    }
1531
1532    pub fn eat_type_no_bounds(&mut self) -> Option<Ty> {
1533        let mut tb = TokenBuilder::new();
1534
1535        if let Some(tys) = self.eat_group(Delimiter::Parenthesis) {
1536            // parenthesized_type
1537            tb.extend_tree(tys);
1538        } else if let Some(ittob) = self.eat_impl_trait_type_one_bound() {
1539            // impl trait one bound
1540            tb.stream(ittob);
1541        } else if let Some(itotob) = self.eat_trait_object_type_one_bound() {
1542            tb.stream(itotob);
1543        } else if let Some(typath) = self.eat_type_path() {
1544            // type path
1545            tb.stream(typath);
1546        } else if let Some(tuple) = self.eat_group(Delimiter::Parenthesis) {
1547            // tuple type
1548            tb.extend_tree(tuple);
1549        } else if let Some(never) = self.eat_punct('!') {
1550            // never type
1551            tb.extend_tree(never);
1552        } else if let Some(raw_ptr) = self.eat_raw_pointer_type() {
1553            // raw pointer type
1554            tb.stream(raw_ptr);
1555        } else if let Some(amp) = self.eat_punct('&') {
1556            // reference type
1557            let mut mutable = false;
1558            let mut lifetime = None;
1559            tb.extend_tree(amp);
1560            if let Some(lt) = self.eat_lifetime() {
1561                lifetime = Some(lt.clone());
1562                tb.stream(lt);
1563            }
1564            if let Some(mut_ident) = self.eat_ident("mut") {
1565                mutable = true;
1566                tb.extend_tree(mut_ident);
1567            }
1568            let rest = self.eat_type_no_bounds()?;
1569            tb.stream(rest.clone().stream);
1570            return Some(Ty {
1571                stream: tb.end(),
1572                kind: TyKind::Ref(Box::new(RefTy {
1573                    mutable,
1574                    lifetime,
1575                    rest,
1576                })),
1577            });
1578        } else if let Some(arr_or_slice) = self.eat_group(Delimiter::Bracket) {
1579            // array type + slice type
1580            tb.extend_tree(arr_or_slice);
1581        } else if let Some(punct) = self.eat_punct('_') {
1582            // inferred type
1583            tb.extend_tree(punct);
1584        } else if let Some(qpit) = self.eat_qualified_path_in_type() {
1585            // qualified path in type
1586            tb.stream(qpit);
1587        } else if let Some(m) = self.eat_macro_invocation() {
1588            tb.stream(m);
1589        } else {
1590            return None;
1591        }
1592        return Some(Ty {
1593            stream: tb.end(),
1594            kind: TyKind::Other,
1595        });
1596    }
1597
1598    pub fn eat_type_param_bounds(&mut self) -> Option<TokenStream> {
1599        if let Some(tpb) = self.eat_type_param_bound() {
1600            let mut tb = TokenBuilder::new();
1601            tb.stream(tpb);
1602            while let Some(plus) = self.eat_punct('+') {
1603                tb.extend_tree(plus);
1604                if let Some(bound) = self.eat_type_param_bound() {
1605                    tb.stream(bound);
1606                }
1607            }
1608            Some(tb.end())
1609        } else {
1610            None
1611        }
1612    }
1613
1614    pub fn eat_type_param_bound(&mut self) -> Option<TokenStream> {
1615        self.eat_lifetime().or_else(|| self.eat_trait_bound())
1616    }
1617
1618    pub fn eat_impl_trait_type(&mut self) -> Option<TokenStream> {
1619        if let Some(impl_ident) = self.eat_ident("impl") {
1620            let mut tb = TokenBuilder::new();
1621            tb.extend_tree(impl_ident);
1622            if let Some(tpbs) = self.eat_type_param_bounds() {
1623                tb.stream(tpbs);
1624                Some(tb.end())
1625            } else {
1626                // self.backtrack(tb.end());
1627                None
1628            }
1629        } else {
1630            None
1631        }
1632    }
1633
1634    pub fn eat_trait_object_type(&mut self) -> Option<TokenStream> {
1635        let mut tb = TokenBuilder::new();
1636        if let Some(dyn_ident) = self.eat_ident("dyn") {
1637            tb.extend_tree(dyn_ident);
1638        }
1639        if let Some(tpbs) = self.eat_type_param_bounds() {
1640            tb.stream(tpbs);
1641            Some(tb.end())
1642        } else {
1643            // self.backtrack(tb.end());
1644            None
1645        }
1646    }
1647
1648    pub fn eat_type(&mut self) -> Option<Ty> {
1649        self.eat_type_no_bounds()
1650            .or_else(|| {
1651                self.eat_impl_trait_type().map(|stream| Ty {
1652                    stream,
1653                    kind: TyKind::Other,
1654                })
1655            })
1656            .or_else(|| {
1657                self.eat_trait_object_type().map(|stream| Ty {
1658                    stream,
1659                    kind: TyKind::Other,
1660                })
1661            })
1662    }
1663
1664    pub fn eat_group(&mut self, delim: Delimiter) -> Option<TokenTree> {
1665        if let Some(TokenTree::Group(group)) = self.peek() {
1666            if group.delimiter() == delim {
1667                let ret = Some(TokenTree::Group(group.clone()));
1668                self.advance();
1669                ret
1670            } else {
1671                None
1672            }
1673        } else {
1674            None
1675        }
1676    }
1677
1678    pub fn eat_any_group(&mut self) -> Option<TokenTree> {
1679        if let Some(TokenTree::Group(group)) = self.peek() {
1680            let ret = Some(TokenTree::Group(group.clone()));
1681            self.advance();
1682            return ret;
1683        }
1684        return None;
1685    }
1686
1687    pub fn eat_visibility(&mut self) -> TokenStream {
1688        let mut tb = TokenBuilder::new();
1689        if let Some(pub_ident) = self.eat_ident("pub") {
1690            tb.extend_tree(pub_ident);
1691            if let Some(tt) = self.eat_group(Delimiter::Bracket) {
1692                tb.extend_tree(tt);
1693            }
1694        }
1695        tb.end()
1696    }
1697}
1698
1699#[cfg(test)]
1700mod test {
1701    use super::TokenParser;
1702    use proc_macro2::TokenStream;
1703    #[test]
1704    fn parse_function() {
1705        let content = "
1706            pub const fn hello<T>(Some(&mut x): Vec<T>) -> bool where T: Default {}
1707            "
1708        .parse::<TokenStream>()
1709        .unwrap();
1710        let mut parser = TokenParser::new(content);
1711        let function1 = parser.eat_function();
1712        assert!(function1.is_some());
1713        // assert!(false, "{}", ts!(function1));
1714
1715        let content = "
1716            async fn hello<T, V: Clone>((x, y, z): (Vec<T>, u8, dyn Clone)) 
1717            "
1718        .parse::<TokenStream>()
1719        .unwrap();
1720        let mut parser = TokenParser::new(content);
1721        let function2 = parser.eat_function();
1722        assert!(function2.is_some());
1723        // assert!(false, "{}", ts!(function2));
1724
1725        let content = "
1726            fn hello() -> impl Fn(&u8) -> dyn Fn(u8)
1727            "
1728        .parse::<TokenStream>()
1729        .unwrap();
1730        let mut parser = TokenParser::new(content);
1731        let function3 = parser.eat_function();
1732
1733        assert!(function3.is_some());
1734        // assert!(false, "{}", ts!(function3));
1735    }
1736}
decent_synquote_alternative/parser.rs

decent_synquote_alternative/
parser.rs
