aboutsummaryrefslogtreecommitdiff
path: root/crates
diff options
context:
space:
mode:
Diffstat (limited to 'crates')
-rw-r--r--crates/ra_parser/src/syntax_kind/generated.rs1
-rw-r--r--crates/ra_syntax/src/ast/generated/nodes.rs213
-rw-r--r--crates/ra_syntax/src/ast/node_ext.rs21
3 files changed, 150 insertions, 85 deletions
diff --git a/crates/ra_parser/src/syntax_kind/generated.rs b/crates/ra_parser/src/syntax_kind/generated.rs
index d1b22f08a..be4da67bc 100644
--- a/crates/ra_parser/src/syntax_kind/generated.rs
+++ b/crates/ra_parser/src/syntax_kind/generated.rs
@@ -231,6 +231,7 @@ pub enum SyntaxKind {
231 LET_STMT, 231 LET_STMT,
232 EXPR_STMT, 232 EXPR_STMT,
233 GENERIC_PARAM_LIST, 233 GENERIC_PARAM_LIST,
234 GENERIC_PARAM,
234 LIFETIME_PARAM, 235 LIFETIME_PARAM,
235 TYPE_PARAM, 236 TYPE_PARAM,
236 CONST_PARAM, 237 CONST_PARAM,
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)
diff --git a/crates/ra_syntax/src/ast/node_ext.rs b/crates/ra_syntax/src/ast/node_ext.rs
index 313f52226..d2ee9586d 100644
--- a/crates/ra_syntax/src/ast/node_ext.rs
+++ b/crates/ra_syntax/src/ast/node_ext.rs
@@ -473,6 +473,27 @@ impl ast::TokenTree {
473 } 473 }
474} 474}
475 475
476impl ast::GenericParamList {
477 pub fn lifetime_params(&self) -> impl Iterator<Item = ast::LifetimeParam> {
478 self.generic_params().filter_map(|param| match param {
479 ast::GenericParam::LifetimeParam(it) => Some(it),
480 ast::GenericParam::TypeParam(_) | ast::GenericParam::ConstParam(_) => None,
481 })
482 }
483 pub fn type_params(&self) -> impl Iterator<Item = ast::TypeParam> {
484 self.generic_params().filter_map(|param| match param {
485 ast::GenericParam::TypeParam(it) => Some(it),
486 ast::GenericParam::LifetimeParam(_) | ast::GenericParam::ConstParam(_) => None,
487 })
488 }
489 pub fn const_params(&self) -> impl Iterator<Item = ast::ConstParam> {
490 self.generic_params().filter_map(|param| match param {
491 ast::GenericParam::ConstParam(it) => Some(it),
492 ast::GenericParam::TypeParam(_) | ast::GenericParam::LifetimeParam(_) => None,
493 })
494 }
495}
496
476impl ast::DocCommentsOwner for ast::SourceFile {} 497impl ast::DocCommentsOwner for ast::SourceFile {}
477impl ast::DocCommentsOwner for ast::Fn {} 498impl ast::DocCommentsOwner for ast::Fn {}
478impl ast::DocCommentsOwner for ast::Struct {} 499impl ast::DocCommentsOwner for ast::Struct {}