aboutsummaryrefslogtreecommitdiff
path: root/crates/ra_syntax
diff options
context:
space:
mode:
Diffstat (limited to 'crates/ra_syntax')
-rw-r--r--crates/ra_syntax/src/ast/generated.rs198
-rw-r--r--crates/ra_syntax/src/ast/generated.rs.tera2
2 files changed, 100 insertions, 100 deletions
diff --git a/crates/ra_syntax/src/ast/generated.rs b/crates/ra_syntax/src/ast/generated.rs
index 9ba775e1c..d0cd060d3 100644
--- a/crates/ra_syntax/src/ast/generated.rs
+++ b/crates/ra_syntax/src/ast/generated.rs
@@ -15,7 +15,7 @@ use crate::{
15pub struct ArgListNode(SyntaxNode); 15pub struct ArgListNode(SyntaxNode);
16 16
17impl ArgListNode { 17impl ArgListNode {
18 pub fn new(&self, ast: ArgList) -> ArgListNode { 18 pub fn new(ast: ArgList) -> ArgListNode {
19 let syntax = ast.syntax().owned(); 19 let syntax = ast.syntax().owned();
20 ArgListNode(syntax) 20 ArgListNode(syntax)
21 } 21 }
@@ -50,7 +50,7 @@ impl<'a> ArgList<'a> {
50pub struct ArrayExprNode(SyntaxNode); 50pub struct ArrayExprNode(SyntaxNode);
51 51
52impl ArrayExprNode { 52impl ArrayExprNode {
53 pub fn new(&self, ast: ArrayExpr) -> ArrayExprNode { 53 pub fn new(ast: ArrayExpr) -> ArrayExprNode {
54 let syntax = ast.syntax().owned(); 54 let syntax = ast.syntax().owned();
55 ArrayExprNode(syntax) 55 ArrayExprNode(syntax)
56 } 56 }
@@ -81,7 +81,7 @@ impl<'a> ArrayExpr<'a> {}
81pub struct ArrayTypeNode(SyntaxNode); 81pub struct ArrayTypeNode(SyntaxNode);
82 82
83impl ArrayTypeNode { 83impl ArrayTypeNode {
84 pub fn new(&self, ast: ArrayType) -> ArrayTypeNode { 84 pub fn new(ast: ArrayType) -> ArrayTypeNode {
85 let syntax = ast.syntax().owned(); 85 let syntax = ast.syntax().owned();
86 ArrayTypeNode(syntax) 86 ArrayTypeNode(syntax)
87 } 87 }
@@ -112,7 +112,7 @@ impl<'a> ArrayType<'a> {}
112pub struct AttrNode(SyntaxNode); 112pub struct AttrNode(SyntaxNode);
113 113
114impl AttrNode { 114impl AttrNode {
115 pub fn new(&self, ast: Attr) -> AttrNode { 115 pub fn new(ast: Attr) -> AttrNode {
116 let syntax = ast.syntax().owned(); 116 let syntax = ast.syntax().owned();
117 AttrNode(syntax) 117 AttrNode(syntax)
118 } 118 }
@@ -147,7 +147,7 @@ impl<'a> Attr<'a> {
147pub struct BinExprNode(SyntaxNode); 147pub struct BinExprNode(SyntaxNode);
148 148
149impl BinExprNode { 149impl BinExprNode {
150 pub fn new(&self, ast: BinExpr) -> BinExprNode { 150 pub fn new(ast: BinExpr) -> BinExprNode {
151 let syntax = ast.syntax().owned(); 151 let syntax = ast.syntax().owned();
152 BinExprNode(syntax) 152 BinExprNode(syntax)
153 } 153 }
@@ -178,7 +178,7 @@ impl<'a> BinExpr<'a> {}
178pub struct BindPatNode(SyntaxNode); 178pub struct BindPatNode(SyntaxNode);
179 179
180impl BindPatNode { 180impl BindPatNode {
181 pub fn new(&self, ast: BindPat) -> BindPatNode { 181 pub fn new(ast: BindPat) -> BindPatNode {
182 let syntax = ast.syntax().owned(); 182 let syntax = ast.syntax().owned();
183 BindPatNode(syntax) 183 BindPatNode(syntax)
184 } 184 }
@@ -210,7 +210,7 @@ impl<'a> BindPat<'a> {}
210pub struct BlockNode(SyntaxNode); 210pub struct BlockNode(SyntaxNode);
211 211
212impl BlockNode { 212impl BlockNode {
213 pub fn new(&self, ast: Block) -> BlockNode { 213 pub fn new(ast: Block) -> BlockNode {
214 let syntax = ast.syntax().owned(); 214 let syntax = ast.syntax().owned();
215 BlockNode(syntax) 215 BlockNode(syntax)
216 } 216 }
@@ -249,7 +249,7 @@ impl<'a> Block<'a> {
249pub struct BlockExprNode(SyntaxNode); 249pub struct BlockExprNode(SyntaxNode);
250 250
251impl BlockExprNode { 251impl BlockExprNode {
252 pub fn new(&self, ast: BlockExpr) -> BlockExprNode { 252 pub fn new(ast: BlockExpr) -> BlockExprNode {
253 let syntax = ast.syntax().owned(); 253 let syntax = ast.syntax().owned();
254 BlockExprNode(syntax) 254 BlockExprNode(syntax)
255 } 255 }
@@ -284,7 +284,7 @@ impl<'a> BlockExpr<'a> {
284pub struct BreakExprNode(SyntaxNode); 284pub struct BreakExprNode(SyntaxNode);
285 285
286impl BreakExprNode { 286impl BreakExprNode {
287 pub fn new(&self, ast: BreakExpr) -> BreakExprNode { 287 pub fn new(ast: BreakExpr) -> BreakExprNode {
288 let syntax = ast.syntax().owned(); 288 let syntax = ast.syntax().owned();
289 BreakExprNode(syntax) 289 BreakExprNode(syntax)
290 } 290 }
@@ -315,7 +315,7 @@ impl<'a> BreakExpr<'a> {}
315pub struct CallExprNode(SyntaxNode); 315pub struct CallExprNode(SyntaxNode);
316 316
317impl CallExprNode { 317impl CallExprNode {
318 pub fn new(&self, ast: CallExpr) -> CallExprNode { 318 pub fn new(ast: CallExpr) -> CallExprNode {
319 let syntax = ast.syntax().owned(); 319 let syntax = ast.syntax().owned();
320 CallExprNode(syntax) 320 CallExprNode(syntax)
321 } 321 }
@@ -351,7 +351,7 @@ impl<'a> CallExpr<'a> {
351pub struct CastExprNode(SyntaxNode); 351pub struct CastExprNode(SyntaxNode);
352 352
353impl CastExprNode { 353impl CastExprNode {
354 pub fn new(&self, ast: CastExpr) -> CastExprNode { 354 pub fn new(ast: CastExpr) -> CastExprNode {
355 let syntax = ast.syntax().owned(); 355 let syntax = ast.syntax().owned();
356 CastExprNode(syntax) 356 CastExprNode(syntax)
357 } 357 }
@@ -382,7 +382,7 @@ impl<'a> CastExpr<'a> {}
382pub struct CommentNode(SyntaxNode); 382pub struct CommentNode(SyntaxNode);
383 383
384impl CommentNode { 384impl CommentNode {
385 pub fn new(&self, ast: Comment) -> CommentNode { 385 pub fn new(ast: Comment) -> CommentNode {
386 let syntax = ast.syntax().owned(); 386 let syntax = ast.syntax().owned();
387 CommentNode(syntax) 387 CommentNode(syntax)
388 } 388 }
@@ -413,7 +413,7 @@ impl<'a> Comment<'a> {}
413pub struct ConditionNode(SyntaxNode); 413pub struct ConditionNode(SyntaxNode);
414 414
415impl ConditionNode { 415impl ConditionNode {
416 pub fn new(&self, ast: Condition) -> ConditionNode { 416 pub fn new(ast: Condition) -> ConditionNode {
417 let syntax = ast.syntax().owned(); 417 let syntax = ast.syntax().owned();
418 ConditionNode(syntax) 418 ConditionNode(syntax)
419 } 419 }
@@ -452,7 +452,7 @@ impl<'a> Condition<'a> {
452pub struct ConstDefNode(SyntaxNode); 452pub struct ConstDefNode(SyntaxNode);
453 453
454impl ConstDefNode { 454impl ConstDefNode {
455 pub fn new(&self, ast: ConstDef) -> ConstDefNode { 455 pub fn new(ast: ConstDef) -> ConstDefNode {
456 let syntax = ast.syntax().owned(); 456 let syntax = ast.syntax().owned();
457 ConstDefNode(syntax) 457 ConstDefNode(syntax)
458 } 458 }
@@ -486,7 +486,7 @@ impl<'a> ConstDef<'a> {}
486pub struct ContinueExprNode(SyntaxNode); 486pub struct ContinueExprNode(SyntaxNode);
487 487
488impl ContinueExprNode { 488impl ContinueExprNode {
489 pub fn new(&self, ast: ContinueExpr) -> ContinueExprNode { 489 pub fn new(ast: ContinueExpr) -> ContinueExprNode {
490 let syntax = ast.syntax().owned(); 490 let syntax = ast.syntax().owned();
491 ContinueExprNode(syntax) 491 ContinueExprNode(syntax)
492 } 492 }
@@ -517,7 +517,7 @@ impl<'a> ContinueExpr<'a> {}
517pub struct DynTraitTypeNode(SyntaxNode); 517pub struct DynTraitTypeNode(SyntaxNode);
518 518
519impl DynTraitTypeNode { 519impl DynTraitTypeNode {
520 pub fn new(&self, ast: DynTraitType) -> DynTraitTypeNode { 520 pub fn new(ast: DynTraitType) -> DynTraitTypeNode {
521 let syntax = ast.syntax().owned(); 521 let syntax = ast.syntax().owned();
522 DynTraitTypeNode(syntax) 522 DynTraitTypeNode(syntax)
523 } 523 }
@@ -548,7 +548,7 @@ impl<'a> DynTraitType<'a> {}
548pub struct EnumDefNode(SyntaxNode); 548pub struct EnumDefNode(SyntaxNode);
549 549
550impl EnumDefNode { 550impl EnumDefNode {
551 pub fn new(&self, ast: EnumDef) -> EnumDefNode { 551 pub fn new(ast: EnumDef) -> EnumDefNode {
552 let syntax = ast.syntax().owned(); 552 let syntax = ast.syntax().owned();
553 EnumDefNode(syntax) 553 EnumDefNode(syntax)
554 } 554 }
@@ -582,7 +582,7 @@ impl<'a> EnumDef<'a> {}
582pub struct ExprNode(SyntaxNode); 582pub struct ExprNode(SyntaxNode);
583 583
584impl ExprNode { 584impl ExprNode {
585 pub fn new(&self, ast: Expr) -> ExprNode { 585 pub fn new(ast: Expr) -> ExprNode {
586 let syntax = ast.syntax().owned(); 586 let syntax = ast.syntax().owned();
587 ExprNode(syntax) 587 ExprNode(syntax)
588 } 588 }
@@ -710,7 +710,7 @@ impl<'a> Expr<'a> {}
710pub struct ExprStmtNode(SyntaxNode); 710pub struct ExprStmtNode(SyntaxNode);
711 711
712impl ExprStmtNode { 712impl ExprStmtNode {
713 pub fn new(&self, ast: ExprStmt) -> ExprStmtNode { 713 pub fn new(ast: ExprStmt) -> ExprStmtNode {
714 let syntax = ast.syntax().owned(); 714 let syntax = ast.syntax().owned();
715 ExprStmtNode(syntax) 715 ExprStmtNode(syntax)
716 } 716 }
@@ -745,7 +745,7 @@ impl<'a> ExprStmt<'a> {
745pub struct ExternCrateItemNode(SyntaxNode); 745pub struct ExternCrateItemNode(SyntaxNode);
746 746
747impl ExternCrateItemNode { 747impl ExternCrateItemNode {
748 pub fn new(&self, ast: ExternCrateItem) -> ExternCrateItemNode { 748 pub fn new(ast: ExternCrateItem) -> ExternCrateItemNode {
749 let syntax = ast.syntax().owned(); 749 let syntax = ast.syntax().owned();
750 ExternCrateItemNode(syntax) 750 ExternCrateItemNode(syntax)
751 } 751 }
@@ -776,7 +776,7 @@ impl<'a> ExternCrateItem<'a> {}
776pub struct FieldExprNode(SyntaxNode); 776pub struct FieldExprNode(SyntaxNode);
777 777
778impl FieldExprNode { 778impl FieldExprNode {
779 pub fn new(&self, ast: FieldExpr) -> FieldExprNode { 779 pub fn new(ast: FieldExpr) -> FieldExprNode {
780 let syntax = ast.syntax().owned(); 780 let syntax = ast.syntax().owned();
781 FieldExprNode(syntax) 781 FieldExprNode(syntax)
782 } 782 }
@@ -807,7 +807,7 @@ impl<'a> FieldExpr<'a> {}
807pub struct FieldPatListNode(SyntaxNode); 807pub struct FieldPatListNode(SyntaxNode);
808 808
809impl FieldPatListNode { 809impl FieldPatListNode {
810 pub fn new(&self, ast: FieldPatList) -> FieldPatListNode { 810 pub fn new(ast: FieldPatList) -> FieldPatListNode {
811 let syntax = ast.syntax().owned(); 811 let syntax = ast.syntax().owned();
812 FieldPatListNode(syntax) 812 FieldPatListNode(syntax)
813 } 813 }
@@ -838,7 +838,7 @@ impl<'a> FieldPatList<'a> {}
838pub struct FnDefNode(SyntaxNode); 838pub struct FnDefNode(SyntaxNode);
839 839
840impl FnDefNode { 840impl FnDefNode {
841 pub fn new(&self, ast: FnDef) -> FnDefNode { 841 pub fn new(ast: FnDef) -> FnDefNode {
842 let syntax = ast.syntax().owned(); 842 let syntax = ast.syntax().owned();
843 FnDefNode(syntax) 843 FnDefNode(syntax)
844 } 844 }
@@ -884,7 +884,7 @@ impl<'a> FnDef<'a> {
884pub struct FnPointerTypeNode(SyntaxNode); 884pub struct FnPointerTypeNode(SyntaxNode);
885 885
886impl FnPointerTypeNode { 886impl FnPointerTypeNode {
887 pub fn new(&self, ast: FnPointerType) -> FnPointerTypeNode { 887 pub fn new(ast: FnPointerType) -> FnPointerTypeNode {
888 let syntax = ast.syntax().owned(); 888 let syntax = ast.syntax().owned();
889 FnPointerTypeNode(syntax) 889 FnPointerTypeNode(syntax)
890 } 890 }
@@ -915,7 +915,7 @@ impl<'a> FnPointerType<'a> {}
915pub struct ForExprNode(SyntaxNode); 915pub struct ForExprNode(SyntaxNode);
916 916
917impl ForExprNode { 917impl ForExprNode {
918 pub fn new(&self, ast: ForExpr) -> ForExprNode { 918 pub fn new(ast: ForExpr) -> ForExprNode {
919 let syntax = ast.syntax().owned(); 919 let syntax = ast.syntax().owned();
920 ForExprNode(syntax) 920 ForExprNode(syntax)
921 } 921 }
@@ -955,7 +955,7 @@ impl<'a> ForExpr<'a> {
955pub struct ForTypeNode(SyntaxNode); 955pub struct ForTypeNode(SyntaxNode);
956 956
957impl ForTypeNode { 957impl ForTypeNode {
958 pub fn new(&self, ast: ForType) -> ForTypeNode { 958 pub fn new(ast: ForType) -> ForTypeNode {
959 let syntax = ast.syntax().owned(); 959 let syntax = ast.syntax().owned();
960 ForTypeNode(syntax) 960 ForTypeNode(syntax)
961 } 961 }
@@ -986,7 +986,7 @@ impl<'a> ForType<'a> {}
986pub struct IfExprNode(SyntaxNode); 986pub struct IfExprNode(SyntaxNode);
987 987
988impl IfExprNode { 988impl IfExprNode {
989 pub fn new(&self, ast: IfExpr) -> IfExprNode { 989 pub fn new(ast: IfExpr) -> IfExprNode {
990 let syntax = ast.syntax().owned(); 990 let syntax = ast.syntax().owned();
991 IfExprNode(syntax) 991 IfExprNode(syntax)
992 } 992 }
@@ -1021,7 +1021,7 @@ impl<'a> IfExpr<'a> {
1021pub struct ImplItemNode(SyntaxNode); 1021pub struct ImplItemNode(SyntaxNode);
1022 1022
1023impl ImplItemNode { 1023impl ImplItemNode {
1024 pub fn new(&self, ast: ImplItem) -> ImplItemNode { 1024 pub fn new(ast: ImplItem) -> ImplItemNode {
1025 let syntax = ast.syntax().owned(); 1025 let syntax = ast.syntax().owned();
1026 ImplItemNode(syntax) 1026 ImplItemNode(syntax)
1027 } 1027 }
@@ -1052,7 +1052,7 @@ impl<'a> ImplItem<'a> {}
1052pub struct ImplTraitTypeNode(SyntaxNode); 1052pub struct ImplTraitTypeNode(SyntaxNode);
1053 1053
1054impl ImplTraitTypeNode { 1054impl ImplTraitTypeNode {
1055 pub fn new(&self, ast: ImplTraitType) -> ImplTraitTypeNode { 1055 pub fn new(ast: ImplTraitType) -> ImplTraitTypeNode {
1056 let syntax = ast.syntax().owned(); 1056 let syntax = ast.syntax().owned();
1057 ImplTraitTypeNode(syntax) 1057 ImplTraitTypeNode(syntax)
1058 } 1058 }
@@ -1083,7 +1083,7 @@ impl<'a> ImplTraitType<'a> {}
1083pub struct IndexExprNode(SyntaxNode); 1083pub struct IndexExprNode(SyntaxNode);
1084 1084
1085impl IndexExprNode { 1085impl IndexExprNode {
1086 pub fn new(&self, ast: IndexExpr) -> IndexExprNode { 1086 pub fn new(ast: IndexExpr) -> IndexExprNode {
1087 let syntax = ast.syntax().owned(); 1087 let syntax = ast.syntax().owned();
1088 IndexExprNode(syntax) 1088 IndexExprNode(syntax)
1089 } 1089 }
@@ -1114,7 +1114,7 @@ impl<'a> IndexExpr<'a> {}
1114pub struct ItemListNode(SyntaxNode); 1114pub struct ItemListNode(SyntaxNode);
1115 1115
1116impl ItemListNode { 1116impl ItemListNode {
1117 pub fn new(&self, ast: ItemList) -> ItemListNode { 1117 pub fn new(ast: ItemList) -> ItemListNode {
1118 let syntax = ast.syntax().owned(); 1118 let syntax = ast.syntax().owned();
1119 ItemListNode(syntax) 1119 ItemListNode(syntax)
1120 } 1120 }
@@ -1147,7 +1147,7 @@ impl<'a> ItemList<'a> {}
1147pub struct LabelNode(SyntaxNode); 1147pub struct LabelNode(SyntaxNode);
1148 1148
1149impl LabelNode { 1149impl LabelNode {
1150 pub fn new(&self, ast: Label) -> LabelNode { 1150 pub fn new(ast: Label) -> LabelNode {
1151 let syntax = ast.syntax().owned(); 1151 let syntax = ast.syntax().owned();
1152 LabelNode(syntax) 1152 LabelNode(syntax)
1153 } 1153 }
@@ -1178,7 +1178,7 @@ impl<'a> Label<'a> {}
1178pub struct LambdaExprNode(SyntaxNode); 1178pub struct LambdaExprNode(SyntaxNode);
1179 1179
1180impl LambdaExprNode { 1180impl LambdaExprNode {
1181 pub fn new(&self, ast: LambdaExpr) -> LambdaExprNode { 1181 pub fn new(ast: LambdaExpr) -> LambdaExprNode {
1182 let syntax = ast.syntax().owned(); 1182 let syntax = ast.syntax().owned();
1183 LambdaExprNode(syntax) 1183 LambdaExprNode(syntax)
1184 } 1184 }
@@ -1217,7 +1217,7 @@ impl<'a> LambdaExpr<'a> {
1217pub struct LetStmtNode(SyntaxNode); 1217pub struct LetStmtNode(SyntaxNode);
1218 1218
1219impl LetStmtNode { 1219impl LetStmtNode {
1220 pub fn new(&self, ast: LetStmt) -> LetStmtNode { 1220 pub fn new(ast: LetStmt) -> LetStmtNode {
1221 let syntax = ast.syntax().owned(); 1221 let syntax = ast.syntax().owned();
1222 LetStmtNode(syntax) 1222 LetStmtNode(syntax)
1223 } 1223 }
@@ -1256,7 +1256,7 @@ impl<'a> LetStmt<'a> {
1256pub struct LifetimeNode(SyntaxNode); 1256pub struct LifetimeNode(SyntaxNode);
1257 1257
1258impl LifetimeNode { 1258impl LifetimeNode {
1259 pub fn new(&self, ast: Lifetime) -> LifetimeNode { 1259 pub fn new(ast: Lifetime) -> LifetimeNode {
1260 let syntax = ast.syntax().owned(); 1260 let syntax = ast.syntax().owned();
1261 LifetimeNode(syntax) 1261 LifetimeNode(syntax)
1262 } 1262 }
@@ -1287,7 +1287,7 @@ impl<'a> Lifetime<'a> {}
1287pub struct LifetimeParamNode(SyntaxNode); 1287pub struct LifetimeParamNode(SyntaxNode);
1288 1288
1289impl LifetimeParamNode { 1289impl LifetimeParamNode {
1290 pub fn new(&self, ast: LifetimeParam) -> LifetimeParamNode { 1290 pub fn new(ast: LifetimeParam) -> LifetimeParamNode {
1291 let syntax = ast.syntax().owned(); 1291 let syntax = ast.syntax().owned();
1292 LifetimeParamNode(syntax) 1292 LifetimeParamNode(syntax)
1293 } 1293 }
@@ -1322,7 +1322,7 @@ impl<'a> LifetimeParam<'a> {
1322pub struct LiteralNode(SyntaxNode); 1322pub struct LiteralNode(SyntaxNode);
1323 1323
1324impl LiteralNode { 1324impl LiteralNode {
1325 pub fn new(&self, ast: Literal) -> LiteralNode { 1325 pub fn new(ast: Literal) -> LiteralNode {
1326 let syntax = ast.syntax().owned(); 1326 let syntax = ast.syntax().owned();
1327 LiteralNode(syntax) 1327 LiteralNode(syntax)
1328 } 1328 }
@@ -1353,7 +1353,7 @@ impl<'a> Literal<'a> {}
1353pub struct LoopExprNode(SyntaxNode); 1353pub struct LoopExprNode(SyntaxNode);
1354 1354
1355impl LoopExprNode { 1355impl LoopExprNode {
1356 pub fn new(&self, ast: LoopExpr) -> LoopExprNode { 1356 pub fn new(ast: LoopExpr) -> LoopExprNode {
1357 let syntax = ast.syntax().owned(); 1357 let syntax = ast.syntax().owned();
1358 LoopExprNode(syntax) 1358 LoopExprNode(syntax)
1359 } 1359 }
@@ -1385,7 +1385,7 @@ impl<'a> LoopExpr<'a> {}
1385pub struct MatchArmNode(SyntaxNode); 1385pub struct MatchArmNode(SyntaxNode);
1386 1386
1387impl MatchArmNode { 1387impl MatchArmNode {
1388 pub fn new(&self, ast: MatchArm) -> MatchArmNode { 1388 pub fn new(ast: MatchArm) -> MatchArmNode {
1389 let syntax = ast.syntax().owned(); 1389 let syntax = ast.syntax().owned();
1390 MatchArmNode(syntax) 1390 MatchArmNode(syntax)
1391 } 1391 }
@@ -1428,7 +1428,7 @@ impl<'a> MatchArm<'a> {
1428pub struct MatchArmListNode(SyntaxNode); 1428pub struct MatchArmListNode(SyntaxNode);
1429 1429
1430impl MatchArmListNode { 1430impl MatchArmListNode {
1431 pub fn new(&self, ast: MatchArmList) -> MatchArmListNode { 1431 pub fn new(ast: MatchArmList) -> MatchArmListNode {
1432 let syntax = ast.syntax().owned(); 1432 let syntax = ast.syntax().owned();
1433 MatchArmListNode(syntax) 1433 MatchArmListNode(syntax)
1434 } 1434 }
@@ -1463,7 +1463,7 @@ impl<'a> MatchArmList<'a> {
1463pub struct MatchExprNode(SyntaxNode); 1463pub struct MatchExprNode(SyntaxNode);
1464 1464
1465impl MatchExprNode { 1465impl MatchExprNode {
1466 pub fn new(&self, ast: MatchExpr) -> MatchExprNode { 1466 pub fn new(ast: MatchExpr) -> MatchExprNode {
1467 let syntax = ast.syntax().owned(); 1467 let syntax = ast.syntax().owned();
1468 MatchExprNode(syntax) 1468 MatchExprNode(syntax)
1469 } 1469 }
@@ -1502,7 +1502,7 @@ impl<'a> MatchExpr<'a> {
1502pub struct MatchGuardNode(SyntaxNode); 1502pub struct MatchGuardNode(SyntaxNode);
1503 1503
1504impl MatchGuardNode { 1504impl MatchGuardNode {
1505 pub fn new(&self, ast: MatchGuard) -> MatchGuardNode { 1505 pub fn new(ast: MatchGuard) -> MatchGuardNode {
1506 let syntax = ast.syntax().owned(); 1506 let syntax = ast.syntax().owned();
1507 MatchGuardNode(syntax) 1507 MatchGuardNode(syntax)
1508 } 1508 }
@@ -1533,7 +1533,7 @@ impl<'a> MatchGuard<'a> {}
1533pub struct MethodCallExprNode(SyntaxNode); 1533pub struct MethodCallExprNode(SyntaxNode);
1534 1534
1535impl MethodCallExprNode { 1535impl MethodCallExprNode {
1536 pub fn new(&self, ast: MethodCallExpr) -> MethodCallExprNode { 1536 pub fn new(ast: MethodCallExpr) -> MethodCallExprNode {
1537 let syntax = ast.syntax().owned(); 1537 let syntax = ast.syntax().owned();
1538 MethodCallExprNode(syntax) 1538 MethodCallExprNode(syntax)
1539 } 1539 }
@@ -1569,7 +1569,7 @@ impl<'a> MethodCallExpr<'a> {
1569pub struct ModuleNode(SyntaxNode); 1569pub struct ModuleNode(SyntaxNode);
1570 1570
1571impl ModuleNode { 1571impl ModuleNode {
1572 pub fn new(&self, ast: Module) -> ModuleNode { 1572 pub fn new(ast: Module) -> ModuleNode {
1573 let syntax = ast.syntax().owned(); 1573 let syntax = ast.syntax().owned();
1574 ModuleNode(syntax) 1574 ModuleNode(syntax)
1575 } 1575 }
@@ -1606,7 +1606,7 @@ impl<'a> Module<'a> {
1606pub struct ModuleItemNode(SyntaxNode); 1606pub struct ModuleItemNode(SyntaxNode);
1607 1607
1608impl ModuleItemNode { 1608impl ModuleItemNode {
1609 pub fn new(&self, ast: ModuleItem) -> ModuleItemNode { 1609 pub fn new(ast: ModuleItem) -> ModuleItemNode {
1610 let syntax = ast.syntax().owned(); 1610 let syntax = ast.syntax().owned();
1611 ModuleItemNode(syntax) 1611 ModuleItemNode(syntax)
1612 } 1612 }
@@ -1671,7 +1671,7 @@ impl<'a> ModuleItem<'a> {}
1671pub struct NameNode(SyntaxNode); 1671pub struct NameNode(SyntaxNode);
1672 1672
1673impl NameNode { 1673impl NameNode {
1674 pub fn new(&self, ast: Name) -> NameNode { 1674 pub fn new(ast: Name) -> NameNode {
1675 let syntax = ast.syntax().owned(); 1675 let syntax = ast.syntax().owned();
1676 NameNode(syntax) 1676 NameNode(syntax)
1677 } 1677 }
@@ -1702,7 +1702,7 @@ impl<'a> Name<'a> {}
1702pub struct NameRefNode(SyntaxNode); 1702pub struct NameRefNode(SyntaxNode);
1703 1703
1704impl NameRefNode { 1704impl NameRefNode {
1705 pub fn new(&self, ast: NameRef) -> NameRefNode { 1705 pub fn new(ast: NameRef) -> NameRefNode {
1706 let syntax = ast.syntax().owned(); 1706 let syntax = ast.syntax().owned();
1707 NameRefNode(syntax) 1707 NameRefNode(syntax)
1708 } 1708 }
@@ -1733,7 +1733,7 @@ impl<'a> NameRef<'a> {}
1733pub struct NamedFieldNode(SyntaxNode); 1733pub struct NamedFieldNode(SyntaxNode);
1734 1734
1735impl NamedFieldNode { 1735impl NamedFieldNode {
1736 pub fn new(&self, ast: NamedField) -> NamedFieldNode { 1736 pub fn new(ast: NamedField) -> NamedFieldNode {
1737 let syntax = ast.syntax().owned(); 1737 let syntax = ast.syntax().owned();
1738 NamedFieldNode(syntax) 1738 NamedFieldNode(syntax)
1739 } 1739 }
@@ -1764,7 +1764,7 @@ impl<'a> NamedField<'a> {}
1764pub struct NamedFieldDefNode(SyntaxNode); 1764pub struct NamedFieldDefNode(SyntaxNode);
1765 1765
1766impl NamedFieldDefNode { 1766impl NamedFieldDefNode {
1767 pub fn new(&self, ast: NamedFieldDef) -> NamedFieldDefNode { 1767 pub fn new(ast: NamedFieldDef) -> NamedFieldDefNode {
1768 let syntax = ast.syntax().owned(); 1768 let syntax = ast.syntax().owned();
1769 NamedFieldDefNode(syntax) 1769 NamedFieldDefNode(syntax)
1770 } 1770 }
@@ -1797,7 +1797,7 @@ impl<'a> NamedFieldDef<'a> {}
1797pub struct NamedFieldListNode(SyntaxNode); 1797pub struct NamedFieldListNode(SyntaxNode);
1798 1798
1799impl NamedFieldListNode { 1799impl NamedFieldListNode {
1800 pub fn new(&self, ast: NamedFieldList) -> NamedFieldListNode { 1800 pub fn new(ast: NamedFieldList) -> NamedFieldListNode {
1801 let syntax = ast.syntax().owned(); 1801 let syntax = ast.syntax().owned();
1802 NamedFieldListNode(syntax) 1802 NamedFieldListNode(syntax)
1803 } 1803 }
@@ -1828,7 +1828,7 @@ impl<'a> NamedFieldList<'a> {}
1828pub struct NeverTypeNode(SyntaxNode); 1828pub struct NeverTypeNode(SyntaxNode);
1829 1829
1830impl NeverTypeNode { 1830impl NeverTypeNode {
1831 pub fn new(&self, ast: NeverType) -> NeverTypeNode { 1831 pub fn new(ast: NeverType) -> NeverTypeNode {
1832 let syntax = ast.syntax().owned(); 1832 let syntax = ast.syntax().owned();
1833 NeverTypeNode(syntax) 1833 NeverTypeNode(syntax)
1834 } 1834 }
@@ -1859,7 +1859,7 @@ impl<'a> NeverType<'a> {}
1859pub struct NominalDefNode(SyntaxNode); 1859pub struct NominalDefNode(SyntaxNode);
1860 1860
1861impl NominalDefNode { 1861impl NominalDefNode {
1862 pub fn new(&self, ast: NominalDef) -> NominalDefNode { 1862 pub fn new(ast: NominalDef) -> NominalDefNode {
1863 let syntax = ast.syntax().owned(); 1863 let syntax = ast.syntax().owned();
1864 NominalDefNode(syntax) 1864 NominalDefNode(syntax)
1865 } 1865 }
@@ -1900,7 +1900,7 @@ impl<'a> NominalDef<'a> {}
1900pub struct ParamNode(SyntaxNode); 1900pub struct ParamNode(SyntaxNode);
1901 1901
1902impl ParamNode { 1902impl ParamNode {
1903 pub fn new(&self, ast: Param) -> ParamNode { 1903 pub fn new(ast: Param) -> ParamNode {
1904 let syntax = ast.syntax().owned(); 1904 let syntax = ast.syntax().owned();
1905 ParamNode(syntax) 1905 ParamNode(syntax)
1906 } 1906 }
@@ -1935,7 +1935,7 @@ impl<'a> Param<'a> {
1935pub struct ParamListNode(SyntaxNode); 1935pub struct ParamListNode(SyntaxNode);
1936 1936
1937impl ParamListNode { 1937impl ParamListNode {
1938 pub fn new(&self, ast: ParamList) -> ParamListNode { 1938 pub fn new(ast: ParamList) -> ParamListNode {
1939 let syntax = ast.syntax().owned(); 1939 let syntax = ast.syntax().owned();
1940 ParamListNode(syntax) 1940 ParamListNode(syntax)
1941 } 1941 }
@@ -1974,7 +1974,7 @@ impl<'a> ParamList<'a> {
1974pub struct ParenExprNode(SyntaxNode); 1974pub struct ParenExprNode(SyntaxNode);
1975 1975
1976impl ParenExprNode { 1976impl ParenExprNode {
1977 pub fn new(&self, ast: ParenExpr) -> ParenExprNode { 1977 pub fn new(ast: ParenExpr) -> ParenExprNode {
1978 let syntax = ast.syntax().owned(); 1978 let syntax = ast.syntax().owned();
1979 ParenExprNode(syntax) 1979 ParenExprNode(syntax)
1980 } 1980 }
@@ -2005,7 +2005,7 @@ impl<'a> ParenExpr<'a> {}
2005pub struct ParenTypeNode(SyntaxNode); 2005pub struct ParenTypeNode(SyntaxNode);
2006 2006
2007impl ParenTypeNode { 2007impl ParenTypeNode {
2008 pub fn new(&self, ast: ParenType) -> ParenTypeNode { 2008 pub fn new(ast: ParenType) -> ParenTypeNode {
2009 let syntax = ast.syntax().owned(); 2009 let syntax = ast.syntax().owned();
2010 ParenTypeNode(syntax) 2010 ParenTypeNode(syntax)
2011 } 2011 }
@@ -2036,7 +2036,7 @@ impl<'a> ParenType<'a> {}
2036pub struct PatNode(SyntaxNode); 2036pub struct PatNode(SyntaxNode);
2037 2037
2038impl PatNode { 2038impl PatNode {
2039 pub fn new(&self, ast: Pat) -> PatNode { 2039 pub fn new(ast: Pat) -> PatNode {
2040 let syntax = ast.syntax().owned(); 2040 let syntax = ast.syntax().owned();
2041 PatNode(syntax) 2041 PatNode(syntax)
2042 } 2042 }
@@ -2098,7 +2098,7 @@ impl<'a> Pat<'a> {}
2098pub struct PathNode(SyntaxNode); 2098pub struct PathNode(SyntaxNode);
2099 2099
2100impl PathNode { 2100impl PathNode {
2101 pub fn new(&self, ast: Path) -> PathNode { 2101 pub fn new(ast: Path) -> PathNode {
2102 let syntax = ast.syntax().owned(); 2102 let syntax = ast.syntax().owned();
2103 PathNode(syntax) 2103 PathNode(syntax)
2104 } 2104 }
@@ -2137,7 +2137,7 @@ impl<'a> Path<'a> {
2137pub struct PathExprNode(SyntaxNode); 2137pub struct PathExprNode(SyntaxNode);
2138 2138
2139impl PathExprNode { 2139impl PathExprNode {
2140 pub fn new(&self, ast: PathExpr) -> PathExprNode { 2140 pub fn new(ast: PathExpr) -> PathExprNode {
2141 let syntax = ast.syntax().owned(); 2141 let syntax = ast.syntax().owned();
2142 PathExprNode(syntax) 2142 PathExprNode(syntax)
2143 } 2143 }
@@ -2172,7 +2172,7 @@ impl<'a> PathExpr<'a> {
2172pub struct PathPatNode(SyntaxNode); 2172pub struct PathPatNode(SyntaxNode);
2173 2173
2174impl PathPatNode { 2174impl PathPatNode {
2175 pub fn new(&self, ast: PathPat) -> PathPatNode { 2175 pub fn new(ast: PathPat) -> PathPatNode {
2176 let syntax = ast.syntax().owned(); 2176 let syntax = ast.syntax().owned();
2177 PathPatNode(syntax) 2177 PathPatNode(syntax)
2178 } 2178 }
@@ -2203,7 +2203,7 @@ impl<'a> PathPat<'a> {}
2203pub struct PathSegmentNode(SyntaxNode); 2203pub struct PathSegmentNode(SyntaxNode);
2204 2204
2205impl PathSegmentNode { 2205impl PathSegmentNode {
2206 pub fn new(&self, ast: PathSegment) -> PathSegmentNode { 2206 pub fn new(ast: PathSegment) -> PathSegmentNode {
2207 let syntax = ast.syntax().owned(); 2207 let syntax = ast.syntax().owned();
2208 PathSegmentNode(syntax) 2208 PathSegmentNode(syntax)
2209 } 2209 }
@@ -2238,7 +2238,7 @@ impl<'a> PathSegment<'a> {
2238pub struct PathTypeNode(SyntaxNode); 2238pub struct PathTypeNode(SyntaxNode);
2239 2239
2240impl PathTypeNode { 2240impl PathTypeNode {
2241 pub fn new(&self, ast: PathType) -> PathTypeNode { 2241 pub fn new(ast: PathType) -> PathTypeNode {
2242 let syntax = ast.syntax().owned(); 2242 let syntax = ast.syntax().owned();
2243 PathTypeNode(syntax) 2243 PathTypeNode(syntax)
2244 } 2244 }
@@ -2269,7 +2269,7 @@ impl<'a> PathType<'a> {}
2269pub struct PlaceholderPatNode(SyntaxNode); 2269pub struct PlaceholderPatNode(SyntaxNode);
2270 2270
2271impl PlaceholderPatNode { 2271impl PlaceholderPatNode {
2272 pub fn new(&self, ast: PlaceholderPat) -> PlaceholderPatNode { 2272 pub fn new(ast: PlaceholderPat) -> PlaceholderPatNode {
2273 let syntax = ast.syntax().owned(); 2273 let syntax = ast.syntax().owned();
2274 PlaceholderPatNode(syntax) 2274 PlaceholderPatNode(syntax)
2275 } 2275 }
@@ -2300,7 +2300,7 @@ impl<'a> PlaceholderPat<'a> {}
2300pub struct PlaceholderTypeNode(SyntaxNode); 2300pub struct PlaceholderTypeNode(SyntaxNode);
2301 2301
2302impl PlaceholderTypeNode { 2302impl PlaceholderTypeNode {
2303 pub fn new(&self, ast: PlaceholderType) -> PlaceholderTypeNode { 2303 pub fn new(ast: PlaceholderType) -> PlaceholderTypeNode {
2304 let syntax = ast.syntax().owned(); 2304 let syntax = ast.syntax().owned();
2305 PlaceholderTypeNode(syntax) 2305 PlaceholderTypeNode(syntax)
2306 } 2306 }
@@ -2331,7 +2331,7 @@ impl<'a> PlaceholderType<'a> {}
2331pub struct PointerTypeNode(SyntaxNode); 2331pub struct PointerTypeNode(SyntaxNode);
2332 2332
2333impl PointerTypeNode { 2333impl PointerTypeNode {
2334 pub fn new(&self, ast: PointerType) -> PointerTypeNode { 2334 pub fn new(ast: PointerType) -> PointerTypeNode {
2335 let syntax = ast.syntax().owned(); 2335 let syntax = ast.syntax().owned();
2336 PointerTypeNode(syntax) 2336 PointerTypeNode(syntax)
2337 } 2337 }
@@ -2362,7 +2362,7 @@ impl<'a> PointerType<'a> {}
2362pub struct PrefixExprNode(SyntaxNode); 2362pub struct PrefixExprNode(SyntaxNode);
2363 2363
2364impl PrefixExprNode { 2364impl PrefixExprNode {
2365 pub fn new(&self, ast: PrefixExpr) -> PrefixExprNode { 2365 pub fn new(ast: PrefixExpr) -> PrefixExprNode {
2366 let syntax = ast.syntax().owned(); 2366 let syntax = ast.syntax().owned();
2367 PrefixExprNode(syntax) 2367 PrefixExprNode(syntax)
2368 } 2368 }
@@ -2393,7 +2393,7 @@ impl<'a> PrefixExpr<'a> {}
2393pub struct RangeExprNode(SyntaxNode); 2393pub struct RangeExprNode(SyntaxNode);
2394 2394
2395impl RangeExprNode { 2395impl RangeExprNode {
2396 pub fn new(&self, ast: RangeExpr) -> RangeExprNode { 2396 pub fn new(ast: RangeExpr) -> RangeExprNode {
2397 let syntax = ast.syntax().owned(); 2397 let syntax = ast.syntax().owned();
2398 RangeExprNode(syntax) 2398 RangeExprNode(syntax)
2399 } 2399 }
@@ -2424,7 +2424,7 @@ impl<'a> RangeExpr<'a> {}
2424pub struct RangePatNode(SyntaxNode); 2424pub struct RangePatNode(SyntaxNode);
2425 2425
2426impl RangePatNode { 2426impl RangePatNode {
2427 pub fn new(&self, ast: RangePat) -> RangePatNode { 2427 pub fn new(ast: RangePat) -> RangePatNode {
2428 let syntax = ast.syntax().owned(); 2428 let syntax = ast.syntax().owned();
2429 RangePatNode(syntax) 2429 RangePatNode(syntax)
2430 } 2430 }
@@ -2455,7 +2455,7 @@ impl<'a> RangePat<'a> {}
2455pub struct RefExprNode(SyntaxNode); 2455pub struct RefExprNode(SyntaxNode);
2456 2456
2457impl RefExprNode { 2457impl RefExprNode {
2458 pub fn new(&self, ast: RefExpr) -> RefExprNode { 2458 pub fn new(ast: RefExpr) -> RefExprNode {
2459 let syntax = ast.syntax().owned(); 2459 let syntax = ast.syntax().owned();
2460 RefExprNode(syntax) 2460 RefExprNode(syntax)
2461 } 2461 }
@@ -2486,7 +2486,7 @@ impl<'a> RefExpr<'a> {}
2486pub struct RefPatNode(SyntaxNode); 2486pub struct RefPatNode(SyntaxNode);
2487 2487
2488impl RefPatNode { 2488impl RefPatNode {
2489 pub fn new(&self, ast: RefPat) -> RefPatNode { 2489 pub fn new(ast: RefPat) -> RefPatNode {
2490 let syntax = ast.syntax().owned(); 2490 let syntax = ast.syntax().owned();
2491 RefPatNode(syntax) 2491 RefPatNode(syntax)
2492 } 2492 }
@@ -2517,7 +2517,7 @@ impl<'a> RefPat<'a> {}
2517pub struct ReferenceTypeNode(SyntaxNode); 2517pub struct ReferenceTypeNode(SyntaxNode);
2518 2518
2519impl ReferenceTypeNode { 2519impl ReferenceTypeNode {
2520 pub fn new(&self, ast: ReferenceType) -> ReferenceTypeNode { 2520 pub fn new(ast: ReferenceType) -> ReferenceTypeNode {
2521 let syntax = ast.syntax().owned(); 2521 let syntax = ast.syntax().owned();
2522 ReferenceTypeNode(syntax) 2522 ReferenceTypeNode(syntax)
2523 } 2523 }
@@ -2548,7 +2548,7 @@ impl<'a> ReferenceType<'a> {}
2548pub struct RetTypeNode(SyntaxNode); 2548pub struct RetTypeNode(SyntaxNode);
2549 2549
2550impl RetTypeNode { 2550impl RetTypeNode {
2551 pub fn new(&self, ast: RetType) -> RetTypeNode { 2551 pub fn new(ast: RetType) -> RetTypeNode {
2552 let syntax = ast.syntax().owned(); 2552 let syntax = ast.syntax().owned();
2553 RetTypeNode(syntax) 2553 RetTypeNode(syntax)
2554 } 2554 }
@@ -2579,7 +2579,7 @@ impl<'a> RetType<'a> {}
2579pub struct ReturnExprNode(SyntaxNode); 2579pub struct ReturnExprNode(SyntaxNode);
2580 2580
2581impl ReturnExprNode { 2581impl ReturnExprNode {
2582 pub fn new(&self, ast: ReturnExpr) -> ReturnExprNode { 2582 pub fn new(ast: ReturnExpr) -> ReturnExprNode {
2583 let syntax = ast.syntax().owned(); 2583 let syntax = ast.syntax().owned();
2584 ReturnExprNode(syntax) 2584 ReturnExprNode(syntax)
2585 } 2585 }
@@ -2610,7 +2610,7 @@ impl<'a> ReturnExpr<'a> {}
2610pub struct RootNode(SyntaxNode); 2610pub struct RootNode(SyntaxNode);
2611 2611
2612impl RootNode { 2612impl RootNode {
2613 pub fn new(&self, ast: Root) -> RootNode { 2613 pub fn new(ast: Root) -> RootNode {
2614 let syntax = ast.syntax().owned(); 2614 let syntax = ast.syntax().owned();
2615 RootNode(syntax) 2615 RootNode(syntax)
2616 } 2616 }
@@ -2647,7 +2647,7 @@ impl<'a> Root<'a> {
2647pub struct SelfParamNode(SyntaxNode); 2647pub struct SelfParamNode(SyntaxNode);
2648 2648
2649impl SelfParamNode { 2649impl SelfParamNode {
2650 pub fn new(&self, ast: SelfParam) -> SelfParamNode { 2650 pub fn new(ast: SelfParam) -> SelfParamNode {
2651 let syntax = ast.syntax().owned(); 2651 let syntax = ast.syntax().owned();
2652 SelfParamNode(syntax) 2652 SelfParamNode(syntax)
2653 } 2653 }
@@ -2678,7 +2678,7 @@ impl<'a> SelfParam<'a> {}
2678pub struct SlicePatNode(SyntaxNode); 2678pub struct SlicePatNode(SyntaxNode);
2679 2679
2680impl SlicePatNode { 2680impl SlicePatNode {
2681 pub fn new(&self, ast: SlicePat) -> SlicePatNode { 2681 pub fn new(ast: SlicePat) -> SlicePatNode {
2682 let syntax = ast.syntax().owned(); 2682 let syntax = ast.syntax().owned();
2683 SlicePatNode(syntax) 2683 SlicePatNode(syntax)
2684 } 2684 }
@@ -2709,7 +2709,7 @@ impl<'a> SlicePat<'a> {}
2709pub struct SliceTypeNode(SyntaxNode); 2709pub struct SliceTypeNode(SyntaxNode);
2710 2710
2711impl SliceTypeNode { 2711impl SliceTypeNode {
2712 pub fn new(&self, ast: SliceType) -> SliceTypeNode { 2712 pub fn new(ast: SliceType) -> SliceTypeNode {
2713 let syntax = ast.syntax().owned(); 2713 let syntax = ast.syntax().owned();
2714 SliceTypeNode(syntax) 2714 SliceTypeNode(syntax)
2715 } 2715 }
@@ -2740,7 +2740,7 @@ impl<'a> SliceType<'a> {}
2740pub struct StaticDefNode(SyntaxNode); 2740pub struct StaticDefNode(SyntaxNode);
2741 2741
2742impl StaticDefNode { 2742impl StaticDefNode {
2743 pub fn new(&self, ast: StaticDef) -> StaticDefNode { 2743 pub fn new(ast: StaticDef) -> StaticDefNode {
2744 let syntax = ast.syntax().owned(); 2744 let syntax = ast.syntax().owned();
2745 StaticDefNode(syntax) 2745 StaticDefNode(syntax)
2746 } 2746 }
@@ -2774,7 +2774,7 @@ impl<'a> StaticDef<'a> {}
2774pub struct StmtNode(SyntaxNode); 2774pub struct StmtNode(SyntaxNode);
2775 2775
2776impl StmtNode { 2776impl StmtNode {
2777 pub fn new(&self, ast: Stmt) -> StmtNode { 2777 pub fn new(ast: Stmt) -> StmtNode {
2778 let syntax = ast.syntax().owned(); 2778 let syntax = ast.syntax().owned();
2779 StmtNode(syntax) 2779 StmtNode(syntax)
2780 } 2780 }
@@ -2812,7 +2812,7 @@ impl<'a> Stmt<'a> {}
2812pub struct StructDefNode(SyntaxNode); 2812pub struct StructDefNode(SyntaxNode);
2813 2813
2814impl StructDefNode { 2814impl StructDefNode {
2815 pub fn new(&self, ast: StructDef) -> StructDefNode { 2815 pub fn new(ast: StructDef) -> StructDefNode {
2816 let syntax = ast.syntax().owned(); 2816 let syntax = ast.syntax().owned();
2817 StructDefNode(syntax) 2817 StructDefNode(syntax)
2818 } 2818 }
@@ -2850,7 +2850,7 @@ impl<'a> StructDef<'a> {
2850pub struct StructLitNode(SyntaxNode); 2850pub struct StructLitNode(SyntaxNode);
2851 2851
2852impl StructLitNode { 2852impl StructLitNode {
2853 pub fn new(&self, ast: StructLit) -> StructLitNode { 2853 pub fn new(ast: StructLit) -> StructLitNode {
2854 let syntax = ast.syntax().owned(); 2854 let syntax = ast.syntax().owned();
2855 StructLitNode(syntax) 2855 StructLitNode(syntax)
2856 } 2856 }
@@ -2881,7 +2881,7 @@ impl<'a> StructLit<'a> {}
2881pub struct StructPatNode(SyntaxNode); 2881pub struct StructPatNode(SyntaxNode);
2882 2882
2883impl StructPatNode { 2883impl StructPatNode {
2884 pub fn new(&self, ast: StructPat) -> StructPatNode { 2884 pub fn new(ast: StructPat) -> StructPatNode {
2885 let syntax = ast.syntax().owned(); 2885 let syntax = ast.syntax().owned();
2886 StructPatNode(syntax) 2886 StructPatNode(syntax)
2887 } 2887 }
@@ -2912,7 +2912,7 @@ impl<'a> StructPat<'a> {}
2912pub struct TokenTreeNode(SyntaxNode); 2912pub struct TokenTreeNode(SyntaxNode);
2913 2913
2914impl TokenTreeNode { 2914impl TokenTreeNode {
2915 pub fn new(&self, ast: TokenTree) -> TokenTreeNode { 2915 pub fn new(ast: TokenTree) -> TokenTreeNode {
2916 let syntax = ast.syntax().owned(); 2916 let syntax = ast.syntax().owned();
2917 TokenTreeNode(syntax) 2917 TokenTreeNode(syntax)
2918 } 2918 }
@@ -2943,7 +2943,7 @@ impl<'a> TokenTree<'a> {}
2943pub struct TraitDefNode(SyntaxNode); 2943pub struct TraitDefNode(SyntaxNode);
2944 2944
2945impl TraitDefNode { 2945impl TraitDefNode {
2946 pub fn new(&self, ast: TraitDef) -> TraitDefNode { 2946 pub fn new(ast: TraitDef) -> TraitDefNode {
2947 let syntax = ast.syntax().owned(); 2947 let syntax = ast.syntax().owned();
2948 TraitDefNode(syntax) 2948 TraitDefNode(syntax)
2949 } 2949 }
@@ -2976,7 +2976,7 @@ impl<'a> TraitDef<'a> {}
2976pub struct TryExprNode(SyntaxNode); 2976pub struct TryExprNode(SyntaxNode);
2977 2977
2978impl TryExprNode { 2978impl TryExprNode {
2979 pub fn new(&self, ast: TryExpr) -> TryExprNode { 2979 pub fn new(ast: TryExpr) -> TryExprNode {
2980 let syntax = ast.syntax().owned(); 2980 let syntax = ast.syntax().owned();
2981 TryExprNode(syntax) 2981 TryExprNode(syntax)
2982 } 2982 }
@@ -3007,7 +3007,7 @@ impl<'a> TryExpr<'a> {}
3007pub struct TupleExprNode(SyntaxNode); 3007pub struct TupleExprNode(SyntaxNode);
3008 3008
3009impl TupleExprNode { 3009impl TupleExprNode {
3010 pub fn new(&self, ast: TupleExpr) -> TupleExprNode { 3010 pub fn new(ast: TupleExpr) -> TupleExprNode {
3011 let syntax = ast.syntax().owned(); 3011 let syntax = ast.syntax().owned();
3012 TupleExprNode(syntax) 3012 TupleExprNode(syntax)
3013 } 3013 }
@@ -3038,7 +3038,7 @@ impl<'a> TupleExpr<'a> {}
3038pub struct TuplePatNode(SyntaxNode); 3038pub struct TuplePatNode(SyntaxNode);
3039 3039
3040impl TuplePatNode { 3040impl TuplePatNode {
3041 pub fn new(&self, ast: TuplePat) -> TuplePatNode { 3041 pub fn new(ast: TuplePat) -> TuplePatNode {
3042 let syntax = ast.syntax().owned(); 3042 let syntax = ast.syntax().owned();
3043 TuplePatNode(syntax) 3043 TuplePatNode(syntax)
3044 } 3044 }
@@ -3069,7 +3069,7 @@ impl<'a> TuplePat<'a> {}
3069pub struct TupleStructPatNode(SyntaxNode); 3069pub struct TupleStructPatNode(SyntaxNode);
3070 3070
3071impl TupleStructPatNode { 3071impl TupleStructPatNode {
3072 pub fn new(&self, ast: TupleStructPat) -> TupleStructPatNode { 3072 pub fn new(ast: TupleStructPat) -> TupleStructPatNode {
3073 let syntax = ast.syntax().owned(); 3073 let syntax = ast.syntax().owned();
3074 TupleStructPatNode(syntax) 3074 TupleStructPatNode(syntax)
3075 } 3075 }
@@ -3100,7 +3100,7 @@ impl<'a> TupleStructPat<'a> {}
3100pub struct TupleTypeNode(SyntaxNode); 3100pub struct TupleTypeNode(SyntaxNode);
3101 3101
3102impl TupleTypeNode { 3102impl TupleTypeNode {
3103 pub fn new(&self, ast: TupleType) -> TupleTypeNode { 3103 pub fn new(ast: TupleType) -> TupleTypeNode {
3104 let syntax = ast.syntax().owned(); 3104 let syntax = ast.syntax().owned();
3105 TupleTypeNode(syntax) 3105 TupleTypeNode(syntax)
3106 } 3106 }
@@ -3131,7 +3131,7 @@ impl<'a> TupleType<'a> {}
3131pub struct TypeDefNode(SyntaxNode); 3131pub struct TypeDefNode(SyntaxNode);
3132 3132
3133impl TypeDefNode { 3133impl TypeDefNode {
3134 pub fn new(&self, ast: TypeDef) -> TypeDefNode { 3134 pub fn new(ast: TypeDef) -> TypeDefNode {
3135 let syntax = ast.syntax().owned(); 3135 let syntax = ast.syntax().owned();
3136 TypeDefNode(syntax) 3136 TypeDefNode(syntax)
3137 } 3137 }
@@ -3165,7 +3165,7 @@ impl<'a> TypeDef<'a> {}
3165pub struct TypeParamNode(SyntaxNode); 3165pub struct TypeParamNode(SyntaxNode);
3166 3166
3167impl TypeParamNode { 3167impl TypeParamNode {
3168 pub fn new(&self, ast: TypeParam) -> TypeParamNode { 3168 pub fn new(ast: TypeParam) -> TypeParamNode {
3169 let syntax = ast.syntax().owned(); 3169 let syntax = ast.syntax().owned();
3170 TypeParamNode(syntax) 3170 TypeParamNode(syntax)
3171 } 3171 }
@@ -3197,7 +3197,7 @@ impl<'a> TypeParam<'a> {}
3197pub struct TypeParamListNode(SyntaxNode); 3197pub struct TypeParamListNode(SyntaxNode);
3198 3198
3199impl TypeParamListNode { 3199impl TypeParamListNode {
3200 pub fn new(&self, ast: TypeParamList) -> TypeParamListNode { 3200 pub fn new(ast: TypeParamList) -> TypeParamListNode {
3201 let syntax = ast.syntax().owned(); 3201 let syntax = ast.syntax().owned();
3202 TypeParamListNode(syntax) 3202 TypeParamListNode(syntax)
3203 } 3203 }
@@ -3236,7 +3236,7 @@ impl<'a> TypeParamList<'a> {
3236pub struct TypeRefNode(SyntaxNode); 3236pub struct TypeRefNode(SyntaxNode);
3237 3237
3238impl TypeRefNode { 3238impl TypeRefNode {
3239 pub fn new(&self, ast: TypeRef) -> TypeRefNode { 3239 pub fn new(ast: TypeRef) -> TypeRefNode {
3240 let syntax = ast.syntax().owned(); 3240 let syntax = ast.syntax().owned();
3241 TypeRefNode(syntax) 3241 TypeRefNode(syntax)
3242 } 3242 }
@@ -3307,7 +3307,7 @@ impl<'a> TypeRef<'a> {}
3307pub struct UseItemNode(SyntaxNode); 3307pub struct UseItemNode(SyntaxNode);
3308 3308
3309impl UseItemNode { 3309impl UseItemNode {
3310 pub fn new(&self, ast: UseItem) -> UseItemNode { 3310 pub fn new(ast: UseItem) -> UseItemNode {
3311 let syntax = ast.syntax().owned(); 3311 let syntax = ast.syntax().owned();
3312 UseItemNode(syntax) 3312 UseItemNode(syntax)
3313 } 3313 }
@@ -3342,7 +3342,7 @@ impl<'a> UseItem<'a> {
3342pub struct UseTreeNode(SyntaxNode); 3342pub struct UseTreeNode(SyntaxNode);
3343 3343
3344impl UseTreeNode { 3344impl UseTreeNode {
3345 pub fn new(&self, ast: UseTree) -> UseTreeNode { 3345 pub fn new(ast: UseTree) -> UseTreeNode {
3346 let syntax = ast.syntax().owned(); 3346 let syntax = ast.syntax().owned();
3347 UseTreeNode(syntax) 3347 UseTreeNode(syntax)
3348 } 3348 }
@@ -3381,7 +3381,7 @@ impl<'a> UseTree<'a> {
3381pub struct UseTreeListNode(SyntaxNode); 3381pub struct UseTreeListNode(SyntaxNode);
3382 3382
3383impl UseTreeListNode { 3383impl UseTreeListNode {
3384 pub fn new(&self, ast: UseTreeList) -> UseTreeListNode { 3384 pub fn new(ast: UseTreeList) -> UseTreeListNode {
3385 let syntax = ast.syntax().owned(); 3385 let syntax = ast.syntax().owned();
3386 UseTreeListNode(syntax) 3386 UseTreeListNode(syntax)
3387 } 3387 }
@@ -3416,7 +3416,7 @@ impl<'a> UseTreeList<'a> {
3416pub struct WhereClauseNode(SyntaxNode); 3416pub struct WhereClauseNode(SyntaxNode);
3417 3417
3418impl WhereClauseNode { 3418impl WhereClauseNode {
3419 pub fn new(&self, ast: WhereClause) -> WhereClauseNode { 3419 pub fn new(ast: WhereClause) -> WhereClauseNode {
3420 let syntax = ast.syntax().owned(); 3420 let syntax = ast.syntax().owned();
3421 WhereClauseNode(syntax) 3421 WhereClauseNode(syntax)
3422 } 3422 }
@@ -3447,7 +3447,7 @@ impl<'a> WhereClause<'a> {}
3447pub struct WhileExprNode(SyntaxNode); 3447pub struct WhileExprNode(SyntaxNode);
3448 3448
3449impl WhileExprNode { 3449impl WhileExprNode {
3450 pub fn new(&self, ast: WhileExpr) -> WhileExprNode { 3450 pub fn new(ast: WhileExpr) -> WhileExprNode {
3451 let syntax = ast.syntax().owned(); 3451 let syntax = ast.syntax().owned();
3452 WhileExprNode(syntax) 3452 WhileExprNode(syntax)
3453 } 3453 }
@@ -3483,7 +3483,7 @@ impl<'a> WhileExpr<'a> {
3483pub struct WhitespaceNode(SyntaxNode); 3483pub struct WhitespaceNode(SyntaxNode);
3484 3484
3485impl WhitespaceNode { 3485impl WhitespaceNode {
3486 pub fn new(&self, ast: Whitespace) -> WhitespaceNode { 3486 pub fn new(ast: Whitespace) -> WhitespaceNode {
3487 let syntax = ast.syntax().owned(); 3487 let syntax = ast.syntax().owned();
3488 WhitespaceNode(syntax) 3488 WhitespaceNode(syntax)
3489 } 3489 }
diff --git a/crates/ra_syntax/src/ast/generated.rs.tera b/crates/ra_syntax/src/ast/generated.rs.tera
index c61c3e80b..d30038cba 100644
--- a/crates/ra_syntax/src/ast/generated.rs.tera
+++ b/crates/ra_syntax/src/ast/generated.rs.tera
@@ -17,7 +17,7 @@ use crate::{
17pub struct {{ node }}Node(SyntaxNode); 17pub struct {{ node }}Node(SyntaxNode);
18 18
19impl {{ node }}Node { 19impl {{ node }}Node {
20 pub fn new(&self, ast: {{ node }}) -> {{ node }}Node { 20 pub fn new(ast: {{ node }}) -> {{ node }}Node {
21 let syntax = ast.syntax().owned(); 21 let syntax = ast.syntax().owned();
22 {{ node }}Node(syntax) 22 {{ node }}Node(syntax)
23 } 23 }