@@ -180,8 +180,12 @@ fn generate_nodes(kinds: KindsSrc, grammar: &AstSrc) -> String {
180
180
. enums
181
181
. iter ( )
182
182
. map ( |en| {
183
- let variants: Vec < _ > =
184
- en. variants . iter ( ) . map ( |var| format_ident ! ( "{}" , var) ) . sorted ( ) . collect ( ) ;
183
+ let variants: Vec < _ > = en
184
+ . variants
185
+ . iter ( )
186
+ . map ( |var| format_ident ! ( "{}" , var) )
187
+ . sorted ( )
188
+ . collect ( ) ;
185
189
let name = format_ident ! ( "{}" , en. name) ;
186
190
let kinds: Vec < _ > = variants
187
191
. iter ( )
@@ -311,8 +315,10 @@ fn generate_nodes(kinds: KindsSrc, grammar: &AstSrc) -> String {
311
315
let enum_names = grammar. enums . iter ( ) . map ( |it| & it. name ) ;
312
316
let node_names = grammar. nodes . iter ( ) . map ( |it| & it. name ) ;
313
317
314
- let display_impls =
315
- enum_names. chain ( node_names. clone ( ) ) . map ( |it| format_ident ! ( "{}" , it) ) . map ( |name| {
318
+ let display_impls = enum_names
319
+ . chain ( node_names. clone ( ) )
320
+ . map ( |it| format_ident ! ( "{}" , it) )
321
+ . map ( |name| {
316
322
quote ! {
317
323
impl std:: fmt:: Display for #name {
318
324
fn fmt( & self , f: & mut std:: fmt:: Formatter <' _>) -> std:: fmt:: Result {
@@ -356,8 +362,11 @@ fn generate_nodes(kinds: KindsSrc, grammar: &AstSrc) -> String {
356
362
357
363
let mut res = String :: with_capacity ( ast. len ( ) * 2 ) ;
358
364
359
- let mut docs =
360
- grammar. nodes . iter ( ) . map ( |it| & it. doc ) . chain ( grammar. enums . iter ( ) . map ( |it| & it. doc ) ) ;
365
+ let mut docs = grammar
366
+ . nodes
367
+ . iter ( )
368
+ . map ( |it| & it. doc )
369
+ . chain ( grammar. enums . iter ( ) . map ( |it| & it. doc ) ) ;
361
370
362
371
for chunk in ast. split ( "# [pretty_doc_comment_placeholder_workaround] " ) {
363
372
res. push_str ( chunk) ;
@@ -393,16 +402,21 @@ fn generate_syntax_kinds(grammar: KindsSrc) -> String {
393
402
quote ! { #( #cs) * }
394
403
}
395
404
} ) ;
396
- let punctuation =
397
- grammar. punct . iter ( ) . map ( |( _token, name) | format_ident ! ( "{}" , name) ) . collect :: < Vec < _ > > ( ) ;
405
+ let punctuation = grammar
406
+ . punct
407
+ . iter ( )
408
+ . map ( |( _token, name) | format_ident ! ( "{}" , name) )
409
+ . collect :: < Vec < _ > > ( ) ;
398
410
399
411
let fmt_kw_as_variant = |& name| match name {
400
412
"Self" => format_ident ! ( "SELF_TYPE_KW" ) ,
401
413
name => format_ident ! ( "{}_KW" , to_upper_snake_case( name) ) ,
402
414
} ;
403
415
let strict_keywords = grammar. keywords ;
404
- let strict_keywords_variants =
405
- strict_keywords. iter ( ) . map ( fmt_kw_as_variant) . collect :: < Vec < _ > > ( ) ;
416
+ let strict_keywords_variants = strict_keywords
417
+ . iter ( )
418
+ . map ( fmt_kw_as_variant)
419
+ . collect :: < Vec < _ > > ( ) ;
406
420
let strict_keywords_tokens = strict_keywords. iter ( ) . map ( |it| format_ident ! ( "{it}" ) ) ;
407
421
408
422
let edition_dependent_keywords_variants_match_arm = grammar
@@ -425,15 +439,23 @@ fn generate_syntax_kinds(grammar: KindsSrc) -> String {
425
439
. iter ( )
426
440
. map ( |( kw, _) | fmt_kw_as_variant ( kw) )
427
441
. collect :: < Vec < _ > > ( ) ;
428
- let edition_dependent_keywords_tokens =
429
- grammar. edition_dependent_keywords . iter ( ) . map ( |( it, _) | format_ident ! ( "{it}" ) ) ;
442
+ let edition_dependent_keywords_tokens = grammar
443
+ . edition_dependent_keywords
444
+ . iter ( )
445
+ . map ( |( it, _) | format_ident ! ( "{it}" ) ) ;
430
446
431
447
let contextual_keywords = grammar. contextual_keywords ;
432
- let contextual_keywords_variants =
433
- contextual_keywords. iter ( ) . map ( fmt_kw_as_variant) . collect :: < Vec < _ > > ( ) ;
448
+ let contextual_keywords_variants = contextual_keywords
449
+ . iter ( )
450
+ . map ( fmt_kw_as_variant)
451
+ . collect :: < Vec < _ > > ( ) ;
434
452
let contextual_keywords_tokens = contextual_keywords. iter ( ) . map ( |it| format_ident ! ( "{it}" ) ) ;
435
453
let contextual_keywords_str_match_arm = grammar. contextual_keywords . iter ( ) . map ( |kw| {
436
- match grammar. edition_dependent_keywords . iter ( ) . find ( |( ed_kw, _) | ed_kw == kw) {
454
+ match grammar
455
+ . edition_dependent_keywords
456
+ . iter ( )
457
+ . find ( |( ed_kw, _) | ed_kw == kw)
458
+ {
437
459
Some ( ( _, ed) ) => quote ! { #kw if edition < #ed } ,
438
460
None => quote ! { #kw } ,
439
461
}
@@ -443,7 +465,11 @@ fn generate_syntax_kinds(grammar: KindsSrc) -> String {
443
465
. iter ( )
444
466
. map ( |kw_s| {
445
467
let kw = fmt_kw_as_variant ( kw_s) ;
446
- match grammar. edition_dependent_keywords . iter ( ) . find ( |( ed_kw, _) | ed_kw == kw_s) {
468
+ match grammar
469
+ . edition_dependent_keywords
470
+ . iter ( )
471
+ . find ( |( ed_kw, _) | ed_kw == kw_s)
472
+ {
447
473
Some ( ( _, ed) ) => quote ! { #kw if edition < #ed } ,
448
474
None => quote ! { #kw } ,
449
475
}
@@ -457,12 +483,23 @@ fn generate_syntax_kinds(grammar: KindsSrc) -> String {
457
483
. dedup ( )
458
484
. collect :: < Vec < _ > > ( ) ;
459
485
460
- let literals =
461
- grammar. literals . iter ( ) . map ( |name| format_ident ! ( "{}" , name) ) . collect :: < Vec < _ > > ( ) ;
486
+ let literals = grammar
487
+ . literals
488
+ . iter ( )
489
+ . map ( |name| format_ident ! ( "{}" , name) )
490
+ . collect :: < Vec < _ > > ( ) ;
462
491
463
- let tokens = grammar. tokens . iter ( ) . map ( |name| format_ident ! ( "{}" , name) ) . collect :: < Vec < _ > > ( ) ;
492
+ let tokens = grammar
493
+ . tokens
494
+ . iter ( )
495
+ . map ( |name| format_ident ! ( "{}" , name) )
496
+ . collect :: < Vec < _ > > ( ) ;
464
497
465
- let nodes = grammar. nodes . iter ( ) . map ( |name| format_ident ! ( "{}" , name) ) . collect :: < Vec < _ > > ( ) ;
498
+ let nodes = grammar
499
+ . nodes
500
+ . iter ( )
501
+ . map ( |name| format_ident ! ( "{}" , name) )
502
+ . collect :: < Vec < _ > > ( ) ;
466
503
467
504
let ast = quote ! {
468
505
#![ allow( bad_style, missing_docs, unreachable_pub) ]
@@ -569,7 +606,10 @@ fn generate_syntax_kinds(grammar: KindsSrc) -> String {
569
606
}
570
607
} ;
571
608
572
- add_preamble ( crate :: flags:: CodegenType :: Grammar , reformat ( ast. to_string ( ) ) )
609
+ add_preamble (
610
+ crate :: flags:: CodegenType :: Grammar ,
611
+ reformat ( ast. to_string ( ) ) ,
612
+ )
573
613
}
574
614
575
615
fn to_upper_snake_case ( s : & str ) -> String {
@@ -719,13 +759,23 @@ pub(crate) fn lower(grammar: &Grammar) -> AstSrc {
719
759
let rule = & grammar[ node] . rule ;
720
760
match lower_enum ( grammar, rule) {
721
761
Some ( variants) => {
722
- let enum_src = AstEnumSrc { doc : Vec :: new ( ) , name, traits : Vec :: new ( ) , variants } ;
762
+ let enum_src = AstEnumSrc {
763
+ doc : Vec :: new ( ) ,
764
+ name,
765
+ traits : Vec :: new ( ) ,
766
+ variants,
767
+ } ;
723
768
res. enums . push ( enum_src) ;
724
769
}
725
770
None => {
726
771
let mut fields = Vec :: new ( ) ;
727
772
lower_rule ( & mut fields, grammar, None , rule) ;
728
- res. nodes . push ( AstNodeSrc { doc : Vec :: new ( ) , name, traits : Vec :: new ( ) , fields } ) ;
773
+ res. nodes . push ( AstNodeSrc {
774
+ doc : Vec :: new ( ) ,
775
+ name,
776
+ traits : Vec :: new ( ) ,
777
+ fields,
778
+ } ) ;
729
779
}
730
780
}
731
781
}
@@ -776,7 +826,11 @@ fn lower_rule(acc: &mut Vec<Field>, grammar: &Grammar, label: Option<&String>, r
776
826
Rule :: Node ( node) => {
777
827
let ty = grammar[ * node] . name . clone ( ) ;
778
828
let name = label. cloned ( ) . unwrap_or_else ( || to_lower_snake_case ( & ty) ) ;
779
- let field = Field :: Node { name, ty, cardinality : Cardinality :: Optional } ;
829
+ let field = Field :: Node {
830
+ name,
831
+ ty,
832
+ cardinality : Cardinality :: Optional ,
833
+ } ;
780
834
acc. push ( field) ;
781
835
}
782
836
Rule :: Token ( token) => {
@@ -791,8 +845,14 @@ fn lower_rule(acc: &mut Vec<Field>, grammar: &Grammar, label: Option<&String>, r
791
845
Rule :: Rep ( inner) => {
792
846
if let Rule :: Node ( node) = & * * inner {
793
847
let ty = grammar[ * node] . name . clone ( ) ;
794
- let name = label. cloned ( ) . unwrap_or_else ( || pluralize ( & to_lower_snake_case ( & ty) ) ) ;
795
- let field = Field :: Node { name, ty, cardinality : Cardinality :: Many } ;
848
+ let name = label
849
+ . cloned ( )
850
+ . unwrap_or_else ( || pluralize ( & to_lower_snake_case ( & ty) ) ) ;
851
+ let field = Field :: Node {
852
+ name,
853
+ ty,
854
+ cardinality : Cardinality :: Many ,
855
+ } ;
796
856
acc. push ( field) ;
797
857
return ;
798
858
}
@@ -863,8 +923,14 @@ fn lower_separated_list(
863
923
return false ;
864
924
}
865
925
let ty = grammar[ * node] . name . clone ( ) ;
866
- let name = label. cloned ( ) . unwrap_or_else ( || pluralize ( & to_lower_snake_case ( & ty) ) ) ;
867
- let field = Field :: Node { name, ty, cardinality : Cardinality :: Many } ;
926
+ let name = label
927
+ . cloned ( )
928
+ . unwrap_or_else ( || pluralize ( & to_lower_snake_case ( & ty) ) ) ;
929
+ let field = Field :: Node {
930
+ name,
931
+ ty,
932
+ cardinality : Cardinality :: Many ,
933
+ } ;
868
934
acc. push ( field) ;
869
935
true
870
936
}
@@ -900,7 +966,11 @@ fn extract_enums(ast: &mut AstSrc) {
900
966
node. remove_field ( to_remove) ;
901
967
let ty = enm. name . clone ( ) ;
902
968
let name = to_lower_snake_case ( & ty) ;
903
- node. fields . push ( Field :: Node { name, ty, cardinality : Cardinality :: Optional } ) ;
969
+ node. fields . push ( Field :: Node {
970
+ name,
971
+ ty,
972
+ cardinality : Cardinality :: Optional ,
973
+ } ) ;
904
974
}
905
975
}
906
976
}
0 commit comments