mirror of
https://github.com/rust-lang/rust-analyzer.git
synced 2025-09-28 12:54:58 +00:00
Generate ast nodes for each ast trait
This commit is contained in:
Lukas Wirth
parent
ba84b91e78
commit
6d6e0b8f21
6 changed files with 480 additions and 51 deletions
|
|
@ -1445,6 +1445,46 @@ pub enum GenericParam {
|
|||
TypeParam(TypeParam),
|
||||
}
|
||||
impl ast::AttrsOwner for GenericParam {}
|
||||
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
|
||||
pub struct DynArgListOwner {
|
||||
pub(crate) syntax: SyntaxNode,
|
||||
}
|
||||
impl ast::ArgListOwner for DynArgListOwner {}
|
||||
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
|
||||
pub struct DynAttrsOwner {
|
||||
pub(crate) syntax: SyntaxNode,
|
||||
}
|
||||
impl ast::AttrsOwner for DynAttrsOwner {}
|
||||
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
|
||||
pub struct DynGenericParamsOwner {
|
||||
pub(crate) syntax: SyntaxNode,
|
||||
}
|
||||
impl ast::GenericParamsOwner for DynGenericParamsOwner {}
|
||||
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
|
||||
pub struct DynLoopBodyOwner {
|
||||
pub(crate) syntax: SyntaxNode,
|
||||
}
|
||||
impl ast::LoopBodyOwner for DynLoopBodyOwner {}
|
||||
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
|
||||
pub struct DynModuleItemOwner {
|
||||
pub(crate) syntax: SyntaxNode,
|
||||
}
|
||||
impl ast::ModuleItemOwner for DynModuleItemOwner {}
|
||||
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
|
||||
pub struct DynNameOwner {
|
||||
pub(crate) syntax: SyntaxNode,
|
||||
}
|
||||
impl ast::NameOwner for DynNameOwner {}
|
||||
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
|
||||
pub struct DynTypeBoundsOwner {
|
||||
pub(crate) syntax: SyntaxNode,
|
||||
}
|
||||
impl ast::TypeBoundsOwner for DynTypeBoundsOwner {}
|
||||
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
|
||||
pub struct DynVisibilityOwner {
|
||||
pub(crate) syntax: SyntaxNode,
|
||||
}
|
||||
impl ast::VisibilityOwner for DynVisibilityOwner {}
|
||||
impl AstNode for Name {
|
||||
fn can_cast(kind: SyntaxKind) -> bool { kind == NAME }
|
||||
fn cast(syntax: SyntaxNode) -> Option<Self> {
|
||||
|
|
@ -3564,6 +3604,364 @@ impl AstNode for GenericParam {
|
|||
}
|
||||
}
|
||||
}
|
||||
impl DynArgListOwner {
|
||||
#[inline]
|
||||
pub fn new<T: ast::ArgListOwner>(node: T) -> DynArgListOwner {
|
||||
DynArgListOwner { syntax: node.syntax().clone() }
|
||||
}
|
||||
}
|
||||
impl AstNode for DynArgListOwner {
|
||||
fn can_cast(kind: SyntaxKind) -> bool {
|
||||
match kind {
|
||||
CALL_EXPR | METHOD_CALL_EXPR => true,
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
fn cast(syntax: SyntaxNode) -> Option<Self> {
|
||||
let res = match syntax.kind() {
|
||||
CALL_EXPR => DynArgListOwner { syntax },
|
||||
METHOD_CALL_EXPR => DynArgListOwner { syntax },
|
||||
_ => return None,
|
||||
};
|
||||
Some(res)
|
||||
}
|
||||
fn syntax(&self) -> &SyntaxNode { &self.syntax }
|
||||
}
|
||||
impl DynAttrsOwner {
|
||||
#[inline]
|
||||
pub fn new<T: ast::AttrsOwner>(node: T) -> DynAttrsOwner {
|
||||
DynAttrsOwner { syntax: node.syntax().clone() }
|
||||
}
|
||||
}
|
||||
impl AstNode for DynAttrsOwner {
|
||||
fn can_cast(kind: SyntaxKind) -> bool {
|
||||
match kind {
|
||||
MACRO_CALL
|
||||
| SOURCE_FILE
|
||||
| CONST
|
||||
| ENUM
|
||||
| EXTERN_BLOCK
|
||||
| EXTERN_CRATE
|
||||
| FN
|
||||
| IMPL
|
||||
| MACRO_RULES
|
||||
| MACRO_DEF
|
||||
| MODULE
|
||||
| STATIC
|
||||
| STRUCT
|
||||
| TRAIT
|
||||
| TYPE_ALIAS
|
||||
| UNION
|
||||
| USE
|
||||
| ITEM_LIST
|
||||
| BLOCK_EXPR
|
||||
| SELF_PARAM
|
||||
| PARAM
|
||||
| RECORD_FIELD
|
||||
| TUPLE_FIELD
|
||||
| VARIANT
|
||||
| ASSOC_ITEM_LIST
|
||||
| EXTERN_ITEM_LIST
|
||||
| CONST_PARAM
|
||||
| LIFETIME_PARAM
|
||||
| TYPE_PARAM
|
||||
| EXPR_STMT
|
||||
| LET_STMT
|
||||
| ARRAY_EXPR
|
||||
| AWAIT_EXPR
|
||||
| BIN_EXPR
|
||||
| BOX_EXPR
|
||||
| BREAK_EXPR
|
||||
| CALL_EXPR
|
||||
| CAST_EXPR
|
||||
| CLOSURE_EXPR
|
||||
| CONTINUE_EXPR
|
||||
| EFFECT_EXPR
|
||||
| FIELD_EXPR
|
||||
| FOR_EXPR
|
||||
| IF_EXPR
|
||||
| INDEX_EXPR
|
||||
| LITERAL
|
||||
| LOOP_EXPR
|
||||
| MATCH_EXPR
|
||||
| METHOD_CALL_EXPR
|
||||
| PAREN_EXPR
|
||||
| PATH_EXPR
|
||||
| PREFIX_EXPR
|
||||
| RANGE_EXPR
|
||||
| REF_EXPR
|
||||
| RETURN_EXPR
|
||||
| TRY_EXPR
|
||||
| TUPLE_EXPR
|
||||
| WHILE_EXPR
|
||||
| YIELD_EXPR
|
||||
| RECORD_EXPR_FIELD_LIST
|
||||
| RECORD_EXPR_FIELD
|
||||
| MATCH_ARM_LIST
|
||||
| MATCH_ARM
|
||||
| IDENT_PAT
|
||||
| RECORD_PAT_FIELD => true,
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
fn cast(syntax: SyntaxNode) -> Option<Self> {
|
||||
let res = match syntax.kind() {
|
||||
MACRO_CALL => DynAttrsOwner { syntax },
|
||||
SOURCE_FILE => DynAttrsOwner { syntax },
|
||||
CONST => DynAttrsOwner { syntax },
|
||||
ENUM => DynAttrsOwner { syntax },
|
||||
EXTERN_BLOCK => DynAttrsOwner { syntax },
|
||||
EXTERN_CRATE => DynAttrsOwner { syntax },
|
||||
FN => DynAttrsOwner { syntax },
|
||||
IMPL => DynAttrsOwner { syntax },
|
||||
MACRO_RULES => DynAttrsOwner { syntax },
|
||||
MACRO_DEF => DynAttrsOwner { syntax },
|
||||
MODULE => DynAttrsOwner { syntax },
|
||||
STATIC => DynAttrsOwner { syntax },
|
||||
STRUCT => DynAttrsOwner { syntax },
|
||||
TRAIT => DynAttrsOwner { syntax },
|
||||
TYPE_ALIAS => DynAttrsOwner { syntax },
|
||||
UNION => DynAttrsOwner { syntax },
|
||||
USE => DynAttrsOwner { syntax },
|
||||
ITEM_LIST => DynAttrsOwner { syntax },
|
||||
BLOCK_EXPR => DynAttrsOwner { syntax },
|
||||
SELF_PARAM => DynAttrsOwner { syntax },
|
||||
PARAM => DynAttrsOwner { syntax },
|
||||
RECORD_FIELD => DynAttrsOwner { syntax },
|
||||
TUPLE_FIELD => DynAttrsOwner { syntax },
|
||||
VARIANT => DynAttrsOwner { syntax },
|
||||
ASSOC_ITEM_LIST => DynAttrsOwner { syntax },
|
||||
EXTERN_ITEM_LIST => DynAttrsOwner { syntax },
|
||||
CONST_PARAM => DynAttrsOwner { syntax },
|
||||
LIFETIME_PARAM => DynAttrsOwner { syntax },
|
||||
TYPE_PARAM => DynAttrsOwner { syntax },
|
||||
EXPR_STMT => DynAttrsOwner { syntax },
|
||||
LET_STMT => DynAttrsOwner { syntax },
|
||||
ARRAY_EXPR => DynAttrsOwner { syntax },
|
||||
AWAIT_EXPR => DynAttrsOwner { syntax },
|
||||
BIN_EXPR => DynAttrsOwner { syntax },
|
||||
BOX_EXPR => DynAttrsOwner { syntax },
|
||||
BREAK_EXPR => DynAttrsOwner { syntax },
|
||||
CALL_EXPR => DynAttrsOwner { syntax },
|
||||
CAST_EXPR => DynAttrsOwner { syntax },
|
||||
CLOSURE_EXPR => DynAttrsOwner { syntax },
|
||||
CONTINUE_EXPR => DynAttrsOwner { syntax },
|
||||
EFFECT_EXPR => DynAttrsOwner { syntax },
|
||||
FIELD_EXPR => DynAttrsOwner { syntax },
|
||||
FOR_EXPR => DynAttrsOwner { syntax },
|
||||
IF_EXPR => DynAttrsOwner { syntax },
|
||||
INDEX_EXPR => DynAttrsOwner { syntax },
|
||||
LITERAL => DynAttrsOwner { syntax },
|
||||
LOOP_EXPR => DynAttrsOwner { syntax },
|
||||
MATCH_EXPR => DynAttrsOwner { syntax },
|
||||
METHOD_CALL_EXPR => DynAttrsOwner { syntax },
|
||||
PAREN_EXPR => DynAttrsOwner { syntax },
|
||||
PATH_EXPR => DynAttrsOwner { syntax },
|
||||
PREFIX_EXPR => DynAttrsOwner { syntax },
|
||||
RANGE_EXPR => DynAttrsOwner { syntax },
|
||||
REF_EXPR => DynAttrsOwner { syntax },
|
||||
RETURN_EXPR => DynAttrsOwner { syntax },
|
||||
TRY_EXPR => DynAttrsOwner { syntax },
|
||||
TUPLE_EXPR => DynAttrsOwner { syntax },
|
||||
WHILE_EXPR => DynAttrsOwner { syntax },
|
||||
YIELD_EXPR => DynAttrsOwner { syntax },
|
||||
RECORD_EXPR_FIELD_LIST => DynAttrsOwner { syntax },
|
||||
RECORD_EXPR_FIELD => DynAttrsOwner { syntax },
|
||||
MATCH_ARM_LIST => DynAttrsOwner { syntax },
|
||||
MATCH_ARM => DynAttrsOwner { syntax },
|
||||
IDENT_PAT => DynAttrsOwner { syntax },
|
||||
RECORD_PAT_FIELD => DynAttrsOwner { syntax },
|
||||
_ => return None,
|
||||
};
|
||||
Some(res)
|
||||
}
|
||||
fn syntax(&self) -> &SyntaxNode { &self.syntax }
|
||||
}
|
||||
impl DynGenericParamsOwner {
|
||||
#[inline]
|
||||
pub fn new<T: ast::GenericParamsOwner>(node: T) -> DynGenericParamsOwner {
|
||||
DynGenericParamsOwner { syntax: node.syntax().clone() }
|
||||
}
|
||||
}
|
||||
impl AstNode for DynGenericParamsOwner {
|
||||
fn can_cast(kind: SyntaxKind) -> bool {
|
||||
match kind {
|
||||
ENUM | FN | IMPL | STRUCT | TRAIT | TYPE_ALIAS | UNION => true,
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
fn cast(syntax: SyntaxNode) -> Option<Self> {
|
||||
let res = match syntax.kind() {
|
||||
ENUM => DynGenericParamsOwner { syntax },
|
||||
FN => DynGenericParamsOwner { syntax },
|
||||
IMPL => DynGenericParamsOwner { syntax },
|
||||
STRUCT => DynGenericParamsOwner { syntax },
|
||||
TRAIT => DynGenericParamsOwner { syntax },
|
||||
TYPE_ALIAS => DynGenericParamsOwner { syntax },
|
||||
UNION => DynGenericParamsOwner { syntax },
|
||||
_ => return None,
|
||||
};
|
||||
Some(res)
|
||||
}
|
||||
fn syntax(&self) -> &SyntaxNode { &self.syntax }
|
||||
}
|
||||
impl DynLoopBodyOwner {
|
||||
#[inline]
|
||||
pub fn new<T: ast::LoopBodyOwner>(node: T) -> DynLoopBodyOwner {
|
||||
DynLoopBodyOwner { syntax: node.syntax().clone() }
|
||||
}
|
||||
}
|
||||
impl AstNode for DynLoopBodyOwner {
|
||||
fn can_cast(kind: SyntaxKind) -> bool {
|
||||
match kind {
|
||||
FOR_EXPR | LOOP_EXPR | WHILE_EXPR => true,
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
fn cast(syntax: SyntaxNode) -> Option<Self> {
|
||||
let res = match syntax.kind() {
|
||||
FOR_EXPR => DynLoopBodyOwner { syntax },
|
||||
LOOP_EXPR => DynLoopBodyOwner { syntax },
|
||||
WHILE_EXPR => DynLoopBodyOwner { syntax },
|
||||
_ => return None,
|
||||
};
|
||||
Some(res)
|
||||
}
|
||||
fn syntax(&self) -> &SyntaxNode { &self.syntax }
|
||||
}
|
||||
impl DynModuleItemOwner {
|
||||
#[inline]
|
||||
pub fn new<T: ast::ModuleItemOwner>(node: T) -> DynModuleItemOwner {
|
||||
DynModuleItemOwner { syntax: node.syntax().clone() }
|
||||
}
|
||||
}
|
||||
impl AstNode for DynModuleItemOwner {
|
||||
fn can_cast(kind: SyntaxKind) -> bool {
|
||||
match kind {
|
||||
MACRO_ITEMS | SOURCE_FILE | ITEM_LIST => true,
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
fn cast(syntax: SyntaxNode) -> Option<Self> {
|
||||
let res = match syntax.kind() {
|
||||
MACRO_ITEMS => DynModuleItemOwner { syntax },
|
||||
SOURCE_FILE => DynModuleItemOwner { syntax },
|
||||
ITEM_LIST => DynModuleItemOwner { syntax },
|
||||
_ => return None,
|
||||
};
|
||||
Some(res)
|
||||
}
|
||||
fn syntax(&self) -> &SyntaxNode { &self.syntax }
|
||||
}
|
||||
impl DynNameOwner {
|
||||
#[inline]
|
||||
pub fn new<T: ast::NameOwner>(node: T) -> DynNameOwner {
|
||||
DynNameOwner { syntax: node.syntax().clone() }
|
||||
}
|
||||
}
|
||||
impl AstNode for DynNameOwner {
|
||||
fn can_cast(kind: SyntaxKind) -> bool {
|
||||
match kind {
|
||||
CONST | ENUM | FN | MACRO_RULES | MACRO_DEF | MODULE | STATIC | STRUCT | TRAIT
|
||||
| TYPE_ALIAS | UNION | RENAME | SELF_PARAM | RECORD_FIELD | VARIANT | CONST_PARAM
|
||||
| TYPE_PARAM | IDENT_PAT => true,
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
fn cast(syntax: SyntaxNode) -> Option<Self> {
|
||||
let res = match syntax.kind() {
|
||||
CONST => DynNameOwner { syntax },
|
||||
ENUM => DynNameOwner { syntax },
|
||||
FN => DynNameOwner { syntax },
|
||||
MACRO_RULES => DynNameOwner { syntax },
|
||||
MACRO_DEF => DynNameOwner { syntax },
|
||||
MODULE => DynNameOwner { syntax },
|
||||
STATIC => DynNameOwner { syntax },
|
||||
STRUCT => DynNameOwner { syntax },
|
||||
TRAIT => DynNameOwner { syntax },
|
||||
TYPE_ALIAS => DynNameOwner { syntax },
|
||||
UNION => DynNameOwner { syntax },
|
||||
RENAME => DynNameOwner { syntax },
|
||||
SELF_PARAM => DynNameOwner { syntax },
|
||||
RECORD_FIELD => DynNameOwner { syntax },
|
||||
VARIANT => DynNameOwner { syntax },
|
||||
CONST_PARAM => DynNameOwner { syntax },
|
||||
TYPE_PARAM => DynNameOwner { syntax },
|
||||
IDENT_PAT => DynNameOwner { syntax },
|
||||
_ => return None,
|
||||
};
|
||||
Some(res)
|
||||
}
|
||||
fn syntax(&self) -> &SyntaxNode { &self.syntax }
|
||||
}
|
||||
impl DynTypeBoundsOwner {
|
||||
#[inline]
|
||||
pub fn new<T: ast::TypeBoundsOwner>(node: T) -> DynTypeBoundsOwner {
|
||||
DynTypeBoundsOwner { syntax: node.syntax().clone() }
|
||||
}
|
||||
}
|
||||
impl AstNode for DynTypeBoundsOwner {
|
||||
fn can_cast(kind: SyntaxKind) -> bool {
|
||||
match kind {
|
||||
ASSOC_TYPE_ARG | TRAIT | TYPE_ALIAS | LIFETIME_PARAM | TYPE_PARAM | WHERE_PRED => true,
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
fn cast(syntax: SyntaxNode) -> Option<Self> {
|
||||
let res = match syntax.kind() {
|
||||
ASSOC_TYPE_ARG => DynTypeBoundsOwner { syntax },
|
||||
TRAIT => DynTypeBoundsOwner { syntax },
|
||||
TYPE_ALIAS => DynTypeBoundsOwner { syntax },
|
||||
LIFETIME_PARAM => DynTypeBoundsOwner { syntax },
|
||||
TYPE_PARAM => DynTypeBoundsOwner { syntax },
|
||||
WHERE_PRED => DynTypeBoundsOwner { syntax },
|
||||
_ => return None,
|
||||
};
|
||||
Some(res)
|
||||
}
|
||||
fn syntax(&self) -> &SyntaxNode { &self.syntax }
|
||||
}
|
||||
impl DynVisibilityOwner {
|
||||
#[inline]
|
||||
pub fn new<T: ast::VisibilityOwner>(node: T) -> DynVisibilityOwner {
|
||||
DynVisibilityOwner { syntax: node.syntax().clone() }
|
||||
}
|
||||
}
|
||||
impl AstNode for DynVisibilityOwner {
|
||||
fn can_cast(kind: SyntaxKind) -> bool {
|
||||
match kind {
|
||||
CONST | ENUM | EXTERN_CRATE | FN | IMPL | MACRO_RULES | MACRO_DEF | MODULE | STATIC
|
||||
| STRUCT | TRAIT | TYPE_ALIAS | UNION | USE | RECORD_FIELD | TUPLE_FIELD | VARIANT => {
|
||||
true
|
||||
}
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
fn cast(syntax: SyntaxNode) -> Option<Self> {
|
||||
let res = match syntax.kind() {
|
||||
CONST => DynVisibilityOwner { syntax },
|
||||
ENUM => DynVisibilityOwner { syntax },
|
||||
EXTERN_CRATE => DynVisibilityOwner { syntax },
|
||||
FN => DynVisibilityOwner { syntax },
|
||||
IMPL => DynVisibilityOwner { syntax },
|
||||
MACRO_RULES => DynVisibilityOwner { syntax },
|
||||
MACRO_DEF => DynVisibilityOwner { syntax },
|
||||
MODULE => DynVisibilityOwner { syntax },
|
||||
STATIC => DynVisibilityOwner { syntax },
|
||||
STRUCT => DynVisibilityOwner { syntax },
|
||||
TRAIT => DynVisibilityOwner { syntax },
|
||||
TYPE_ALIAS => DynVisibilityOwner { syntax },
|
||||
UNION => DynVisibilityOwner { syntax },
|
||||
USE => DynVisibilityOwner { syntax },
|
||||
RECORD_FIELD => DynVisibilityOwner { syntax },
|
||||
TUPLE_FIELD => DynVisibilityOwner { syntax },
|
||||
VARIANT => DynVisibilityOwner { syntax },
|
||||
_ => return None,
|
||||
};
|
||||
Some(res)
|
||||
}
|
||||
fn syntax(&self) -> &SyntaxNode { &self.syntax }
|
||||
}
|
||||
impl std::fmt::Display for GenericArg {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
std::fmt::Display::fmt(self.syntax(), f)
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue