aboutsummaryrefslogtreecommitdiff
path: root/crates/ra_syntax/src/ast/generated
diff options
context:
space:
mode:
authorbors[bot] <26634292+bors[bot]@users.noreply.github.com>2020-07-30 17:52:59 +0100
committerGitHub <[email protected]>2020-07-30 17:52:59 +0100
commitbc8610e2b58fe101ddc34d0ce389cfa829060c62 (patch)
treefac9cf9a1ac4e4e28570261f2e755aa4f92f904d /crates/ra_syntax/src/ast/generated
parentaf8132e610d1e649e67ab797e372d1efcf106c48 (diff)
parent3dce34aaf83c67836c94a526cb90eba8f36e3985 (diff)
Merge #5608
5608: Introduce GenericParam r=matklad a=matklad bors r+ 🤖 Co-authored-by: Aleksey Kladov <[email protected]>
Diffstat (limited to 'crates/ra_syntax/src/ast/generated')
-rw-r--r--crates/ra_syntax/src/ast/generated/nodes.rs213
1 files changed, 128 insertions, 85 deletions
diff --git a/crates/ra_syntax/src/ast/generated/nodes.rs b/crates/ra_syntax/src/ast/generated/nodes.rs
index 9345a5e8f..e3b3f44cc 100644
--- a/crates/ra_syntax/src/ast/generated/nodes.rs
+++ b/crates/ra_syntax/src/ast/generated/nodes.rs
@@ -312,9 +312,7 @@ pub struct GenericParamList {
312} 312}
313impl GenericParamList { 313impl GenericParamList {
314 pub fn l_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![<]) } 314 pub fn l_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![<]) }
315 pub fn type_params(&self) -> AstChildren<TypeParam> { support::children(&self.syntax) } 315 pub fn generic_params(&self) -> AstChildren<GenericParam> { support::children(&self.syntax) }
316 pub fn lifetime_params(&self) -> AstChildren<LifetimeParam> { support::children(&self.syntax) }
317 pub fn const_params(&self) -> AstChildren<ConstParam> { support::children(&self.syntax) }
318 pub fn r_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![>]) } 316 pub fn r_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![>]) }
319} 317}
320#[derive(Debug, Clone, PartialEq, Eq, Hash)] 318#[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -470,6 +468,40 @@ impl ExternItemList {
470 pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) } 468 pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
471} 469}
472#[derive(Debug, Clone, PartialEq, Eq, Hash)] 470#[derive(Debug, Clone, PartialEq, Eq, Hash)]
471pub struct LifetimeParam {
472 pub(crate) syntax: SyntaxNode,
473}
474impl ast::AttrsOwner for LifetimeParam {}
475impl LifetimeParam {
476 pub fn lifetime_token(&self) -> Option<SyntaxToken> {
477 support::token(&self.syntax, T![lifetime])
478 }
479}
480#[derive(Debug, Clone, PartialEq, Eq, Hash)]
481pub struct TypeParam {
482 pub(crate) syntax: SyntaxNode,
483}
484impl ast::AttrsOwner for TypeParam {}
485impl ast::NameOwner for TypeParam {}
486impl ast::TypeBoundsOwner for TypeParam {}
487impl TypeParam {
488 pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
489 pub fn default_type(&self) -> Option<TypeRef> { support::child(&self.syntax) }
490}
491#[derive(Debug, Clone, PartialEq, Eq, Hash)]
492pub struct ConstParam {
493 pub(crate) syntax: SyntaxNode,
494}
495impl ast::AttrsOwner for ConstParam {}
496impl ast::NameOwner for ConstParam {}
497impl ast::TypeAscriptionOwner for ConstParam {}
498impl ConstParam {
499 pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
500 pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
501 pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
502 pub fn default_val(&self) -> Option<Expr> { support::child(&self.syntax) }
503}
504#[derive(Debug, Clone, PartialEq, Eq, Hash)]
473pub struct ParenType { 505pub struct ParenType {
474 pub(crate) syntax: SyntaxNode, 506 pub(crate) syntax: SyntaxNode,
475} 507}
@@ -1133,40 +1165,6 @@ impl MacroStmts {
1133 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } 1165 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
1134} 1166}
1135#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1167#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1136pub struct TypeParam {
1137 pub(crate) syntax: SyntaxNode,
1138}
1139impl ast::AttrsOwner for TypeParam {}
1140impl ast::NameOwner for TypeParam {}
1141impl ast::TypeBoundsOwner for TypeParam {}
1142impl TypeParam {
1143 pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
1144 pub fn default_type(&self) -> Option<TypeRef> { support::child(&self.syntax) }
1145}
1146#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1147pub struct LifetimeParam {
1148 pub(crate) syntax: SyntaxNode,
1149}
1150impl ast::AttrsOwner for LifetimeParam {}
1151impl LifetimeParam {
1152 pub fn lifetime_token(&self) -> Option<SyntaxToken> {
1153 support::token(&self.syntax, T![lifetime])
1154 }
1155}
1156#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1157pub struct ConstParam {
1158 pub(crate) syntax: SyntaxNode,
1159}
1160impl ast::AttrsOwner for ConstParam {}
1161impl ast::NameOwner for ConstParam {}
1162impl ast::TypeAscriptionOwner for ConstParam {}
1163impl ConstParam {
1164 pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
1165 pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
1166 pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
1167 pub fn default_val(&self) -> Option<Expr> { support::child(&self.syntax) }
1168}
1169#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1170pub struct TypeBound { 1168pub struct TypeBound {
1171 pub(crate) syntax: SyntaxNode, 1169 pub(crate) syntax: SyntaxNode,
1172} 1170}
@@ -1383,6 +1381,13 @@ pub enum ExternItem {
1383impl ast::AttrsOwner for ExternItem {} 1381impl ast::AttrsOwner for ExternItem {}
1384impl ast::NameOwner for ExternItem {} 1382impl ast::NameOwner for ExternItem {}
1385#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1383#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1384pub enum GenericParam {
1385 LifetimeParam(LifetimeParam),
1386 TypeParam(TypeParam),
1387 ConstParam(ConstParam),
1388}
1389impl ast::AttrsOwner for GenericParam {}
1390#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1386pub enum Stmt { 1391pub enum Stmt {
1387 LetStmt(LetStmt), 1392 LetStmt(LetStmt),
1388 ExprStmt(ExprStmt), 1393 ExprStmt(ExprStmt),
@@ -1854,6 +1859,39 @@ impl AstNode for ExternItemList {
1854 } 1859 }
1855 fn syntax(&self) -> &SyntaxNode { &self.syntax } 1860 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1856} 1861}
1862impl AstNode for LifetimeParam {
1863 fn can_cast(kind: SyntaxKind) -> bool { kind == LIFETIME_PARAM }
1864 fn cast(syntax: SyntaxNode) -> Option<Self> {
1865 if Self::can_cast(syntax.kind()) {
1866 Some(Self { syntax })
1867 } else {
1868 None
1869 }
1870 }
1871 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1872}
1873impl AstNode for TypeParam {
1874 fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_PARAM }
1875 fn cast(syntax: SyntaxNode) -> Option<Self> {
1876 if Self::can_cast(syntax.kind()) {
1877 Some(Self { syntax })
1878 } else {
1879 None
1880 }
1881 }
1882 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1883}
1884impl AstNode for ConstParam {
1885 fn can_cast(kind: SyntaxKind) -> bool { kind == CONST_PARAM }
1886 fn cast(syntax: SyntaxNode) -> Option<Self> {
1887 if Self::can_cast(syntax.kind()) {
1888 Some(Self { syntax })
1889 } else {
1890 None
1891 }
1892 }
1893 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1894}
1857impl AstNode for ParenType { 1895impl AstNode for ParenType {
1858 fn can_cast(kind: SyntaxKind) -> bool { kind == PAREN_TYPE } 1896 fn can_cast(kind: SyntaxKind) -> bool { kind == PAREN_TYPE }
1859 fn cast(syntax: SyntaxNode) -> Option<Self> { 1897 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -2635,39 +2673,6 @@ impl AstNode for MacroStmts {
2635 } 2673 }
2636 fn syntax(&self) -> &SyntaxNode { &self.syntax } 2674 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2637} 2675}
2638impl AstNode for TypeParam {
2639 fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_PARAM }
2640 fn cast(syntax: SyntaxNode) -> Option<Self> {
2641 if Self::can_cast(syntax.kind()) {
2642 Some(Self { syntax })
2643 } else {
2644 None
2645 }
2646 }
2647 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2648}
2649impl AstNode for LifetimeParam {
2650 fn can_cast(kind: SyntaxKind) -> bool { kind == LIFETIME_PARAM }
2651 fn cast(syntax: SyntaxNode) -> Option<Self> {
2652 if Self::can_cast(syntax.kind()) {
2653 Some(Self { syntax })
2654 } else {
2655 None
2656 }
2657 }
2658 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2659}
2660impl AstNode for ConstParam {
2661 fn can_cast(kind: SyntaxKind) -> bool { kind == CONST_PARAM }
2662 fn cast(syntax: SyntaxNode) -> Option<Self> {
2663 if Self::can_cast(syntax.kind()) {
2664 Some(Self { syntax })
2665 } else {
2666 None
2667 }
2668 }
2669 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2670}
2671impl AstNode for TypeBound { 2676impl AstNode for TypeBound {
2672 fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_BOUND } 2677 fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_BOUND }
2673 fn cast(syntax: SyntaxNode) -> Option<Self> { 2678 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -3325,6 +3330,39 @@ impl AstNode for ExternItem {
3325 } 3330 }
3326 } 3331 }
3327} 3332}
3333impl From<LifetimeParam> for GenericParam {
3334 fn from(node: LifetimeParam) -> GenericParam { GenericParam::LifetimeParam(node) }
3335}
3336impl From<TypeParam> for GenericParam {
3337 fn from(node: TypeParam) -> GenericParam { GenericParam::TypeParam(node) }
3338}
3339impl From<ConstParam> for GenericParam {
3340 fn from(node: ConstParam) -> GenericParam { GenericParam::ConstParam(node) }
3341}
3342impl AstNode for GenericParam {
3343 fn can_cast(kind: SyntaxKind) -> bool {
3344 match kind {
3345 LIFETIME_PARAM | TYPE_PARAM | CONST_PARAM => true,
3346 _ => false,
3347 }
3348 }
3349 fn cast(syntax: SyntaxNode) -> Option<Self> {
3350 let res = match syntax.kind() {
3351 LIFETIME_PARAM => GenericParam::LifetimeParam(LifetimeParam { syntax }),
3352 TYPE_PARAM => GenericParam::TypeParam(TypeParam { syntax }),
3353 CONST_PARAM => GenericParam::ConstParam(ConstParam { syntax }),
3354 _ => return None,
3355 };
3356 Some(res)
3357 }
3358 fn syntax(&self) -> &SyntaxNode {
3359 match self {
3360 GenericParam::LifetimeParam(it) => &it.syntax,
3361 GenericParam::TypeParam(it) => &it.syntax,
3362 GenericParam::ConstParam(it) => &it.syntax,
3363 }
3364 }
3365}
3328impl From<LetStmt> for Stmt { 3366impl From<LetStmt> for Stmt {
3329 fn from(node: LetStmt) -> Stmt { Stmt::LetStmt(node) } 3367 fn from(node: LetStmt) -> Stmt { Stmt::LetStmt(node) }
3330} 3368}
@@ -3449,6 +3487,11 @@ impl std::fmt::Display for ExternItem {
3449 std::fmt::Display::fmt(self.syntax(), f) 3487 std::fmt::Display::fmt(self.syntax(), f)
3450 } 3488 }
3451} 3489}
3490impl std::fmt::Display for GenericParam {
3491 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3492 std::fmt::Display::fmt(self.syntax(), f)
3493 }
3494}
3452impl std::fmt::Display for Stmt { 3495impl std::fmt::Display for Stmt {
3453 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { 3496 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3454 std::fmt::Display::fmt(self.syntax(), f) 3497 std::fmt::Display::fmt(self.syntax(), f)
@@ -3669,6 +3712,21 @@ impl std::fmt::Display for ExternItemList {
3669 std::fmt::Display::fmt(self.syntax(), f) 3712 std::fmt::Display::fmt(self.syntax(), f)
3670 } 3713 }
3671} 3714}
3715impl std::fmt::Display for LifetimeParam {
3716 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3717 std::fmt::Display::fmt(self.syntax(), f)
3718 }
3719}
3720impl std::fmt::Display for TypeParam {
3721 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3722 std::fmt::Display::fmt(self.syntax(), f)
3723 }
3724}
3725impl std::fmt::Display for ConstParam {
3726 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3727 std::fmt::Display::fmt(self.syntax(), f)
3728 }
3729}
3672impl std::fmt::Display for ParenType { 3730impl std::fmt::Display for ParenType {
3673 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { 3731 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3674 std::fmt::Display::fmt(self.syntax(), f) 3732 std::fmt::Display::fmt(self.syntax(), f)
@@ -4024,21 +4082,6 @@ impl std::fmt::Display for MacroStmts {
4024 std::fmt::Display::fmt(self.syntax(), f) 4082 std::fmt::Display::fmt(self.syntax(), f)
4025 } 4083 }
4026} 4084}
4027impl std::fmt::Display for TypeParam {
4028 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4029 std::fmt::Display::fmt(self.syntax(), f)
4030 }
4031}
4032impl std::fmt::Display for LifetimeParam {
4033 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4034 std::fmt::Display::fmt(self.syntax(), f)
4035 }
4036}
4037impl std::fmt::Display for ConstParam {
4038 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4039 std::fmt::Display::fmt(self.syntax(), f)
4040 }
4041}
4042impl std::fmt::Display for TypeBound { 4085impl std::fmt::Display for TypeBound {
4043 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { 4086 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4044 std::fmt::Display::fmt(self.syntax(), f) 4087 std::fmt::Display::fmt(self.syntax(), f)