@@ -502,6 +502,23 @@ impl ConstParam {
502
502
pub fn default_val ( & self ) -> Option < Expr > { support:: child ( & self . syntax ) }
503
503
}
504
504
#[ derive( Debug , Clone , PartialEq , Eq , Hash ) ]
505
+ pub struct Literal {
506
+ pub ( crate ) syntax : SyntaxNode ,
507
+ }
508
+ impl Literal { }
509
+ #[ derive( Debug , Clone , PartialEq , Eq , Hash ) ]
510
+ pub struct TokenTree {
511
+ pub ( crate ) syntax : SyntaxNode ,
512
+ }
513
+ impl TokenTree {
514
+ pub fn l_paren_token ( & self ) -> Option < SyntaxToken > { support:: token ( & self . syntax , T ! [ '(' ] ) }
515
+ pub fn r_paren_token ( & self ) -> Option < SyntaxToken > { support:: token ( & self . syntax , T ! [ ')' ] ) }
516
+ pub fn l_curly_token ( & self ) -> Option < SyntaxToken > { support:: token ( & self . syntax , T ! [ '{' ] ) }
517
+ pub fn r_curly_token ( & self ) -> Option < SyntaxToken > { support:: token ( & self . syntax , T ! [ '}' ] ) }
518
+ pub fn l_brack_token ( & self ) -> Option < SyntaxToken > { support:: token ( & self . syntax , T ! [ '[' ] ) }
519
+ pub fn r_brack_token ( & self ) -> Option < SyntaxToken > { support:: token ( & self . syntax , T ! [ ']' ] ) }
520
+ }
521
+ #[ derive( Debug , Clone , PartialEq , Eq , Hash ) ]
505
522
pub struct ParenType {
506
523
pub ( crate ) syntax : SyntaxNode ,
507
524
}
@@ -908,11 +925,6 @@ pub struct BinExpr {
908
925
impl ast:: AttrsOwner for BinExpr { }
909
926
impl BinExpr { }
910
927
#[ derive( Debug , Clone , PartialEq , Eq , Hash ) ]
911
- pub struct Literal {
912
- pub ( crate ) syntax : SyntaxNode ,
913
- }
914
- impl Literal { }
915
- #[ derive( Debug , Clone , PartialEq , Eq , Hash ) ]
916
928
pub struct MatchExpr {
917
929
pub ( crate ) syntax : SyntaxNode ,
918
930
}
@@ -1131,18 +1143,6 @@ impl TuplePat {
1131
1143
pub fn r_paren_token ( & self ) -> Option < SyntaxToken > { support:: token ( & self . syntax , T ! [ ')' ] ) }
1132
1144
}
1133
1145
#[ derive( Debug , Clone , PartialEq , Eq , Hash ) ]
1134
- pub struct TokenTree {
1135
- pub ( crate ) syntax : SyntaxNode ,
1136
- }
1137
- impl TokenTree {
1138
- pub fn l_paren_token ( & self ) -> Option < SyntaxToken > { support:: token ( & self . syntax , T ! [ '(' ] ) }
1139
- pub fn r_paren_token ( & self ) -> Option < SyntaxToken > { support:: token ( & self . syntax , T ! [ ')' ] ) }
1140
- pub fn l_curly_token ( & self ) -> Option < SyntaxToken > { support:: token ( & self . syntax , T ! [ '{' ] ) }
1141
- pub fn r_curly_token ( & self ) -> Option < SyntaxToken > { support:: token ( & self . syntax , T ! [ '}' ] ) }
1142
- pub fn l_brack_token ( & self ) -> Option < SyntaxToken > { support:: token ( & self . syntax , T ! [ '[' ] ) }
1143
- pub fn r_brack_token ( & self ) -> Option < SyntaxToken > { support:: token ( & self . syntax , T ! [ ']' ] ) }
1144
- }
1145
- #[ derive( Debug , Clone , PartialEq , Eq , Hash ) ]
1146
1146
pub struct MacroDef {
1147
1147
pub ( crate ) syntax : SyntaxNode ,
1148
1148
}
@@ -1263,16 +1263,6 @@ impl ConstArg {
1263
1263
pub fn block_expr ( & self ) -> Option < BlockExpr > { support:: child ( & self . syntax ) }
1264
1264
}
1265
1265
#[ derive( Debug , Clone , PartialEq , Eq , Hash ) ]
1266
- pub struct MetaItem {
1267
- pub ( crate ) syntax : SyntaxNode ,
1268
- }
1269
- impl MetaItem {
1270
- pub fn path ( & self ) -> Option < Path > { support:: child ( & self . syntax ) }
1271
- pub fn eq_token ( & self ) -> Option < SyntaxToken > { support:: token ( & self . syntax , T ! [ =] ) }
1272
- pub fn attr_input ( & self ) -> Option < AttrInput > { support:: child ( & self . syntax ) }
1273
- pub fn nested_meta_items ( & self ) -> AstChildren < MetaItem > { support:: children ( & self . syntax ) }
1274
- }
1275
- #[ derive( Debug , Clone , PartialEq , Eq , Hash ) ]
1276
1266
pub enum Item {
1277
1267
Const ( Const ) ,
1278
1268
Enum ( Enum ) ,
@@ -1388,17 +1378,17 @@ pub enum GenericParam {
1388
1378
}
1389
1379
impl ast:: AttrsOwner for GenericParam { }
1390
1380
#[ derive( Debug , Clone , PartialEq , Eq , Hash ) ]
1381
+ pub enum AttrInput {
1382
+ Literal ( Literal ) ,
1383
+ TokenTree ( TokenTree ) ,
1384
+ }
1385
+ #[ derive( Debug , Clone , PartialEq , Eq , Hash ) ]
1391
1386
pub enum Stmt {
1392
1387
LetStmt ( LetStmt ) ,
1393
1388
ExprStmt ( ExprStmt ) ,
1394
1389
}
1395
1390
impl ast:: AttrsOwner for Stmt { }
1396
1391
#[ derive( Debug , Clone , PartialEq , Eq , Hash ) ]
1397
- pub enum AttrInput {
1398
- Literal ( Literal ) ,
1399
- TokenTree ( TokenTree ) ,
1400
- }
1401
- #[ derive( Debug , Clone , PartialEq , Eq , Hash ) ]
1402
1392
pub enum AdtDef {
1403
1393
Struct ( Struct ) ,
1404
1394
Enum ( Enum ) ,
@@ -1892,6 +1882,28 @@ impl AstNode for ConstParam {
1892
1882
}
1893
1883
fn syntax ( & self ) -> & SyntaxNode { & self . syntax }
1894
1884
}
1885
+ impl AstNode for Literal {
1886
+ fn can_cast ( kind : SyntaxKind ) -> bool { kind == LITERAL }
1887
+ fn cast ( syntax : SyntaxNode ) -> Option < Self > {
1888
+ if Self :: can_cast ( syntax. kind ( ) ) {
1889
+ Some ( Self { syntax } )
1890
+ } else {
1891
+ None
1892
+ }
1893
+ }
1894
+ fn syntax ( & self ) -> & SyntaxNode { & self . syntax }
1895
+ }
1896
+ impl AstNode for TokenTree {
1897
+ fn can_cast ( kind : SyntaxKind ) -> bool { kind == TOKEN_TREE }
1898
+ fn cast ( syntax : SyntaxNode ) -> Option < Self > {
1899
+ if Self :: can_cast ( syntax. kind ( ) ) {
1900
+ Some ( Self { syntax } )
1901
+ } else {
1902
+ None
1903
+ }
1904
+ }
1905
+ fn syntax ( & self ) -> & SyntaxNode { & self . syntax }
1906
+ }
1895
1907
impl AstNode for ParenType {
1896
1908
fn can_cast ( kind : SyntaxKind ) -> bool { kind == PAREN_TYPE }
1897
1909
fn cast ( syntax : SyntaxNode ) -> Option < Self > {
@@ -2354,17 +2366,6 @@ impl AstNode for BinExpr {
2354
2366
}
2355
2367
fn syntax ( & self ) -> & SyntaxNode { & self . syntax }
2356
2368
}
2357
- impl AstNode for Literal {
2358
- fn can_cast ( kind : SyntaxKind ) -> bool { kind == LITERAL }
2359
- fn cast ( syntax : SyntaxNode ) -> Option < Self > {
2360
- if Self :: can_cast ( syntax. kind ( ) ) {
2361
- Some ( Self { syntax } )
2362
- } else {
2363
- None
2364
- }
2365
- }
2366
- fn syntax ( & self ) -> & SyntaxNode { & self . syntax }
2367
- }
2368
2369
impl AstNode for MatchExpr {
2369
2370
fn can_cast ( kind : SyntaxKind ) -> bool { kind == MATCH_EXPR }
2370
2371
fn cast ( syntax : SyntaxNode ) -> Option < Self > {
@@ -2629,17 +2630,6 @@ impl AstNode for TuplePat {
2629
2630
}
2630
2631
fn syntax ( & self ) -> & SyntaxNode { & self . syntax }
2631
2632
}
2632
- impl AstNode for TokenTree {
2633
- fn can_cast ( kind : SyntaxKind ) -> bool { kind == TOKEN_TREE }
2634
- fn cast ( syntax : SyntaxNode ) -> Option < Self > {
2635
- if Self :: can_cast ( syntax. kind ( ) ) {
2636
- Some ( Self { syntax } )
2637
- } else {
2638
- None
2639
- }
2640
- }
2641
- fn syntax ( & self ) -> & SyntaxNode { & self . syntax }
2642
- }
2643
2633
impl AstNode for MacroDef {
2644
2634
fn can_cast ( kind : SyntaxKind ) -> bool { kind == MACRO_DEF }
2645
2635
fn cast ( syntax : SyntaxNode ) -> Option < Self > {
@@ -2772,17 +2762,6 @@ impl AstNode for ConstArg {
2772
2762
}
2773
2763
fn syntax ( & self ) -> & SyntaxNode { & self . syntax }
2774
2764
}
2775
- impl AstNode for MetaItem {
2776
- fn can_cast ( kind : SyntaxKind ) -> bool { kind == META_ITEM }
2777
- fn cast ( syntax : SyntaxNode ) -> Option < Self > {
2778
- if Self :: can_cast ( syntax. kind ( ) ) {
2779
- Some ( Self { syntax } )
2780
- } else {
2781
- None
2782
- }
2783
- }
2784
- fn syntax ( & self ) -> & SyntaxNode { & self . syntax }
2785
- }
2786
2765
impl From < Const > for Item {
2787
2766
fn from ( node : Const ) -> Item { Item :: Const ( node) }
2788
2767
}
@@ -3363,59 +3342,59 @@ impl AstNode for GenericParam {
3363
3342
}
3364
3343
}
3365
3344
}
3366
- impl From < LetStmt > for Stmt {
3367
- fn from ( node : LetStmt ) -> Stmt { Stmt :: LetStmt ( node) }
3345
+ impl From < Literal > for AttrInput {
3346
+ fn from ( node : Literal ) -> AttrInput { AttrInput :: Literal ( node) }
3368
3347
}
3369
- impl From < ExprStmt > for Stmt {
3370
- fn from ( node : ExprStmt ) -> Stmt { Stmt :: ExprStmt ( node) }
3348
+ impl From < TokenTree > for AttrInput {
3349
+ fn from ( node : TokenTree ) -> AttrInput { AttrInput :: TokenTree ( node) }
3371
3350
}
3372
- impl AstNode for Stmt {
3351
+ impl AstNode for AttrInput {
3373
3352
fn can_cast ( kind : SyntaxKind ) -> bool {
3374
3353
match kind {
3375
- LET_STMT | EXPR_STMT => true ,
3354
+ LITERAL | TOKEN_TREE => true ,
3376
3355
_ => false ,
3377
3356
}
3378
3357
}
3379
3358
fn cast ( syntax : SyntaxNode ) -> Option < Self > {
3380
3359
let res = match syntax. kind ( ) {
3381
- LET_STMT => Stmt :: LetStmt ( LetStmt { syntax } ) ,
3382
- EXPR_STMT => Stmt :: ExprStmt ( ExprStmt { syntax } ) ,
3360
+ LITERAL => AttrInput :: Literal ( Literal { syntax } ) ,
3361
+ TOKEN_TREE => AttrInput :: TokenTree ( TokenTree { syntax } ) ,
3383
3362
_ => return None ,
3384
3363
} ;
3385
3364
Some ( res)
3386
3365
}
3387
3366
fn syntax ( & self ) -> & SyntaxNode {
3388
3367
match self {
3389
- Stmt :: LetStmt ( it) => & it. syntax ,
3390
- Stmt :: ExprStmt ( it) => & it. syntax ,
3368
+ AttrInput :: Literal ( it) => & it. syntax ,
3369
+ AttrInput :: TokenTree ( it) => & it. syntax ,
3391
3370
}
3392
3371
}
3393
3372
}
3394
- impl From < Literal > for AttrInput {
3395
- fn from ( node : Literal ) -> AttrInput { AttrInput :: Literal ( node) }
3373
+ impl From < LetStmt > for Stmt {
3374
+ fn from ( node : LetStmt ) -> Stmt { Stmt :: LetStmt ( node) }
3396
3375
}
3397
- impl From < TokenTree > for AttrInput {
3398
- fn from ( node : TokenTree ) -> AttrInput { AttrInput :: TokenTree ( node) }
3376
+ impl From < ExprStmt > for Stmt {
3377
+ fn from ( node : ExprStmt ) -> Stmt { Stmt :: ExprStmt ( node) }
3399
3378
}
3400
- impl AstNode for AttrInput {
3379
+ impl AstNode for Stmt {
3401
3380
fn can_cast ( kind : SyntaxKind ) -> bool {
3402
3381
match kind {
3403
- LITERAL | TOKEN_TREE => true ,
3382
+ LET_STMT | EXPR_STMT => true ,
3404
3383
_ => false ,
3405
3384
}
3406
3385
}
3407
3386
fn cast ( syntax : SyntaxNode ) -> Option < Self > {
3408
3387
let res = match syntax. kind ( ) {
3409
- LITERAL => AttrInput :: Literal ( Literal { syntax } ) ,
3410
- TOKEN_TREE => AttrInput :: TokenTree ( TokenTree { syntax } ) ,
3388
+ LET_STMT => Stmt :: LetStmt ( LetStmt { syntax } ) ,
3389
+ EXPR_STMT => Stmt :: ExprStmt ( ExprStmt { syntax } ) ,
3411
3390
_ => return None ,
3412
3391
} ;
3413
3392
Some ( res)
3414
3393
}
3415
3394
fn syntax ( & self ) -> & SyntaxNode {
3416
3395
match self {
3417
- AttrInput :: Literal ( it) => & it. syntax ,
3418
- AttrInput :: TokenTree ( it) => & it. syntax ,
3396
+ Stmt :: LetStmt ( it) => & it. syntax ,
3397
+ Stmt :: ExprStmt ( it) => & it. syntax ,
3419
3398
}
3420
3399
}
3421
3400
}
@@ -3492,12 +3471,12 @@ impl std::fmt::Display for GenericParam {
3492
3471
std:: fmt:: Display :: fmt ( self . syntax ( ) , f)
3493
3472
}
3494
3473
}
3495
- impl std:: fmt:: Display for Stmt {
3474
+ impl std:: fmt:: Display for AttrInput {
3496
3475
fn fmt ( & self , f : & mut std:: fmt:: Formatter < ' _ > ) -> std:: fmt:: Result {
3497
3476
std:: fmt:: Display :: fmt ( self . syntax ( ) , f)
3498
3477
}
3499
3478
}
3500
- impl std:: fmt:: Display for AttrInput {
3479
+ impl std:: fmt:: Display for Stmt {
3501
3480
fn fmt ( & self , f : & mut std:: fmt:: Formatter < ' _ > ) -> std:: fmt:: Result {
3502
3481
std:: fmt:: Display :: fmt ( self . syntax ( ) , f)
3503
3482
}
@@ -3727,6 +3706,16 @@ impl std::fmt::Display for ConstParam {
3727
3706
std:: fmt:: Display :: fmt ( self . syntax ( ) , f)
3728
3707
}
3729
3708
}
3709
+ impl std:: fmt:: Display for Literal {
3710
+ fn fmt ( & self , f : & mut std:: fmt:: Formatter < ' _ > ) -> std:: fmt:: Result {
3711
+ std:: fmt:: Display :: fmt ( self . syntax ( ) , f)
3712
+ }
3713
+ }
3714
+ impl std:: fmt:: Display for TokenTree {
3715
+ fn fmt ( & self , f : & mut std:: fmt:: Formatter < ' _ > ) -> std:: fmt:: Result {
3716
+ std:: fmt:: Display :: fmt ( self . syntax ( ) , f)
3717
+ }
3718
+ }
3730
3719
impl std:: fmt:: Display for ParenType {
3731
3720
fn fmt ( & self , f : & mut std:: fmt:: Formatter < ' _ > ) -> std:: fmt:: Result {
3732
3721
std:: fmt:: Display :: fmt ( self . syntax ( ) , f)
@@ -3937,11 +3926,6 @@ impl std::fmt::Display for BinExpr {
3937
3926
std:: fmt:: Display :: fmt ( self . syntax ( ) , f)
3938
3927
}
3939
3928
}
3940
- impl std:: fmt:: Display for Literal {
3941
- fn fmt ( & self , f : & mut std:: fmt:: Formatter < ' _ > ) -> std:: fmt:: Result {
3942
- std:: fmt:: Display :: fmt ( self . syntax ( ) , f)
3943
- }
3944
- }
3945
3929
impl std:: fmt:: Display for MatchExpr {
3946
3930
fn fmt ( & self , f : & mut std:: fmt:: Formatter < ' _ > ) -> std:: fmt:: Result {
3947
3931
std:: fmt:: Display :: fmt ( self . syntax ( ) , f)
@@ -4062,11 +4046,6 @@ impl std::fmt::Display for TuplePat {
4062
4046
std:: fmt:: Display :: fmt ( self . syntax ( ) , f)
4063
4047
}
4064
4048
}
4065
- impl std:: fmt:: Display for TokenTree {
4066
- fn fmt ( & self , f : & mut std:: fmt:: Formatter < ' _ > ) -> std:: fmt:: Result {
4067
- std:: fmt:: Display :: fmt ( self . syntax ( ) , f)
4068
- }
4069
- }
4070
4049
impl std:: fmt:: Display for MacroDef {
4071
4050
fn fmt ( & self , f : & mut std:: fmt:: Formatter < ' _ > ) -> std:: fmt:: Result {
4072
4051
std:: fmt:: Display :: fmt ( self . syntax ( ) , f)
@@ -4127,8 +4106,3 @@ impl std::fmt::Display for ConstArg {
4127
4106
std:: fmt:: Display :: fmt ( self . syntax ( ) , f)
4128
4107
}
4129
4108
}
4130
- impl std:: fmt:: Display for MetaItem {
4131
- fn fmt ( & self , f : & mut std:: fmt:: Formatter < ' _ > ) -> std:: fmt:: Result {
4132
- std:: fmt:: Display :: fmt ( self . syntax ( ) , f)
4133
- }
4134
- }
0 commit comments