From 572f1c08b6ba43bdd57c5cb99f79a08ecd821c1c Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Fri, 31 Jul 2020 19:49:26 +0200 Subject: Minor gramamr reorder --- crates/ra_syntax/src/ast/generated/nodes.rs | 659 ++++++++++++++-------------- xtask/src/codegen/rust.ungram | 124 +++--- 2 files changed, 391 insertions(+), 392 deletions(-) diff --git a/crates/ra_syntax/src/ast/generated/nodes.rs b/crates/ra_syntax/src/ast/generated/nodes.rs index 6ce9c4adc..66821a31c 100644 --- a/crates/ra_syntax/src/ast/generated/nodes.rs +++ b/crates/ra_syntax/src/ast/generated/nodes.rs @@ -6,6 +6,20 @@ use crate::{ SyntaxNode, SyntaxToken, T, }; #[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Name { + pub(crate) syntax: SyntaxNode, +} +impl Name { + pub fn ident_token(&self) -> Option { support::token(&self.syntax, T![ident]) } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct NameRef { + pub(crate) syntax: SyntaxNode, +} +impl NameRef { + pub fn ident_token(&self) -> Option { support::token(&self.syntax, T![ident]) } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] pub struct Path { pub(crate) syntax: SyntaxNode, } @@ -33,13 +47,6 @@ impl PathSegment { pub fn r_angle_token(&self) -> Option { support::token(&self.syntax, T![>]) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct NameRef { - pub(crate) syntax: SyntaxNode, -} -impl NameRef { - pub fn ident_token(&self) -> Option { support::token(&self.syntax, T![ident]) } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] pub struct GenericArgList { pub(crate) syntax: SyntaxNode, } @@ -116,13 +123,16 @@ impl TypeBoundList { pub fn bounds(&self) -> AstChildren { support::children(&self.syntax) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct SourceFile { +pub struct MacroCall { pub(crate) syntax: SyntaxNode, } -impl ast::AttrsOwner for SourceFile {} -impl ast::ModuleItemOwner for SourceFile {} -impl SourceFile { - pub fn shebang_token(&self) -> Option { support::token(&self.syntax, T![shebang]) } +impl ast::AttrsOwner for MacroCall {} +impl ast::NameOwner for MacroCall {} +impl MacroCall { + pub fn path(&self) -> Option { support::child(&self.syntax) } + pub fn excl_token(&self) -> Option { support::token(&self.syntax, T![!]) } + pub fn token_tree(&self) -> Option { support::child(&self.syntax) } + pub fn semicolon_token(&self) -> Option { support::token(&self.syntax, T![;]) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub struct Attr { @@ -139,6 +149,41 @@ impl Attr { pub fn r_brack_token(&self) -> Option { support::token(&self.syntax, T![']']) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct TokenTree { + pub(crate) syntax: SyntaxNode, +} +impl TokenTree { + pub fn l_paren_token(&self) -> Option { support::token(&self.syntax, T!['(']) } + pub fn r_paren_token(&self) -> Option { support::token(&self.syntax, T![')']) } + pub fn l_curly_token(&self) -> Option { support::token(&self.syntax, T!['{']) } + pub fn r_curly_token(&self) -> Option { support::token(&self.syntax, T!['}']) } + pub fn l_brack_token(&self) -> Option { support::token(&self.syntax, T!['[']) } + pub fn r_brack_token(&self) -> Option { support::token(&self.syntax, T![']']) } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct MacroItems { + pub(crate) syntax: SyntaxNode, +} +impl ast::ModuleItemOwner for MacroItems {} +impl MacroItems {} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct MacroStmts { + pub(crate) syntax: SyntaxNode, +} +impl MacroStmts { + pub fn statements(&self) -> AstChildren { support::children(&self.syntax) } + pub fn expr(&self) -> Option { support::child(&self.syntax) } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct SourceFile { + pub(crate) syntax: SyntaxNode, +} +impl ast::AttrsOwner for SourceFile {} +impl ast::ModuleItemOwner for SourceFile {} +impl SourceFile { + pub fn shebang_token(&self) -> Option { support::token(&self.syntax, T![shebang]) } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] pub struct Const { pub(crate) syntax: SyntaxNode, } @@ -228,18 +273,6 @@ impl Impl { pub fn assoc_item_list(&self) -> Option { support::child(&self.syntax) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct MacroCall { - pub(crate) syntax: SyntaxNode, -} -impl ast::AttrsOwner for MacroCall {} -impl ast::NameOwner for MacroCall {} -impl MacroCall { - pub fn path(&self) -> Option { support::child(&self.syntax) } - pub fn excl_token(&self) -> Option { support::token(&self.syntax, T![!]) } - pub fn token_tree(&self) -> Option { support::child(&self.syntax) } - pub fn semicolon_token(&self) -> Option { support::token(&self.syntax, T![;]) } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] pub struct Module { pub(crate) syntax: SyntaxNode, } @@ -349,13 +382,6 @@ impl Visibility { pub fn r_paren_token(&self) -> Option { support::token(&self.syntax, T![')']) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Name { - pub(crate) syntax: SyntaxNode, -} -impl Name { - pub fn ident_token(&self) -> Option { support::token(&self.syntax, T![ident]) } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] pub struct ItemList { pub(crate) syntax: SyntaxNode, } @@ -589,18 +615,6 @@ pub struct Literal { impl ast::AttrsOwner for Literal {} impl Literal {} #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct TokenTree { - pub(crate) syntax: SyntaxNode, -} -impl TokenTree { - pub fn l_paren_token(&self) -> Option { support::token(&self.syntax, T!['(']) } - pub fn r_paren_token(&self) -> Option { support::token(&self.syntax, T![')']) } - pub fn l_curly_token(&self) -> Option { support::token(&self.syntax, T!['{']) } - pub fn r_curly_token(&self) -> Option { support::token(&self.syntax, T!['}']) } - pub fn l_brack_token(&self) -> Option { support::token(&self.syntax, T!['[']) } - pub fn r_brack_token(&self) -> Option { support::token(&self.syntax, T![']']) } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] pub struct ExprStmt { pub(crate) syntax: SyntaxNode, } @@ -1097,28 +1111,15 @@ impl TypeBound { pub fn ty(&self) -> Option { support::child(&self.syntax) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct OrPat { - pub(crate) syntax: SyntaxNode, -} -impl OrPat { - pub fn pats(&self) -> AstChildren { support::children(&self.syntax) } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ParenPat { - pub(crate) syntax: SyntaxNode, -} -impl ParenPat { - pub fn l_paren_token(&self) -> Option { support::token(&self.syntax, T!['(']) } - pub fn pat(&self) -> Option { support::child(&self.syntax) } - pub fn r_paren_token(&self) -> Option { support::token(&self.syntax, T![')']) } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct RefPat { +pub struct BindPat { pub(crate) syntax: SyntaxNode, } -impl RefPat { - pub fn amp_token(&self) -> Option { support::token(&self.syntax, T![&]) } +impl ast::AttrsOwner for BindPat {} +impl ast::NameOwner for BindPat {} +impl BindPat { + pub fn ref_token(&self) -> Option { support::token(&self.syntax, T![ref]) } pub fn mut_token(&self) -> Option { support::token(&self.syntax, T![mut]) } + pub fn at_token(&self) -> Option { support::token(&self.syntax, T![@]) } pub fn pat(&self) -> Option { support::child(&self.syntax) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] @@ -1130,69 +1131,61 @@ impl BoxPat { pub fn path(&self) -> Option { support::child(&self.syntax) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct BindPat { +pub struct DotDotPat { pub(crate) syntax: SyntaxNode, } -impl ast::AttrsOwner for BindPat {} -impl ast::NameOwner for BindPat {} -impl BindPat { - pub fn ref_token(&self) -> Option { support::token(&self.syntax, T![ref]) } - pub fn mut_token(&self) -> Option { support::token(&self.syntax, T![mut]) } - pub fn at_token(&self) -> Option { support::token(&self.syntax, T![@]) } - pub fn pat(&self) -> Option { support::child(&self.syntax) } +impl DotDotPat { + pub fn dotdot_token(&self) -> Option { support::token(&self.syntax, T![..]) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct PlaceholderPat { +pub struct LiteralPat { pub(crate) syntax: SyntaxNode, } -impl PlaceholderPat { - pub fn underscore_token(&self) -> Option { support::token(&self.syntax, T![_]) } +impl LiteralPat { + pub fn literal(&self) -> Option { support::child(&self.syntax) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct DotDotPat { +pub struct MacroPat { pub(crate) syntax: SyntaxNode, } -impl DotDotPat { - pub fn dotdot_token(&self) -> Option { support::token(&self.syntax, T![..]) } +impl MacroPat { + pub fn macro_call(&self) -> Option { support::child(&self.syntax) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct PathPat { +pub struct OrPat { pub(crate) syntax: SyntaxNode, } -impl PathPat { - pub fn path(&self) -> Option { support::child(&self.syntax) } +impl OrPat { + pub fn pats(&self) -> AstChildren { support::children(&self.syntax) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct SlicePat { +pub struct ParenPat { pub(crate) syntax: SyntaxNode, } -impl SlicePat { - pub fn l_brack_token(&self) -> Option { support::token(&self.syntax, T!['[']) } - pub fn args(&self) -> AstChildren { support::children(&self.syntax) } - pub fn r_brack_token(&self) -> Option { support::token(&self.syntax, T![']']) } +impl ParenPat { + pub fn l_paren_token(&self) -> Option { support::token(&self.syntax, T!['(']) } + pub fn pat(&self) -> Option { support::child(&self.syntax) } + pub fn r_paren_token(&self) -> Option { support::token(&self.syntax, T![')']) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct RangePat { +pub struct PathPat { pub(crate) syntax: SyntaxNode, } -impl RangePat { - pub fn dotdot_token(&self) -> Option { support::token(&self.syntax, T![..]) } - pub fn dotdoteq_token(&self) -> Option { support::token(&self.syntax, T![..=]) } +impl PathPat { + pub fn path(&self) -> Option { support::child(&self.syntax) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct LiteralPat { +pub struct PlaceholderPat { pub(crate) syntax: SyntaxNode, } -impl LiteralPat { - pub fn literal(&self) -> Option { support::child(&self.syntax) } +impl PlaceholderPat { + pub fn underscore_token(&self) -> Option { support::token(&self.syntax, T![_]) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct MacroPat { +pub struct RangePat { pub(crate) syntax: SyntaxNode, } -impl MacroPat { - pub fn macro_call(&self) -> Option { support::child(&self.syntax) } -} +impl RangePat {} #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub struct RecordPat { pub(crate) syntax: SyntaxNode, @@ -1204,60 +1197,64 @@ impl RecordPat { } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct RecordFieldPatList { +pub struct RefPat { pub(crate) syntax: SyntaxNode, } -impl RecordFieldPatList { - pub fn l_curly_token(&self) -> Option { support::token(&self.syntax, T!['{']) } - pub fn record_field_pats(&self) -> AstChildren { - support::children(&self.syntax) - } - pub fn bind_pats(&self) -> AstChildren { support::children(&self.syntax) } - pub fn dotdot_token(&self) -> Option { support::token(&self.syntax, T![..]) } - pub fn r_curly_token(&self) -> Option { support::token(&self.syntax, T!['}']) } +impl RefPat { + pub fn amp_token(&self) -> Option { support::token(&self.syntax, T![&]) } + pub fn mut_token(&self) -> Option { support::token(&self.syntax, T![mut]) } + pub fn pat(&self) -> Option { support::child(&self.syntax) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct RecordFieldPat { +pub struct SlicePat { pub(crate) syntax: SyntaxNode, } -impl ast::AttrsOwner for RecordFieldPat {} -impl RecordFieldPat { - pub fn name_ref(&self) -> Option { support::child(&self.syntax) } - pub fn colon_token(&self) -> Option { support::token(&self.syntax, T![:]) } - pub fn pat(&self) -> Option { support::child(&self.syntax) } +impl SlicePat { + pub fn l_brack_token(&self) -> Option { support::token(&self.syntax, T!['[']) } + pub fn args(&self) -> AstChildren { support::children(&self.syntax) } + pub fn r_brack_token(&self) -> Option { support::token(&self.syntax, T![']']) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct TupleStructPat { +pub struct TuplePat { pub(crate) syntax: SyntaxNode, } -impl TupleStructPat { - pub fn path(&self) -> Option { support::child(&self.syntax) } +impl TuplePat { pub fn l_paren_token(&self) -> Option { support::token(&self.syntax, T!['(']) } pub fn args(&self) -> AstChildren { support::children(&self.syntax) } pub fn r_paren_token(&self) -> Option { support::token(&self.syntax, T![')']) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct TuplePat { +pub struct TupleStructPat { pub(crate) syntax: SyntaxNode, } -impl TuplePat { +impl TupleStructPat { + pub fn path(&self) -> Option { support::child(&self.syntax) } pub fn l_paren_token(&self) -> Option { support::token(&self.syntax, T!['(']) } pub fn args(&self) -> AstChildren { support::children(&self.syntax) } pub fn r_paren_token(&self) -> Option { support::token(&self.syntax, T![')']) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct MacroItems { +pub struct RecordFieldPatList { pub(crate) syntax: SyntaxNode, } -impl ast::ModuleItemOwner for MacroItems {} -impl MacroItems {} +impl RecordFieldPatList { + pub fn l_curly_token(&self) -> Option { support::token(&self.syntax, T!['{']) } + pub fn record_field_pats(&self) -> AstChildren { + support::children(&self.syntax) + } + pub fn bind_pats(&self) -> AstChildren { support::children(&self.syntax) } + pub fn dotdot_token(&self) -> Option { support::token(&self.syntax, T![..]) } + pub fn r_curly_token(&self) -> Option { support::token(&self.syntax, T!['}']) } +} #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct MacroStmts { +pub struct RecordFieldPat { pub(crate) syntax: SyntaxNode, } -impl MacroStmts { - pub fn statements(&self) -> AstChildren { support::children(&self.syntax) } - pub fn expr(&self) -> Option { support::child(&self.syntax) } +impl ast::AttrsOwner for RecordFieldPat {} +impl RecordFieldPat { + pub fn name_ref(&self) -> Option { support::child(&self.syntax) } + pub fn colon_token(&self) -> Option { support::token(&self.syntax, T![:]) } + pub fn pat(&self) -> Option { support::child(&self.syntax) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub enum GenericArg { @@ -1334,22 +1331,28 @@ pub enum Item { } impl ast::AttrsOwner for Item {} #[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub enum Stmt { + ExprStmt(ExprStmt), + Item(Item), + LetStmt(LetStmt), +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] pub enum Pat { - OrPat(OrPat), - ParenPat(ParenPat), - RefPat(RefPat), - BoxPat(BoxPat), BindPat(BindPat), - PlaceholderPat(PlaceholderPat), + BoxPat(BoxPat), DotDotPat(DotDotPat), + LiteralPat(LiteralPat), + MacroPat(MacroPat), + OrPat(OrPat), + ParenPat(ParenPat), PathPat(PathPat), + PlaceholderPat(PlaceholderPat), + RangePat(RangePat), RecordPat(RecordPat), - TupleStructPat(TupleStructPat), - TuplePat(TuplePat), + RefPat(RefPat), SlicePat(SlicePat), - RangePat(RangePat), - LiteralPat(LiteralPat), - MacroPat(MacroPat), + TuplePat(TuplePat), + TupleStructPat(TupleStructPat), } #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub enum FieldList { @@ -1390,14 +1393,19 @@ pub enum GenericParam { TypeParam(TypeParam), } impl ast::AttrsOwner for GenericParam {} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub enum Stmt { - ExprStmt(ExprStmt), - Item(Item), - LetStmt(LetStmt), +impl AstNode for Name { + fn can_cast(kind: SyntaxKind) -> bool { kind == NAME } + fn cast(syntax: SyntaxNode) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl AstNode for Path { - fn can_cast(kind: SyntaxKind) -> bool { kind == PATH } +impl AstNode for NameRef { + fn can_cast(kind: SyntaxKind) -> bool { kind == NAME_REF } fn cast(syntax: SyntaxNode) -> Option { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -1407,8 +1415,8 @@ impl AstNode for Path { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl AstNode for PathSegment { - fn can_cast(kind: SyntaxKind) -> bool { kind == PATH_SEGMENT } +impl AstNode for Path { + fn can_cast(kind: SyntaxKind) -> bool { kind == PATH } fn cast(syntax: SyntaxNode) -> Option { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -1418,8 +1426,8 @@ impl AstNode for PathSegment { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl AstNode for NameRef { - fn can_cast(kind: SyntaxKind) -> bool { kind == NAME_REF } +impl AstNode for PathSegment { + fn can_cast(kind: SyntaxKind) -> bool { kind == PATH_SEGMENT } fn cast(syntax: SyntaxNode) -> Option { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -1528,8 +1536,8 @@ impl AstNode for TypeBoundList { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl AstNode for SourceFile { - fn can_cast(kind: SyntaxKind) -> bool { kind == SOURCE_FILE } +impl AstNode for MacroCall { + fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_CALL } fn cast(syntax: SyntaxNode) -> Option { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -1550,6 +1558,50 @@ impl AstNode for Attr { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } +impl AstNode for TokenTree { + fn can_cast(kind: SyntaxKind) -> bool { kind == TOKEN_TREE } + fn cast(syntax: SyntaxNode) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxNode { &self.syntax } +} +impl AstNode for MacroItems { + fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_ITEMS } + fn cast(syntax: SyntaxNode) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxNode { &self.syntax } +} +impl AstNode for MacroStmts { + fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_STMTS } + fn cast(syntax: SyntaxNode) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxNode { &self.syntax } +} +impl AstNode for SourceFile { + fn can_cast(kind: SyntaxKind) -> bool { kind == SOURCE_FILE } + fn cast(syntax: SyntaxNode) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxNode { &self.syntax } +} impl AstNode for Const { fn can_cast(kind: SyntaxKind) -> bool { kind == CONST } fn cast(syntax: SyntaxNode) -> Option { @@ -1616,17 +1668,6 @@ impl AstNode for Impl { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl AstNode for MacroCall { - fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_CALL } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { &self.syntax } -} impl AstNode for Module { fn can_cast(kind: SyntaxKind) -> bool { kind == MODULE } fn cast(syntax: SyntaxNode) -> Option { @@ -1715,17 +1756,6 @@ impl AstNode for Visibility { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl AstNode for Name { - fn can_cast(kind: SyntaxKind) -> bool { kind == NAME } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { &self.syntax } -} impl AstNode for ItemList { fn can_cast(kind: SyntaxKind) -> bool { kind == ITEM_LIST } fn cast(syntax: SyntaxNode) -> Option { @@ -1979,17 +2009,6 @@ impl AstNode for Literal { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl AstNode for TokenTree { - fn can_cast(kind: SyntaxKind) -> bool { kind == TOKEN_TREE } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { &self.syntax } -} impl AstNode for ExprStmt { fn can_cast(kind: SyntaxKind) -> bool { kind == EXPR_STMT } fn cast(syntax: SyntaxNode) -> Option { @@ -2529,30 +2548,8 @@ impl AstNode for TupleType { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl AstNode for TypeBound { - fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_BOUND } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { &self.syntax } -} -impl AstNode for OrPat { - fn can_cast(kind: SyntaxKind) -> bool { kind == OR_PAT } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { &self.syntax } -} -impl AstNode for ParenPat { - fn can_cast(kind: SyntaxKind) -> bool { kind == PAREN_PAT } +impl AstNode for TypeBound { + fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_BOUND } fn cast(syntax: SyntaxNode) -> Option { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2562,8 +2559,8 @@ impl AstNode for ParenPat { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl AstNode for RefPat { - fn can_cast(kind: SyntaxKind) -> bool { kind == REF_PAT } +impl AstNode for BindPat { + fn can_cast(kind: SyntaxKind) -> bool { kind == BIND_PAT } fn cast(syntax: SyntaxNode) -> Option { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2584,8 +2581,8 @@ impl AstNode for BoxPat { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl AstNode for BindPat { - fn can_cast(kind: SyntaxKind) -> bool { kind == BIND_PAT } +impl AstNode for DotDotPat { + fn can_cast(kind: SyntaxKind) -> bool { kind == DOT_DOT_PAT } fn cast(syntax: SyntaxNode) -> Option { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2595,8 +2592,8 @@ impl AstNode for BindPat { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl AstNode for PlaceholderPat { - fn can_cast(kind: SyntaxKind) -> bool { kind == PLACEHOLDER_PAT } +impl AstNode for LiteralPat { + fn can_cast(kind: SyntaxKind) -> bool { kind == LITERAL_PAT } fn cast(syntax: SyntaxNode) -> Option { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2606,8 +2603,8 @@ impl AstNode for PlaceholderPat { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl AstNode for DotDotPat { - fn can_cast(kind: SyntaxKind) -> bool { kind == DOT_DOT_PAT } +impl AstNode for MacroPat { + fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_PAT } fn cast(syntax: SyntaxNode) -> Option { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2617,8 +2614,8 @@ impl AstNode for DotDotPat { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl AstNode for PathPat { - fn can_cast(kind: SyntaxKind) -> bool { kind == PATH_PAT } +impl AstNode for OrPat { + fn can_cast(kind: SyntaxKind) -> bool { kind == OR_PAT } fn cast(syntax: SyntaxNode) -> Option { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2628,8 +2625,8 @@ impl AstNode for PathPat { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl AstNode for SlicePat { - fn can_cast(kind: SyntaxKind) -> bool { kind == SLICE_PAT } +impl AstNode for ParenPat { + fn can_cast(kind: SyntaxKind) -> bool { kind == PAREN_PAT } fn cast(syntax: SyntaxNode) -> Option { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2639,8 +2636,8 @@ impl AstNode for SlicePat { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl AstNode for RangePat { - fn can_cast(kind: SyntaxKind) -> bool { kind == RANGE_PAT } +impl AstNode for PathPat { + fn can_cast(kind: SyntaxKind) -> bool { kind == PATH_PAT } fn cast(syntax: SyntaxNode) -> Option { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2650,8 +2647,8 @@ impl AstNode for RangePat { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl AstNode for LiteralPat { - fn can_cast(kind: SyntaxKind) -> bool { kind == LITERAL_PAT } +impl AstNode for PlaceholderPat { + fn can_cast(kind: SyntaxKind) -> bool { kind == PLACEHOLDER_PAT } fn cast(syntax: SyntaxNode) -> Option { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2661,8 +2658,8 @@ impl AstNode for LiteralPat { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl AstNode for MacroPat { - fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_PAT } +impl AstNode for RangePat { + fn can_cast(kind: SyntaxKind) -> bool { kind == RANGE_PAT } fn cast(syntax: SyntaxNode) -> Option { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2683,8 +2680,8 @@ impl AstNode for RecordPat { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl AstNode for RecordFieldPatList { - fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_FIELD_PAT_LIST } +impl AstNode for RefPat { + fn can_cast(kind: SyntaxKind) -> bool { kind == REF_PAT } fn cast(syntax: SyntaxNode) -> Option { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2694,8 +2691,8 @@ impl AstNode for RecordFieldPatList { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl AstNode for RecordFieldPat { - fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_FIELD_PAT } +impl AstNode for SlicePat { + fn can_cast(kind: SyntaxKind) -> bool { kind == SLICE_PAT } fn cast(syntax: SyntaxNode) -> Option { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2705,8 +2702,8 @@ impl AstNode for RecordFieldPat { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl AstNode for TupleStructPat { - fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_STRUCT_PAT } +impl AstNode for TuplePat { + fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_PAT } fn cast(syntax: SyntaxNode) -> Option { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2716,8 +2713,8 @@ impl AstNode for TupleStructPat { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl AstNode for TuplePat { - fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_PAT } +impl AstNode for TupleStructPat { + fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_STRUCT_PAT } fn cast(syntax: SyntaxNode) -> Option { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2727,8 +2724,8 @@ impl AstNode for TuplePat { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl AstNode for MacroItems { - fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_ITEMS } +impl AstNode for RecordFieldPatList { + fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_FIELD_PAT_LIST } fn cast(syntax: SyntaxNode) -> Option { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2738,8 +2735,8 @@ impl AstNode for MacroItems { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl AstNode for MacroStmts { - fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_STMTS } +impl AstNode for RecordFieldPat { + fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_FIELD_PAT } fn cast(syntax: SyntaxNode) -> Option { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -3133,98 +3130,107 @@ impl AstNode for Item { } } } -impl From for Pat { - fn from(node: OrPat) -> Pat { Pat::OrPat(node) } -} -impl From for Pat { - fn from(node: ParenPat) -> Pat { Pat::ParenPat(node) } +impl From for Stmt { + fn from(node: ExprStmt) -> Stmt { Stmt::ExprStmt(node) } } -impl From for Pat { - fn from(node: RefPat) -> Pat { Pat::RefPat(node) } +impl From for Stmt { + fn from(node: Item) -> Stmt { Stmt::Item(node) } } -impl From for Pat { - fn from(node: BoxPat) -> Pat { Pat::BoxPat(node) } +impl From for Stmt { + fn from(node: LetStmt) -> Stmt { Stmt::LetStmt(node) } } impl From for Pat { fn from(node: BindPat) -> Pat { Pat::BindPat(node) } } -impl From for Pat { - fn from(node: PlaceholderPat) -> Pat { Pat::PlaceholderPat(node) } +impl From for Pat { + fn from(node: BoxPat) -> Pat { Pat::BoxPat(node) } } impl From for Pat { fn from(node: DotDotPat) -> Pat { Pat::DotDotPat(node) } } +impl From for Pat { + fn from(node: LiteralPat) -> Pat { Pat::LiteralPat(node) } +} +impl From for Pat { + fn from(node: MacroPat) -> Pat { Pat::MacroPat(node) } +} +impl From for Pat { + fn from(node: OrPat) -> Pat { Pat::OrPat(node) } +} +impl From for Pat { + fn from(node: ParenPat) -> Pat { Pat::ParenPat(node) } +} impl From for Pat { fn from(node: PathPat) -> Pat { Pat::PathPat(node) } } +impl From for Pat { + fn from(node: PlaceholderPat) -> Pat { Pat::PlaceholderPat(node) } +} +impl From for Pat { + fn from(node: RangePat) -> Pat { Pat::RangePat(node) } +} impl From for Pat { fn from(node: RecordPat) -> Pat { Pat::RecordPat(node) } } -impl From for Pat { - fn from(node: TupleStructPat) -> Pat { Pat::TupleStructPat(node) } -} -impl From for Pat { - fn from(node: TuplePat) -> Pat { Pat::TuplePat(node) } +impl From for Pat { + fn from(node: RefPat) -> Pat { Pat::RefPat(node) } } impl From for Pat { fn from(node: SlicePat) -> Pat { Pat::SlicePat(node) } } -impl From for Pat { - fn from(node: RangePat) -> Pat { Pat::RangePat(node) } -} -impl From for Pat { - fn from(node: LiteralPat) -> Pat { Pat::LiteralPat(node) } +impl From for Pat { + fn from(node: TuplePat) -> Pat { Pat::TuplePat(node) } } -impl From for Pat { - fn from(node: MacroPat) -> Pat { Pat::MacroPat(node) } +impl From for Pat { + fn from(node: TupleStructPat) -> Pat { Pat::TupleStructPat(node) } } impl AstNode for Pat { fn can_cast(kind: SyntaxKind) -> bool { match kind { - OR_PAT | PAREN_PAT | REF_PAT | BOX_PAT | BIND_PAT | PLACEHOLDER_PAT | DOT_DOT_PAT - | PATH_PAT | RECORD_PAT | TUPLE_STRUCT_PAT | TUPLE_PAT | SLICE_PAT | RANGE_PAT - | LITERAL_PAT | MACRO_PAT => true, + BIND_PAT | BOX_PAT | DOT_DOT_PAT | LITERAL_PAT | MACRO_PAT | OR_PAT | PAREN_PAT + | PATH_PAT | PLACEHOLDER_PAT | RANGE_PAT | RECORD_PAT | REF_PAT | SLICE_PAT + | TUPLE_PAT | TUPLE_STRUCT_PAT => true, _ => false, } } fn cast(syntax: SyntaxNode) -> Option { let res = match syntax.kind() { - OR_PAT => Pat::OrPat(OrPat { syntax }), - PAREN_PAT => Pat::ParenPat(ParenPat { syntax }), - REF_PAT => Pat::RefPat(RefPat { syntax }), - BOX_PAT => Pat::BoxPat(BoxPat { syntax }), BIND_PAT => Pat::BindPat(BindPat { syntax }), - PLACEHOLDER_PAT => Pat::PlaceholderPat(PlaceholderPat { syntax }), + BOX_PAT => Pat::BoxPat(BoxPat { syntax }), DOT_DOT_PAT => Pat::DotDotPat(DotDotPat { syntax }), + LITERAL_PAT => Pat::LiteralPat(LiteralPat { syntax }), + MACRO_PAT => Pat::MacroPat(MacroPat { syntax }), + OR_PAT => Pat::OrPat(OrPat { syntax }), + PAREN_PAT => Pat::ParenPat(ParenPat { syntax }), PATH_PAT => Pat::PathPat(PathPat { syntax }), + PLACEHOLDER_PAT => Pat::PlaceholderPat(PlaceholderPat { syntax }), + RANGE_PAT => Pat::RangePat(RangePat { syntax }), RECORD_PAT => Pat::RecordPat(RecordPat { syntax }), - TUPLE_STRUCT_PAT => Pat::TupleStructPat(TupleStructPat { syntax }), - TUPLE_PAT => Pat::TuplePat(TuplePat { syntax }), + REF_PAT => Pat::RefPat(RefPat { syntax }), SLICE_PAT => Pat::SlicePat(SlicePat { syntax }), - RANGE_PAT => Pat::RangePat(RangePat { syntax }), - LITERAL_PAT => Pat::LiteralPat(LiteralPat { syntax }), - MACRO_PAT => Pat::MacroPat(MacroPat { syntax }), + TUPLE_PAT => Pat::TuplePat(TuplePat { syntax }), + TUPLE_STRUCT_PAT => Pat::TupleStructPat(TupleStructPat { syntax }), _ => return None, }; Some(res) } fn syntax(&self) -> &SyntaxNode { match self { - Pat::OrPat(it) => &it.syntax, - Pat::ParenPat(it) => &it.syntax, - Pat::RefPat(it) => &it.syntax, - Pat::BoxPat(it) => &it.syntax, Pat::BindPat(it) => &it.syntax, - Pat::PlaceholderPat(it) => &it.syntax, + Pat::BoxPat(it) => &it.syntax, Pat::DotDotPat(it) => &it.syntax, + Pat::LiteralPat(it) => &it.syntax, + Pat::MacroPat(it) => &it.syntax, + Pat::OrPat(it) => &it.syntax, + Pat::ParenPat(it) => &it.syntax, Pat::PathPat(it) => &it.syntax, + Pat::PlaceholderPat(it) => &it.syntax, + Pat::RangePat(it) => &it.syntax, Pat::RecordPat(it) => &it.syntax, - Pat::TupleStructPat(it) => &it.syntax, - Pat::TuplePat(it) => &it.syntax, + Pat::RefPat(it) => &it.syntax, Pat::SlicePat(it) => &it.syntax, - Pat::RangePat(it) => &it.syntax, - Pat::LiteralPat(it) => &it.syntax, - Pat::MacroPat(it) => &it.syntax, + Pat::TuplePat(it) => &it.syntax, + Pat::TupleStructPat(it) => &it.syntax, } } } @@ -3393,15 +3399,6 @@ impl AstNode for GenericParam { } } } -impl From for Stmt { - fn from(node: ExprStmt) -> Stmt { Stmt::ExprStmt(node) } -} -impl From for Stmt { - fn from(node: Item) -> Stmt { Stmt::Item(node) } -} -impl From for Stmt { - fn from(node: LetStmt) -> Stmt { Stmt::LetStmt(node) } -} impl std::fmt::Display for GenericArg { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { std::fmt::Display::fmt(self.syntax(), f) @@ -3422,6 +3419,11 @@ impl std::fmt::Display for Item { std::fmt::Display::fmt(self.syntax(), f) } } +impl std::fmt::Display for Stmt { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + std::fmt::Display::fmt(self.syntax(), f) + } +} impl std::fmt::Display for Pat { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { std::fmt::Display::fmt(self.syntax(), f) @@ -3452,22 +3454,22 @@ impl std::fmt::Display for GenericParam { std::fmt::Display::fmt(self.syntax(), f) } } -impl std::fmt::Display for Stmt { +impl std::fmt::Display for Name { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { std::fmt::Display::fmt(self.syntax(), f) } } -impl std::fmt::Display for Path { +impl std::fmt::Display for NameRef { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { std::fmt::Display::fmt(self.syntax(), f) } } -impl std::fmt::Display for PathSegment { +impl std::fmt::Display for Path { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { std::fmt::Display::fmt(self.syntax(), f) } } -impl std::fmt::Display for NameRef { +impl std::fmt::Display for PathSegment { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { std::fmt::Display::fmt(self.syntax(), f) } @@ -3517,7 +3519,7 @@ impl std::fmt::Display for TypeBoundList { std::fmt::Display::fmt(self.syntax(), f) } } -impl std::fmt::Display for SourceFile { +impl std::fmt::Display for MacroCall { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { std::fmt::Display::fmt(self.syntax(), f) } @@ -3527,6 +3529,26 @@ impl std::fmt::Display for Attr { std::fmt::Display::fmt(self.syntax(), f) } } +impl std::fmt::Display for TokenTree { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + std::fmt::Display::fmt(self.syntax(), f) + } +} +impl std::fmt::Display for MacroItems { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + std::fmt::Display::fmt(self.syntax(), f) + } +} +impl std::fmt::Display for MacroStmts { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + std::fmt::Display::fmt(self.syntax(), f) + } +} +impl std::fmt::Display for SourceFile { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + std::fmt::Display::fmt(self.syntax(), f) + } +} impl std::fmt::Display for Const { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { std::fmt::Display::fmt(self.syntax(), f) @@ -3557,11 +3579,6 @@ impl std::fmt::Display for Impl { std::fmt::Display::fmt(self.syntax(), f) } } -impl std::fmt::Display for MacroCall { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} impl std::fmt::Display for Module { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { std::fmt::Display::fmt(self.syntax(), f) @@ -3602,11 +3619,6 @@ impl std::fmt::Display for Visibility { std::fmt::Display::fmt(self.syntax(), f) } } -impl std::fmt::Display for Name { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} impl std::fmt::Display for ItemList { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { std::fmt::Display::fmt(self.syntax(), f) @@ -3722,11 +3734,6 @@ impl std::fmt::Display for Literal { std::fmt::Display::fmt(self.syntax(), f) } } -impl std::fmt::Display for TokenTree { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} impl std::fmt::Display for ExprStmt { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { std::fmt::Display::fmt(self.syntax(), f) @@ -3977,37 +3984,37 @@ impl std::fmt::Display for TypeBound { std::fmt::Display::fmt(self.syntax(), f) } } -impl std::fmt::Display for OrPat { +impl std::fmt::Display for BindPat { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { std::fmt::Display::fmt(self.syntax(), f) } } -impl std::fmt::Display for ParenPat { +impl std::fmt::Display for BoxPat { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { std::fmt::Display::fmt(self.syntax(), f) } } -impl std::fmt::Display for RefPat { +impl std::fmt::Display for DotDotPat { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { std::fmt::Display::fmt(self.syntax(), f) } } -impl std::fmt::Display for BoxPat { +impl std::fmt::Display for LiteralPat { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { std::fmt::Display::fmt(self.syntax(), f) } } -impl std::fmt::Display for BindPat { +impl std::fmt::Display for MacroPat { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { std::fmt::Display::fmt(self.syntax(), f) } } -impl std::fmt::Display for PlaceholderPat { +impl std::fmt::Display for OrPat { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { std::fmt::Display::fmt(self.syntax(), f) } } -impl std::fmt::Display for DotDotPat { +impl std::fmt::Display for ParenPat { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { std::fmt::Display::fmt(self.syntax(), f) } @@ -4017,7 +4024,7 @@ impl std::fmt::Display for PathPat { std::fmt::Display::fmt(self.syntax(), f) } } -impl std::fmt::Display for SlicePat { +impl std::fmt::Display for PlaceholderPat { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { std::fmt::Display::fmt(self.syntax(), f) } @@ -4027,47 +4034,37 @@ impl std::fmt::Display for RangePat { std::fmt::Display::fmt(self.syntax(), f) } } -impl std::fmt::Display for LiteralPat { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl std::fmt::Display for MacroPat { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} impl std::fmt::Display for RecordPat { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { std::fmt::Display::fmt(self.syntax(), f) } } -impl std::fmt::Display for RecordFieldPatList { +impl std::fmt::Display for RefPat { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { std::fmt::Display::fmt(self.syntax(), f) } } -impl std::fmt::Display for RecordFieldPat { +impl std::fmt::Display for SlicePat { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { std::fmt::Display::fmt(self.syntax(), f) } } -impl std::fmt::Display for TupleStructPat { +impl std::fmt::Display for TuplePat { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { std::fmt::Display::fmt(self.syntax(), f) } } -impl std::fmt::Display for TuplePat { +impl std::fmt::Display for TupleStructPat { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { std::fmt::Display::fmt(self.syntax(), f) } } -impl std::fmt::Display for MacroItems { +impl std::fmt::Display for RecordFieldPatList { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { std::fmt::Display::fmt(self.syntax(), f) } } -impl std::fmt::Display for MacroStmts { +impl std::fmt::Display for RecordFieldPat { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { std::fmt::Display::fmt(self.syntax(), f) } diff --git a/xtask/src/codegen/rust.ungram b/xtask/src/codegen/rust.ungram index 2e3b45011..27bf563b6 100644 --- a/xtask/src/codegen/rust.ungram +++ b/xtask/src/codegen/rust.ungram @@ -1,3 +1,9 @@ +Name = + 'ident' + +NameRef = + 'ident' | 'int_number' + Path = (qualifier:Path '::')? segment:PathSegment @@ -29,6 +35,21 @@ LifetimeArg = ConstArg = Expr +MacroCall = + Attr* Path '!' Name? TokenTree ';'? + +TokenTree = + '(' ')' +| '{' '}' +| '[' ']' + +MacroItems = + Item* + +MacroStmts = + statements:Stmt* + Expr? + SourceFile = 'shebang'? Attr* @@ -475,41 +496,37 @@ TypeBound = 'lifetime' | '?'? Type -OrPat = - Pat* - -ParenPat = - '(' Pat ')' - -RefPat = - '&' 'mut'? Pat - -BoxPat = - 'box' Path - -BindPat = - Attr* 'ref'? 'mut'? Name ('@' Pat)? - -PlaceholderPat = - '_' +Pat = + BindPat +| BoxPat +| DotDotPat +| LiteralPat +| MacroPat +| OrPat +| ParenPat +| PathPat +| PlaceholderPat +| RangePat +| RecordPat +| RefPat +| SlicePat +| TuplePat +| TupleStructPat -DotDotPat = - '..' +LiteralPat = + Literal PathPat = Path -SlicePat = - '[' args:Pat* ']' +PlaceholderPat = + '_' RangePat = - '..' | '..=' - -LiteralPat = - Literal + start:Pat op:('..' | '..=') end:Pat -MacroPat = - MacroCall +RefPat = + '&' 'mut'? Pat RecordPat = Path RecordFieldPatList @@ -522,46 +539,31 @@ RecordFieldPatList = '}' RecordFieldPat = - Attr* NameRef ':' Pat + Attr* (NameRef ':')? Pat -TupleStructPat = - Path '(' args:Pat* ')' +OrPat = + Pat* -TuplePat = - '(' args:Pat* ')' +ParenPat = + '(' Pat ')' -Name = - 'ident' +BoxPat = + 'box' Path -NameRef = - 'ident' | 'int_number' +BindPat = + Attr* 'ref'? 'mut'? Name ('@' Pat)? -MacroCall = - Attr* Path '!' Name? TokenTree ';'? +DotDotPat = + '..' -TokenTree = - '(' ')' | '{' '}' | '[' ']' +SlicePat = + '[' args:Pat* ']' -MacroItems = - Item* +MacroPat = + MacroCall -MacroStmts = - statements:Stmt* - Expr? +TupleStructPat = + Path '(' args:Pat* ')' -Pat = - OrPat -| ParenPat -| RefPat -| BoxPat -| BindPat -| PlaceholderPat -| DotDotPat -| PathPat -| RecordPat -| TupleStructPat -| TuplePat -| SlicePat -| RangePat -| LiteralPat -| MacroPat +TuplePat = + '(' args:Pat* ')' -- cgit v1.2.3 From 14cb96ec0e6be3b99bfe4ea373c058dcbd2a4f79 Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Fri, 31 Jul 2020 19:54:16 +0200 Subject: Allign RecordPat with RecordExpr --- crates/ra_assists/src/handlers/reorder_fields.rs | 4 +-- crates/ra_hir/src/semantics.rs | 4 +-- crates/ra_hir/src/source_analyzer.rs | 2 +- crates/ra_hir_def/src/body/lower.rs | 39 ++++++++++------------ crates/ra_hir_ty/src/diagnostics.rs | 2 +- crates/ra_hir_ty/src/diagnostics/expr.rs | 2 +- crates/ra_ide/src/completion/completion_context.rs | 6 ++-- crates/ra_ide/src/extend_selection.rs | 2 +- crates/ra_ide/src/folding_ranges.rs | 2 +- crates/ra_ide_db/src/defs.rs | 4 +-- crates/ra_parser/src/grammar/patterns.rs | 4 +-- crates/ra_parser/src/syntax_kind/generated.rs | 4 +-- crates/ra_syntax/src/ast/generated/nodes.rs | 29 ++++++++-------- crates/ra_syntax/src/ast/node_ext.rs | 2 +- .../test_data/parser/inline/ok/0008_path_part.rast | 2 +- .../inline/ok/0102_record_field_pat_list.rast | 16 ++++----- .../test_data/parser/inline/ok/0143_box_pat.rast | 6 ++-- .../parser/inline/ok/0145_record_field_pat.rast | 8 ++--- .../parser/ok/0063_trait_fn_patterns.rast | 6 ++-- .../test_data/parser/ok/0064_impl_fn_params.rast | 6 ++-- xtask/src/ast_src.rs | 4 +-- xtask/src/codegen/rust.ungram | 9 +++-- 22 files changed, 78 insertions(+), 85 deletions(-) diff --git a/crates/ra_assists/src/handlers/reorder_fields.rs b/crates/ra_assists/src/handlers/reorder_fields.rs index 120250e79..6a19a4002 100644 --- a/crates/ra_assists/src/handlers/reorder_fields.rs +++ b/crates/ra_assists/src/handlers/reorder_fields.rs @@ -57,7 +57,7 @@ fn reorder(acc: &mut Assists, ctx: &AssistContext) -> Option<()> { fn get_fields_kind(node: &SyntaxNode) -> Vec { match node.kind() { RECORD_EXPR => vec![RECORD_EXPR_FIELD], - RECORD_PAT => vec![RECORD_FIELD_PAT, BIND_PAT], + RECORD_PAT => vec![RECORD_PAT_FIELD, BIND_PAT], _ => vec![], } } @@ -66,7 +66,7 @@ fn get_field_name(node: &SyntaxNode) -> String { let res = match_ast! { match node { ast::RecordExprField(field) => field.field_name().map(|it| it.to_string()), - ast::RecordFieldPat(field) => field.field_name().map(|it| it.to_string()), + ast::RecordPatField(field) => field.field_name().map(|it| it.to_string()), _ => None, } }; diff --git a/crates/ra_hir/src/semantics.rs b/crates/ra_hir/src/semantics.rs index 6f3b3dc9a..44c71857e 100644 --- a/crates/ra_hir/src/semantics.rs +++ b/crates/ra_hir/src/semantics.rs @@ -216,7 +216,7 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> { self.imp.resolve_record_field(field) } - pub fn resolve_record_field_pat(&self, field: &ast::RecordFieldPat) -> Option { + pub fn resolve_record_field_pat(&self, field: &ast::RecordPatField) -> Option { self.imp.resolve_record_field_pat(field) } @@ -429,7 +429,7 @@ impl<'db> SemanticsImpl<'db> { self.analyze(field.syntax()).resolve_record_field(self.db, field) } - fn resolve_record_field_pat(&self, field: &ast::RecordFieldPat) -> Option { + fn resolve_record_field_pat(&self, field: &ast::RecordPatField) -> Option { self.analyze(field.syntax()).resolve_record_field_pat(self.db, field) } diff --git a/crates/ra_hir/src/source_analyzer.rs b/crates/ra_hir/src/source_analyzer.rs index f2e630ef1..37b33cc4f 100644 --- a/crates/ra_hir/src/source_analyzer.rs +++ b/crates/ra_hir/src/source_analyzer.rs @@ -182,7 +182,7 @@ impl SourceAnalyzer { pub(crate) fn resolve_record_field_pat( &self, _db: &dyn HirDatabase, - field: &ast::RecordFieldPat, + field: &ast::RecordPatField, ) -> Option { let pat_id = self.pat_id(&field.pat()?)?; let struct_field = self.infer.as_ref()?.record_field_pat_resolution(pat_id)?; diff --git a/crates/ra_hir_def/src/body/lower.rs b/crates/ra_hir_def/src/body/lower.rs index 6bedc6b56..25e29b7cd 100644 --- a/crates/ra_hir_def/src/body/lower.rs +++ b/crates/ra_hir_def/src/body/lower.rs @@ -1,6 +1,8 @@ //! Transforms `ast::Expr` into an equivalent `hir_def::expr::Expr` //! representation. +use std::{any::type_name, sync::Arc}; + use either::Either; use hir_expand::{ hygiene::Hygiene, @@ -10,11 +12,12 @@ use hir_expand::{ use ra_arena::Arena; use ra_syntax::{ ast::{ - self, ArgListOwner, ArrayExprKind, LiteralKind, LoopBodyOwner, NameOwner, + self, ArgListOwner, ArrayExprKind, AstChildren, LiteralKind, LoopBodyOwner, NameOwner, SlicePatComponents, }, AstNode, AstPtr, }; +use rustc_hash::FxHashMap; use test_utils::mark; use crate::{ @@ -35,9 +38,6 @@ use crate::{ }; use super::{ExprSource, PatSource}; -use ast::AstChildren; -use rustc_hash::FxHashMap; -use std::{any::type_name, sync::Arc}; pub(crate) struct LowerCtx { hygiene: Hygiene, @@ -786,29 +786,26 @@ impl ExprCollector<'_> { ast::Pat::PlaceholderPat(_) => Pat::Wild, ast::Pat::RecordPat(p) => { let path = p.path().and_then(|path| self.expander.parse_path(path)); - let record_field_pat_list = - p.record_field_pat_list().expect("every struct should have a field list"); - let mut fields: Vec<_> = record_field_pat_list - .bind_pats() - .filter_map(|bind_pat| { - let ast_pat = - ast::Pat::cast(bind_pat.syntax().clone()).expect("bind pat is a pat"); + + let args: Vec<_> = p + .record_pat_field_list() + .expect("every struct should have a field list") + .fields() + .filter_map(|f| { + let ast_pat = f.pat()?; let pat = self.collect_pat(ast_pat); - let name = bind_pat.name()?.as_name(); + let name = f.field_name()?.as_name(); Some(RecordFieldPat { name, pat }) }) .collect(); - let iter = record_field_pat_list.record_field_pats().filter_map(|f| { - let ast_pat = f.pat()?; - let pat = self.collect_pat(ast_pat); - let name = f.field_name()?.as_name(); - Some(RecordFieldPat { name, pat }) - }); - fields.extend(iter); - let ellipsis = record_field_pat_list.dotdot_token().is_some(); + let ellipsis = p + .record_pat_field_list() + .expect("every struct should have a field list") + .dotdot_token() + .is_some(); - Pat::Record { path, args: fields, ellipsis } + Pat::Record { path, args, ellipsis } } ast::Pat::SlicePat(p) => { let SlicePatComponents { prefix, slice, suffix } = p.components(); diff --git a/crates/ra_hir_ty/src/diagnostics.rs b/crates/ra_hir_ty/src/diagnostics.rs index f210c305a..977c0525b 100644 --- a/crates/ra_hir_ty/src/diagnostics.rs +++ b/crates/ra_hir_ty/src/diagnostics.rs @@ -92,7 +92,7 @@ impl AstDiagnostic for MissingFields { #[derive(Debug)] pub struct MissingPatFields { pub file: HirFileId, - pub field_list: AstPtr, + pub field_list: AstPtr, pub missed_fields: Vec, } diff --git a/crates/ra_hir_ty/src/diagnostics/expr.rs b/crates/ra_hir_ty/src/diagnostics/expr.rs index f0e0f2988..95bbf2d95 100644 --- a/crates/ra_hir_ty/src/diagnostics/expr.rs +++ b/crates/ra_hir_ty/src/diagnostics/expr.rs @@ -131,7 +131,7 @@ impl<'a, 'b> ExprValidator<'a, 'b> { if let Some(expr) = source_ptr.value.as_ref().left() { let root = source_ptr.file_syntax(db.upcast()); if let ast::Pat::RecordPat(record_pat) = expr.to_node(&root) { - if let Some(field_list) = record_pat.record_field_pat_list() { + if let Some(field_list) = record_pat.record_pat_field_list() { let variant_data = variant_data(db.upcast(), variant_def); let missed_fields = missed_fields .into_iter() diff --git a/crates/ra_ide/src/completion/completion_context.rs b/crates/ra_ide/src/completion/completion_context.rs index 2a5f3c3d2..29955754c 100644 --- a/crates/ra_ide/src/completion/completion_context.rs +++ b/crates/ra_ide/src/completion/completion_context.rs @@ -265,7 +265,7 @@ impl<'a> CompletionContext<'a> { return; } // FIXME: remove this (V) duplication and make the check more precise - if name_ref.syntax().ancestors().find_map(ast::RecordFieldPatList::cast).is_some() { + if name_ref.syntax().ancestors().find_map(ast::RecordPatFieldList::cast).is_some() { self.record_pat_syntax = self.sema.find_node_at_offset_with_macros(&original_file, offset); } @@ -283,7 +283,7 @@ impl<'a> CompletionContext<'a> { { self.is_pat_binding_or_const = false; } - if bind_pat.syntax().parent().and_then(ast::RecordFieldPatList::cast).is_some() { + if bind_pat.syntax().parent().and_then(ast::RecordPatFieldList::cast).is_some() { self.is_pat_binding_or_const = false; } if let Some(let_stmt) = bind_pat.syntax().ancestors().find_map(ast::LetStmt::cast) { @@ -300,7 +300,7 @@ impl<'a> CompletionContext<'a> { return; } // FIXME: remove this (^) duplication and make the check more precise - if name.syntax().ancestors().find_map(ast::RecordFieldPatList::cast).is_some() { + if name.syntax().ancestors().find_map(ast::RecordPatFieldList::cast).is_some() { self.record_pat_syntax = self.sema.find_node_at_offset_with_macros(&original_file, offset); } diff --git a/crates/ra_ide/src/extend_selection.rs b/crates/ra_ide/src/extend_selection.rs index 319fd500d..7230a0ff9 100644 --- a/crates/ra_ide/src/extend_selection.rs +++ b/crates/ra_ide/src/extend_selection.rs @@ -37,7 +37,7 @@ fn try_extend_selection( let string_kinds = [COMMENT, STRING, RAW_STRING, BYTE_STRING, RAW_BYTE_STRING]; let list_kinds = [ - RECORD_FIELD_PAT_LIST, + RECORD_PAT_FIELD_LIST, MATCH_ARM_LIST, RECORD_FIELD_LIST, TUPLE_FIELD_LIST, diff --git a/crates/ra_ide/src/folding_ranges.rs b/crates/ra_ide/src/folding_ranges.rs index 5a6e17936..903c34996 100644 --- a/crates/ra_ide/src/folding_ranges.rs +++ b/crates/ra_ide/src/folding_ranges.rs @@ -86,7 +86,7 @@ fn fold_kind(kind: SyntaxKind) -> Option { USE => Some(FoldKind::Imports), ARG_LIST | PARAM_LIST => Some(FoldKind::ArgList), RECORD_FIELD_LIST - | RECORD_FIELD_PAT_LIST + | RECORD_PAT_FIELD_LIST | RECORD_EXPR_FIELD_LIST | ITEM_LIST | EXTERN_ITEM_LIST diff --git a/crates/ra_ide_db/src/defs.rs b/crates/ra_ide_db/src/defs.rs index df56f2d9e..6bf80a34c 100644 --- a/crates/ra_ide_db/src/defs.rs +++ b/crates/ra_ide_db/src/defs.rs @@ -131,7 +131,7 @@ pub fn classify_name(sema: &Semantics, name: &ast::Name) -> Option ast::BindPat(it) => { let local = sema.to_def(&it)?; - if let Some(record_field_pat) = it.syntax().parent().and_then(ast::RecordFieldPat::cast) { + if let Some(record_field_pat) = it.syntax().parent().and_then(ast::RecordPatField::cast) { if record_field_pat.name_ref().is_none() { if let Some(field) = sema.resolve_record_field_pat(&record_field_pat) { let field = Definition::Field(field); @@ -247,7 +247,7 @@ pub fn classify_name_ref( } } - if let Some(record_field_pat) = ast::RecordFieldPat::cast(parent.clone()) { + if let Some(record_field_pat) = ast::RecordPatField::cast(parent.clone()) { if let Some(field) = sema.resolve_record_field_pat(&record_field_pat) { let field = Definition::Field(field); return Some(NameRefClass::Definition(field)); diff --git a/crates/ra_parser/src/grammar/patterns.rs b/crates/ra_parser/src/grammar/patterns.rs index 427c0eb49..d5dd9ffa2 100644 --- a/crates/ra_parser/src/grammar/patterns.rs +++ b/crates/ra_parser/src/grammar/patterns.rs @@ -217,7 +217,7 @@ fn record_field_pat_list(p: &mut Parser) { bind_pat(p, false); } } - m.complete(p, RECORD_FIELD_PAT); + m.complete(p, RECORD_PAT_FIELD); } } if !p.at(T!['}']) { @@ -225,7 +225,7 @@ fn record_field_pat_list(p: &mut Parser) { } } p.expect(T!['}']); - m.complete(p, RECORD_FIELD_PAT_LIST); + m.complete(p, RECORD_PAT_FIELD_LIST); } // test placeholder_pat diff --git a/crates/ra_parser/src/syntax_kind/generated.rs b/crates/ra_parser/src/syntax_kind/generated.rs index c3670fb62..9db328dc3 100644 --- a/crates/ra_parser/src/syntax_kind/generated.rs +++ b/crates/ra_parser/src/syntax_kind/generated.rs @@ -161,8 +161,8 @@ pub enum SyntaxKind { DOT_DOT_PAT, PATH_PAT, RECORD_PAT, - RECORD_FIELD_PAT_LIST, - RECORD_FIELD_PAT, + RECORD_PAT_FIELD_LIST, + RECORD_PAT_FIELD, TUPLE_STRUCT_PAT, TUPLE_PAT, SLICE_PAT, diff --git a/crates/ra_syntax/src/ast/generated/nodes.rs b/crates/ra_syntax/src/ast/generated/nodes.rs index 66821a31c..7708ae806 100644 --- a/crates/ra_syntax/src/ast/generated/nodes.rs +++ b/crates/ra_syntax/src/ast/generated/nodes.rs @@ -1192,7 +1192,7 @@ pub struct RecordPat { } impl RecordPat { pub fn path(&self) -> Option { support::child(&self.syntax) } - pub fn record_field_pat_list(&self) -> Option { + pub fn record_pat_field_list(&self) -> Option { support::child(&self.syntax) } } @@ -1234,24 +1234,21 @@ impl TupleStructPat { pub fn r_paren_token(&self) -> Option { support::token(&self.syntax, T![')']) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct RecordFieldPatList { +pub struct RecordPatFieldList { pub(crate) syntax: SyntaxNode, } -impl RecordFieldPatList { +impl RecordPatFieldList { pub fn l_curly_token(&self) -> Option { support::token(&self.syntax, T!['{']) } - pub fn record_field_pats(&self) -> AstChildren { - support::children(&self.syntax) - } - pub fn bind_pats(&self) -> AstChildren { support::children(&self.syntax) } + pub fn fields(&self) -> AstChildren { support::children(&self.syntax) } pub fn dotdot_token(&self) -> Option { support::token(&self.syntax, T![..]) } pub fn r_curly_token(&self) -> Option { support::token(&self.syntax, T!['}']) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct RecordFieldPat { +pub struct RecordPatField { pub(crate) syntax: SyntaxNode, } -impl ast::AttrsOwner for RecordFieldPat {} -impl RecordFieldPat { +impl ast::AttrsOwner for RecordPatField {} +impl RecordPatField { pub fn name_ref(&self) -> Option { support::child(&self.syntax) } pub fn colon_token(&self) -> Option { support::token(&self.syntax, T![:]) } pub fn pat(&self) -> Option { support::child(&self.syntax) } @@ -2724,8 +2721,8 @@ impl AstNode for TupleStructPat { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl AstNode for RecordFieldPatList { - fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_FIELD_PAT_LIST } +impl AstNode for RecordPatFieldList { + fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_PAT_FIELD_LIST } fn cast(syntax: SyntaxNode) -> Option { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2735,8 +2732,8 @@ impl AstNode for RecordFieldPatList { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl AstNode for RecordFieldPat { - fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_FIELD_PAT } +impl AstNode for RecordPatField { + fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_PAT_FIELD } fn cast(syntax: SyntaxNode) -> Option { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -4059,12 +4056,12 @@ impl std::fmt::Display for TupleStructPat { std::fmt::Display::fmt(self.syntax(), f) } } -impl std::fmt::Display for RecordFieldPatList { +impl std::fmt::Display for RecordPatFieldList { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { std::fmt::Display::fmt(self.syntax(), f) } } -impl std::fmt::Display for RecordFieldPat { +impl std::fmt::Display for RecordPatField { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { 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 69726fb93..2cfdac225 100644 --- a/crates/ra_syntax/src/ast/node_ext.rs +++ b/crates/ra_syntax/src/ast/node_ext.rs @@ -227,7 +227,7 @@ impl fmt::Display for NameOrNameRef { } } -impl ast::RecordFieldPat { +impl ast::RecordPatField { /// Deals with field init shorthand pub fn field_name(&self) -> Option { if let Some(name_ref) = self.name_ref() { diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0008_path_part.rast b/crates/ra_syntax/test_data/parser/inline/ok/0008_path_part.rast index 3ce2acfae..d848f3c88 100644 --- a/crates/ra_syntax/test_data/parser/inline/ok/0008_path_part.rast +++ b/crates/ra_syntax/test_data/parser/inline/ok/0008_path_part.rast @@ -58,7 +58,7 @@ SOURCE_FILE@0..103 NAME_REF@62..65 IDENT@62..65 "Bar" WHITESPACE@65..66 " " - RECORD_FIELD_PAT_LIST@66..72 + RECORD_PAT_FIELD_LIST@66..72 L_CURLY@66..67 "{" WHITESPACE@67..68 " " DOT2@68..70 ".." diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0102_record_field_pat_list.rast b/crates/ra_syntax/test_data/parser/inline/ok/0102_record_field_pat_list.rast index fe1c290c3..003c517ac 100644 --- a/crates/ra_syntax/test_data/parser/inline/ok/0102_record_field_pat_list.rast +++ b/crates/ra_syntax/test_data/parser/inline/ok/0102_record_field_pat_list.rast @@ -20,7 +20,7 @@ SOURCE_FILE@0..119 NAME_REF@19..20 IDENT@19..20 "S" WHITESPACE@20..21 " " - RECORD_FIELD_PAT_LIST@21..23 + RECORD_PAT_FIELD_LIST@21..23 L_CURLY@21..22 "{" R_CURLY@22..23 "}" WHITESPACE@23..24 " " @@ -40,16 +40,16 @@ SOURCE_FILE@0..119 NAME_REF@38..39 IDENT@38..39 "S" WHITESPACE@39..40 " " - RECORD_FIELD_PAT_LIST@40..56 + RECORD_PAT_FIELD_LIST@40..56 L_CURLY@40..41 "{" WHITESPACE@41..42 " " - RECORD_FIELD_PAT@42..43 + RECORD_PAT_FIELD@42..43 BIND_PAT@42..43 NAME@42..43 IDENT@42..43 "f" COMMA@43..44 "," WHITESPACE@44..45 " " - RECORD_FIELD_PAT@45..54 + RECORD_PAT_FIELD@45..54 BIND_PAT@45..54 REF_KW@45..48 "ref" WHITESPACE@48..49 " " @@ -76,10 +76,10 @@ SOURCE_FILE@0..119 NAME_REF@71..72 IDENT@71..72 "S" WHITESPACE@72..73 " " - RECORD_FIELD_PAT_LIST@73..84 + RECORD_PAT_FIELD_LIST@73..84 L_CURLY@73..74 "{" WHITESPACE@74..75 " " - RECORD_FIELD_PAT@75..79 + RECORD_PAT_FIELD@75..79 NAME_REF@75..76 IDENT@75..76 "h" COLON@76..77 ":" @@ -107,10 +107,10 @@ SOURCE_FILE@0..119 NAME_REF@99..100 IDENT@99..100 "S" WHITESPACE@100..101 " " - RECORD_FIELD_PAT_LIST@101..110 + RECORD_PAT_FIELD_LIST@101..110 L_CURLY@101..102 "{" WHITESPACE@102..103 " " - RECORD_FIELD_PAT@103..107 + RECORD_PAT_FIELD@103..107 NAME_REF@103..104 IDENT@103..104 "h" COLON@104..105 ":" diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0143_box_pat.rast b/crates/ra_syntax/test_data/parser/inline/ok/0143_box_pat.rast index 09fd9e9b8..caae3e2dc 100644 --- a/crates/ra_syntax/test_data/parser/inline/ok/0143_box_pat.rast +++ b/crates/ra_syntax/test_data/parser/inline/ok/0143_box_pat.rast @@ -40,10 +40,10 @@ SOURCE_FILE@0..118 NAME_REF@44..49 IDENT@44..49 "Outer" WHITESPACE@49..50 " " - RECORD_FIELD_PAT_LIST@50..81 + RECORD_PAT_FIELD_LIST@50..81 L_CURLY@50..51 "{" WHITESPACE@51..52 " " - RECORD_FIELD_PAT@52..57 + RECORD_PAT_FIELD@52..57 BOX_PAT@52..57 BOX_KW@52..55 "box" WHITESPACE@55..56 " " @@ -52,7 +52,7 @@ SOURCE_FILE@0..118 IDENT@56..57 "i" COMMA@57..58 "," WHITESPACE@58..59 " " - RECORD_FIELD_PAT@59..79 + RECORD_PAT_FIELD@59..79 NAME_REF@59..60 IDENT@59..60 "j" COLON@60..61 ":" diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0145_record_field_pat.rast b/crates/ra_syntax/test_data/parser/inline/ok/0145_record_field_pat.rast index b41ef4098..925409bdf 100644 --- a/crates/ra_syntax/test_data/parser/inline/ok/0145_record_field_pat.rast +++ b/crates/ra_syntax/test_data/parser/inline/ok/0145_record_field_pat.rast @@ -20,10 +20,10 @@ SOURCE_FILE@0..63 NAME_REF@19..20 IDENT@19..20 "S" WHITESPACE@20..21 " " - RECORD_FIELD_PAT_LIST@21..29 + RECORD_PAT_FIELD_LIST@21..29 L_CURLY@21..22 "{" WHITESPACE@22..23 " " - RECORD_FIELD_PAT@23..27 + RECORD_PAT_FIELD@23..27 NAME_REF@23..24 INT_NUMBER@23..24 "0" COLON@24..25 ":" @@ -50,10 +50,10 @@ SOURCE_FILE@0..63 NAME_REF@44..45 IDENT@44..45 "S" WHITESPACE@45..46 " " - RECORD_FIELD_PAT_LIST@46..54 + RECORD_PAT_FIELD_LIST@46..54 L_CURLY@46..47 "{" WHITESPACE@47..48 " " - RECORD_FIELD_PAT@48..52 + RECORD_PAT_FIELD@48..52 NAME_REF@48..49 IDENT@48..49 "x" COLON@49..50 ":" diff --git a/crates/ra_syntax/test_data/parser/ok/0063_trait_fn_patterns.rast b/crates/ra_syntax/test_data/parser/ok/0063_trait_fn_patterns.rast index facce8167..7c5467289 100644 --- a/crates/ra_syntax/test_data/parser/ok/0063_trait_fn_patterns.rast +++ b/crates/ra_syntax/test_data/parser/ok/0063_trait_fn_patterns.rast @@ -64,16 +64,16 @@ SOURCE_FILE@0..170 NAME_REF@57..58 IDENT@57..58 "S" WHITESPACE@58..59 " " - RECORD_FIELD_PAT_LIST@59..67 + RECORD_PAT_FIELD_LIST@59..67 L_CURLY@59..60 "{" WHITESPACE@60..61 " " - RECORD_FIELD_PAT@61..62 + RECORD_PAT_FIELD@61..62 BIND_PAT@61..62 NAME@61..62 IDENT@61..62 "a" COMMA@62..63 "," WHITESPACE@63..64 " " - RECORD_FIELD_PAT@64..65 + RECORD_PAT_FIELD@64..65 BIND_PAT@64..65 NAME@64..65 IDENT@64..65 "b" diff --git a/crates/ra_syntax/test_data/parser/ok/0064_impl_fn_params.rast b/crates/ra_syntax/test_data/parser/ok/0064_impl_fn_params.rast index 453757c3c..087053f25 100644 --- a/crates/ra_syntax/test_data/parser/ok/0064_impl_fn_params.rast +++ b/crates/ra_syntax/test_data/parser/ok/0064_impl_fn_params.rast @@ -67,16 +67,16 @@ SOURCE_FILE@0..137 NAME_REF@56..57 IDENT@56..57 "S" WHITESPACE@57..58 " " - RECORD_FIELD_PAT_LIST@58..66 + RECORD_PAT_FIELD_LIST@58..66 L_CURLY@58..59 "{" WHITESPACE@59..60 " " - RECORD_FIELD_PAT@60..61 + RECORD_PAT_FIELD@60..61 BIND_PAT@60..61 NAME@60..61 IDENT@60..61 "a" COMMA@61..62 "," WHITESPACE@62..63 " " - RECORD_FIELD_PAT@63..64 + RECORD_PAT_FIELD@63..64 BIND_PAT@63..64 NAME@63..64 IDENT@63..64 "b" diff --git a/xtask/src/ast_src.rs b/xtask/src/ast_src.rs index 762d9265e..869bdaa0d 100644 --- a/xtask/src/ast_src.rs +++ b/xtask/src/ast_src.rs @@ -131,8 +131,8 @@ pub(crate) const KINDS_SRC: KindsSrc = KindsSrc { "DOT_DOT_PAT", "PATH_PAT", "RECORD_PAT", - "RECORD_FIELD_PAT_LIST", - "RECORD_FIELD_PAT", + "RECORD_PAT_FIELD_LIST", + "RECORD_PAT_FIELD", "TUPLE_STRUCT_PAT", "TUPLE_PAT", "SLICE_PAT", diff --git a/xtask/src/codegen/rust.ungram b/xtask/src/codegen/rust.ungram index 27bf563b6..643668863 100644 --- a/xtask/src/codegen/rust.ungram +++ b/xtask/src/codegen/rust.ungram @@ -529,16 +529,15 @@ RefPat = '&' 'mut'? Pat RecordPat = - Path RecordFieldPatList + Path RecordPatFieldList -RecordFieldPatList = +RecordPatFieldList = '{' - record_field_pats:RecordFieldPat* - BindPat* + fields:(RecordPatField (',' RecordPatField)* ','?) '..'? '}' -RecordFieldPat = +RecordPatField = Attr* (NameRef ':')? Pat OrPat = -- cgit v1.2.3 From d7f75db90d99216c13000681ff2c4a887451c4b2 Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Fri, 31 Jul 2020 20:04:40 +0200 Subject: Reorder --- crates/ra_hir_def/src/body/lower.rs | 1 - crates/ra_syntax/src/ast/generated/nodes.rs | 2 +- xtask/src/codegen/rust.ungram | 34 ++++++++++++++--------------- 3 files changed, 18 insertions(+), 19 deletions(-) diff --git a/crates/ra_hir_def/src/body/lower.rs b/crates/ra_hir_def/src/body/lower.rs index 25e29b7cd..ef1c0df01 100644 --- a/crates/ra_hir_def/src/body/lower.rs +++ b/crates/ra_hir_def/src/body/lower.rs @@ -786,7 +786,6 @@ impl ExprCollector<'_> { ast::Pat::PlaceholderPat(_) => Pat::Wild, ast::Pat::RecordPat(p) => { let path = p.path().and_then(|path| self.expander.parse_path(path)); - let args: Vec<_> = p .record_pat_field_list() .expect("every struct should have a field list") diff --git a/crates/ra_syntax/src/ast/generated/nodes.rs b/crates/ra_syntax/src/ast/generated/nodes.rs index 7708ae806..713aebcfa 100644 --- a/crates/ra_syntax/src/ast/generated/nodes.rs +++ b/crates/ra_syntax/src/ast/generated/nodes.rs @@ -1128,7 +1128,7 @@ pub struct BoxPat { } impl BoxPat { pub fn box_token(&self) -> Option { support::token(&self.syntax, T![box]) } - pub fn path(&self) -> Option { support::child(&self.syntax) } + pub fn pat(&self) -> Option { support::child(&self.syntax) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub struct DotDotPat { diff --git a/xtask/src/codegen/rust.ungram b/xtask/src/codegen/rust.ungram index 643668863..cb8a307fe 100644 --- a/xtask/src/codegen/rust.ungram +++ b/xtask/src/codegen/rust.ungram @@ -516,8 +516,8 @@ Pat = LiteralPat = Literal -PathPat = - Path +BindPat = + Attr* 'ref'? 'mut'? Name ('@' Pat)? PlaceholderPat = '_' @@ -540,29 +540,29 @@ RecordPatFieldList = RecordPatField = Attr* (NameRef ':')? Pat -OrPat = - Pat* +TupleStructPat = + Path '(' args:(Pat (',' Pat)* ','?)? ')' + +TuplePat = + '(' args:(Pat (',' Pat)* ','?)? ')' ParenPat = '(' Pat ')' -BoxPat = - 'box' Path +SlicePat = + '[' args:(Pat (',' Pat)* ','?)? ']' -BindPat = - Attr* 'ref'? 'mut'? Name ('@' Pat)? +PathPat = + Path + +OrPat = + (Pat ('|' Pat)* '|'?) + +BoxPat = + 'box' Pat DotDotPat = '..' -SlicePat = - '[' args:Pat* ']' - MacroPat = MacroCall - -TupleStructPat = - Path '(' args:Pat* ')' - -TuplePat = - '(' args:Pat* ')' -- cgit v1.2.3 From 6791eb9685375da94556bb910ea71f78b08be5ec Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Fri, 31 Jul 2020 20:07:21 +0200 Subject: Rename PalceholderPat -> WildcardPat --- crates/ra_assists/src/handlers/fill_match_arms.rs | 22 ++++++++++------------ crates/ra_assists/src/handlers/merge_match_arms.rs | 2 +- .../src/handlers/replace_let_with_if_let.rs | 3 +-- crates/ra_hir_def/src/body/lower.rs | 2 +- crates/ra_parser/src/grammar/patterns.rs | 2 +- crates/ra_parser/src/syntax_kind/generated.rs | 2 +- crates/ra_syntax/src/ast/edit.rs | 2 +- crates/ra_syntax/src/ast/generated/nodes.rs | 22 +++++++++++----------- crates/ra_syntax/src/ast/make.rs | 4 ++-- .../parser/err/0024_many_type_parens.rast | 6 +++--- .../parser/err/0032_match_arms_inner_attrs.rast | 12 ++++++------ .../parser/err/0033_match_arms_outer_attrs.rast | 4 ++-- .../inline/err/0007_async_without_semicolon.rast | 2 +- .../parser/inline/ok/0026_tuple_pat_fields.rast | 6 +++--- .../test_data/parser/inline/ok/0030_cond.rast | 14 +++++++------- .../test_data/parser/inline/ok/0042_call_expr.rast | 6 +++--- .../test_data/parser/inline/ok/0053_path_expr.rast | 8 ++++---- .../parser/inline/ok/0059_match_arms_commas.rast | 6 +++--- .../test_data/parser/inline/ok/0066_match_arm.rast | 4 ++-- .../inline/ok/0070_stmt_bin_expr_ambiguity.rast | 2 +- .../parser/inline/ok/0071_match_expr.rast | 2 +- .../ok/0074_stmt_postfix_expr_ambiguity.rast | 2 +- .../test_data/parser/inline/ok/0075_block.rast | 2 +- .../parser/inline/ok/0080_postfix_range.rast | 4 ++-- .../test_data/parser/inline/ok/0082_ref_expr.rast | 12 ++++++------ .../parser/inline/ok/0085_expr_literals.rast | 20 ++++++++++---------- .../parser/inline/ok/0095_placeholder_pat.rast | 2 +- .../parser/inline/ok/0096_no_semi_after_block.rast | 2 +- .../inline/ok/0102_record_field_pat_list.rast | 4 ++-- .../test_data/parser/inline/ok/0112_bind_pat.rast | 4 ++-- .../parser/inline/ok/0118_match_guard.rast | 2 +- .../inline/ok/0120_match_arms_inner_attribute.rast | 2 +- .../ok/0121_match_arms_outer_attributes.rast | 6 +++--- .../ok/0122_generic_lifetime_type_attribute.rast | 2 +- .../test_data/parser/inline/ok/0130_let_stmt.rast | 2 +- .../parser/inline/ok/0130_try_block_expr.rast | 2 +- .../parser/inline/ok/0146_as_precedence.rast | 2 +- .../parser/inline/ok/0156_or_pattern.rast | 16 ++++++++-------- .../inline/ok/0157_fn_pointer_unnamed_arg.rast | 2 +- .../test_data/parser/ok/0030_string_suffixes.rast | 8 ++++---- .../test_data/parser/ok/0035_weird_exprs.rast | 6 +++--- .../test_data/parser/ok/0042_ufcs_call_list.rast | 2 +- .../parser/ok/0047_minus_in_inner_pattern.rast | 6 +++--- .../test_data/parser/ok/0051_parameter_attrs.rast | 2 +- .../parser/ok/0054_qual_path_in_type_arg.rast | 4 ++-- .../test_data/parser/ok/0059_loops_in_parens.rast | 2 +- .../parser/ok/0063_trait_fn_patterns.rast | 2 +- .../test_data/parser/ok/0063_variadic_fun.rast | 8 ++++---- xtask/src/ast_src.rs | 2 +- xtask/src/codegen/rust.ungram | 4 ++-- 50 files changed, 132 insertions(+), 135 deletions(-) diff --git a/crates/ra_assists/src/handlers/fill_match_arms.rs b/crates/ra_assists/src/handlers/fill_match_arms.rs index 708e1bc6c..36658f104 100644 --- a/crates/ra_assists/src/handlers/fill_match_arms.rs +++ b/crates/ra_assists/src/handlers/fill_match_arms.rs @@ -43,7 +43,7 @@ pub(crate) fn fill_match_arms(acc: &mut Assists, ctx: &AssistContext) -> Option< let mut arms: Vec = match_arm_list.arms().collect(); if arms.len() == 1 { - if let Some(Pat::PlaceholderPat(..)) = arms[0].pat() { + if let Some(Pat::WildcardPat(..)) = arms[0].pat() { arms.clear(); } } @@ -116,17 +116,15 @@ pub(crate) fn fill_match_arms(acc: &mut Assists, ctx: &AssistContext) -> Option< match (first_new_arm, ctx.config.snippet_cap) { (Some(first_new_arm), Some(cap)) => { let extend_lifetime; - let cursor = match first_new_arm - .syntax() - .descendants() - .find_map(ast::PlaceholderPat::cast) - { - Some(it) => { - extend_lifetime = it.syntax().clone(); - Cursor::Replace(&extend_lifetime) - } - None => Cursor::Before(first_new_arm.syntax()), - }; + let cursor = + match first_new_arm.syntax().descendants().find_map(ast::WildcardPat::cast) + { + Some(it) => { + extend_lifetime = it.syntax().clone(); + Cursor::Replace(&extend_lifetime) + } + None => Cursor::Before(first_new_arm.syntax()), + }; let snippet = render_snippet(cap, new_arm_list.syntax(), cursor); builder.replace_snippet(cap, old_range, snippet); } diff --git a/crates/ra_assists/src/handlers/merge_match_arms.rs b/crates/ra_assists/src/handlers/merge_match_arms.rs index 186a1f618..563292282 100644 --- a/crates/ra_assists/src/handlers/merge_match_arms.rs +++ b/crates/ra_assists/src/handlers/merge_match_arms.rs @@ -86,7 +86,7 @@ pub(crate) fn merge_match_arms(acc: &mut Assists, ctx: &AssistContext) -> Option } fn contains_placeholder(a: &ast::MatchArm) -> bool { - matches!(a.pat(), Some(ast::Pat::PlaceholderPat(..))) + matches!(a.pat(), Some(ast::Pat::WildcardPat(..))) } #[cfg(test)] diff --git a/crates/ra_assists/src/handlers/replace_let_with_if_let.rs b/crates/ra_assists/src/handlers/replace_let_with_if_let.rs index a49292c97..64ad15a23 100644 --- a/crates/ra_assists/src/handlers/replace_let_with_if_let.rs +++ b/crates/ra_assists/src/handlers/replace_let_with_if_let.rs @@ -62,8 +62,7 @@ pub(crate) fn replace_let_with_if_let(acc: &mut Assists, ctx: &AssistContext) -> let if_ = make::expr_if(make::condition(init, Some(with_placeholder)), block); let stmt = make::expr_stmt(if_); - let placeholder = - stmt.syntax().descendants().find_map(ast::PlaceholderPat::cast).unwrap(); + let placeholder = stmt.syntax().descendants().find_map(ast::WildcardPat::cast).unwrap(); let stmt = stmt.replace_descendant(placeholder.into(), original_pat); edit.replace_ast(ast::Stmt::from(let_stmt), ast::Stmt::from(stmt)); diff --git a/crates/ra_hir_def/src/body/lower.rs b/crates/ra_hir_def/src/body/lower.rs index ef1c0df01..7b988ae33 100644 --- a/crates/ra_hir_def/src/body/lower.rs +++ b/crates/ra_hir_def/src/body/lower.rs @@ -783,7 +783,7 @@ impl ExprCollector<'_> { let (args, ellipsis) = self.collect_tuple_pat(p.args()); Pat::Tuple { args, ellipsis } } - ast::Pat::PlaceholderPat(_) => Pat::Wild, + ast::Pat::WildcardPat(_) => Pat::Wild, ast::Pat::RecordPat(p) => { let path = p.path().and_then(|path| self.expander.parse_path(path)); let args: Vec<_> = p diff --git a/crates/ra_parser/src/grammar/patterns.rs b/crates/ra_parser/src/grammar/patterns.rs index d5dd9ffa2..51e413cd6 100644 --- a/crates/ra_parser/src/grammar/patterns.rs +++ b/crates/ra_parser/src/grammar/patterns.rs @@ -234,7 +234,7 @@ fn placeholder_pat(p: &mut Parser) -> CompletedMarker { assert!(p.at(T![_])); let m = p.start(); p.bump(T![_]); - m.complete(p, PLACEHOLDER_PAT) + m.complete(p, WILDCARD_PAT) } // test dot_dot_pat diff --git a/crates/ra_parser/src/syntax_kind/generated.rs b/crates/ra_parser/src/syntax_kind/generated.rs index 9db328dc3..c24611f4b 100644 --- a/crates/ra_parser/src/syntax_kind/generated.rs +++ b/crates/ra_parser/src/syntax_kind/generated.rs @@ -157,7 +157,7 @@ pub enum SyntaxKind { REF_PAT, BOX_PAT, BIND_PAT, - PLACEHOLDER_PAT, + WILDCARD_PAT, DOT_DOT_PAT, PATH_PAT, RECORD_PAT, diff --git a/crates/ra_syntax/src/ast/edit.rs b/crates/ra_syntax/src/ast/edit.rs index 04746ef8f..667a9294f 100644 --- a/crates/ra_syntax/src/ast/edit.rs +++ b/crates/ra_syntax/src/ast/edit.rs @@ -390,7 +390,7 @@ impl ast::MatchArmList { #[must_use] pub fn remove_placeholder(&self) -> ast::MatchArmList { let placeholder = - self.arms().find(|arm| matches!(arm.pat(), Some(ast::Pat::PlaceholderPat(_)))); + self.arms().find(|arm| matches!(arm.pat(), Some(ast::Pat::WildcardPat(_)))); if let Some(placeholder) = placeholder { self.remove_arm(&placeholder) } else { diff --git a/crates/ra_syntax/src/ast/generated/nodes.rs b/crates/ra_syntax/src/ast/generated/nodes.rs index 713aebcfa..f6b3fa6ef 100644 --- a/crates/ra_syntax/src/ast/generated/nodes.rs +++ b/crates/ra_syntax/src/ast/generated/nodes.rs @@ -1175,10 +1175,10 @@ impl PathPat { pub fn path(&self) -> Option { support::child(&self.syntax) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct PlaceholderPat { +pub struct WildcardPat { pub(crate) syntax: SyntaxNode, } -impl PlaceholderPat { +impl WildcardPat { pub fn underscore_token(&self) -> Option { support::token(&self.syntax, T![_]) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] @@ -1343,7 +1343,7 @@ pub enum Pat { OrPat(OrPat), ParenPat(ParenPat), PathPat(PathPat), - PlaceholderPat(PlaceholderPat), + WildcardPat(WildcardPat), RangePat(RangePat), RecordPat(RecordPat), RefPat(RefPat), @@ -2644,8 +2644,8 @@ impl AstNode for PathPat { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl AstNode for PlaceholderPat { - fn can_cast(kind: SyntaxKind) -> bool { kind == PLACEHOLDER_PAT } +impl AstNode for WildcardPat { + fn can_cast(kind: SyntaxKind) -> bool { kind == WILDCARD_PAT } fn cast(syntax: SyntaxNode) -> Option { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -3160,8 +3160,8 @@ impl From for Pat { impl From for Pat { fn from(node: PathPat) -> Pat { Pat::PathPat(node) } } -impl From for Pat { - fn from(node: PlaceholderPat) -> Pat { Pat::PlaceholderPat(node) } +impl From for Pat { + fn from(node: WildcardPat) -> Pat { Pat::WildcardPat(node) } } impl From for Pat { fn from(node: RangePat) -> Pat { Pat::RangePat(node) } @@ -3185,7 +3185,7 @@ impl AstNode for Pat { fn can_cast(kind: SyntaxKind) -> bool { match kind { BIND_PAT | BOX_PAT | DOT_DOT_PAT | LITERAL_PAT | MACRO_PAT | OR_PAT | PAREN_PAT - | PATH_PAT | PLACEHOLDER_PAT | RANGE_PAT | RECORD_PAT | REF_PAT | SLICE_PAT + | PATH_PAT | WILDCARD_PAT | RANGE_PAT | RECORD_PAT | REF_PAT | SLICE_PAT | TUPLE_PAT | TUPLE_STRUCT_PAT => true, _ => false, } @@ -3200,7 +3200,7 @@ impl AstNode for Pat { OR_PAT => Pat::OrPat(OrPat { syntax }), PAREN_PAT => Pat::ParenPat(ParenPat { syntax }), PATH_PAT => Pat::PathPat(PathPat { syntax }), - PLACEHOLDER_PAT => Pat::PlaceholderPat(PlaceholderPat { syntax }), + WILDCARD_PAT => Pat::WildcardPat(WildcardPat { syntax }), RANGE_PAT => Pat::RangePat(RangePat { syntax }), RECORD_PAT => Pat::RecordPat(RecordPat { syntax }), REF_PAT => Pat::RefPat(RefPat { syntax }), @@ -3221,7 +3221,7 @@ impl AstNode for Pat { Pat::OrPat(it) => &it.syntax, Pat::ParenPat(it) => &it.syntax, Pat::PathPat(it) => &it.syntax, - Pat::PlaceholderPat(it) => &it.syntax, + Pat::WildcardPat(it) => &it.syntax, Pat::RangePat(it) => &it.syntax, Pat::RecordPat(it) => &it.syntax, Pat::RefPat(it) => &it.syntax, @@ -4021,7 +4021,7 @@ impl std::fmt::Display for PathPat { std::fmt::Display::fmt(self.syntax(), f) } } -impl std::fmt::Display for PlaceholderPat { +impl std::fmt::Display for WildcardPat { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { std::fmt::Display::fmt(self.syntax(), f) } diff --git a/crates/ra_syntax/src/ast/make.rs b/crates/ra_syntax/src/ast/make.rs index 3d4fed64c..efb2cb4a3 100644 --- a/crates/ra_syntax/src/ast/make.rs +++ b/crates/ra_syntax/src/ast/make.rs @@ -156,10 +156,10 @@ pub fn bind_pat(name: ast::Name) -> ast::BindPat { } } -pub fn placeholder_pat() -> ast::PlaceholderPat { +pub fn placeholder_pat() -> ast::WildcardPat { return from_text("_"); - fn from_text(text: &str) -> ast::PlaceholderPat { + fn from_text(text: &str) -> ast::WildcardPat { ast_from_text(&format!("fn f({}: ())", text)) } } diff --git a/crates/ra_syntax/test_data/parser/err/0024_many_type_parens.rast b/crates/ra_syntax/test_data/parser/err/0024_many_type_parens.rast index 1cb1e9757..e3be6b22e 100644 --- a/crates/ra_syntax/test_data/parser/err/0024_many_type_parens.rast +++ b/crates/ra_syntax/test_data/parser/err/0024_many_type_parens.rast @@ -80,7 +80,7 @@ SOURCE_FILE@0..240 LET_STMT@71..121 LET_KW@71..74 "let" WHITESPACE@74..75 " " - PLACEHOLDER_PAT@75..76 + WILDCARD_PAT@75..76 UNDERSCORE@75..76 "_" COLON@76..77 ":" WHITESPACE@77..78 " " @@ -147,7 +147,7 @@ SOURCE_FILE@0..240 LET_STMT@128..141 LET_KW@128..131 "let" WHITESPACE@131..132 " " - PLACEHOLDER_PAT@132..133 + WILDCARD_PAT@132..133 UNDERSCORE@132..133 "_" COLON@133..134 ":" WHITESPACE@134..135 " " @@ -223,7 +223,7 @@ SOURCE_FILE@0..240 LET_STMT@185..235 LET_KW@185..188 "let" WHITESPACE@188..189 " " - PLACEHOLDER_PAT@189..190 + WILDCARD_PAT@189..190 UNDERSCORE@189..190 "_" COLON@190..191 ":" WHITESPACE@191..192 " " diff --git a/crates/ra_syntax/test_data/parser/err/0032_match_arms_inner_attrs.rast b/crates/ra_syntax/test_data/parser/err/0032_match_arms_inner_attrs.rast index ec9f556aa..672dd054a 100644 --- a/crates/ra_syntax/test_data/parser/err/0032_match_arms_inner_attrs.rast +++ b/crates/ra_syntax/test_data/parser/err/0032_match_arms_inner_attrs.rast @@ -23,7 +23,7 @@ SOURCE_FILE@0..293 L_CURLY@24..25 "{" WHITESPACE@25..34 "\n " MATCH_ARM@34..41 - PLACEHOLDER_PAT@34..35 + WILDCARD_PAT@34..35 UNDERSCORE@34..35 "_" WHITESPACE@35..36 " " FAT_ARROW@36..38 "=>" @@ -54,7 +54,7 @@ SOURCE_FILE@0..293 R_BRACK@77..78 "]" WHITESPACE@78..87 "\n " MATCH_ARM@87..94 - PLACEHOLDER_PAT@87..88 + WILDCARD_PAT@87..88 UNDERSCORE@87..88 "_" WHITESPACE@88..89 " " FAT_ARROW@89..91 "=>" @@ -78,7 +78,7 @@ SOURCE_FILE@0..293 L_CURLY@116..117 "{" WHITESPACE@117..126 "\n " MATCH_ARM@126..133 - PLACEHOLDER_PAT@126..127 + WILDCARD_PAT@126..127 UNDERSCORE@126..127 "_" WHITESPACE@127..128 " " FAT_ARROW@128..130 "=>" @@ -89,7 +89,7 @@ SOURCE_FILE@0..293 COMMA@133..134 "," WHITESPACE@134..143 "\n " MATCH_ARM@143..150 - PLACEHOLDER_PAT@143..144 + WILDCARD_PAT@143..144 UNDERSCORE@143..144 "_" WHITESPACE@144..145 " " FAT_ARROW@145..147 "=>" @@ -165,7 +165,7 @@ SOURCE_FILE@0..293 R_BRACK@249..250 "]" WHITESPACE@250..259 "\n " MATCH_ARM@259..266 - PLACEHOLDER_PAT@259..260 + WILDCARD_PAT@259..260 UNDERSCORE@259..260 "_" WHITESPACE@260..261 " " FAT_ARROW@261..263 "=>" @@ -176,7 +176,7 @@ SOURCE_FILE@0..293 COMMA@266..267 "," WHITESPACE@267..276 "\n " MATCH_ARM@276..283 - PLACEHOLDER_PAT@276..277 + WILDCARD_PAT@276..277 UNDERSCORE@276..277 "_" WHITESPACE@277..278 " " FAT_ARROW@278..280 "=>" diff --git a/crates/ra_syntax/test_data/parser/err/0033_match_arms_outer_attrs.rast b/crates/ra_syntax/test_data/parser/err/0033_match_arms_outer_attrs.rast index 063532e02..33bb085e9 100644 --- a/crates/ra_syntax/test_data/parser/err/0033_match_arms_outer_attrs.rast +++ b/crates/ra_syntax/test_data/parser/err/0033_match_arms_outer_attrs.rast @@ -22,7 +22,7 @@ SOURCE_FILE@0..89 L_CURLY@24..25 "{" WHITESPACE@25..34 "\n " MATCH_ARM@34..41 - PLACEHOLDER_PAT@34..35 + WILDCARD_PAT@34..35 UNDERSCORE@34..35 "_" WHITESPACE@35..36 " " FAT_ARROW@36..38 "=>" @@ -33,7 +33,7 @@ SOURCE_FILE@0..89 COMMA@41..42 "," WHITESPACE@42..51 "\n " MATCH_ARM@51..58 - PLACEHOLDER_PAT@51..52 + WILDCARD_PAT@51..52 UNDERSCORE@51..52 "_" WHITESPACE@52..53 " " FAT_ARROW@53..55 "=>" diff --git a/crates/ra_syntax/test_data/parser/inline/err/0007_async_without_semicolon.rast b/crates/ra_syntax/test_data/parser/inline/err/0007_async_without_semicolon.rast index 3f3a7f1b9..2c9570678 100644 --- a/crates/ra_syntax/test_data/parser/inline/err/0007_async_without_semicolon.rast +++ b/crates/ra_syntax/test_data/parser/inline/err/0007_async_without_semicolon.rast @@ -14,7 +14,7 @@ SOURCE_FILE@0..30 LET_STMT@11..27 LET_KW@11..14 "let" WHITESPACE@14..15 " " - PLACEHOLDER_PAT@15..16 + WILDCARD_PAT@15..16 UNDERSCORE@15..16 "_" WHITESPACE@16..17 " " EQ@17..18 "=" diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0026_tuple_pat_fields.rast b/crates/ra_syntax/test_data/parser/inline/ok/0026_tuple_pat_fields.rast index e5f550347..45d17e800 100644 --- a/crates/ra_syntax/test_data/parser/inline/ok/0026_tuple_pat_fields.rast +++ b/crates/ra_syntax/test_data/parser/inline/ok/0026_tuple_pat_fields.rast @@ -38,7 +38,7 @@ SOURCE_FILE@0..97 NAME_REF@37..38 IDENT@37..38 "S" L_PAREN@38..39 "(" - PLACEHOLDER_PAT@39..40 + WILDCARD_PAT@39..40 UNDERSCORE@39..40 "_" R_PAREN@40..41 ")" WHITESPACE@41..42 " " @@ -58,7 +58,7 @@ SOURCE_FILE@0..97 NAME_REF@56..57 IDENT@56..57 "S" L_PAREN@57..58 "(" - PLACEHOLDER_PAT@58..59 + WILDCARD_PAT@58..59 UNDERSCORE@58..59 "_" COMMA@59..60 "," R_PAREN@60..61 ")" @@ -79,7 +79,7 @@ SOURCE_FILE@0..97 NAME_REF@76..77 IDENT@76..77 "S" L_PAREN@77..78 "(" - PLACEHOLDER_PAT@78..79 + WILDCARD_PAT@78..79 UNDERSCORE@78..79 "_" COMMA@79..80 "," WHITESPACE@80..81 " " diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0030_cond.rast b/crates/ra_syntax/test_data/parser/inline/ok/0030_cond.rast index 381284dc5..58a97d3ad 100644 --- a/crates/ra_syntax/test_data/parser/inline/ok/0030_cond.rast +++ b/crates/ra_syntax/test_data/parser/inline/ok/0030_cond.rast @@ -23,7 +23,7 @@ SOURCE_FILE@0..197 NAME_REF@18..22 IDENT@18..22 "Some" L_PAREN@22..23 "(" - PLACEHOLDER_PAT@23..24 + WILDCARD_PAT@23..24 UNDERSCORE@23..24 "_" R_PAREN@24..25 ")" WHITESPACE@25..26 " " @@ -67,7 +67,7 @@ SOURCE_FILE@0..197 NAME_REF@60..64 IDENT@60..64 "Some" L_PAREN@64..65 "(" - PLACEHOLDER_PAT@65..66 + WILDCARD_PAT@65..66 UNDERSCORE@65..66 "_" R_PAREN@66..67 ")" WHITESPACE@67..68 " " @@ -79,7 +79,7 @@ SOURCE_FILE@0..197 NAME_REF@70..74 IDENT@70..74 "Some" L_PAREN@74..75 "(" - PLACEHOLDER_PAT@75..76 + WILDCARD_PAT@75..76 UNDERSCORE@75..76 "_" R_PAREN@76..77 ")" WHITESPACE@77..78 " " @@ -110,7 +110,7 @@ SOURCE_FILE@0..197 NAME_REF@101..105 IDENT@101..105 "Some" L_PAREN@105..106 "(" - PLACEHOLDER_PAT@106..107 + WILDCARD_PAT@106..107 UNDERSCORE@106..107 "_" R_PAREN@107..108 ")" WHITESPACE@108..109 " " @@ -140,7 +140,7 @@ SOURCE_FILE@0..197 NAME_REF@133..137 IDENT@133..137 "Some" L_PAREN@137..138 "(" - PLACEHOLDER_PAT@138..139 + WILDCARD_PAT@138..139 UNDERSCORE@138..139 "_" R_PAREN@139..140 ")" WHITESPACE@140..141 " " @@ -152,7 +152,7 @@ SOURCE_FILE@0..197 NAME_REF@143..147 IDENT@143..147 "Some" L_PAREN@147..148 "(" - PLACEHOLDER_PAT@148..149 + WILDCARD_PAT@148..149 UNDERSCORE@148..149 "_" R_PAREN@149..150 ")" WHITESPACE@150..151 " " @@ -182,7 +182,7 @@ SOURCE_FILE@0..197 NAME_REF@177..181 IDENT@177..181 "Some" L_PAREN@181..182 "(" - PLACEHOLDER_PAT@182..183 + WILDCARD_PAT@182..183 UNDERSCORE@182..183 "_" R_PAREN@183..184 ")" WHITESPACE@184..185 " " diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0042_call_expr.rast b/crates/ra_syntax/test_data/parser/inline/ok/0042_call_expr.rast index 40875ae1e..fa38e9466 100644 --- a/crates/ra_syntax/test_data/parser/inline/ok/0042_call_expr.rast +++ b/crates/ra_syntax/test_data/parser/inline/ok/0042_call_expr.rast @@ -14,7 +14,7 @@ SOURCE_FILE@0..118 LET_STMT@15..27 LET_KW@15..18 "let" WHITESPACE@18..19 " " - PLACEHOLDER_PAT@19..20 + WILDCARD_PAT@19..20 UNDERSCORE@19..20 "_" WHITESPACE@20..21 " " EQ@21..22 "=" @@ -33,7 +33,7 @@ SOURCE_FILE@0..118 LET_STMT@32..54 LET_KW@32..35 "let" WHITESPACE@35..36 " " - PLACEHOLDER_PAT@36..37 + WILDCARD_PAT@36..37 UNDERSCORE@36..37 "_" WHITESPACE@37..38 " " EQ@38..39 "=" @@ -69,7 +69,7 @@ SOURCE_FILE@0..118 LET_STMT@59..84 LET_KW@59..62 "let" WHITESPACE@62..63 " " - PLACEHOLDER_PAT@63..64 + WILDCARD_PAT@63..64 UNDERSCORE@63..64 "_" WHITESPACE@64..65 " " EQ@65..66 "=" diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0053_path_expr.rast b/crates/ra_syntax/test_data/parser/inline/ok/0053_path_expr.rast index de2016f18..c34cfeb31 100644 --- a/crates/ra_syntax/test_data/parser/inline/ok/0053_path_expr.rast +++ b/crates/ra_syntax/test_data/parser/inline/ok/0053_path_expr.rast @@ -14,7 +14,7 @@ SOURCE_FILE@0..91 LET_STMT@15..25 LET_KW@15..18 "let" WHITESPACE@18..19 " " - PLACEHOLDER_PAT@19..20 + WILDCARD_PAT@19..20 UNDERSCORE@19..20 "_" WHITESPACE@20..21 " " EQ@21..22 "=" @@ -29,7 +29,7 @@ SOURCE_FILE@0..91 LET_STMT@30..43 LET_KW@30..33 "let" WHITESPACE@33..34 " " - PLACEHOLDER_PAT@34..35 + WILDCARD_PAT@34..35 UNDERSCORE@34..35 "_" WHITESPACE@35..36 " " EQ@36..37 "=" @@ -49,7 +49,7 @@ SOURCE_FILE@0..91 LET_STMT@48..65 LET_KW@48..51 "let" WHITESPACE@51..52 " " - PLACEHOLDER_PAT@52..53 + WILDCARD_PAT@52..53 UNDERSCORE@52..53 "_" WHITESPACE@53..54 " " EQ@54..55 "=" @@ -75,7 +75,7 @@ SOURCE_FILE@0..91 LET_STMT@70..88 LET_KW@70..73 "let" WHITESPACE@73..74 " " - PLACEHOLDER_PAT@74..75 + WILDCARD_PAT@74..75 UNDERSCORE@74..75 "_" WHITESPACE@75..76 " " EQ@76..77 "=" diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0059_match_arms_commas.rast b/crates/ra_syntax/test_data/parser/inline/ok/0059_match_arms_commas.rast index fa659c19b..984829317 100644 --- a/crates/ra_syntax/test_data/parser/inline/ok/0059_match_arms_commas.rast +++ b/crates/ra_syntax/test_data/parser/inline/ok/0059_match_arms_commas.rast @@ -22,7 +22,7 @@ SOURCE_FILE@0..83 L_CURLY@24..25 "{" WHITESPACE@25..34 "\n " MATCH_ARM@34..41 - PLACEHOLDER_PAT@34..35 + WILDCARD_PAT@34..35 UNDERSCORE@34..35 "_" WHITESPACE@35..36 " " FAT_ARROW@36..38 "=>" @@ -33,7 +33,7 @@ SOURCE_FILE@0..83 COMMA@41..42 "," WHITESPACE@42..51 "\n " MATCH_ARM@51..58 - PLACEHOLDER_PAT@51..52 + WILDCARD_PAT@51..52 UNDERSCORE@51..52 "_" WHITESPACE@52..53 " " FAT_ARROW@53..55 "=>" @@ -43,7 +43,7 @@ SOURCE_FILE@0..83 R_CURLY@57..58 "}" WHITESPACE@58..67 "\n " MATCH_ARM@67..74 - PLACEHOLDER_PAT@67..68 + WILDCARD_PAT@67..68 UNDERSCORE@67..68 "_" WHITESPACE@68..69 " " FAT_ARROW@69..71 "=>" diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0066_match_arm.rast b/crates/ra_syntax/test_data/parser/inline/ok/0066_match_arm.rast index 37ca478e6..d873a7ecb 100644 --- a/crates/ra_syntax/test_data/parser/inline/ok/0066_match_arm.rast +++ b/crates/ra_syntax/test_data/parser/inline/ok/0066_match_arm.rast @@ -23,7 +23,7 @@ SOURCE_FILE@0..167 L_CURLY@24..25 "{" WHITESPACE@25..34 "\n " MATCH_ARM@34..41 - PLACEHOLDER_PAT@34..35 + WILDCARD_PAT@34..35 UNDERSCORE@34..35 "_" WHITESPACE@35..36 " " FAT_ARROW@36..38 "=>" @@ -34,7 +34,7 @@ SOURCE_FILE@0..167 COMMA@41..42 "," WHITESPACE@42..51 "\n " MATCH_ARM@51..83 - PLACEHOLDER_PAT@51..52 + WILDCARD_PAT@51..52 UNDERSCORE@51..52 "_" WHITESPACE@52..53 " " MATCH_GUARD@53..77 diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0070_stmt_bin_expr_ambiguity.rast b/crates/ra_syntax/test_data/parser/inline/ok/0070_stmt_bin_expr_ambiguity.rast index 4c1165dc8..36c9cd5bb 100644 --- a/crates/ra_syntax/test_data/parser/inline/ok/0070_stmt_bin_expr_ambiguity.rast +++ b/crates/ra_syntax/test_data/parser/inline/ok/0070_stmt_bin_expr_ambiguity.rast @@ -14,7 +14,7 @@ SOURCE_FILE@0..46 LET_STMT@15..31 LET_KW@15..18 "let" WHITESPACE@18..19 " " - PLACEHOLDER_PAT@19..20 + WILDCARD_PAT@19..20 UNDERSCORE@19..20 "_" WHITESPACE@20..21 " " EQ@21..22 "=" diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0071_match_expr.rast b/crates/ra_syntax/test_data/parser/inline/ok/0071_match_expr.rast index 673d396ee..d34d98ced 100644 --- a/crates/ra_syntax/test_data/parser/inline/ok/0071_match_expr.rast +++ b/crates/ra_syntax/test_data/parser/inline/ok/0071_match_expr.rast @@ -53,7 +53,7 @@ SOURCE_FILE@0..97 L_CURLY@59..60 "{" WHITESPACE@60..61 " " MATCH_ARM@61..68 - PLACEHOLDER_PAT@61..62 + WILDCARD_PAT@61..62 UNDERSCORE@61..62 "_" WHITESPACE@62..63 " " FAT_ARROW@63..65 "=>" diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0074_stmt_postfix_expr_ambiguity.rast b/crates/ra_syntax/test_data/parser/inline/ok/0074_stmt_postfix_expr_ambiguity.rast index 3ca70f021..3a789b9f5 100644 --- a/crates/ra_syntax/test_data/parser/inline/ok/0074_stmt_postfix_expr_ambiguity.rast +++ b/crates/ra_syntax/test_data/parser/inline/ok/0074_stmt_postfix_expr_ambiguity.rast @@ -22,7 +22,7 @@ SOURCE_FILE@0..84 L_CURLY@24..25 "{" WHITESPACE@25..34 "\n " MATCH_ARM@34..41 - PLACEHOLDER_PAT@34..35 + WILDCARD_PAT@34..35 UNDERSCORE@34..35 "_" WHITESPACE@35..36 " " FAT_ARROW@36..38 "=>" diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0075_block.rast b/crates/ra_syntax/test_data/parser/inline/ok/0075_block.rast index 5cefc5076..e847ce9b2 100644 --- a/crates/ra_syntax/test_data/parser/inline/ok/0075_block.rast +++ b/crates/ra_syntax/test_data/parser/inline/ok/0075_block.rast @@ -27,7 +27,7 @@ SOURCE_FILE@0..65 LET_STMT@19..29 LET_KW@19..22 "let" WHITESPACE@22..23 " " - PLACEHOLDER_PAT@23..24 + WILDCARD_PAT@23..24 UNDERSCORE@23..24 "_" WHITESPACE@24..25 " " EQ@25..26 "=" diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0080_postfix_range.rast b/crates/ra_syntax/test_data/parser/inline/ok/0080_postfix_range.rast index 3c80846db..0c19d29c6 100644 --- a/crates/ra_syntax/test_data/parser/inline/ok/0080_postfix_range.rast +++ b/crates/ra_syntax/test_data/parser/inline/ok/0080_postfix_range.rast @@ -39,7 +39,7 @@ SOURCE_FILE@0..89 L_CURLY@42..43 "{" WHITESPACE@43..44 " " MATCH_ARM@44..51 - PLACEHOLDER_PAT@44..45 + WILDCARD_PAT@44..45 UNDERSCORE@44..45 "_" WHITESPACE@45..46 " " FAT_ARROW@46..48 "=>" @@ -79,7 +79,7 @@ SOURCE_FILE@0..89 L_CURLY@74..75 "{" WHITESPACE@75..76 " " MATCH_ARM@76..83 - PLACEHOLDER_PAT@76..77 + WILDCARD_PAT@76..77 UNDERSCORE@76..77 "_" WHITESPACE@77..78 " " FAT_ARROW@78..80 "=>" diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0082_ref_expr.rast b/crates/ra_syntax/test_data/parser/inline/ok/0082_ref_expr.rast index 1563b1988..70b975c0b 100644 --- a/crates/ra_syntax/test_data/parser/inline/ok/0082_ref_expr.rast +++ b/crates/ra_syntax/test_data/parser/inline/ok/0082_ref_expr.rast @@ -16,7 +16,7 @@ SOURCE_FILE@0..200 LET_STMT@41..52 LET_KW@41..44 "let" WHITESPACE@44..45 " " - PLACEHOLDER_PAT@45..46 + WILDCARD_PAT@45..46 UNDERSCORE@45..46 "_" WHITESPACE@46..47 " " EQ@47..48 "=" @@ -30,7 +30,7 @@ SOURCE_FILE@0..200 LET_STMT@57..75 LET_KW@57..60 "let" WHITESPACE@60..61 " " - PLACEHOLDER_PAT@61..62 + WILDCARD_PAT@61..62 UNDERSCORE@61..62 "_" WHITESPACE@62..63 " " EQ@63..64 "=" @@ -55,7 +55,7 @@ SOURCE_FILE@0..200 LET_STMT@80..93 LET_KW@80..83 "let" WHITESPACE@83..84 " " - PLACEHOLDER_PAT@84..85 + WILDCARD_PAT@84..85 UNDERSCORE@84..85 "_" WHITESPACE@85..86 " " EQ@86..87 "=" @@ -72,7 +72,7 @@ SOURCE_FILE@0..200 LET_STMT@98..113 LET_KW@98..101 "let" WHITESPACE@101..102 " " - PLACEHOLDER_PAT@102..103 + WILDCARD_PAT@102..103 UNDERSCORE@102..103 "_" WHITESPACE@103..104 " " EQ@104..105 "=" @@ -95,7 +95,7 @@ SOURCE_FILE@0..200 LET_STMT@148..169 LET_KW@148..151 "let" WHITESPACE@151..152 " " - PLACEHOLDER_PAT@152..153 + WILDCARD_PAT@152..153 UNDERSCORE@152..153 "_" WHITESPACE@153..154 " " EQ@154..155 "=" @@ -116,7 +116,7 @@ SOURCE_FILE@0..200 LET_STMT@174..197 LET_KW@174..177 "let" WHITESPACE@177..178 " " - PLACEHOLDER_PAT@178..179 + WILDCARD_PAT@178..179 UNDERSCORE@178..179 "_" WHITESPACE@179..180 " " EQ@180..181 "=" diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0085_expr_literals.rast b/crates/ra_syntax/test_data/parser/inline/ok/0085_expr_literals.rast index ded36949a..9a87b5b93 100644 --- a/crates/ra_syntax/test_data/parser/inline/ok/0085_expr_literals.rast +++ b/crates/ra_syntax/test_data/parser/inline/ok/0085_expr_literals.rast @@ -14,7 +14,7 @@ SOURCE_FILE@0..189 LET_STMT@15..28 LET_KW@15..18 "let" WHITESPACE@18..19 " " - PLACEHOLDER_PAT@19..20 + WILDCARD_PAT@19..20 UNDERSCORE@19..20 "_" WHITESPACE@20..21 " " EQ@21..22 "=" @@ -26,7 +26,7 @@ SOURCE_FILE@0..189 LET_STMT@33..47 LET_KW@33..36 "let" WHITESPACE@36..37 " " - PLACEHOLDER_PAT@37..38 + WILDCARD_PAT@37..38 UNDERSCORE@37..38 "_" WHITESPACE@38..39 " " EQ@39..40 "=" @@ -38,7 +38,7 @@ SOURCE_FILE@0..189 LET_STMT@52..62 LET_KW@52..55 "let" WHITESPACE@55..56 " " - PLACEHOLDER_PAT@56..57 + WILDCARD_PAT@56..57 UNDERSCORE@56..57 "_" WHITESPACE@57..58 " " EQ@58..59 "=" @@ -50,7 +50,7 @@ SOURCE_FILE@0..189 LET_STMT@67..79 LET_KW@67..70 "let" WHITESPACE@70..71 " " - PLACEHOLDER_PAT@71..72 + WILDCARD_PAT@71..72 UNDERSCORE@71..72 "_" WHITESPACE@72..73 " " EQ@73..74 "=" @@ -62,7 +62,7 @@ SOURCE_FILE@0..189 LET_STMT@84..97 LET_KW@84..87 "let" WHITESPACE@87..88 " " - PLACEHOLDER_PAT@88..89 + WILDCARD_PAT@88..89 UNDERSCORE@88..89 "_" WHITESPACE@89..90 " " EQ@90..91 "=" @@ -74,7 +74,7 @@ SOURCE_FILE@0..189 LET_STMT@102..114 LET_KW@102..105 "let" WHITESPACE@105..106 " " - PLACEHOLDER_PAT@106..107 + WILDCARD_PAT@106..107 UNDERSCORE@106..107 "_" WHITESPACE@107..108 " " EQ@108..109 "=" @@ -86,7 +86,7 @@ SOURCE_FILE@0..189 LET_STMT@119..131 LET_KW@119..122 "let" WHITESPACE@122..123 " " - PLACEHOLDER_PAT@123..124 + WILDCARD_PAT@123..124 UNDERSCORE@123..124 "_" WHITESPACE@124..125 " " EQ@125..126 "=" @@ -98,7 +98,7 @@ SOURCE_FILE@0..189 LET_STMT@136..149 LET_KW@136..139 "let" WHITESPACE@139..140 " " - PLACEHOLDER_PAT@140..141 + WILDCARD_PAT@140..141 UNDERSCORE@140..141 "_" WHITESPACE@141..142 " " EQ@142..143 "=" @@ -110,7 +110,7 @@ SOURCE_FILE@0..189 LET_STMT@154..167 LET_KW@154..157 "let" WHITESPACE@157..158 " " - PLACEHOLDER_PAT@158..159 + WILDCARD_PAT@158..159 UNDERSCORE@158..159 "_" WHITESPACE@159..160 " " EQ@160..161 "=" @@ -122,7 +122,7 @@ SOURCE_FILE@0..189 LET_STMT@172..186 LET_KW@172..175 "let" WHITESPACE@175..176 " " - PLACEHOLDER_PAT@176..177 + WILDCARD_PAT@176..177 UNDERSCORE@176..177 "_" WHITESPACE@177..178 " " EQ@178..179 "=" diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0095_placeholder_pat.rast b/crates/ra_syntax/test_data/parser/inline/ok/0095_placeholder_pat.rast index 25706d2a4..c1fdc6e25 100644 --- a/crates/ra_syntax/test_data/parser/inline/ok/0095_placeholder_pat.rast +++ b/crates/ra_syntax/test_data/parser/inline/ok/0095_placeholder_pat.rast @@ -14,7 +14,7 @@ SOURCE_FILE@0..26 LET_STMT@12..23 LET_KW@12..15 "let" WHITESPACE@15..16 " " - PLACEHOLDER_PAT@16..17 + WILDCARD_PAT@16..17 UNDERSCORE@16..17 "_" WHITESPACE@17..18 " " EQ@18..19 "=" diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0096_no_semi_after_block.rast b/crates/ra_syntax/test_data/parser/inline/ok/0096_no_semi_after_block.rast index cb5316a0d..e757249f0 100644 --- a/crates/ra_syntax/test_data/parser/inline/ok/0096_no_semi_after_block.rast +++ b/crates/ra_syntax/test_data/parser/inline/ok/0096_no_semi_after_block.rast @@ -59,7 +59,7 @@ SOURCE_FILE@0..167 FOR_EXPR@76..90 FOR_KW@76..79 "for" WHITESPACE@79..80 " " - PLACEHOLDER_PAT@80..81 + WILDCARD_PAT@80..81 UNDERSCORE@80..81 "_" WHITESPACE@81..82 " " IN_KW@82..84 "in" diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0102_record_field_pat_list.rast b/crates/ra_syntax/test_data/parser/inline/ok/0102_record_field_pat_list.rast index 003c517ac..d0f70e9d7 100644 --- a/crates/ra_syntax/test_data/parser/inline/ok/0102_record_field_pat_list.rast +++ b/crates/ra_syntax/test_data/parser/inline/ok/0102_record_field_pat_list.rast @@ -84,7 +84,7 @@ SOURCE_FILE@0..119 IDENT@75..76 "h" COLON@76..77 ":" WHITESPACE@77..78 " " - PLACEHOLDER_PAT@78..79 + WILDCARD_PAT@78..79 UNDERSCORE@78..79 "_" COMMA@79..80 "," WHITESPACE@80..81 " " @@ -115,7 +115,7 @@ SOURCE_FILE@0..119 IDENT@103..104 "h" COLON@104..105 ":" WHITESPACE@105..106 " " - PLACEHOLDER_PAT@106..107 + WILDCARD_PAT@106..107 UNDERSCORE@106..107 "_" COMMA@107..108 "," WHITESPACE@108..109 " " diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0112_bind_pat.rast b/crates/ra_syntax/test_data/parser/inline/ok/0112_bind_pat.rast index 3cd554d45..65d5944c0 100644 --- a/crates/ra_syntax/test_data/parser/inline/ok/0112_bind_pat.rast +++ b/crates/ra_syntax/test_data/parser/inline/ok/0112_bind_pat.rast @@ -84,7 +84,7 @@ SOURCE_FILE@0..146 WHITESPACE@101..102 " " AT@102..103 "@" WHITESPACE@103..104 " " - PLACEHOLDER_PAT@104..105 + WILDCARD_PAT@104..105 UNDERSCORE@104..105 "_" WHITESPACE@105..106 " " EQ@106..107 "=" @@ -113,7 +113,7 @@ SOURCE_FILE@0..146 WHITESPACE@133..134 " " AT@134..135 "@" WHITESPACE@135..136 " " - PLACEHOLDER_PAT@136..137 + WILDCARD_PAT@136..137 UNDERSCORE@136..137 "_" WHITESPACE@137..138 " " EQ@138..139 "=" diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0118_match_guard.rast b/crates/ra_syntax/test_data/parser/inline/ok/0118_match_guard.rast index aaaf803b7..0cf4eb0a5 100644 --- a/crates/ra_syntax/test_data/parser/inline/ok/0118_match_guard.rast +++ b/crates/ra_syntax/test_data/parser/inline/ok/0118_match_guard.rast @@ -22,7 +22,7 @@ SOURCE_FILE@0..58 L_CURLY@24..25 "{" WHITESPACE@25..34 "\n " MATCH_ARM@34..48 - PLACEHOLDER_PAT@34..35 + WILDCARD_PAT@34..35 UNDERSCORE@34..35 "_" WHITESPACE@35..36 " " MATCH_GUARD@36..42 diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0120_match_arms_inner_attribute.rast b/crates/ra_syntax/test_data/parser/inline/ok/0120_match_arms_inner_attribute.rast index 4b5f9cdc9..ec7a00f1d 100644 --- a/crates/ra_syntax/test_data/parser/inline/ok/0120_match_arms_inner_attribute.rast +++ b/crates/ra_syntax/test_data/parser/inline/ok/0120_match_arms_inner_attribute.rast @@ -64,7 +64,7 @@ SOURCE_FILE@0..139 R_BRACK@112..113 "]" WHITESPACE@113..122 "\n " MATCH_ARM@122..129 - PLACEHOLDER_PAT@122..123 + WILDCARD_PAT@122..123 UNDERSCORE@122..123 "_" WHITESPACE@123..124 " " FAT_ARROW@124..126 "=>" diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0121_match_arms_outer_attributes.rast b/crates/ra_syntax/test_data/parser/inline/ok/0121_match_arms_outer_attributes.rast index 54cc3be3a..97924da05 100644 --- a/crates/ra_syntax/test_data/parser/inline/ok/0121_match_arms_outer_attributes.rast +++ b/crates/ra_syntax/test_data/parser/inline/ok/0121_match_arms_outer_attributes.rast @@ -39,7 +39,7 @@ SOURCE_FILE@0..259 R_PAREN@56..57 ")" R_BRACK@57..58 "]" WHITESPACE@58..67 "\n " - PLACEHOLDER_PAT@67..68 + WILDCARD_PAT@67..68 UNDERSCORE@67..68 "_" WHITESPACE@68..69 " " FAT_ARROW@69..71 "=>" @@ -67,7 +67,7 @@ SOURCE_FILE@0..259 R_PAREN@107..108 ")" R_BRACK@108..109 "]" WHITESPACE@109..118 "\n " - PLACEHOLDER_PAT@118..119 + WILDCARD_PAT@118..119 UNDERSCORE@118..119 "_" WHITESPACE@119..120 " " FAT_ARROW@120..122 "=>" @@ -129,7 +129,7 @@ SOURCE_FILE@0..259 R_PAREN@231..232 ")" R_BRACK@232..233 "]" WHITESPACE@233..242 "\n " - PLACEHOLDER_PAT@242..243 + WILDCARD_PAT@242..243 UNDERSCORE@242..243 "_" WHITESPACE@243..244 " " FAT_ARROW@244..246 "=>" diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0122_generic_lifetime_type_attribute.rast b/crates/ra_syntax/test_data/parser/inline/ok/0122_generic_lifetime_type_attribute.rast index edac8d5d9..8d029b592 100644 --- a/crates/ra_syntax/test_data/parser/inline/ok/0122_generic_lifetime_type_attribute.rast +++ b/crates/ra_syntax/test_data/parser/inline/ok/0122_generic_lifetime_type_attribute.rast @@ -43,7 +43,7 @@ SOURCE_FILE@0..64 PARAM_LIST@49..59 L_PAREN@49..50 "(" PARAM@50..58 - PLACEHOLDER_PAT@50..51 + WILDCARD_PAT@50..51 UNDERSCORE@50..51 "_" COLON@51..52 ":" WHITESPACE@52..53 " " diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0130_let_stmt.rast b/crates/ra_syntax/test_data/parser/inline/ok/0130_let_stmt.rast index d2fd6e567..16d616bd4 100644 --- a/crates/ra_syntax/test_data/parser/inline/ok/0130_let_stmt.rast +++ b/crates/ra_syntax/test_data/parser/inline/ok/0130_let_stmt.rast @@ -82,7 +82,7 @@ SOURCE_FILE@0..135 LET_STMT@93..107 LET_KW@93..96 "let" WHITESPACE@96..97 " " - PLACEHOLDER_PAT@97..98 + WILDCARD_PAT@97..98 UNDERSCORE@97..98 "_" COLON@98..99 ":" WHITESPACE@99..100 " " diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0130_try_block_expr.rast b/crates/ra_syntax/test_data/parser/inline/ok/0130_try_block_expr.rast index 0fe3bf582..ffdffe2f8 100644 --- a/crates/ra_syntax/test_data/parser/inline/ok/0130_try_block_expr.rast +++ b/crates/ra_syntax/test_data/parser/inline/ok/0130_try_block_expr.rast @@ -14,7 +14,7 @@ SOURCE_FILE@0..33 LET_STMT@15..30 LET_KW@15..18 "let" WHITESPACE@18..19 " " - PLACEHOLDER_PAT@19..20 + WILDCARD_PAT@19..20 UNDERSCORE@19..20 "_" WHITESPACE@20..21 " " EQ@21..22 "=" diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0146_as_precedence.rast b/crates/ra_syntax/test_data/parser/inline/ok/0146_as_precedence.rast index 2d0c83458..ca739825a 100644 --- a/crates/ra_syntax/test_data/parser/inline/ok/0146_as_precedence.rast +++ b/crates/ra_syntax/test_data/parser/inline/ok/0146_as_precedence.rast @@ -14,7 +14,7 @@ SOURCE_FILE@0..43 LET_STMT@15..40 LET_KW@15..18 "let" WHITESPACE@18..19 " " - PLACEHOLDER_PAT@19..20 + WILDCARD_PAT@19..20 UNDERSCORE@19..20 "_" WHITESPACE@20..21 " " EQ@21..22 "=" diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0156_or_pattern.rast b/crates/ra_syntax/test_data/parser/inline/ok/0156_or_pattern.rast index 4d4c41f1a..88a513cee 100644 --- a/crates/ra_syntax/test_data/parser/inline/ok/0156_or_pattern.rast +++ b/crates/ra_syntax/test_data/parser/inline/ok/0156_or_pattern.rast @@ -25,12 +25,12 @@ SOURCE_FILE@0..130 PAREN_PAT@35..42 L_PAREN@35..36 "(" OR_PAT@36..41 - PLACEHOLDER_PAT@36..37 + WILDCARD_PAT@36..37 UNDERSCORE@36..37 "_" WHITESPACE@37..38 " " PIPE@38..39 "|" WHITESPACE@39..40 " " - PLACEHOLDER_PAT@40..41 + WILDCARD_PAT@40..41 UNDERSCORE@40..41 "_" R_PAREN@41..42 ")" WHITESPACE@42..43 " " @@ -47,12 +47,12 @@ SOURCE_FILE@0..130 PAREN_PAT@59..66 L_PAREN@59..60 "(" OR_PAT@60..65 - PLACEHOLDER_PAT@60..61 + WILDCARD_PAT@60..61 UNDERSCORE@60..61 "_" WHITESPACE@61..62 " " PIPE@62..63 "|" WHITESPACE@63..64 " " - PLACEHOLDER_PAT@64..65 + WILDCARD_PAT@64..65 UNDERSCORE@64..65 "_" R_PAREN@65..66 ")" WHITESPACE@66..67 " " @@ -67,12 +67,12 @@ SOURCE_FILE@0..130 TUPLE_PAT@82..90 L_PAREN@82..83 "(" OR_PAT@83..88 - PLACEHOLDER_PAT@83..84 + WILDCARD_PAT@83..84 UNDERSCORE@83..84 "_" WHITESPACE@84..85 " " PIPE@85..86 "|" WHITESPACE@86..87 " " - PLACEHOLDER_PAT@87..88 + WILDCARD_PAT@87..88 UNDERSCORE@87..88 "_" COMMA@88..89 "," R_PAREN@89..90 ")" @@ -88,12 +88,12 @@ SOURCE_FILE@0..130 SLICE_PAT@106..114 L_BRACK@106..107 "[" OR_PAT@107..112 - PLACEHOLDER_PAT@107..108 + WILDCARD_PAT@107..108 UNDERSCORE@107..108 "_" WHITESPACE@108..109 " " PIPE@109..110 "|" WHITESPACE@110..111 " " - PLACEHOLDER_PAT@111..112 + WILDCARD_PAT@111..112 UNDERSCORE@111..112 "_" COMMA@112..113 "," R_BRACK@113..114 "]" diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0157_fn_pointer_unnamed_arg.rast b/crates/ra_syntax/test_data/parser/inline/ok/0157_fn_pointer_unnamed_arg.rast index ccca045b6..3079e5bf8 100644 --- a/crates/ra_syntax/test_data/parser/inline/ok/0157_fn_pointer_unnamed_arg.rast +++ b/crates/ra_syntax/test_data/parser/inline/ok/0157_fn_pointer_unnamed_arg.rast @@ -12,7 +12,7 @@ SOURCE_FILE@0..23 PARAM_LIST@13..21 L_PAREN@13..14 "(" PARAM@14..20 - PLACEHOLDER_PAT@14..15 + WILDCARD_PAT@14..15 UNDERSCORE@14..15 "_" COLON@15..16 ":" WHITESPACE@16..17 " " diff --git a/crates/ra_syntax/test_data/parser/ok/0030_string_suffixes.rast b/crates/ra_syntax/test_data/parser/ok/0030_string_suffixes.rast index 93f766149..80f7f5942 100644 --- a/crates/ra_syntax/test_data/parser/ok/0030_string_suffixes.rast +++ b/crates/ra_syntax/test_data/parser/ok/0030_string_suffixes.rast @@ -14,7 +14,7 @@ SOURCE_FILE@0..112 LET_STMT@16..31 LET_KW@16..19 "let" WHITESPACE@19..20 " " - PLACEHOLDER_PAT@20..21 + WILDCARD_PAT@20..21 UNDERSCORE@20..21 "_" WHITESPACE@21..22 " " EQ@22..23 "=" @@ -26,7 +26,7 @@ SOURCE_FILE@0..112 LET_STMT@36..60 LET_KW@36..39 "let" WHITESPACE@39..40 " " - PLACEHOLDER_PAT@40..41 + WILDCARD_PAT@40..41 UNDERSCORE@40..41 "_" WHITESPACE@41..42 " " EQ@42..43 "=" @@ -38,7 +38,7 @@ SOURCE_FILE@0..112 LET_STMT@65..83 LET_KW@65..68 "let" WHITESPACE@68..69 " " - PLACEHOLDER_PAT@69..70 + WILDCARD_PAT@69..70 UNDERSCORE@69..70 "_" WHITESPACE@70..71 " " EQ@71..72 "=" @@ -50,7 +50,7 @@ SOURCE_FILE@0..112 LET_STMT@88..109 LET_KW@88..91 "let" WHITESPACE@91..92 " " - PLACEHOLDER_PAT@92..93 + WILDCARD_PAT@92..93 UNDERSCORE@92..93 "_" WHITESPACE@93..94 " " EQ@94..95 "=" diff --git a/crates/ra_syntax/test_data/parser/ok/0035_weird_exprs.rast b/crates/ra_syntax/test_data/parser/ok/0035_weird_exprs.rast index 0e0c8c9dc..d48f638cd 100644 --- a/crates/ra_syntax/test_data/parser/ok/0035_weird_exprs.rast +++ b/crates/ra_syntax/test_data/parser/ok/0035_weird_exprs.rast @@ -506,7 +506,7 @@ SOURCE_FILE@0..3813 R_CURLY@1146..1147 "}" WHITESPACE@1147..1168 "\n " MATCH_ARM@1168..1183 - PLACEHOLDER_PAT@1168..1169 + WILDCARD_PAT@1168..1169 UNDERSCORE@1168..1169 "_" WHITESPACE@1169..1170 " " FAT_ARROW@1170..1172 "=>" @@ -1102,7 +1102,7 @@ SOURCE_FILE@0..3813 COMMA@1863..1864 "," WHITESPACE@1864..1865 " " MATCH_ARM@1865..1883 - PLACEHOLDER_PAT@1865..1866 + WILDCARD_PAT@1865..1866 UNDERSCORE@1865..1866 "_" WHITESPACE@1866..1867 " " FAT_ARROW@1867..1869 "=>" @@ -1652,7 +1652,7 @@ SOURCE_FILE@0..3813 NAME@2963..2965 IDENT@2963..2965 "__" AT@2965..2966 "@" - PLACEHOLDER_PAT@2966..2967 + WILDCARD_PAT@2966..2967 UNDERSCORE@2966..2967 "_" PIPE@2967..2968 "|" PATH_EXPR@2968..2970 diff --git a/crates/ra_syntax/test_data/parser/ok/0042_ufcs_call_list.rast b/crates/ra_syntax/test_data/parser/ok/0042_ufcs_call_list.rast index ed29b0812..e71e069f1 100644 --- a/crates/ra_syntax/test_data/parser/ok/0042_ufcs_call_list.rast +++ b/crates/ra_syntax/test_data/parser/ok/0042_ufcs_call_list.rast @@ -63,7 +63,7 @@ SOURCE_FILE@0..199 PARAM_LIST@149..158 L_PAREN@149..150 "(" PARAM@150..157 - PLACEHOLDER_PAT@150..151 + WILDCARD_PAT@150..151 UNDERSCORE@150..151 "_" COLON@151..152 ":" WHITESPACE@152..153 " " diff --git a/crates/ra_syntax/test_data/parser/ok/0047_minus_in_inner_pattern.rast b/crates/ra_syntax/test_data/parser/ok/0047_minus_in_inner_pattern.rast index 7a54fa113..4f8dff909 100644 --- a/crates/ra_syntax/test_data/parser/ok/0047_minus_in_inner_pattern.rast +++ b/crates/ra_syntax/test_data/parser/ok/0047_minus_in_inner_pattern.rast @@ -55,7 +55,7 @@ SOURCE_FILE@0..395 COMMA@117..118 "," WHITESPACE@118..127 "\n " MATCH_ARM@127..134 - PLACEHOLDER_PAT@127..128 + WILDCARD_PAT@127..128 UNDERSCORE@127..128 "_" WHITESPACE@128..129 " " FAT_ARROW@129..131 "=>" @@ -127,7 +127,7 @@ SOURCE_FILE@0..395 COMMA@198..199 "," WHITESPACE@199..208 "\n " MATCH_ARM@208..215 - PLACEHOLDER_PAT@208..209 + WILDCARD_PAT@208..209 UNDERSCORE@208..209 "_" WHITESPACE@209..210 " " FAT_ARROW@210..212 "=>" @@ -203,7 +203,7 @@ SOURCE_FILE@0..395 COMMA@275..276 "," WHITESPACE@276..285 "\n " MATCH_ARM@285..292 - PLACEHOLDER_PAT@285..286 + WILDCARD_PAT@285..286 UNDERSCORE@285..286 "_" WHITESPACE@286..287 " " FAT_ARROW@287..289 "=>" diff --git a/crates/ra_syntax/test_data/parser/ok/0051_parameter_attrs.rast b/crates/ra_syntax/test_data/parser/ok/0051_parameter_attrs.rast index 706ccdc39..a80a6cd7a 100644 --- a/crates/ra_syntax/test_data/parser/ok/0051_parameter_attrs.rast +++ b/crates/ra_syntax/test_data/parser/ok/0051_parameter_attrs.rast @@ -212,7 +212,7 @@ SOURCE_FILE@0..519 R_BRACK@203..204 "]" WHITESPACE@204..205 " " PARAM@205..211 - PLACEHOLDER_PAT@205..206 + WILDCARD_PAT@205..206 UNDERSCORE@205..206 "_" COLON@206..207 ":" WHITESPACE@207..208 " " diff --git a/crates/ra_syntax/test_data/parser/ok/0054_qual_path_in_type_arg.rast b/crates/ra_syntax/test_data/parser/ok/0054_qual_path_in_type_arg.rast index 0d48c7e81..f71ceecd7 100644 --- a/crates/ra_syntax/test_data/parser/ok/0054_qual_path_in_type_arg.rast +++ b/crates/ra_syntax/test_data/parser/ok/0054_qual_path_in_type_arg.rast @@ -43,7 +43,7 @@ SOURCE_FILE@0..88 PARAM_LIST@32..53 L_PAREN@32..33 "(" PARAM@33..52 - PLACEHOLDER_PAT@33..34 + WILDCARD_PAT@33..34 UNDERSCORE@33..34 "_" COLON@34..35 ":" WHITESPACE@35..36 " " @@ -85,7 +85,7 @@ SOURCE_FILE@0..88 PARAM_LIST@62..84 L_PAREN@62..63 "(" PARAM@63..83 - PLACEHOLDER_PAT@63..64 + WILDCARD_PAT@63..64 UNDERSCORE@63..64 "_" COLON@64..65 ":" WHITESPACE@65..66 " " diff --git a/crates/ra_syntax/test_data/parser/ok/0059_loops_in_parens.rast b/crates/ra_syntax/test_data/parser/ok/0059_loops_in_parens.rast index 767b516a2..213f7b381 100644 --- a/crates/ra_syntax/test_data/parser/ok/0059_loops_in_parens.rast +++ b/crates/ra_syntax/test_data/parser/ok/0059_loops_in_parens.rast @@ -23,7 +23,7 @@ SOURCE_FILE@0..105 FOR_EXPR@21..48 FOR_KW@21..24 "for" WHITESPACE@24..25 " " - PLACEHOLDER_PAT@25..26 + WILDCARD_PAT@25..26 UNDERSCORE@25..26 "_" WHITESPACE@26..27 " " IN_KW@27..29 "in" diff --git a/crates/ra_syntax/test_data/parser/ok/0063_trait_fn_patterns.rast b/crates/ra_syntax/test_data/parser/ok/0063_trait_fn_patterns.rast index 7c5467289..9d88e4cbf 100644 --- a/crates/ra_syntax/test_data/parser/ok/0063_trait_fn_patterns.rast +++ b/crates/ra_syntax/test_data/parser/ok/0063_trait_fn_patterns.rast @@ -163,7 +163,7 @@ SOURCE_FILE@0..170 PARAM_LIST@146..166 L_PAREN@146..147 "(" PARAM@147..153 - PLACEHOLDER_PAT@147..148 + WILDCARD_PAT@147..148 UNDERSCORE@147..148 "_" COLON@148..149 ":" WHITESPACE@149..150 " " diff --git a/crates/ra_syntax/test_data/parser/ok/0063_variadic_fun.rast b/crates/ra_syntax/test_data/parser/ok/0063_variadic_fun.rast index 7adedb02e..d8bf1f8c8 100644 --- a/crates/ra_syntax/test_data/parser/ok/0063_variadic_fun.rast +++ b/crates/ra_syntax/test_data/parser/ok/0063_variadic_fun.rast @@ -16,7 +16,7 @@ SOURCE_FILE@0..126 PARAM_LIST@21..39 L_PAREN@21..22 "(" PARAM@22..32 - PLACEHOLDER_PAT@22..23 + WILDCARD_PAT@22..23 UNDERSCORE@22..23 "_" COLON@23..24 ":" WHITESPACE@24..25 " " @@ -45,7 +45,7 @@ SOURCE_FILE@0..126 PARAM_LIST@49..69 L_PAREN@49..50 "(" PARAM@50..60 - PLACEHOLDER_PAT@50..51 + WILDCARD_PAT@50..51 UNDERSCORE@50..51 "_" COLON@51..52 ":" WHITESPACE@52..53 " " @@ -61,7 +61,7 @@ SOURCE_FILE@0..126 COMMA@60..61 "," WHITESPACE@61..62 " " PARAM@62..68 - PLACEHOLDER_PAT@62..63 + WILDCARD_PAT@62..63 UNDERSCORE@62..63 "_" COLON@63..64 ":" WHITESPACE@64..65 " " @@ -77,7 +77,7 @@ SOURCE_FILE@0..126 PARAM_LIST@79..122 L_PAREN@79..80 "(" PARAM@80..90 - PLACEHOLDER_PAT@80..81 + WILDCARD_PAT@80..81 UNDERSCORE@80..81 "_" COLON@81..82 ":" WHITESPACE@82..83 " " diff --git a/xtask/src/ast_src.rs b/xtask/src/ast_src.rs index 869bdaa0d..fbe36d2f5 100644 --- a/xtask/src/ast_src.rs +++ b/xtask/src/ast_src.rs @@ -127,7 +127,7 @@ pub(crate) const KINDS_SRC: KindsSrc = KindsSrc { "REF_PAT", "BOX_PAT", "BIND_PAT", - "PLACEHOLDER_PAT", + "WILDCARD_PAT", "DOT_DOT_PAT", "PATH_PAT", "RECORD_PAT", diff --git a/xtask/src/codegen/rust.ungram b/xtask/src/codegen/rust.ungram index cb8a307fe..7c814240a 100644 --- a/xtask/src/codegen/rust.ungram +++ b/xtask/src/codegen/rust.ungram @@ -505,7 +505,7 @@ Pat = | OrPat | ParenPat | PathPat -| PlaceholderPat +| WildcardPat | RangePat | RecordPat | RefPat @@ -519,7 +519,7 @@ LiteralPat = BindPat = Attr* 'ref'? 'mut'? Name ('@' Pat)? -PlaceholderPat = +WildcardPat = '_' RangePat = -- cgit v1.2.3 From 98181087984157e27faba0b969e384f3c62c39d5 Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Fri, 31 Jul 2020 20:09:09 +0200 Subject: Rename BindPat -> IdentPat --- .../ra_assists/src/handlers/add_explicit_type.rs | 2 +- crates/ra_assists/src/handlers/fill_match_arms.rs | 2 +- .../src/handlers/inline_local_variable.rs | 2 +- crates/ra_assists/src/handlers/reorder_fields.rs | 2 +- crates/ra_hir/src/code_model.rs | 2 +- crates/ra_hir/src/semantics.rs | 6 +- crates/ra_hir/src/semantics/source_to_def.rs | 2 +- crates/ra_hir/src/source_analyzer.rs | 2 +- crates/ra_hir_def/src/body/lower.rs | 2 +- crates/ra_ide/src/completion/completion_context.rs | 2 +- crates/ra_ide/src/completion/patterns.rs | 2 +- crates/ra_ide/src/display/navigation_target.rs | 4 +- crates/ra_ide/src/inlay_hints.rs | 14 ++-- crates/ra_ide/src/references.rs | 14 ++-- crates/ra_ide/src/syntax_highlighting.rs | 2 +- crates/ra_ide_db/src/defs.rs | 4 +- crates/ra_mbe/src/tests.rs | 4 +- crates/ra_parser/src/grammar/patterns.rs | 2 +- crates/ra_parser/src/syntax_kind/generated.rs | 2 +- crates/ra_ssr/src/parsing.rs | 2 +- crates/ra_ssr/src/resolving.rs | 2 +- crates/ra_ssr/src/tests.rs | 2 +- crates/ra_syntax/src/ast/generated/nodes.rs | 26 +++--- crates/ra_syntax/src/ast/make.rs | 4 +- crates/ra_syntax/src/ast/node_ext.rs | 6 +- .../test_data/parser/err/0012_broken_lambda.rast | 36 ++++----- .../parser/err/0017_incomplete_binexpr.rast | 4 +- .../test_data/parser/err/0018_incomplete_fn.rast | 2 +- .../test_data/parser/err/0019_let_recover.rast | 6 +- .../parser/err/0021_incomplete_param.rast | 4 +- .../ra_syntax/test_data/parser/err/0025_nope.rast | 4 +- .../parser/err/0029_field_completion.rast | 2 +- .../parser/err/0031_block_inner_attrs.rast | 2 +- .../test_data/parser/err/0034_bad_box_pattern.rast | 6 +- .../test_data/parser/err/0039_lambda_recovery.rast | 2 +- .../parser/fragments/pattern/ok/0000_enum.rast | 2 +- .../parser/inline/ok/0006_self_param.rast | 2 +- .../test_data/parser/inline/ok/0024_slice_pat.rast | 4 +- .../parser/inline/ok/0026_tuple_pat_fields.rast | 2 +- .../test_data/parser/inline/ok/0027_ref_pat.rast | 4 +- .../parser/inline/ok/0031_while_expr.rast | 2 +- .../test_data/parser/inline/ok/0066_match_arm.rast | 10 +-- .../parser/inline/ok/0080_postfix_range.rast | 2 +- .../parser/inline/ok/0088_break_ambiguity.rast | 2 +- .../parser/inline/ok/0099_param_list.rast | 8 +- .../test_data/parser/inline/ok/0100_for_expr.rast | 2 +- .../inline/ok/0102_record_field_pat_list.rast | 4 +- .../parser/inline/ok/0106_lambda_expr.rast | 4 +- .../test_data/parser/inline/ok/0109_label.rast | 2 +- .../test_data/parser/inline/ok/0111_tuple_pat.rast | 6 +- .../test_data/parser/inline/ok/0112_bind_pat.rast | 14 ++-- .../parser/inline/ok/0123_param_list_vararg.rast | 2 +- .../test_data/parser/inline/ok/0130_let_stmt.rast | 12 +-- .../test_data/parser/inline/ok/0132_box_expr.rast | 6 +- .../inline/ok/0138_associated_type_bounds.rast | 2 +- .../inline/ok/0138_expression_after_block.rast | 2 +- .../parser/inline/ok/0139_param_outer_arg.rast | 2 +- .../parser/inline/ok/0142_for_range_from.rast | 2 +- .../test_data/parser/inline/ok/0143_box_pat.rast | 8 +- .../parser/inline/ok/0144_dot_dot_pat.rast | 44 +++++----- .../ok/0154_fn_pointer_param_ident_path.rast | 2 +- .../parser/inline/ok/0155_closure_params.rast | 8 +- .../parser/inline/ok/0156_fn_def_param.rast | 4 +- .../parser/ok/0028_operator_binding_power.rast | 2 +- .../test_data/parser/ok/0029_range_forms.rast | 4 +- .../ra_syntax/test_data/parser/ok/0030_traits.rast | 2 +- .../ra_syntax/test_data/parser/ok/0031_extern.rast | 94 +++++++++++----------- .../test_data/parser/ok/0033_label_break.rast | 2 +- .../test_data/parser/ok/0035_weird_exprs.rast | 36 ++++----- .../test_data/parser/ok/0041_raw_keywords.rast | 4 +- .../test_data/parser/ok/0044_let_attrs.rast | 2 +- .../parser/ok/0045_block_inner_attrs.rast | 2 +- .../parser/ok/0048_compound_assignment.rast | 2 +- .../parser/ok/0050_async_block_as_argument.rast | 2 +- .../test_data/parser/ok/0051_parameter_attrs.rast | 8 +- .../test_data/parser/ok/0052_for_range_block.rast | 2 +- .../test_data/parser/ok/0057_loop_in_call.rast | 2 +- .../parser/ok/0063_trait_fn_patterns.rast | 14 ++-- .../test_data/parser/ok/0063_variadic_fun.rast | 6 +- .../test_data/parser/ok/0064_impl_fn_params.rast | 12 +-- .../test_data/parser/ok/0067_where_for_pred.rast | 2 +- xtask/src/ast_src.rs | 2 +- xtask/src/codegen/rust.ungram | 4 +- 83 files changed, 277 insertions(+), 273 deletions(-) diff --git a/crates/ra_assists/src/handlers/add_explicit_type.rs b/crates/ra_assists/src/handlers/add_explicit_type.rs index d8b0af0f5..135a2ac9c 100644 --- a/crates/ra_assists/src/handlers/add_explicit_type.rs +++ b/crates/ra_assists/src/handlers/add_explicit_type.rs @@ -27,7 +27,7 @@ pub(crate) fn add_explicit_type(acc: &mut Assists, ctx: &AssistContext) -> Optio let expr = let_stmt.initializer()?; // Must be a binding let pat = match let_stmt.pat()? { - ast::Pat::BindPat(bind_pat) => bind_pat, + ast::Pat::IdentPat(bind_pat) => bind_pat, _ => return None, }; let pat_range = pat.syntax().text_range(); diff --git a/crates/ra_assists/src/handlers/fill_match_arms.rs b/crates/ra_assists/src/handlers/fill_match_arms.rs index 36658f104..b2e14f9d7 100644 --- a/crates/ra_assists/src/handlers/fill_match_arms.rs +++ b/crates/ra_assists/src/handlers/fill_match_arms.rs @@ -150,7 +150,7 @@ fn does_pat_match_variant(pat: &Pat, var: &Pat) -> bool { let first_node_text = |pat: &Pat| pat.syntax().first_child().map(|node| node.text()); let pat_head = match pat { - Pat::BindPat(bind_pat) => { + Pat::IdentPat(bind_pat) => { if let Some(p) = bind_pat.pat() { first_node_text(&p) } else { diff --git a/crates/ra_assists/src/handlers/inline_local_variable.rs b/crates/ra_assists/src/handlers/inline_local_variable.rs index 2fdfabaf5..3c58020f8 100644 --- a/crates/ra_assists/src/handlers/inline_local_variable.rs +++ b/crates/ra_assists/src/handlers/inline_local_variable.rs @@ -29,7 +29,7 @@ use crate::{ pub(crate) fn inline_local_variable(acc: &mut Assists, ctx: &AssistContext) -> Option<()> { let let_stmt = ctx.find_node_at_offset::()?; let bind_pat = match let_stmt.pat()? { - ast::Pat::BindPat(pat) => pat, + ast::Pat::IdentPat(pat) => pat, _ => return None, }; if bind_pat.mut_token().is_some() { diff --git a/crates/ra_assists/src/handlers/reorder_fields.rs b/crates/ra_assists/src/handlers/reorder_fields.rs index 6a19a4002..c9b743a06 100644 --- a/crates/ra_assists/src/handlers/reorder_fields.rs +++ b/crates/ra_assists/src/handlers/reorder_fields.rs @@ -57,7 +57,7 @@ fn reorder(acc: &mut Assists, ctx: &AssistContext) -> Option<()> { fn get_fields_kind(node: &SyntaxNode) -> Vec { match node.kind() { RECORD_EXPR => vec![RECORD_EXPR_FIELD], - RECORD_PAT => vec![RECORD_PAT_FIELD, BIND_PAT], + RECORD_PAT => vec![RECORD_PAT_FIELD, IDENT_PAT], _ => vec![], } } diff --git a/crates/ra_hir/src/code_model.rs b/crates/ra_hir/src/code_model.rs index 36c0bdc9e..27cdabea0 100644 --- a/crates/ra_hir/src/code_model.rs +++ b/crates/ra_hir/src/code_model.rs @@ -1002,7 +1002,7 @@ impl Local { Type::new(db, krate, def, ty) } - pub fn source(self, db: &dyn HirDatabase) -> InFile> { + pub fn source(self, db: &dyn HirDatabase) -> InFile> { let (_body, source_map) = db.body_with_source_map(self.parent.into()); let src = source_map.pat_syntax(self.pat_id).unwrap(); // Hmm... let root = src.file_syntax(db.upcast()); diff --git a/crates/ra_hir/src/semantics.rs b/crates/ra_hir/src/semantics.rs index 44c71857e..307b336f2 100644 --- a/crates/ra_hir/src/semantics.rs +++ b/crates/ra_hir/src/semantics.rs @@ -236,7 +236,7 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> { self.imp.lower_path(path) } - pub fn resolve_bind_pat_to_const(&self, pat: &ast::BindPat) -> Option { + pub fn resolve_bind_pat_to_const(&self, pat: &ast::IdentPat) -> Option { self.imp.resolve_bind_pat_to_const(pat) } @@ -452,7 +452,7 @@ impl<'db> SemanticsImpl<'db> { Path::from_src(path.clone(), &Hygiene::new(self.db.upcast(), src.file_id.into())) } - fn resolve_bind_pat_to_const(&self, pat: &ast::BindPat) -> Option { + fn resolve_bind_pat_to_const(&self, pat: &ast::IdentPat) -> Option { self.analyze(pat.syntax()).resolve_bind_pat_to_const(self.db, pat) } @@ -594,7 +594,7 @@ to_def_impls![ (crate::EnumVariant, ast::Variant, enum_variant_to_def), (crate::TypeParam, ast::TypeParam, type_param_to_def), (crate::MacroDef, ast::MacroCall, macro_call_to_def), // this one is dubious, not all calls are macros - (crate::Local, ast::BindPat, bind_pat_to_def), + (crate::Local, ast::IdentPat, bind_pat_to_def), ]; fn find_root(node: &SyntaxNode) -> SyntaxNode { diff --git a/crates/ra_hir/src/semantics/source_to_def.rs b/crates/ra_hir/src/semantics/source_to_def.rs index d1994e2e7..863e8e5ff 100644 --- a/crates/ra_hir/src/semantics/source_to_def.rs +++ b/crates/ra_hir/src/semantics/source_to_def.rs @@ -106,7 +106,7 @@ impl SourceToDefCtx<'_, '_> { } pub(super) fn bind_pat_to_def( &mut self, - src: InFile, + src: InFile, ) -> Option<(DefWithBodyId, PatId)> { let container = self.find_pat_container(src.as_ref().map(|it| it.syntax()))?; let (_body, source_map) = self.db.body_with_source_map(container); diff --git a/crates/ra_hir/src/source_analyzer.rs b/crates/ra_hir/src/source_analyzer.rs index 37b33cc4f..d0cb62ef0 100644 --- a/crates/ra_hir/src/source_analyzer.rs +++ b/crates/ra_hir/src/source_analyzer.rs @@ -202,7 +202,7 @@ impl SourceAnalyzer { pub(crate) fn resolve_bind_pat_to_const( &self, db: &dyn HirDatabase, - pat: &ast::BindPat, + pat: &ast::IdentPat, ) -> Option { let pat_id = self.pat_id(&pat.clone().into())?; let body = self.body.as_ref()?; diff --git a/crates/ra_hir_def/src/body/lower.rs b/crates/ra_hir_def/src/body/lower.rs index 7b988ae33..3f210547e 100644 --- a/crates/ra_hir_def/src/body/lower.rs +++ b/crates/ra_hir_def/src/body/lower.rs @@ -723,7 +723,7 @@ impl ExprCollector<'_> { fn collect_pat(&mut self, pat: ast::Pat) -> PatId { let pattern = match &pat { - ast::Pat::BindPat(bp) => { + ast::Pat::IdentPat(bp) => { let name = bp.name().map(|nr| nr.as_name()).unwrap_or_else(Name::missing); let annotation = BindingAnnotation::new(bp.mut_token().is_some(), bp.ref_token().is_some()); diff --git a/crates/ra_ide/src/completion/completion_context.rs b/crates/ra_ide/src/completion/completion_context.rs index 29955754c..6b03b30bb 100644 --- a/crates/ra_ide/src/completion/completion_context.rs +++ b/crates/ra_ide/src/completion/completion_context.rs @@ -275,7 +275,7 @@ impl<'a> CompletionContext<'a> { // Otherwise, see if this is a declaration. We can use heuristics to // suggest declaration names, see `CompletionKind::Magic`. if let Some(name) = find_node_at_offset::(&file_with_fake_ident, offset) { - if let Some(bind_pat) = name.syntax().ancestors().find_map(ast::BindPat::cast) { + if let Some(bind_pat) = name.syntax().ancestors().find_map(ast::IdentPat::cast) { self.is_pat_binding_or_const = true; if bind_pat.at_token().is_some() || bind_pat.ref_token().is_some() diff --git a/crates/ra_ide/src/completion/patterns.rs b/crates/ra_ide/src/completion/patterns.rs index 9e654b373..7c4feff6d 100644 --- a/crates/ra_ide/src/completion/patterns.rs +++ b/crates/ra_ide/src/completion/patterns.rs @@ -44,7 +44,7 @@ fn test_has_block_expr_parent() { } pub(crate) fn has_bind_pat_parent(element: SyntaxElement) -> bool { - element.ancestors().find(|it| it.kind() == BIND_PAT).is_some() + element.ancestors().find(|it| it.kind() == IDENT_PAT).is_some() } #[test] fn test_has_bind_pat_parent() { diff --git a/crates/ra_ide/src/display/navigation_target.rs b/crates/ra_ide/src/display/navigation_target.rs index 45fbc86ef..d70e33e72 100644 --- a/crates/ra_ide/src/display/navigation_target.rs +++ b/crates/ra_ide/src/display/navigation_target.rs @@ -7,7 +7,7 @@ use ra_ide_db::{defs::Definition, RootDatabase}; use ra_syntax::{ ast::{self, DocCommentsOwner, NameOwner}, match_ast, AstNode, SmolStr, - SyntaxKind::{self, BIND_PAT, TYPE_PARAM}, + SyntaxKind::{self, IDENT_PAT, TYPE_PARAM}, TextRange, }; @@ -339,7 +339,7 @@ impl ToNav for hir::Local { NavigationTarget { file_id: full_range.file_id, name, - kind: BIND_PAT, + kind: IDENT_PAT, full_range: full_range.range, focus_range: None, container_name: None, diff --git a/crates/ra_ide/src/inlay_hints.rs b/crates/ra_ide/src/inlay_hints.rs index 4bbbcd258..1bacead63 100644 --- a/crates/ra_ide/src/inlay_hints.rs +++ b/crates/ra_ide/src/inlay_hints.rs @@ -78,7 +78,7 @@ pub(crate) fn inlay_hints( match node { ast::CallExpr(it) => { get_param_name_hints(&mut res, &sema, config, ast::Expr::from(it)); }, ast::MethodCallExpr(it) => { get_param_name_hints(&mut res, &sema, config, ast::Expr::from(it)); }, - ast::BindPat(it) => { get_bind_pat_hints(&mut res, &sema, config, it); }, + ast::IdentPat(it) => { get_bind_pat_hints(&mut res, &sema, config, it); }, _ => (), } } @@ -161,7 +161,7 @@ fn get_param_name_hints( Either::Left(self_param) => Some((self_param.to_string(), arg)), Either::Right(pat) => { let param_name = match pat { - ast::Pat::BindPat(it) => it.name()?.to_string(), + ast::Pat::IdentPat(it) => it.name()?.to_string(), it => it.to_string(), }; Some((param_name, arg)) @@ -182,7 +182,7 @@ fn get_bind_pat_hints( acc: &mut Vec, sema: &Semantics, config: &InlayHintsConfig, - pat: ast::BindPat, + pat: ast::IdentPat, ) -> Option<()> { if !config.type_hints { return None; @@ -202,7 +202,7 @@ fn get_bind_pat_hints( Some(()) } -fn pat_is_enum_variant(db: &RootDatabase, bind_pat: &ast::BindPat, pat_ty: &Type) -> bool { +fn pat_is_enum_variant(db: &RootDatabase, bind_pat: &ast::IdentPat, pat_ty: &Type) -> bool { if let Some(Adt::Enum(enum_data)) = pat_ty.as_adt() { let pat_text = bind_pat.to_string(); enum_data @@ -215,7 +215,11 @@ fn pat_is_enum_variant(db: &RootDatabase, bind_pat: &ast::BindPat, pat_ty: &Type } } -fn should_not_display_type_hint(db: &RootDatabase, bind_pat: &ast::BindPat, pat_ty: &Type) -> bool { +fn should_not_display_type_hint( + db: &RootDatabase, + bind_pat: &ast::IdentPat, + pat_ty: &Type, +) -> bool { if pat_ty.is_unknown() { return true; } diff --git a/crates/ra_ide/src/references.rs b/crates/ra_ide/src/references.rs index 519e4bf1a..cf456630a 100644 --- a/crates/ra_ide/src/references.rs +++ b/crates/ra_ide/src/references.rs @@ -150,7 +150,7 @@ fn decl_access(def: &Definition, syntax: &SyntaxNode, range: TextRange) -> Optio let stmt = find_node_at_offset::(syntax, range.start())?; if stmt.initializer().is_some() { let pat = stmt.pat()?; - if let ast::Pat::BindPat(it) = pat { + if let ast::Pat::IdentPat(it) = pat { if it.mut_token().is_some() { return Some(ReferenceAccess::Write); } @@ -290,7 +290,7 @@ fn main() { ); check_result( refs, - "i BIND_PAT FileId(1) 24..25 Other Write", + "i IDENT_PAT FileId(1) 24..25 Other Write", &[ "FileId(1) 50..51 Other Write", "FileId(1) 54..55 Other Read", @@ -316,7 +316,7 @@ fn bar() { ); check_result( refs, - "spam BIND_PAT FileId(1) 19..23 Other", + "spam IDENT_PAT FileId(1) 19..23 Other", &["FileId(1) 34..38 Other Read", "FileId(1) 41..45 Other Read"], ); } @@ -330,7 +330,7 @@ fn foo(i : u32) -> u32 { } "#, ); - check_result(refs, "i BIND_PAT FileId(1) 7..8 Other", &["FileId(1) 29..30 Other Read"]); + check_result(refs, "i IDENT_PAT FileId(1) 7..8 Other", &["FileId(1) 29..30 Other Read"]); } #[test] @@ -342,7 +342,7 @@ fn foo(i<|> : u32) -> u32 { } "#, ); - check_result(refs, "i BIND_PAT FileId(1) 7..8 Other", &["FileId(1) 29..30 Other Read"]); + check_result(refs, "i IDENT_PAT FileId(1) 7..8 Other", &["FileId(1) 29..30 Other Read"]); } #[test] @@ -559,7 +559,7 @@ fn foo() { ); check_result( refs, - "i BIND_PAT FileId(1) 23..24 Other Write", + "i IDENT_PAT FileId(1) 23..24 Other Write", &["FileId(1) 34..35 Other Write", "FileId(1) 38..39 Other Read"], ); } @@ -595,7 +595,7 @@ fn foo() { } "#, ); - check_result(refs, "i BIND_PAT FileId(1) 19..20 Other", &["FileId(1) 26..27 Other Write"]); + check_result(refs, "i IDENT_PAT FileId(1) 19..20 Other", &["FileId(1) 26..27 Other Write"]); } #[test] diff --git a/crates/ra_ide/src/syntax_highlighting.rs b/crates/ra_ide/src/syntax_highlighting.rs index e3a96f9d5..027fdecd0 100644 --- a/crates/ra_ide/src/syntax_highlighting.rs +++ b/crates/ra_ide/src/syntax_highlighting.rs @@ -717,7 +717,7 @@ fn highlight_name_by_syntax(name: ast::Name) -> Highlight { CONST => HighlightTag::Constant, STATIC => HighlightTag::Static, VARIANT => HighlightTag::EnumVariant, - BIND_PAT => HighlightTag::Local, + IDENT_PAT => HighlightTag::Local, _ => default, }; diff --git a/crates/ra_ide_db/src/defs.rs b/crates/ra_ide_db/src/defs.rs index 6bf80a34c..66c048714 100644 --- a/crates/ra_ide_db/src/defs.rs +++ b/crates/ra_ide_db/src/defs.rs @@ -111,7 +111,7 @@ pub fn classify_name(sema: &Semantics, name: &ast::Name) -> Option let parent = name.syntax().parent()?; - if let Some(bind_pat) = ast::BindPat::cast(parent.clone()) { + if let Some(bind_pat) = ast::IdentPat::cast(parent.clone()) { if let Some(def) = sema.resolve_bind_pat_to_const(&bind_pat) { return Some(NameClass::ConstReference(Definition::ModuleDef(def))); } @@ -128,7 +128,7 @@ pub fn classify_name(sema: &Semantics, name: &ast::Name) -> Option Some(NameClass::Definition(name_ref_class.definition())) }, - ast::BindPat(it) => { + ast::IdentPat(it) => { let local = sema.to_def(&it)?; if let Some(record_field_pat) = it.syntax().parent().and_then(ast::RecordPatField::cast) { diff --git a/crates/ra_mbe/src/tests.rs b/crates/ra_mbe/src/tests.rs index 707e84f42..286983d60 100644 --- a/crates/ra_mbe/src/tests.rs +++ b/crates/ra_mbe/src/tests.rs @@ -625,7 +625,7 @@ fn test_tt_to_stmts() { r#"MACRO_STMTS@0..15 LET_STMT@0..7 LET_KW@0..3 "let" - BIND_PAT@3..4 + IDENT_PAT@3..4 NAME@3..4 IDENT@3..4 "a" EQ@4..5 "=" @@ -1116,7 +1116,7 @@ fn test_vec() { L_CURLY@0..1 "{" LET_STMT@1..20 LET_KW@1..4 "let" - BIND_PAT@4..8 + IDENT_PAT@4..8 MUT_KW@4..7 "mut" NAME@7..8 IDENT@7..8 "v" diff --git a/crates/ra_parser/src/grammar/patterns.rs b/crates/ra_parser/src/grammar/patterns.rs index 51e413cd6..623e8d6d4 100644 --- a/crates/ra_parser/src/grammar/patterns.rs +++ b/crates/ra_parser/src/grammar/patterns.rs @@ -361,7 +361,7 @@ fn bind_pat(p: &mut Parser, with_at: bool) -> CompletedMarker { if with_at && p.eat(T![@]) { pattern_single(p); } - m.complete(p, BIND_PAT) + m.complete(p, IDENT_PAT) } // test box_pat diff --git a/crates/ra_parser/src/syntax_kind/generated.rs b/crates/ra_parser/src/syntax_kind/generated.rs index c24611f4b..b5dda25a9 100644 --- a/crates/ra_parser/src/syntax_kind/generated.rs +++ b/crates/ra_parser/src/syntax_kind/generated.rs @@ -156,7 +156,7 @@ pub enum SyntaxKind { PAREN_PAT, REF_PAT, BOX_PAT, - BIND_PAT, + IDENT_PAT, WILDCARD_PAT, DOT_DOT_PAT, PATH_PAT, diff --git a/crates/ra_ssr/src/parsing.rs b/crates/ra_ssr/src/parsing.rs index 4e046910c..f455eb5b7 100644 --- a/crates/ra_ssr/src/parsing.rs +++ b/crates/ra_ssr/src/parsing.rs @@ -109,7 +109,7 @@ impl RuleBuilder { // path refers to semantically the same thing, whereas the non-path-based rules could match // anything. Specifically, if we have a rule like `foo ==>> bar` we only want to match the // `foo` that is in the current scope, not any `foo`. However "foo" can be parsed as a - // pattern (BIND_PAT -> NAME -> IDENT). Allowing such a rule through would result in + // pattern (IDENT_PAT -> NAME -> IDENT). Allowing such a rule through would result in // renaming everything called `foo` to `bar`. It'd also be slow, since without a path, we'd // have to use the slow-scan search mechanism. if self.rules.iter().any(|rule| contains_path(&rule.pattern)) { diff --git a/crates/ra_ssr/src/resolving.rs b/crates/ra_ssr/src/resolving.rs index c2fd3b905..6f62000f4 100644 --- a/crates/ra_ssr/src/resolving.rs +++ b/crates/ra_ssr/src/resolving.rs @@ -198,7 +198,7 @@ fn pick_node_for_resolution(node: SyntaxNode) -> SyntaxNode { return n; } } - SyntaxKind::LET_STMT | SyntaxKind::BIND_PAT => { + SyntaxKind::LET_STMT | SyntaxKind::IDENT_PAT => { if let Some(next) = node.next_sibling() { return pick_node_for_resolution(next); } diff --git a/crates/ra_ssr/src/tests.rs b/crates/ra_ssr/src/tests.rs index a4fa2cb44..2ae03c64c 100644 --- a/crates/ra_ssr/src/tests.rs +++ b/crates/ra_ssr/src/tests.rs @@ -924,7 +924,7 @@ fn ufcs_matches_method_call() { fn pattern_is_a_single_segment_path() { mark::check!(pattern_is_a_single_segment_path); // The first function should not be altered because the `foo` in scope at the cursor position is - // a different `foo`. This case is special because "foo" can be parsed as a pattern (BIND_PAT -> + // a different `foo`. This case is special because "foo" can be parsed as a pattern (IDENT_PAT -> // NAME -> IDENT), which contains no path. If we're not careful we'll end up matching the `foo` // in `let foo` from the first function. Whether we should match the `let foo` in the second // function is less clear. At the moment, we don't. Doing so sounds like a rename operation, diff --git a/crates/ra_syntax/src/ast/generated/nodes.rs b/crates/ra_syntax/src/ast/generated/nodes.rs index f6b3fa6ef..231a0f727 100644 --- a/crates/ra_syntax/src/ast/generated/nodes.rs +++ b/crates/ra_syntax/src/ast/generated/nodes.rs @@ -1111,12 +1111,12 @@ impl TypeBound { pub fn ty(&self) -> Option { support::child(&self.syntax) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct BindPat { +pub struct IdentPat { pub(crate) syntax: SyntaxNode, } -impl ast::AttrsOwner for BindPat {} -impl ast::NameOwner for BindPat {} -impl BindPat { +impl ast::AttrsOwner for IdentPat {} +impl ast::NameOwner for IdentPat {} +impl IdentPat { pub fn ref_token(&self) -> Option { support::token(&self.syntax, T![ref]) } pub fn mut_token(&self) -> Option { support::token(&self.syntax, T![mut]) } pub fn at_token(&self) -> Option { support::token(&self.syntax, T![@]) } @@ -1335,7 +1335,7 @@ pub enum Stmt { } #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub enum Pat { - BindPat(BindPat), + IdentPat(IdentPat), BoxPat(BoxPat), DotDotPat(DotDotPat), LiteralPat(LiteralPat), @@ -2556,8 +2556,8 @@ impl AstNode for TypeBound { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl AstNode for BindPat { - fn can_cast(kind: SyntaxKind) -> bool { kind == BIND_PAT } +impl AstNode for IdentPat { + fn can_cast(kind: SyntaxKind) -> bool { kind == IDENT_PAT } fn cast(syntax: SyntaxNode) -> Option { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -3136,8 +3136,8 @@ impl From for Stmt { impl From for Stmt { fn from(node: LetStmt) -> Stmt { Stmt::LetStmt(node) } } -impl From for Pat { - fn from(node: BindPat) -> Pat { Pat::BindPat(node) } +impl From for Pat { + fn from(node: IdentPat) -> Pat { Pat::IdentPat(node) } } impl From for Pat { fn from(node: BoxPat) -> Pat { Pat::BoxPat(node) } @@ -3184,7 +3184,7 @@ impl From for Pat { impl AstNode for Pat { fn can_cast(kind: SyntaxKind) -> bool { match kind { - BIND_PAT | BOX_PAT | DOT_DOT_PAT | LITERAL_PAT | MACRO_PAT | OR_PAT | PAREN_PAT + IDENT_PAT | BOX_PAT | DOT_DOT_PAT | LITERAL_PAT | MACRO_PAT | OR_PAT | PAREN_PAT | PATH_PAT | WILDCARD_PAT | RANGE_PAT | RECORD_PAT | REF_PAT | SLICE_PAT | TUPLE_PAT | TUPLE_STRUCT_PAT => true, _ => false, @@ -3192,7 +3192,7 @@ impl AstNode for Pat { } fn cast(syntax: SyntaxNode) -> Option { let res = match syntax.kind() { - BIND_PAT => Pat::BindPat(BindPat { syntax }), + IDENT_PAT => Pat::IdentPat(IdentPat { syntax }), BOX_PAT => Pat::BoxPat(BoxPat { syntax }), DOT_DOT_PAT => Pat::DotDotPat(DotDotPat { syntax }), LITERAL_PAT => Pat::LiteralPat(LiteralPat { syntax }), @@ -3213,7 +3213,7 @@ impl AstNode for Pat { } fn syntax(&self) -> &SyntaxNode { match self { - Pat::BindPat(it) => &it.syntax, + Pat::IdentPat(it) => &it.syntax, Pat::BoxPat(it) => &it.syntax, Pat::DotDotPat(it) => &it.syntax, Pat::LiteralPat(it) => &it.syntax, @@ -3981,7 +3981,7 @@ impl std::fmt::Display for TypeBound { std::fmt::Display::fmt(self.syntax(), f) } } -impl std::fmt::Display for BindPat { +impl std::fmt::Display for IdentPat { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { std::fmt::Display::fmt(self.syntax(), f) } diff --git a/crates/ra_syntax/src/ast/make.rs b/crates/ra_syntax/src/ast/make.rs index efb2cb4a3..673777015 100644 --- a/crates/ra_syntax/src/ast/make.rs +++ b/crates/ra_syntax/src/ast/make.rs @@ -148,10 +148,10 @@ pub fn condition(expr: ast::Expr, pattern: Option) -> ast::Condition { } } -pub fn bind_pat(name: ast::Name) -> ast::BindPat { +pub fn bind_pat(name: ast::Name) -> ast::IdentPat { return from_text(name.text()); - fn from_text(text: &str) -> ast::BindPat { + fn from_text(text: &str) -> ast::IdentPat { ast_from_text(&format!("fn f({}: ())", text)) } } diff --git a/crates/ra_syntax/src/ast/node_ext.rs b/crates/ra_syntax/src/ast/node_ext.rs index 2cfdac225..4b4a72375 100644 --- a/crates/ra_syntax/src/ast/node_ext.rs +++ b/crates/ra_syntax/src/ast/node_ext.rs @@ -233,7 +233,7 @@ impl ast::RecordPatField { if let Some(name_ref) = self.name_ref() { return Some(NameOrNameRef::NameRef(name_ref)); } - if let Some(ast::Pat::BindPat(pat)) = self.pat() { + if let Some(ast::Pat::IdentPat(pat)) = self.pat() { let name = pat.name()?; return Some(NameOrNameRef::Name(name)); } @@ -294,13 +294,13 @@ impl ast::SlicePat { let prefix = args .peeking_take_while(|p| match p { ast::Pat::DotDotPat(_) => false, - ast::Pat::BindPat(bp) => match bp.pat() { + ast::Pat::IdentPat(bp) => match bp.pat() { Some(ast::Pat::DotDotPat(_)) => false, _ => true, }, ast::Pat::RefPat(rp) => match rp.pat() { Some(ast::Pat::DotDotPat(_)) => false, - Some(ast::Pat::BindPat(bp)) => match bp.pat() { + Some(ast::Pat::IdentPat(bp)) => match bp.pat() { Some(ast::Pat::DotDotPat(_)) => false, _ => true, }, diff --git a/crates/ra_syntax/test_data/parser/err/0012_broken_lambda.rast b/crates/ra_syntax/test_data/parser/err/0012_broken_lambda.rast index 307d9b31b..c131b79a7 100644 --- a/crates/ra_syntax/test_data/parser/err/0012_broken_lambda.rast +++ b/crates/ra_syntax/test_data/parser/err/0012_broken_lambda.rast @@ -34,7 +34,7 @@ SOURCE_FILE@0..389 PARAM_LIST@38..93 L_PAREN@38..39 PARAM@39..54 - BIND_PAT@39..46 + IDENT_PAT@39..46 NAME@39..46 IDENT@39..46 "builder" COLON@46..47 @@ -51,7 +51,7 @@ SOURCE_FILE@0..389 COMMA@54..55 WHITESPACE@55..56 PARAM@56..72 - BIND_PAT@56..62 + IDENT_PAT@56..62 NAME@56..62 IDENT@56..62 "tokens" COLON@62..63 @@ -69,7 +69,7 @@ SOURCE_FILE@0..389 COMMA@72..73 WHITESPACE@73..74 PARAM@74..92 - BIND_PAT@74..80 + IDENT_PAT@74..80 NAME@74..80 IDENT@74..80 "events" COLON@80..81 @@ -96,7 +96,7 @@ SOURCE_FILE@0..389 LET_STMT@100..125 LET_KW@100..103 WHITESPACE@103..104 - BIND_PAT@104..120 + IDENT_PAT@104..120 MUT_KW@104..107 WHITESPACE@107..108 NAME@108..120 @@ -111,7 +111,7 @@ SOURCE_FILE@0..389 LET_STMT@130..389 LET_KW@130..133 WHITESPACE@133..134 - BIND_PAT@134..140 + IDENT_PAT@134..140 NAME@134..140 IDENT@134..140 "eat_ws" WHITESPACE@140..141 @@ -121,7 +121,7 @@ SOURCE_FILE@0..389 PARAM_LIST@143..388 PIPE@143..144 PARAM@144..159 - BIND_PAT@144..147 + IDENT_PAT@144..147 NAME@144..147 IDENT@144..147 "idx" COLON@147..148 @@ -172,7 +172,7 @@ SOURCE_FILE@0..389 NAME_REF@188..192 IDENT@188..192 "Some" L_PAREN@192..193 - BIND_PAT@193..198 + IDENT_PAT@193..198 NAME@193..198 IDENT@193..198 "token" R_PAREN@198..199 @@ -185,7 +185,7 @@ SOURCE_FILE@0..389 err: `expected COMMA` WHITESPACE@201..202 PARAM@202..208 - BIND_PAT@202..208 + IDENT_PAT@202..208 NAME@202..208 IDENT@202..208 "tokens" err: `expected COMMA` @@ -205,7 +205,7 @@ SOURCE_FILE@0..389 ERROR@213..214 STAR@213..214 err: `expected COMMA` - BIND_PAT@214..217 + IDENT_PAT@214..217 NAME@214..217 IDENT@214..217 "idx" R_PAREN@217..218 @@ -229,7 +229,7 @@ SOURCE_FILE@0..389 BANG@236..237 err: `expected COMMA` PARAM@237..242 - BIND_PAT@237..242 + IDENT_PAT@237..242 NAME@237..242 IDENT@237..242 "token" err: `expected COMMA` @@ -239,7 +239,7 @@ SOURCE_FILE@0..389 DOT@242..243 err: `expected COMMA` PARAM@243..247 - BIND_PAT@243..247 + IDENT_PAT@243..247 NAME@243..247 IDENT@243..247 "kind" err: `expected COMMA` @@ -265,7 +265,7 @@ SOURCE_FILE@0..389 err: `expected COMMA` WHITESPACE@261..278 PARAM@278..283 - BIND_PAT@278..283 + IDENT_PAT@278..283 NAME@278..283 IDENT@278..283 "break" err: `expected COMMA` @@ -282,7 +282,7 @@ SOURCE_FILE@0..389 err: `expected COMMA` WHITESPACE@298..311 PARAM@311..318 - BIND_PAT@311..318 + IDENT_PAT@311..318 NAME@311..318 IDENT@311..318 "builder" err: `expected COMMA` @@ -298,7 +298,7 @@ SOURCE_FILE@0..389 NAME_REF@319..323 IDENT@319..323 "leaf" L_PAREN@323..324 - BIND_PAT@324..329 + IDENT_PAT@324..329 NAME@324..329 IDENT@324..329 "token" err: `expected COMMA` @@ -306,12 +306,12 @@ SOURCE_FILE@0..389 ERROR@329..330 DOT@329..330 err: `expected COMMA` - BIND_PAT@330..334 + IDENT_PAT@330..334 NAME@330..334 IDENT@330..334 "kind" COMMA@334..335 WHITESPACE@335..336 - BIND_PAT@336..341 + IDENT_PAT@336..341 NAME@336..341 IDENT@336..341 "token" err: `expected COMMA` @@ -319,7 +319,7 @@ SOURCE_FILE@0..389 ERROR@341..342 DOT@341..342 err: `expected COMMA` - BIND_PAT@342..345 + IDENT_PAT@342..345 NAME@342..345 IDENT@342..345 "len" R_PAREN@345..346 @@ -336,7 +336,7 @@ SOURCE_FILE@0..389 STAR@360..361 err: `expected COMMA` PARAM@361..364 - BIND_PAT@361..364 + IDENT_PAT@361..364 NAME@361..364 IDENT@361..364 "idx" err: `expected COMMA` diff --git a/crates/ra_syntax/test_data/parser/err/0017_incomplete_binexpr.rast b/crates/ra_syntax/test_data/parser/err/0017_incomplete_binexpr.rast index bb4a28f4e..fe094f61c 100644 --- a/crates/ra_syntax/test_data/parser/err/0017_incomplete_binexpr.rast +++ b/crates/ra_syntax/test_data/parser/err/0017_incomplete_binexpr.rast @@ -7,7 +7,7 @@ SOURCE_FILE@0..47 PARAM_LIST@6..16 L_PAREN@6..7 "(" PARAM@7..15 - BIND_PAT@7..10 + IDENT_PAT@7..10 NAME@7..10 IDENT@7..10 "foo" COLON@10..11 ":" @@ -25,7 +25,7 @@ SOURCE_FILE@0..47 LET_STMT@23..36 LET_KW@23..26 "let" WHITESPACE@26..27 " " - BIND_PAT@27..30 + IDENT_PAT@27..30 NAME@27..30 IDENT@27..30 "bar" WHITESPACE@30..31 " " diff --git a/crates/ra_syntax/test_data/parser/err/0018_incomplete_fn.rast b/crates/ra_syntax/test_data/parser/err/0018_incomplete_fn.rast index bc95b8512..72939fc98 100644 --- a/crates/ra_syntax/test_data/parser/err/0018_incomplete_fn.rast +++ b/crates/ra_syntax/test_data/parser/err/0018_incomplete_fn.rast @@ -38,7 +38,7 @@ SOURCE_FILE@0..183 LET_STMT@57..85 LET_KW@57..60 "let" WHITESPACE@60..61 " " - BIND_PAT@61..64 + IDENT_PAT@61..64 NAME@61..64 IDENT@61..64 "res" WHITESPACE@64..65 " " diff --git a/crates/ra_syntax/test_data/parser/err/0019_let_recover.rast b/crates/ra_syntax/test_data/parser/err/0019_let_recover.rast index f6fa964b7..72c05bd96 100644 --- a/crates/ra_syntax/test_data/parser/err/0019_let_recover.rast +++ b/crates/ra_syntax/test_data/parser/err/0019_let_recover.rast @@ -14,7 +14,7 @@ SOURCE_FILE@0..139 LET_STMT@15..24 LET_KW@15..18 "let" WHITESPACE@18..19 " " - BIND_PAT@19..22 + IDENT_PAT@19..22 NAME@19..22 IDENT@19..22 "foo" WHITESPACE@22..23 " " @@ -23,7 +23,7 @@ SOURCE_FILE@0..139 LET_STMT@29..41 LET_KW@29..32 "let" WHITESPACE@32..33 " " - BIND_PAT@33..36 + IDENT_PAT@33..36 NAME@33..36 IDENT@33..36 "bar" WHITESPACE@36..37 " " @@ -39,7 +39,7 @@ SOURCE_FILE@0..139 LET_STMT@54..67 LET_KW@54..57 "let" WHITESPACE@57..58 " " - BIND_PAT@58..61 + IDENT_PAT@58..61 NAME@58..61 IDENT@58..61 "baz" WHITESPACE@61..62 " " diff --git a/crates/ra_syntax/test_data/parser/err/0021_incomplete_param.rast b/crates/ra_syntax/test_data/parser/err/0021_incomplete_param.rast index ba4ce4795..b32845537 100644 --- a/crates/ra_syntax/test_data/parser/err/0021_incomplete_param.rast +++ b/crates/ra_syntax/test_data/parser/err/0021_incomplete_param.rast @@ -7,7 +7,7 @@ SOURCE_FILE@0..22 PARAM_LIST@6..17 L_PAREN@6..7 "(" PARAM@7..13 - BIND_PAT@7..8 + IDENT_PAT@7..8 NAME@7..8 IDENT@7..8 "x" COLON@8..9 ":" @@ -20,7 +20,7 @@ SOURCE_FILE@0..22 COMMA@13..14 "," WHITESPACE@14..15 " " PARAM@15..16 - BIND_PAT@15..16 + IDENT_PAT@15..16 NAME@15..16 IDENT@15..16 "y" R_PAREN@16..17 ")" diff --git a/crates/ra_syntax/test_data/parser/err/0025_nope.rast b/crates/ra_syntax/test_data/parser/err/0025_nope.rast index fca646557..83fc9fe77 100644 --- a/crates/ra_syntax/test_data/parser/err/0025_nope.rast +++ b/crates/ra_syntax/test_data/parser/err/0025_nope.rast @@ -69,7 +69,7 @@ SOURCE_FILE@0..575 LET_STMT@176..186 LET_KW@176..179 "let" WHITESPACE@179..180 " " - BIND_PAT@180..181 + IDENT_PAT@180..181 NAME@180..181 IDENT@180..181 "a" WHITESPACE@181..182 " " @@ -175,7 +175,7 @@ SOURCE_FILE@0..575 LET_STMT@491..510 LET_KW@491..494 "let" WHITESPACE@494..495 " " - BIND_PAT@495..505 + IDENT_PAT@495..505 NAME@495..505 IDENT@495..505 "bad_syntax" WHITESPACE@505..506 " " diff --git a/crates/ra_syntax/test_data/parser/err/0029_field_completion.rast b/crates/ra_syntax/test_data/parser/err/0029_field_completion.rast index bfcd0149e..c6402cdd8 100644 --- a/crates/ra_syntax/test_data/parser/err/0029_field_completion.rast +++ b/crates/ra_syntax/test_data/parser/err/0029_field_completion.rast @@ -7,7 +7,7 @@ SOURCE_FILE@0..24 PARAM_LIST@6..12 L_PAREN@6..7 "(" PARAM@7..11 - BIND_PAT@7..8 + IDENT_PAT@7..8 NAME@7..8 IDENT@7..8 "a" COLON@8..9 ":" diff --git a/crates/ra_syntax/test_data/parser/err/0031_block_inner_attrs.rast b/crates/ra_syntax/test_data/parser/err/0031_block_inner_attrs.rast index 55ff3943f..a443b37db 100644 --- a/crates/ra_syntax/test_data/parser/err/0031_block_inner_attrs.rast +++ b/crates/ra_syntax/test_data/parser/err/0031_block_inner_attrs.rast @@ -14,7 +14,7 @@ SOURCE_FILE@0..350 LET_STMT@17..129 LET_KW@17..20 "let" WHITESPACE@20..21 " " - BIND_PAT@21..26 + IDENT_PAT@21..26 NAME@21..26 IDENT@21..26 "inner" WHITESPACE@26..27 " " diff --git a/crates/ra_syntax/test_data/parser/err/0034_bad_box_pattern.rast b/crates/ra_syntax/test_data/parser/err/0034_bad_box_pattern.rast index 303a49576..d9d49bfb5 100644 --- a/crates/ra_syntax/test_data/parser/err/0034_bad_box_pattern.rast +++ b/crates/ra_syntax/test_data/parser/err/0034_bad_box_pattern.rast @@ -14,7 +14,7 @@ SOURCE_FILE@0..91 LET_STMT@16..27 LET_KW@16..19 "let" WHITESPACE@19..20 " " - BIND_PAT@20..27 + IDENT_PAT@20..27 REF_KW@20..23 "ref" WHITESPACE@23..24 " " ERROR@24..27 @@ -38,7 +38,7 @@ SOURCE_FILE@0..91 LET_STMT@40..51 LET_KW@40..43 "let" WHITESPACE@43..44 " " - BIND_PAT@44..51 + IDENT_PAT@44..51 MUT_KW@44..47 "mut" WHITESPACE@47..48 " " ERROR@48..51 @@ -62,7 +62,7 @@ SOURCE_FILE@0..91 LET_STMT@64..79 LET_KW@64..67 "let" WHITESPACE@67..68 " " - BIND_PAT@68..79 + IDENT_PAT@68..79 REF_KW@68..71 "ref" WHITESPACE@71..72 " " MUT_KW@72..75 "mut" diff --git a/crates/ra_syntax/test_data/parser/err/0039_lambda_recovery.rast b/crates/ra_syntax/test_data/parser/err/0039_lambda_recovery.rast index 7a5e115bc..a9c5b70fd 100644 --- a/crates/ra_syntax/test_data/parser/err/0039_lambda_recovery.rast +++ b/crates/ra_syntax/test_data/parser/err/0039_lambda_recovery.rast @@ -53,7 +53,7 @@ SOURCE_FILE@0..83 PARAM_LIST@52..56 PIPE@52..53 "|" PARAM@53..55 - BIND_PAT@53..55 + IDENT_PAT@53..55 NAME@53..55 IDENT@53..55 "it" PIPE@55..56 "|" diff --git a/crates/ra_syntax/test_data/parser/fragments/pattern/ok/0000_enum.rast b/crates/ra_syntax/test_data/parser/fragments/pattern/ok/0000_enum.rast index 15eb7f9c6..dcf102339 100644 --- a/crates/ra_syntax/test_data/parser/fragments/pattern/ok/0000_enum.rast +++ b/crates/ra_syntax/test_data/parser/fragments/pattern/ok/0000_enum.rast @@ -4,7 +4,7 @@ TUPLE_STRUCT_PAT@0..7 NAME_REF@0..4 IDENT@0..4 "Some" L_PAREN@4..5 "(" - BIND_PAT@5..6 + IDENT_PAT@5..6 NAME@5..6 IDENT@5..6 "x" R_PAREN@6..7 ")" diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0006_self_param.rast b/crates/ra_syntax/test_data/parser/inline/ok/0006_self_param.rast index ae61cbad8..d24ad7423 100644 --- a/crates/ra_syntax/test_data/parser/inline/ok/0006_self_param.rast +++ b/crates/ra_syntax/test_data/parser/inline/ok/0006_self_param.rast @@ -79,7 +79,7 @@ SOURCE_FILE@0..128 COMMA@91..92 "," WHITESPACE@92..93 " " PARAM@93..99 - BIND_PAT@93..94 + IDENT_PAT@93..94 NAME@93..94 IDENT@93..94 "x" COLON@94..95 ":" diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0024_slice_pat.rast b/crates/ra_syntax/test_data/parser/inline/ok/0024_slice_pat.rast index dea0c73f7..66f906fae 100644 --- a/crates/ra_syntax/test_data/parser/inline/ok/0024_slice_pat.rast +++ b/crates/ra_syntax/test_data/parser/inline/ok/0024_slice_pat.rast @@ -16,12 +16,12 @@ SOURCE_FILE@0..39 WHITESPACE@19..20 " " SLICE_PAT@20..30 L_BRACK@20..21 "[" - BIND_PAT@21..22 + IDENT_PAT@21..22 NAME@21..22 IDENT@21..22 "a" COMMA@22..23 "," WHITESPACE@23..24 " " - BIND_PAT@24..25 + IDENT_PAT@24..25 NAME@24..25 IDENT@24..25 "b" COMMA@25..26 "," diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0026_tuple_pat_fields.rast b/crates/ra_syntax/test_data/parser/inline/ok/0026_tuple_pat_fields.rast index 45d17e800..e049e4df7 100644 --- a/crates/ra_syntax/test_data/parser/inline/ok/0026_tuple_pat_fields.rast +++ b/crates/ra_syntax/test_data/parser/inline/ok/0026_tuple_pat_fields.rast @@ -88,7 +88,7 @@ SOURCE_FILE@0..97 WHITESPACE@83..84 " " COMMA@84..85 "," WHITESPACE@85..86 " " - BIND_PAT@86..87 + IDENT_PAT@86..87 NAME@86..87 IDENT@86..87 "x" R_PAREN@87..88 ")" diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0027_ref_pat.rast b/crates/ra_syntax/test_data/parser/inline/ok/0027_ref_pat.rast index 9e76d881e..348b54dc9 100644 --- a/crates/ra_syntax/test_data/parser/inline/ok/0027_ref_pat.rast +++ b/crates/ra_syntax/test_data/parser/inline/ok/0027_ref_pat.rast @@ -16,7 +16,7 @@ SOURCE_FILE@0..52 WHITESPACE@19..20 " " REF_PAT@20..22 AMP@20..21 "&" - BIND_PAT@21..22 + IDENT_PAT@21..22 NAME@21..22 IDENT@21..22 "a" WHITESPACE@22..23 " " @@ -34,7 +34,7 @@ SOURCE_FILE@0..52 AMP@37..38 "&" MUT_KW@38..41 "mut" WHITESPACE@41..42 " " - BIND_PAT@42..43 + IDENT_PAT@42..43 NAME@42..43 IDENT@42..43 "b" WHITESPACE@43..44 " " diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0031_while_expr.rast b/crates/ra_syntax/test_data/parser/inline/ok/0031_while_expr.rast index ffe1a3a01..173cecf6d 100644 --- a/crates/ra_syntax/test_data/parser/inline/ok/0031_while_expr.rast +++ b/crates/ra_syntax/test_data/parser/inline/ok/0031_while_expr.rast @@ -37,7 +37,7 @@ SOURCE_FILE@0..93 NAME_REF@44..48 IDENT@44..48 "Some" L_PAREN@48..49 "(" - BIND_PAT@49..50 + IDENT_PAT@49..50 NAME@49..50 IDENT@49..50 "x" R_PAREN@50..51 ")" diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0066_match_arm.rast b/crates/ra_syntax/test_data/parser/inline/ok/0066_match_arm.rast index d873a7ecb..57d0661a5 100644 --- a/crates/ra_syntax/test_data/parser/inline/ok/0066_match_arm.rast +++ b/crates/ra_syntax/test_data/parser/inline/ok/0066_match_arm.rast @@ -74,13 +74,13 @@ SOURCE_FILE@0..167 WHITESPACE@84..93 "\n " MATCH_ARM@93..109 OR_PAT@93..98 - BIND_PAT@93..94 + IDENT_PAT@93..94 NAME@93..94 IDENT@93..94 "X" WHITESPACE@94..95 " " PIPE@95..96 "|" WHITESPACE@96..97 " " - BIND_PAT@97..98 + IDENT_PAT@97..98 NAME@97..98 IDENT@97..98 "Y" WHITESPACE@98..99 " " @@ -104,13 +104,13 @@ SOURCE_FILE@0..167 PIPE@119..120 "|" WHITESPACE@120..121 " " OR_PAT@121..126 - BIND_PAT@121..122 + IDENT_PAT@121..122 NAME@121..122 IDENT@121..122 "X" WHITESPACE@122..123 " " PIPE@123..124 "|" WHITESPACE@124..125 " " - BIND_PAT@125..126 + IDENT_PAT@125..126 NAME@125..126 IDENT@125..126 "Y" WHITESPACE@126..127 " " @@ -133,7 +133,7 @@ SOURCE_FILE@0..167 MATCH_ARM@147..156 PIPE@147..148 "|" WHITESPACE@148..149 " " - BIND_PAT@149..150 + IDENT_PAT@149..150 NAME@149..150 IDENT@149..150 "X" WHITESPACE@150..151 " " diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0080_postfix_range.rast b/crates/ra_syntax/test_data/parser/inline/ok/0080_postfix_range.rast index 0c19d29c6..b3003577c 100644 --- a/crates/ra_syntax/test_data/parser/inline/ok/0080_postfix_range.rast +++ b/crates/ra_syntax/test_data/parser/inline/ok/0080_postfix_range.rast @@ -14,7 +14,7 @@ SOURCE_FILE@0..89 LET_STMT@15..27 LET_KW@15..18 "let" WHITESPACE@18..19 " " - BIND_PAT@19..20 + IDENT_PAT@19..20 NAME@19..20 IDENT@19..20 "x" WHITESPACE@20..21 " " diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0088_break_ambiguity.rast b/crates/ra_syntax/test_data/parser/inline/ok/0088_break_ambiguity.rast index 34f520994..f7b839303 100644 --- a/crates/ra_syntax/test_data/parser/inline/ok/0088_break_ambiguity.rast +++ b/crates/ra_syntax/test_data/parser/inline/ok/0088_break_ambiguity.rast @@ -38,7 +38,7 @@ SOURCE_FILE@0..88 FOR_EXPR@49..66 FOR_KW@49..52 "for" WHITESPACE@52..53 " " - BIND_PAT@53..54 + IDENT_PAT@53..54 NAME@53..54 IDENT@53..54 "i" WHITESPACE@54..55 " " diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0099_param_list.rast b/crates/ra_syntax/test_data/parser/inline/ok/0099_param_list.rast index 1627556c8..f19e9fd52 100644 --- a/crates/ra_syntax/test_data/parser/inline/ok/0099_param_list.rast +++ b/crates/ra_syntax/test_data/parser/inline/ok/0099_param_list.rast @@ -20,7 +20,7 @@ SOURCE_FILE@0..67 PARAM_LIST@14..22 L_PAREN@14..15 "(" PARAM@15..21 - BIND_PAT@15..16 + IDENT_PAT@15..16 NAME@15..16 IDENT@15..16 "x" COLON@16..17 ":" @@ -44,7 +44,7 @@ SOURCE_FILE@0..67 PARAM_LIST@30..40 L_PAREN@30..31 "(" PARAM@31..37 - BIND_PAT@31..32 + IDENT_PAT@31..32 NAME@31..32 IDENT@31..32 "x" COLON@32..33 ":" @@ -70,7 +70,7 @@ SOURCE_FILE@0..67 PARAM_LIST@48..63 L_PAREN@48..49 "(" PARAM@49..55 - BIND_PAT@49..50 + IDENT_PAT@49..50 NAME@49..50 IDENT@49..50 "x" COLON@50..51 ":" @@ -83,7 +83,7 @@ SOURCE_FILE@0..67 COMMA@55..56 "," WHITESPACE@56..57 " " PARAM@57..62 - BIND_PAT@57..58 + IDENT_PAT@57..58 NAME@57..58 IDENT@57..58 "y" COLON@58..59 ":" diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0100_for_expr.rast b/crates/ra_syntax/test_data/parser/inline/ok/0100_for_expr.rast index 766de4efe..5c4055e44 100644 --- a/crates/ra_syntax/test_data/parser/inline/ok/0100_for_expr.rast +++ b/crates/ra_syntax/test_data/parser/inline/ok/0100_for_expr.rast @@ -15,7 +15,7 @@ SOURCE_FILE@0..33 FOR_EXPR@15..29 FOR_KW@15..18 "for" WHITESPACE@18..19 " " - BIND_PAT@19..20 + IDENT_PAT@19..20 NAME@19..20 IDENT@19..20 "x" WHITESPACE@20..21 " " diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0102_record_field_pat_list.rast b/crates/ra_syntax/test_data/parser/inline/ok/0102_record_field_pat_list.rast index d0f70e9d7..866e60ed8 100644 --- a/crates/ra_syntax/test_data/parser/inline/ok/0102_record_field_pat_list.rast +++ b/crates/ra_syntax/test_data/parser/inline/ok/0102_record_field_pat_list.rast @@ -44,13 +44,13 @@ SOURCE_FILE@0..119 L_CURLY@40..41 "{" WHITESPACE@41..42 " " RECORD_PAT_FIELD@42..43 - BIND_PAT@42..43 + IDENT_PAT@42..43 NAME@42..43 IDENT@42..43 "f" COMMA@43..44 "," WHITESPACE@44..45 " " RECORD_PAT_FIELD@45..54 - BIND_PAT@45..54 + IDENT_PAT@45..54 REF_KW@45..48 "ref" WHITESPACE@48..49 " " MUT_KW@49..52 "mut" diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0106_lambda_expr.rast b/crates/ra_syntax/test_data/parser/inline/ok/0106_lambda_expr.rast index a80d79563..9b8381619 100644 --- a/crates/ra_syntax/test_data/parser/inline/ok/0106_lambda_expr.rast +++ b/crates/ra_syntax/test_data/parser/inline/ok/0106_lambda_expr.rast @@ -51,7 +51,7 @@ SOURCE_FILE@0..134 PARAM_LIST@48..51 PIPE@48..49 "|" PARAM@49..50 - BIND_PAT@49..50 + IDENT_PAT@49..50 NAME@49..50 IDENT@49..50 "x" PIPE@50..51 "|" @@ -70,7 +70,7 @@ SOURCE_FILE@0..134 PARAM_LIST@64..73 PIPE@64..65 "|" PARAM@65..71 - BIND_PAT@65..66 + IDENT_PAT@65..66 NAME@65..66 IDENT@65..66 "x" COLON@66..67 ":" diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0109_label.rast b/crates/ra_syntax/test_data/parser/inline/ok/0109_label.rast index a6a169f1b..c9588025c 100644 --- a/crates/ra_syntax/test_data/parser/inline/ok/0109_label.rast +++ b/crates/ra_syntax/test_data/parser/inline/ok/0109_label.rast @@ -46,7 +46,7 @@ SOURCE_FILE@0..74 WHITESPACE@56..57 " " FOR_KW@57..60 "for" WHITESPACE@60..61 " " - BIND_PAT@61..62 + IDENT_PAT@61..62 NAME@61..62 IDENT@61..62 "x" WHITESPACE@62..63 " " diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0111_tuple_pat.rast b/crates/ra_syntax/test_data/parser/inline/ok/0111_tuple_pat.rast index 432318da0..f94a2ebde 100644 --- a/crates/ra_syntax/test_data/parser/inline/ok/0111_tuple_pat.rast +++ b/crates/ra_syntax/test_data/parser/inline/ok/0111_tuple_pat.rast @@ -16,12 +16,12 @@ SOURCE_FILE@0..94 WHITESPACE@19..20 " " TUPLE_PAT@20..30 L_PAREN@20..21 "(" - BIND_PAT@21..22 + IDENT_PAT@21..22 NAME@21..22 IDENT@21..22 "a" COMMA@22..23 "," WHITESPACE@23..24 " " - BIND_PAT@24..25 + IDENT_PAT@24..25 NAME@24..25 IDENT@24..25 "b" COMMA@25..26 "," @@ -42,7 +42,7 @@ SOURCE_FILE@0..94 WHITESPACE@44..45 " " TUPLE_PAT@45..49 L_PAREN@45..46 "(" - BIND_PAT@46..47 + IDENT_PAT@46..47 NAME@46..47 IDENT@46..47 "a" COMMA@47..48 "," diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0112_bind_pat.rast b/crates/ra_syntax/test_data/parser/inline/ok/0112_bind_pat.rast index 65d5944c0..7b9a498c8 100644 --- a/crates/ra_syntax/test_data/parser/inline/ok/0112_bind_pat.rast +++ b/crates/ra_syntax/test_data/parser/inline/ok/0112_bind_pat.rast @@ -14,7 +14,7 @@ SOURCE_FILE@0..146 LET_STMT@16..27 LET_KW@16..19 "let" WHITESPACE@19..20 " " - BIND_PAT@20..21 + IDENT_PAT@20..21 NAME@20..21 IDENT@20..21 "a" WHITESPACE@21..22 " " @@ -28,7 +28,7 @@ SOURCE_FILE@0..146 LET_STMT@32..47 LET_KW@32..35 "let" WHITESPACE@35..36 " " - BIND_PAT@36..41 + IDENT_PAT@36..41 MUT_KW@36..39 "mut" WHITESPACE@39..40 " " NAME@40..41 @@ -44,7 +44,7 @@ SOURCE_FILE@0..146 LET_STMT@52..67 LET_KW@52..55 "let" WHITESPACE@55..56 " " - BIND_PAT@56..61 + IDENT_PAT@56..61 REF_KW@56..59 "ref" WHITESPACE@59..60 " " NAME@60..61 @@ -60,7 +60,7 @@ SOURCE_FILE@0..146 LET_STMT@72..91 LET_KW@72..75 "let" WHITESPACE@75..76 " " - BIND_PAT@76..85 + IDENT_PAT@76..85 REF_KW@76..79 "ref" WHITESPACE@79..80 " " MUT_KW@80..83 "mut" @@ -78,7 +78,7 @@ SOURCE_FILE@0..146 LET_STMT@96..111 LET_KW@96..99 "let" WHITESPACE@99..100 " " - BIND_PAT@100..105 + IDENT_PAT@100..105 NAME@100..101 IDENT@100..101 "e" WHITESPACE@101..102 " " @@ -97,7 +97,7 @@ SOURCE_FILE@0..146 LET_STMT@116..143 LET_KW@116..119 "let" WHITESPACE@119..120 " " - BIND_PAT@120..137 + IDENT_PAT@120..137 REF_KW@120..123 "ref" WHITESPACE@123..124 " " MUT_KW@124..127 "mut" @@ -107,7 +107,7 @@ SOURCE_FILE@0..146 WHITESPACE@129..130 " " AT@130..131 "@" WHITESPACE@131..132 " " - BIND_PAT@132..137 + IDENT_PAT@132..137 NAME@132..133 IDENT@132..133 "g" WHITESPACE@133..134 " " diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0123_param_list_vararg.rast b/crates/ra_syntax/test_data/parser/inline/ok/0123_param_list_vararg.rast index f155743cf..27c4f141f 100644 --- a/crates/ra_syntax/test_data/parser/inline/ok/0123_param_list_vararg.rast +++ b/crates/ra_syntax/test_data/parser/inline/ok/0123_param_list_vararg.rast @@ -16,7 +16,7 @@ SOURCE_FILE@0..57 PARAM_LIST@22..46 L_PAREN@22..23 "(" PARAM@23..40 - BIND_PAT@23..29 + IDENT_PAT@23..29 NAME@23..29 IDENT@23..29 "format" COLON@29..30 ":" diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0130_let_stmt.rast b/crates/ra_syntax/test_data/parser/inline/ok/0130_let_stmt.rast index 16d616bd4..4c07cefa6 100644 --- a/crates/ra_syntax/test_data/parser/inline/ok/0130_let_stmt.rast +++ b/crates/ra_syntax/test_data/parser/inline/ok/0130_let_stmt.rast @@ -14,7 +14,7 @@ SOURCE_FILE@0..135 LET_STMT@15..21 LET_KW@15..18 "let" WHITESPACE@18..19 " " - BIND_PAT@19..20 + IDENT_PAT@19..20 NAME@19..20 IDENT@19..20 "a" SEMICOLON@20..21 ";" @@ -22,7 +22,7 @@ SOURCE_FILE@0..135 LET_STMT@26..37 LET_KW@26..29 "let" WHITESPACE@29..30 " " - BIND_PAT@30..31 + IDENT_PAT@30..31 NAME@30..31 IDENT@30..31 "b" COLON@31..32 ":" @@ -37,7 +37,7 @@ SOURCE_FILE@0..135 LET_STMT@42..53 LET_KW@42..45 "let" WHITESPACE@45..46 " " - BIND_PAT@46..47 + IDENT_PAT@46..47 NAME@46..47 IDENT@46..47 "c" WHITESPACE@47..48 " " @@ -50,7 +50,7 @@ SOURCE_FILE@0..135 LET_STMT@58..74 LET_KW@58..61 "let" WHITESPACE@61..62 " " - BIND_PAT@62..63 + IDENT_PAT@62..63 NAME@62..63 IDENT@62..63 "d" COLON@63..64 ":" @@ -70,7 +70,7 @@ SOURCE_FILE@0..135 LET_STMT@79..88 LET_KW@79..82 "let" WHITESPACE@82..83 " " - BIND_PAT@83..84 + IDENT_PAT@83..84 NAME@83..84 IDENT@83..84 "e" COLON@84..85 ":" @@ -99,7 +99,7 @@ SOURCE_FILE@0..135 LET_STMT@112..132 LET_KW@112..115 "let" WHITESPACE@115..116 " " - BIND_PAT@116..117 + IDENT_PAT@116..117 NAME@116..117 IDENT@116..117 "f" WHITESPACE@117..118 " " diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0132_box_expr.rast b/crates/ra_syntax/test_data/parser/inline/ok/0132_box_expr.rast index 48f483813..c55038247 100644 --- a/crates/ra_syntax/test_data/parser/inline/ok/0132_box_expr.rast +++ b/crates/ra_syntax/test_data/parser/inline/ok/0132_box_expr.rast @@ -14,7 +14,7 @@ SOURCE_FILE@0..106 LET_STMT@15..32 LET_KW@15..18 "let" WHITESPACE@18..19 " " - BIND_PAT@19..20 + IDENT_PAT@19..20 NAME@19..20 IDENT@19..20 "x" WHITESPACE@20..21 " " @@ -30,7 +30,7 @@ SOURCE_FILE@0..106 LET_STMT@37..66 LET_KW@37..40 "let" WHITESPACE@40..41 " " - BIND_PAT@41..42 + IDENT_PAT@41..42 NAME@41..42 IDENT@41..42 "y" WHITESPACE@42..43 " " @@ -56,7 +56,7 @@ SOURCE_FILE@0..106 LET_STMT@71..103 LET_KW@71..74 "let" WHITESPACE@74..75 " " - BIND_PAT@75..76 + IDENT_PAT@75..76 NAME@75..76 IDENT@75..76 "z" WHITESPACE@76..77 " " diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0138_associated_type_bounds.rast b/crates/ra_syntax/test_data/parser/inline/ok/0138_associated_type_bounds.rast index e0a82df75..3870ec135 100644 --- a/crates/ra_syntax/test_data/parser/inline/ok/0138_associated_type_bounds.rast +++ b/crates/ra_syntax/test_data/parser/inline/ok/0138_associated_type_bounds.rast @@ -37,7 +37,7 @@ SOURCE_FILE@0..59 PARAM_LIST@40..55 L_PAREN@40..41 "(" PARAM@41..54 - BIND_PAT@41..51 + IDENT_PAT@41..51 NAME@41..51 IDENT@41..51 "printables" COLON@51..52 ":" diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0138_expression_after_block.rast b/crates/ra_syntax/test_data/parser/inline/ok/0138_expression_after_block.rast index a7f87c020..f7c0e0ab0 100644 --- a/crates/ra_syntax/test_data/parser/inline/ok/0138_expression_after_block.rast +++ b/crates/ra_syntax/test_data/parser/inline/ok/0138_expression_after_block.rast @@ -14,7 +14,7 @@ SOURCE_FILE@0..52 LET_STMT@14..34 LET_KW@14..17 "let" WHITESPACE@17..18 " " - BIND_PAT@18..23 + IDENT_PAT@18..23 MUT_KW@18..21 "mut" WHITESPACE@21..22 " " NAME@22..23 diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0139_param_outer_arg.rast b/crates/ra_syntax/test_data/parser/inline/ok/0139_param_outer_arg.rast index 36fd2997b..495e4c51b 100644 --- a/crates/ra_syntax/test_data/parser/inline/ok/0139_param_outer_arg.rast +++ b/crates/ra_syntax/test_data/parser/inline/ok/0139_param_outer_arg.rast @@ -16,7 +16,7 @@ SOURCE_FILE@0..28 R_BRACK@12..13 "]" WHITESPACE@13..14 " " PARAM@14..23 - BIND_PAT@14..17 + IDENT_PAT@14..17 NAME@14..17 IDENT@14..17 "pat" COLON@17..18 ":" diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0142_for_range_from.rast b/crates/ra_syntax/test_data/parser/inline/ok/0142_for_range_from.rast index d11019076..36e448c94 100644 --- a/crates/ra_syntax/test_data/parser/inline/ok/0142_for_range_from.rast +++ b/crates/ra_syntax/test_data/parser/inline/ok/0142_for_range_from.rast @@ -14,7 +14,7 @@ SOURCE_FILE@0..51 FOR_EXPR@14..48 FOR_KW@14..17 "for" WHITESPACE@17..18 " " - BIND_PAT@18..19 + IDENT_PAT@18..19 NAME@18..19 IDENT@18..19 "x" WHITESPACE@19..20 " " diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0143_box_pat.rast b/crates/ra_syntax/test_data/parser/inline/ok/0143_box_pat.rast index caae3e2dc..65887b962 100644 --- a/crates/ra_syntax/test_data/parser/inline/ok/0143_box_pat.rast +++ b/crates/ra_syntax/test_data/parser/inline/ok/0143_box_pat.rast @@ -17,7 +17,7 @@ SOURCE_FILE@0..118 BOX_PAT@20..25 BOX_KW@20..23 "box" WHITESPACE@23..24 " " - BIND_PAT@24..25 + IDENT_PAT@24..25 NAME@24..25 IDENT@24..25 "i" WHITESPACE@25..26 " " @@ -47,7 +47,7 @@ SOURCE_FILE@0..118 BOX_PAT@52..57 BOX_KW@52..55 "box" WHITESPACE@55..56 " " - BIND_PAT@56..57 + IDENT_PAT@56..57 NAME@56..57 IDENT@56..57 "i" COMMA@57..58 "," @@ -71,7 +71,7 @@ SOURCE_FILE@0..118 WHITESPACE@75..76 " " REF_PAT@76..78 AMP@76..77 "&" - BIND_PAT@77..78 + IDENT_PAT@77..78 NAME@77..78 IDENT@77..78 "x" R_PAREN@78..79 ")" @@ -91,7 +91,7 @@ SOURCE_FILE@0..118 BOX_PAT@96..109 BOX_KW@96..99 "box" WHITESPACE@99..100 " " - BIND_PAT@100..109 + IDENT_PAT@100..109 REF_KW@100..103 "ref" WHITESPACE@103..104 " " MUT_KW@104..107 "mut" diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0144_dot_dot_pat.rast b/crates/ra_syntax/test_data/parser/inline/ok/0144_dot_dot_pat.rast index 8d0f1ead5..8fb0db031 100644 --- a/crates/ra_syntax/test_data/parser/inline/ok/0144_dot_dot_pat.rast +++ b/crates/ra_syntax/test_data/parser/inline/ok/0144_dot_dot_pat.rast @@ -35,7 +35,7 @@ SOURCE_FILE@0..555 WHITESPACE@64..65 " " TUPLE_PAT@65..72 L_PAREN@65..66 "(" - BIND_PAT@66..67 + IDENT_PAT@66..67 NAME@66..67 IDENT@66..67 "a" COMMA@67..68 "," @@ -56,7 +56,7 @@ SOURCE_FILE@0..555 WHITESPACE@86..87 " " TUPLE_PAT@87..95 L_PAREN@87..88 "(" - BIND_PAT@88..89 + IDENT_PAT@88..89 NAME@88..89 IDENT@88..89 "a" COMMA@89..90 "," @@ -82,7 +82,7 @@ SOURCE_FILE@0..555 NAME_REF@110..115 IDENT@110..115 "Tuple" L_PAREN@115..116 "(" - BIND_PAT@116..117 + IDENT_PAT@116..117 NAME@116..117 IDENT@116..117 "a" COMMA@117..118 "," @@ -107,7 +107,7 @@ SOURCE_FILE@0..555 NAME_REF@137..142 IDENT@137..142 "Tuple" L_PAREN@142..143 "(" - BIND_PAT@143..144 + IDENT_PAT@143..144 NAME@143..144 IDENT@143..144 "a" COMMA@144..145 "," @@ -177,7 +177,7 @@ SOURCE_FILE@0..555 DOT2@217..219 ".." COMMA@219..220 "," WHITESPACE@220..221 " " - BIND_PAT@221..222 + IDENT_PAT@221..222 NAME@221..222 IDENT@221..222 "a" COMMA@222..223 "," @@ -206,7 +206,7 @@ SOURCE_FILE@0..555 DOT2@248..250 ".." COMMA@250..251 "," WHITESPACE@251..252 " " - BIND_PAT@252..253 + IDENT_PAT@252..253 NAME@252..253 IDENT@252..253 "a" COMMA@253..254 "," @@ -249,7 +249,7 @@ SOURCE_FILE@0..555 WHITESPACE@319..320 " " SLICE_PAT@320..330 L_BRACK@320..321 "[" - BIND_PAT@321..325 + IDENT_PAT@321..325 NAME@321..325 IDENT@321..325 "head" COMMA@325..326 "," @@ -270,12 +270,12 @@ SOURCE_FILE@0..555 WHITESPACE@344..345 " " SLICE_PAT@345..362 L_BRACK@345..346 "[" - BIND_PAT@346..350 + IDENT_PAT@346..350 NAME@346..350 IDENT@346..350 "head" COMMA@350..351 "," WHITESPACE@351..352 " " - BIND_PAT@352..361 + IDENT_PAT@352..361 NAME@352..356 IDENT@352..356 "tail" WHITESPACE@356..357 " " @@ -297,7 +297,7 @@ SOURCE_FILE@0..555 WHITESPACE@376..377 " " SLICE_PAT@377..393 L_BRACK@377..378 "[" - BIND_PAT@378..382 + IDENT_PAT@378..382 NAME@378..382 IDENT@378..382 "head" COMMA@382..383 "," @@ -306,7 +306,7 @@ SOURCE_FILE@0..555 DOT2@384..386 ".." COMMA@386..387 "," WHITESPACE@387..388 " " - BIND_PAT@388..392 + IDENT_PAT@388..392 NAME@388..392 IDENT@388..392 "cons" R_BRACK@392..393 "]" @@ -323,12 +323,12 @@ SOURCE_FILE@0..555 WHITESPACE@407..408 " " SLICE_PAT@408..430 L_BRACK@408..409 "[" - BIND_PAT@409..413 + IDENT_PAT@409..413 NAME@409..413 IDENT@409..413 "head" COMMA@413..414 "," WHITESPACE@414..415 " " - BIND_PAT@415..423 + IDENT_PAT@415..423 NAME@415..418 IDENT@415..418 "mid" WHITESPACE@418..419 " " @@ -338,7 +338,7 @@ SOURCE_FILE@0..555 DOT2@421..423 ".." COMMA@423..424 "," WHITESPACE@424..425 " " - BIND_PAT@425..429 + IDENT_PAT@425..429 NAME@425..429 IDENT@425..429 "cons" R_BRACK@429..430 "]" @@ -355,7 +355,7 @@ SOURCE_FILE@0..555 WHITESPACE@444..445 " " SLICE_PAT@445..465 L_BRACK@445..446 "[" - BIND_PAT@446..450 + IDENT_PAT@446..450 NAME@446..450 IDENT@446..450 "head" COMMA@450..451 "," @@ -368,7 +368,7 @@ SOURCE_FILE@0..555 DOT2@456..458 ".." COMMA@458..459 "," WHITESPACE@459..460 " " - BIND_PAT@460..464 + IDENT_PAT@460..464 NAME@460..464 IDENT@460..464 "cons" R_BRACK@464..465 "]" @@ -385,7 +385,7 @@ SOURCE_FILE@0..555 WHITESPACE@479..480 " " SLICE_PAT@480..506 L_BRACK@480..481 "[" - BIND_PAT@481..485 + IDENT_PAT@481..485 NAME@481..485 IDENT@481..485 "head" COMMA@485..486 "," @@ -394,12 +394,12 @@ SOURCE_FILE@0..555 DOT2@487..489 ".." COMMA@489..490 "," WHITESPACE@490..491 " " - BIND_PAT@491..494 + IDENT_PAT@491..494 NAME@491..494 IDENT@491..494 "mid" COMMA@494..495 "," WHITESPACE@495..496 " " - BIND_PAT@496..505 + IDENT_PAT@496..505 NAME@496..500 IDENT@496..500 "tail" WHITESPACE@500..501 " " @@ -421,7 +421,7 @@ SOURCE_FILE@0..555 WHITESPACE@520..521 " " SLICE_PAT@521..546 L_BRACK@521..522 "[" - BIND_PAT@522..526 + IDENT_PAT@522..526 NAME@522..526 IDENT@522..526 "head" COMMA@526..527 "," @@ -430,7 +430,7 @@ SOURCE_FILE@0..555 DOT2@528..530 ".." COMMA@530..531 "," WHITESPACE@531..532 " " - BIND_PAT@532..535 + IDENT_PAT@532..535 NAME@532..535 IDENT@532..535 "mid" COMMA@535..536 "," @@ -439,7 +439,7 @@ SOURCE_FILE@0..555 DOT2@537..539 ".." COMMA@539..540 "," WHITESPACE@540..541 " " - BIND_PAT@541..545 + IDENT_PAT@541..545 NAME@541..545 IDENT@541..545 "cons" R_BRACK@545..546 "]" diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0154_fn_pointer_param_ident_path.rast b/crates/ra_syntax/test_data/parser/inline/ok/0154_fn_pointer_param_ident_path.rast index 69b4d73d7..c48fed03e 100644 --- a/crates/ra_syntax/test_data/parser/inline/ok/0154_fn_pointer_param_ident_path.rast +++ b/crates/ra_syntax/test_data/parser/inline/ok/0154_fn_pointer_param_ident_path.rast @@ -38,7 +38,7 @@ SOURCE_FILE@0..55 PARAM_LIST@38..53 L_PAREN@38..39 "(" PARAM@39..52 - BIND_PAT@39..42 + IDENT_PAT@39..42 NAME@39..42 IDENT@39..42 "baz" COLON@42..43 ":" diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0155_closure_params.rast b/crates/ra_syntax/test_data/parser/inline/ok/0155_closure_params.rast index 0a9f7c137..31671b420 100644 --- a/crates/ra_syntax/test_data/parser/inline/ok/0155_closure_params.rast +++ b/crates/ra_syntax/test_data/parser/inline/ok/0155_closure_params.rast @@ -14,7 +14,7 @@ SOURCE_FILE@0..63 LET_STMT@15..60 LET_KW@15..18 "let" WHITESPACE@18..19 " " - BIND_PAT@19..22 + IDENT_PAT@19..22 NAME@19..22 IDENT@19..22 "foo" WHITESPACE@22..23 " " @@ -24,13 +24,13 @@ SOURCE_FILE@0..63 PARAM_LIST@25..56 PIPE@25..26 "|" PARAM@26..29 - BIND_PAT@26..29 + IDENT_PAT@26..29 NAME@26..29 IDENT@26..29 "bar" COMMA@29..30 "," WHITESPACE@30..31 " " PARAM@31..39 - BIND_PAT@31..34 + IDENT_PAT@31..34 NAME@31..34 IDENT@31..34 "baz" COLON@34..35 ":" @@ -43,7 +43,7 @@ SOURCE_FILE@0..63 COMMA@39..40 "," WHITESPACE@40..41 " " PARAM@41..55 - BIND_PAT@41..44 + IDENT_PAT@41..44 NAME@41..44 IDENT@41..44 "qux" COLON@44..45 ":" diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0156_fn_def_param.rast b/crates/ra_syntax/test_data/parser/inline/ok/0156_fn_def_param.rast index 3b8dfefc6..508b4aca7 100644 --- a/crates/ra_syntax/test_data/parser/inline/ok/0156_fn_def_param.rast +++ b/crates/ra_syntax/test_data/parser/inline/ok/0156_fn_def_param.rast @@ -9,12 +9,12 @@ SOURCE_FILE@0..30 PARAM@7..25 TUPLE_PAT@7..13 L_PAREN@7..8 "(" - BIND_PAT@8..9 + IDENT_PAT@8..9 NAME@8..9 IDENT@8..9 "x" COMMA@9..10 "," WHITESPACE@10..11 " " - BIND_PAT@11..12 + IDENT_PAT@11..12 NAME@11..12 IDENT@11..12 "y" R_PAREN@12..13 ")" diff --git a/crates/ra_syntax/test_data/parser/ok/0028_operator_binding_power.rast b/crates/ra_syntax/test_data/parser/ok/0028_operator_binding_power.rast index efe018484..3271a4695 100644 --- a/crates/ra_syntax/test_data/parser/ok/0028_operator_binding_power.rast +++ b/crates/ra_syntax/test_data/parser/ok/0028_operator_binding_power.rast @@ -14,7 +14,7 @@ SOURCE_FILE@0..248 LET_STMT@25..55 LET_KW@25..28 "let" WHITESPACE@28..29 " " - BIND_PAT@29..30 + IDENT_PAT@29..30 NAME@29..30 IDENT@29..30 "x" WHITESPACE@30..31 " " diff --git a/crates/ra_syntax/test_data/parser/ok/0029_range_forms.rast b/crates/ra_syntax/test_data/parser/ok/0029_range_forms.rast index 47e46f009..a732f11c4 100644 --- a/crates/ra_syntax/test_data/parser/ok/0029_range_forms.rast +++ b/crates/ra_syntax/test_data/parser/ok/0029_range_forms.rast @@ -67,7 +67,7 @@ SOURCE_FILE@0..153 LET_STMT@64..76 LET_KW@64..67 "let" WHITESPACE@67..68 " " - BIND_PAT@68..69 + IDENT_PAT@68..69 NAME@68..69 IDENT@68..69 "x" WHITESPACE@69..70 " " @@ -135,7 +135,7 @@ SOURCE_FILE@0..153 LET_STMT@138..150 LET_KW@138..141 "let" WHITESPACE@141..142 " " - BIND_PAT@142..143 + IDENT_PAT@142..143 NAME@142..143 IDENT@142..143 "x" WHITESPACE@143..144 " " diff --git a/crates/ra_syntax/test_data/parser/ok/0030_traits.rast b/crates/ra_syntax/test_data/parser/ok/0030_traits.rast index 280d4cb82..d07c6683a 100644 --- a/crates/ra_syntax/test_data/parser/ok/0030_traits.rast +++ b/crates/ra_syntax/test_data/parser/ok/0030_traits.rast @@ -37,7 +37,7 @@ SOURCE_FILE@0..96 PARAM_LIST@79..92 L_PAREN@79..80 "(" PARAM@80..91 - BIND_PAT@80..81 + IDENT_PAT@80..81 NAME@80..81 IDENT@80..81 "x" COLON@81..82 ":" diff --git a/crates/ra_syntax/test_data/parser/ok/0031_extern.rast b/crates/ra_syntax/test_data/parser/ok/0031_extern.rast index 0509f7504..79ea098a2 100644 --- a/crates/ra_syntax/test_data/parser/ok/0031_extern.rast +++ b/crates/ra_syntax/test_data/parser/ok/0031_extern.rast @@ -17,7 +17,7 @@ SOURCE_FILE@0..1598 PARAM_LIST@26..75 L_PAREN@26..27 "(" PARAM@27..42 - BIND_PAT@27..33 + IDENT_PAT@27..33 NAME@27..33 IDENT@27..33 "domain" COLON@33..34 ":" @@ -31,7 +31,7 @@ SOURCE_FILE@0..1598 COMMA@42..43 "," WHITESPACE@43..44 " " PARAM@44..55 - BIND_PAT@44..46 + IDENT_PAT@44..46 NAME@44..46 IDENT@44..46 "ty" COLON@46..47 ":" @@ -45,7 +45,7 @@ SOURCE_FILE@0..1598 COMMA@55..56 "," WHITESPACE@56..57 " " PARAM@57..74 - BIND_PAT@57..65 + IDENT_PAT@57..65 NAME@57..65 IDENT@57..65 "protocol" COLON@65..66 ":" @@ -80,7 +80,7 @@ SOURCE_FILE@0..1598 PARAM_LIST@103..155 L_PAREN@103..104 "(" PARAM@104..115 - BIND_PAT@104..106 + IDENT_PAT@104..106 NAME@104..106 IDENT@104..106 "fd" COLON@106..107 ":" @@ -94,7 +94,7 @@ SOURCE_FILE@0..1598 COMMA@115..116 "," WHITESPACE@116..117 " " PARAM@117..138 - BIND_PAT@117..121 + IDENT_PAT@117..121 NAME@117..121 IDENT@117..121 "addr" COLON@121..122 ":" @@ -111,7 +111,7 @@ SOURCE_FILE@0..1598 COMMA@138..139 "," WHITESPACE@139..140 " " PARAM@140..154 - BIND_PAT@140..143 + IDENT_PAT@140..143 NAME@140..143 IDENT@140..143 "len" COLON@143..144 ":" @@ -145,7 +145,7 @@ SOURCE_FILE@0..1598 PARAM_LIST@186..264 L_PAREN@186..187 "(" PARAM@187..202 - BIND_PAT@187..193 + IDENT_PAT@187..193 NAME@187..193 IDENT@187..193 "socket" COLON@193..194 ":" @@ -159,7 +159,7 @@ SOURCE_FILE@0..1598 COMMA@202..203 "," WHITESPACE@203..204 " " PARAM@204..228 - BIND_PAT@204..211 + IDENT_PAT@204..211 NAME@204..211 IDENT@204..211 "address" COLON@211..212 ":" @@ -176,7 +176,7 @@ SOURCE_FILE@0..1598 COMMA@228..229 "," WHITESPACE@229..249 "\n " PARAM@249..263 - BIND_PAT@249..252 + IDENT_PAT@249..252 NAME@249..252 IDENT@249..252 "len" COLON@252..253 ":" @@ -210,7 +210,7 @@ SOURCE_FILE@0..1598 PARAM_LIST@294..329 L_PAREN@294..295 "(" PARAM@295..310 - BIND_PAT@295..301 + IDENT_PAT@295..301 NAME@295..301 IDENT@295..301 "socket" COLON@301..302 ":" @@ -224,7 +224,7 @@ SOURCE_FILE@0..1598 COMMA@310..311 "," WHITESPACE@311..312 " " PARAM@312..328 - BIND_PAT@312..319 + IDENT_PAT@312..319 NAME@312..319 IDENT@312..319 "backlog" COLON@319..320 ":" @@ -259,7 +259,7 @@ SOURCE_FILE@0..1598 PARAM_LIST@364..457 L_PAREN@364..365 "(" PARAM@365..380 - BIND_PAT@365..371 + IDENT_PAT@365..371 NAME@365..371 IDENT@365..371 "socket" COLON@371..372 ":" @@ -273,7 +273,7 @@ SOURCE_FILE@0..1598 COMMA@380..381 "," WHITESPACE@381..382 " " PARAM@382..404 - BIND_PAT@382..389 + IDENT_PAT@382..389 NAME@382..389 IDENT@382..389 "address" COLON@389..390 ":" @@ -290,7 +290,7 @@ SOURCE_FILE@0..1598 COMMA@404..405 "," WHITESPACE@405..429 "\n " PARAM@429..456 - BIND_PAT@429..440 + IDENT_PAT@429..440 NAME@429..440 IDENT@429..440 "address_len" COLON@440..441 ":" @@ -328,7 +328,7 @@ SOURCE_FILE@0..1598 PARAM_LIST@491..679 L_PAREN@491..492 "(" PARAM@492..507 - BIND_PAT@492..498 + IDENT_PAT@492..498 NAME@492..498 IDENT@492..498 "sockfd" COLON@498..499 ":" @@ -342,7 +342,7 @@ SOURCE_FILE@0..1598 COMMA@507..508 "," WHITESPACE@508..531 "\n " PARAM@531..545 - BIND_PAT@531..536 + IDENT_PAT@531..536 NAME@531..536 IDENT@531..536 "level" COLON@536..537 ":" @@ -356,7 +356,7 @@ SOURCE_FILE@0..1598 COMMA@545..546 "," WHITESPACE@546..569 "\n " PARAM@569..585 - BIND_PAT@569..576 + IDENT_PAT@569..576 NAME@569..576 IDENT@569..576 "optname" COLON@576..577 ":" @@ -370,7 +370,7 @@ SOURCE_FILE@0..1598 COMMA@585..586 "," WHITESPACE@586..609 "\n " PARAM@609..630 - BIND_PAT@609..615 + IDENT_PAT@609..615 NAME@609..615 IDENT@609..615 "optval" COLON@615..616 ":" @@ -388,7 +388,7 @@ SOURCE_FILE@0..1598 COMMA@630..631 "," WHITESPACE@631..654 "\n " PARAM@654..678 - BIND_PAT@654..660 + IDENT_PAT@654..660 NAME@654..660 IDENT@654..660 "optlen" COLON@660..661 ":" @@ -427,7 +427,7 @@ SOURCE_FILE@0..1598 PARAM_LIST@713..852 L_PAREN@713..714 "(" PARAM@714..729 - BIND_PAT@714..720 + IDENT_PAT@714..720 NAME@714..720 IDENT@714..720 "socket" COLON@720..721 ":" @@ -441,7 +441,7 @@ SOURCE_FILE@0..1598 COMMA@729..730 "," WHITESPACE@730..731 " " PARAM@731..745 - BIND_PAT@731..736 + IDENT_PAT@731..736 NAME@731..736 IDENT@731..736 "level" COLON@736..737 ":" @@ -455,7 +455,7 @@ SOURCE_FILE@0..1598 COMMA@745..746 "," WHITESPACE@746..747 " " PARAM@747..760 - BIND_PAT@747..751 + IDENT_PAT@747..751 NAME@747..751 IDENT@747..751 "name" COLON@751..752 ":" @@ -469,7 +469,7 @@ SOURCE_FILE@0..1598 COMMA@760..761 "," WHITESPACE@761..784 "\n " PARAM@784..806 - BIND_PAT@784..789 + IDENT_PAT@784..789 NAME@784..789 IDENT@784..789 "value" COLON@789..790 ":" @@ -487,7 +487,7 @@ SOURCE_FILE@0..1598 COMMA@806..807 "," WHITESPACE@807..830 "\n " PARAM@830..851 - BIND_PAT@830..840 + IDENT_PAT@830..840 NAME@830..840 IDENT@830..840 "option_len" COLON@840..841 ":" @@ -521,7 +521,7 @@ SOURCE_FILE@0..1598 PARAM_LIST@887..980 L_PAREN@887..888 "(" PARAM@888..903 - BIND_PAT@888..894 + IDENT_PAT@888..894 NAME@888..894 IDENT@888..894 "socket" COLON@894..895 ":" @@ -535,7 +535,7 @@ SOURCE_FILE@0..1598 COMMA@903..904 "," WHITESPACE@904..905 " " PARAM@905..927 - BIND_PAT@905..912 + IDENT_PAT@905..912 NAME@905..912 IDENT@905..912 "address" COLON@912..913 ":" @@ -552,7 +552,7 @@ SOURCE_FILE@0..1598 COMMA@927..928 "," WHITESPACE@928..952 "\n " PARAM@952..979 - BIND_PAT@952..963 + IDENT_PAT@952..963 NAME@952..963 IDENT@952..963 "address_len" COLON@963..964 ":" @@ -590,7 +590,7 @@ SOURCE_FILE@0..1598 PARAM_LIST@1010..1159 L_PAREN@1010..1011 "(" PARAM@1011..1026 - BIND_PAT@1011..1017 + IDENT_PAT@1011..1017 NAME@1011..1017 IDENT@1011..1017 "socket" COLON@1017..1018 ":" @@ -604,7 +604,7 @@ SOURCE_FILE@0..1598 COMMA@1026..1027 "," WHITESPACE@1027..1028 " " PARAM@1028..1048 - BIND_PAT@1028..1031 + IDENT_PAT@1028..1031 NAME@1028..1031 IDENT@1028..1031 "buf" COLON@1031..1032 ":" @@ -622,7 +622,7 @@ SOURCE_FILE@0..1598 COMMA@1048..1049 "," WHITESPACE@1049..1050 " " PARAM@1050..1063 - BIND_PAT@1050..1053 + IDENT_PAT@1050..1053 NAME@1050..1053 IDENT@1050..1053 "len" COLON@1053..1054 ":" @@ -636,7 +636,7 @@ SOURCE_FILE@0..1598 COMMA@1063..1064 "," WHITESPACE@1064..1083 "\n " PARAM@1083..1097 - BIND_PAT@1083..1088 + IDENT_PAT@1083..1088 NAME@1083..1088 IDENT@1083..1088 "flags" COLON@1088..1089 ":" @@ -650,7 +650,7 @@ SOURCE_FILE@0..1598 COMMA@1097..1098 "," WHITESPACE@1098..1099 " " PARAM@1099..1120 - BIND_PAT@1099..1103 + IDENT_PAT@1099..1103 NAME@1099..1103 IDENT@1099..1103 "addr" COLON@1103..1104 ":" @@ -667,7 +667,7 @@ SOURCE_FILE@0..1598 COMMA@1120..1121 "," WHITESPACE@1121..1140 "\n " PARAM@1140..1158 - BIND_PAT@1140..1147 + IDENT_PAT@1140..1147 NAME@1140..1147 IDENT@1140..1147 "addrlen" COLON@1147..1148 ":" @@ -701,7 +701,7 @@ SOURCE_FILE@0..1598 PARAM_LIST@1189..1275 L_PAREN@1189..1190 "(" PARAM@1190..1205 - BIND_PAT@1190..1196 + IDENT_PAT@1190..1196 NAME@1190..1196 IDENT@1190..1196 "socket" COLON@1196..1197 ":" @@ -715,7 +715,7 @@ SOURCE_FILE@0..1598 COMMA@1205..1206 "," WHITESPACE@1206..1207 " " PARAM@1207..1227 - BIND_PAT@1207..1210 + IDENT_PAT@1207..1210 NAME@1207..1210 IDENT@1207..1210 "buf" COLON@1210..1211 ":" @@ -733,7 +733,7 @@ SOURCE_FILE@0..1598 COMMA@1227..1228 "," WHITESPACE@1228..1229 " " PARAM@1229..1242 - BIND_PAT@1229..1232 + IDENT_PAT@1229..1232 NAME@1229..1232 IDENT@1229..1232 "len" COLON@1232..1233 ":" @@ -747,7 +747,7 @@ SOURCE_FILE@0..1598 COMMA@1242..1243 "," WHITESPACE@1243..1260 "\n " PARAM@1260..1274 - BIND_PAT@1260..1265 + IDENT_PAT@1260..1265 NAME@1260..1265 IDENT@1260..1265 "flags" COLON@1265..1266 ":" @@ -782,7 +782,7 @@ SOURCE_FILE@0..1598 PARAM_LIST@1309..1467 L_PAREN@1309..1310 "(" PARAM@1310..1325 - BIND_PAT@1310..1316 + IDENT_PAT@1310..1316 NAME@1310..1316 IDENT@1310..1316 "socket" COLON@1316..1317 ":" @@ -796,7 +796,7 @@ SOURCE_FILE@0..1598 COMMA@1325..1326 "," WHITESPACE@1326..1327 " " PARAM@1327..1345 - BIND_PAT@1327..1330 + IDENT_PAT@1327..1330 NAME@1327..1330 IDENT@1327..1330 "buf" COLON@1330..1331 ":" @@ -814,7 +814,7 @@ SOURCE_FILE@0..1598 COMMA@1345..1346 "," WHITESPACE@1346..1347 " " PARAM@1347..1360 - BIND_PAT@1347..1350 + IDENT_PAT@1347..1350 NAME@1347..1350 IDENT@1347..1350 "len" COLON@1350..1351 ":" @@ -828,7 +828,7 @@ SOURCE_FILE@0..1598 COMMA@1360..1361 "," WHITESPACE@1361..1382 "\n " PARAM@1382..1396 - BIND_PAT@1382..1387 + IDENT_PAT@1382..1387 NAME@1382..1387 IDENT@1382..1387 "flags" COLON@1387..1388 ":" @@ -842,7 +842,7 @@ SOURCE_FILE@0..1598 COMMA@1396..1397 "," WHITESPACE@1397..1398 " " PARAM@1398..1419 - BIND_PAT@1398..1402 + IDENT_PAT@1398..1402 NAME@1398..1402 IDENT@1398..1402 "addr" COLON@1402..1403 ":" @@ -860,7 +860,7 @@ SOURCE_FILE@0..1598 COMMA@1419..1420 "," WHITESPACE@1420..1441 "\n " PARAM@1441..1466 - BIND_PAT@1441..1448 + IDENT_PAT@1441..1448 NAME@1441..1448 IDENT@1441..1448 "addrlen" COLON@1448..1449 ":" @@ -899,7 +899,7 @@ SOURCE_FILE@0..1598 PARAM_LIST@1497..1581 L_PAREN@1497..1498 "(" PARAM@1498..1513 - BIND_PAT@1498..1504 + IDENT_PAT@1498..1504 NAME@1498..1504 IDENT@1498..1504 "socket" COLON@1504..1505 ":" @@ -913,7 +913,7 @@ SOURCE_FILE@0..1598 COMMA@1513..1514 "," WHITESPACE@1514..1515 " " PARAM@1515..1533 - BIND_PAT@1515..1518 + IDENT_PAT@1515..1518 NAME@1515..1518 IDENT@1515..1518 "buf" COLON@1518..1519 ":" @@ -931,7 +931,7 @@ SOURCE_FILE@0..1598 COMMA@1533..1534 "," WHITESPACE@1534..1535 " " PARAM@1535..1548 - BIND_PAT@1535..1538 + IDENT_PAT@1535..1538 NAME@1535..1538 IDENT@1535..1538 "len" COLON@1538..1539 ":" @@ -945,7 +945,7 @@ SOURCE_FILE@0..1598 COMMA@1548..1549 "," WHITESPACE@1549..1566 "\n " PARAM@1566..1580 - BIND_PAT@1566..1571 + IDENT_PAT@1566..1571 NAME@1566..1571 IDENT@1566..1571 "flags" COLON@1571..1572 ":" diff --git a/crates/ra_syntax/test_data/parser/ok/0033_label_break.rast b/crates/ra_syntax/test_data/parser/ok/0033_label_break.rast index b3f29638c..88800ca7a 100644 --- a/crates/ra_syntax/test_data/parser/ok/0033_label_break.rast +++ b/crates/ra_syntax/test_data/parser/ok/0033_label_break.rast @@ -127,7 +127,7 @@ SOURCE_FILE@0..506 LET_STMT@301..503 LET_KW@301..304 "let" WHITESPACE@304..305 " " - BIND_PAT@305..311 + IDENT_PAT@305..311 NAME@305..311 IDENT@305..311 "result" WHITESPACE@311..312 " " diff --git a/crates/ra_syntax/test_data/parser/ok/0035_weird_exprs.rast b/crates/ra_syntax/test_data/parser/ok/0035_weird_exprs.rast index d48f638cd..ac9c1fa79 100644 --- a/crates/ra_syntax/test_data/parser/ok/0035_weird_exprs.rast +++ b/crates/ra_syntax/test_data/parser/ok/0035_weird_exprs.rast @@ -144,7 +144,7 @@ SOURCE_FILE@0..3813 LET_STMT@543..570 LET_KW@543..546 "let" WHITESPACE@546..547 " " - BIND_PAT@547..549 + IDENT_PAT@547..549 NAME@547..549 IDENT@547..549 "_x" COLON@549..550 ":" @@ -186,7 +186,7 @@ SOURCE_FILE@0..3813 PARAM_LIST@595..603 L_PAREN@595..596 "(" PARAM@596..602 - BIND_PAT@596..598 + IDENT_PAT@596..598 NAME@596..598 IDENT@596..598 "_x" COLON@598..599 ":" @@ -237,7 +237,7 @@ SOURCE_FILE@0..3813 PARAM_LIST@648..664 L_PAREN@648..649 "(" PARAM@649..663 - BIND_PAT@649..650 + IDENT_PAT@649..650 NAME@649..650 IDENT@649..650 "x" COLON@650..651 ":" @@ -314,7 +314,7 @@ SOURCE_FILE@0..3813 LET_STMT@725..751 LET_KW@725..728 "let" WHITESPACE@728..729 " " - BIND_PAT@729..730 + IDENT_PAT@729..730 NAME@729..730 IDENT@729..730 "i" WHITESPACE@730..731 " " @@ -343,7 +343,7 @@ SOURCE_FILE@0..3813 LET_STMT@756..778 LET_KW@756..759 "let" WHITESPACE@759..760 " " - BIND_PAT@760..764 + IDENT_PAT@760..764 NAME@760..764 IDENT@760..764 "dont" WHITESPACE@764..765 " " @@ -587,7 +587,7 @@ SOURCE_FILE@0..3813 LET_STMT@1343..1361 LET_KW@1343..1346 "let" WHITESPACE@1346..1347 " " - BIND_PAT@1347..1353 + IDENT_PAT@1347..1353 MUT_KW@1347..1350 "mut" WHITESPACE@1350..1351 " " NAME@1351..1353 @@ -604,7 +604,7 @@ SOURCE_FILE@0..3813 LET_STMT@1366..1400 LET_KW@1366..1369 "let" WHITESPACE@1369..1370 " " - BIND_PAT@1370..1376 + IDENT_PAT@1370..1376 MUT_KW@1370..1373 "mut" WHITESPACE@1373..1374 " " NAME@1374..1376 @@ -649,7 +649,7 @@ SOURCE_FILE@0..3813 LET_STMT@1405..1438 LET_KW@1405..1408 "let" WHITESPACE@1408..1409 " " - BIND_PAT@1409..1415 + IDENT_PAT@1409..1415 MUT_KW@1409..1412 "mut" WHITESPACE@1412..1413 " " NAME@1413..1415 @@ -694,7 +694,7 @@ SOURCE_FILE@0..3813 LET_STMT@1443..1474 LET_KW@1443..1446 "let" WHITESPACE@1446..1447 " " - BIND_PAT@1447..1449 + IDENT_PAT@1447..1449 NAME@1447..1449 IDENT@1447..1449 "_a" WHITESPACE@1449..1450 " " @@ -737,7 +737,7 @@ SOURCE_FILE@0..3813 LET_STMT@1479..1537 LET_KW@1479..1482 "let" WHITESPACE@1482..1483 " " - BIND_PAT@1483..1485 + IDENT_PAT@1483..1485 NAME@1483..1485 IDENT@1483..1485 "_b" WHITESPACE@1485..1486 " " @@ -859,7 +859,7 @@ SOURCE_FILE@0..3813 LET_STMT@1603..1648 LET_KW@1603..1606 "let" WHITESPACE@1606..1607 " " - BIND_PAT@1607..1609 + IDENT_PAT@1607..1609 NAME@1607..1609 IDENT@1607..1609 "_a" WHITESPACE@1609..1610 " " @@ -906,7 +906,7 @@ SOURCE_FILE@0..3813 LET_STMT@1653..1685 LET_KW@1653..1656 "let" WHITESPACE@1656..1657 " " - BIND_PAT@1657..1659 + IDENT_PAT@1657..1659 NAME@1657..1659 IDENT@1657..1659 "_c" WHITESPACE@1659..1660 " " @@ -943,7 +943,7 @@ SOURCE_FILE@0..3813 LET_STMT@1690..1739 LET_KW@1690..1693 "let" WHITESPACE@1693..1694 " " - BIND_PAT@1694..1696 + IDENT_PAT@1694..1696 NAME@1694..1696 IDENT@1694..1696 "_b" COLON@1696..1697 ":" @@ -1024,7 +1024,7 @@ SOURCE_FILE@0..3813 LET_STMT@1790..1804 LET_KW@1790..1793 "let" WHITESPACE@1793..1794 " " - BIND_PAT@1794..1799 + IDENT_PAT@1794..1799 MUT_KW@1794..1797 "mut" WHITESPACE@1797..1798 " " NAME@1798..1799 @@ -1146,7 +1146,7 @@ SOURCE_FILE@0..3813 LET_STMT@1926..1958 LET_KW@1926..1929 "let" WHITESPACE@1929..1930 " " - BIND_PAT@1930..1935 + IDENT_PAT@1930..1935 NAME@1930..1935 IDENT@1930..1935 "_evil" WHITESPACE@1935..1936 " " @@ -1292,7 +1292,7 @@ SOURCE_FILE@0..3813 PARAM_LIST@2205..2213 L_PAREN@2205..2206 "(" PARAM@2206..2212 - BIND_PAT@2206..2208 + IDENT_PAT@2206..2208 NAME@2206..2208 IDENT@2206..2208 "u8" COLON@2208..2209 ":" @@ -1614,7 +1614,7 @@ SOURCE_FILE@0..3813 LET_STMT@2938..3021 LET_KW@2938..2941 "let" WHITESPACE@2941..2942 " " - BIND_PAT@2942..2945 + IDENT_PAT@2942..2945 NAME@2942..2945 IDENT@2942..2945 "val" WHITESPACE@2945..2946 " " @@ -1648,7 +1648,7 @@ SOURCE_FILE@0..3813 R_PAREN@2961..2962 ")" COMMA@2962..2963 "," PARAM@2963..2967 - BIND_PAT@2963..2967 + IDENT_PAT@2963..2967 NAME@2963..2965 IDENT@2963..2965 "__" AT@2965..2966 "@" diff --git a/crates/ra_syntax/test_data/parser/ok/0041_raw_keywords.rast b/crates/ra_syntax/test_data/parser/ok/0041_raw_keywords.rast index 92ede8ccb..4035aef6f 100644 --- a/crates/ra_syntax/test_data/parser/ok/0041_raw_keywords.rast +++ b/crates/ra_syntax/test_data/parser/ok/0041_raw_keywords.rast @@ -14,7 +14,7 @@ SOURCE_FILE@0..59 LET_STMT@11..29 LET_KW@11..14 "let" WHITESPACE@14..15 " " - BIND_PAT@15..23 + IDENT_PAT@15..23 NAME@15..23 IDENT@15..23 "r#struct" WHITESPACE@23..24 " " @@ -27,7 +27,7 @@ SOURCE_FILE@0..59 LET_STMT@30..57 LET_KW@30..33 "let" WHITESPACE@33..34 " " - BIND_PAT@34..41 + IDENT_PAT@34..41 NAME@34..41 IDENT@34..41 "r#trait" WHITESPACE@41..42 " " diff --git a/crates/ra_syntax/test_data/parser/ok/0044_let_attrs.rast b/crates/ra_syntax/test_data/parser/ok/0044_let_attrs.rast index 650f4e310..af44a4dbe 100644 --- a/crates/ra_syntax/test_data/parser/ok/0044_let_attrs.rast +++ b/crates/ra_syntax/test_data/parser/ok/0044_let_attrs.rast @@ -33,7 +33,7 @@ SOURCE_FILE@0..166 WHITESPACE@106..111 "\n " LET_KW@111..114 "let" WHITESPACE@114..115 " " - BIND_PAT@115..124 + IDENT_PAT@115..124 NAME@115..124 IDENT@115..124 "exit_code" WHITESPACE@124..125 " " diff --git a/crates/ra_syntax/test_data/parser/ok/0045_block_inner_attrs.rast b/crates/ra_syntax/test_data/parser/ok/0045_block_inner_attrs.rast index bd152ffa3..0ac56df6d 100644 --- a/crates/ra_syntax/test_data/parser/ok/0045_block_inner_attrs.rast +++ b/crates/ra_syntax/test_data/parser/ok/0045_block_inner_attrs.rast @@ -114,7 +114,7 @@ SOURCE_FILE@0..686 COMMA@564..565 "," WHITESPACE@565..566 " " PARAM@566..600 - BIND_PAT@566..574 + IDENT_PAT@566..574 NAME@566..574 IDENT@566..574 "event_fn" COLON@574..575 ":" diff --git a/crates/ra_syntax/test_data/parser/ok/0048_compound_assignment.rast b/crates/ra_syntax/test_data/parser/ok/0048_compound_assignment.rast index 662576e5f..eaab47843 100644 --- a/crates/ra_syntax/test_data/parser/ok/0048_compound_assignment.rast +++ b/crates/ra_syntax/test_data/parser/ok/0048_compound_assignment.rast @@ -16,7 +16,7 @@ SOURCE_FILE@0..257 LET_STMT@91..105 LET_KW@91..94 "let" WHITESPACE@94..95 " " - BIND_PAT@95..100 + IDENT_PAT@95..100 MUT_KW@95..98 "mut" WHITESPACE@98..99 " " NAME@99..100 diff --git a/crates/ra_syntax/test_data/parser/ok/0050_async_block_as_argument.rast b/crates/ra_syntax/test_data/parser/ok/0050_async_block_as_argument.rast index 48e1f07d1..c7ce12e93 100644 --- a/crates/ra_syntax/test_data/parser/ok/0050_async_block_as_argument.rast +++ b/crates/ra_syntax/test_data/parser/ok/0050_async_block_as_argument.rast @@ -7,7 +7,7 @@ SOURCE_FILE@0..95 PARAM_LIST@6..49 L_PAREN@6..7 "(" PARAM@7..48 - BIND_PAT@7..8 + IDENT_PAT@7..8 NAME@7..8 IDENT@7..8 "x" COLON@8..9 ":" diff --git a/crates/ra_syntax/test_data/parser/ok/0051_parameter_attrs.rast b/crates/ra_syntax/test_data/parser/ok/0051_parameter_attrs.rast index a80a6cd7a..0303b198f 100644 --- a/crates/ra_syntax/test_data/parser/ok/0051_parameter_attrs.rast +++ b/crates/ra_syntax/test_data/parser/ok/0051_parameter_attrs.rast @@ -25,7 +25,7 @@ SOURCE_FILE@0..519 R_BRACK@22..23 "]" WHITESPACE@23..24 " " PARAM@24..33 - BIND_PAT@24..27 + IDENT_PAT@24..27 NAME@24..27 IDENT@24..27 "pat" COLON@27..28 ":" @@ -58,7 +58,7 @@ SOURCE_FILE@0..519 R_BRACK@51..52 "]" WHITESPACE@52..53 " " PARAM@53..58 - BIND_PAT@53..54 + IDENT_PAT@53..54 NAME@53..54 IDENT@53..54 "x" COLON@54..55 ":" @@ -91,7 +91,7 @@ SOURCE_FILE@0..519 PARAM_LIST@86..118 L_PAREN@86..87 "(" PARAM@87..104 - BIND_PAT@87..93 + IDENT_PAT@87..93 NAME@87..93 IDENT@87..93 "format" COLON@93..94 ":" @@ -234,7 +234,7 @@ SOURCE_FILE@0..519 R_BRACK@220..221 "]" WHITESPACE@221..222 " " PARAM@222..232 - BIND_PAT@222..227 + IDENT_PAT@222..227 MUT_KW@222..225 "mut" WHITESPACE@225..226 " " NAME@226..227 diff --git a/crates/ra_syntax/test_data/parser/ok/0052_for_range_block.rast b/crates/ra_syntax/test_data/parser/ok/0052_for_range_block.rast index fd4f4f242..350823ba3 100644 --- a/crates/ra_syntax/test_data/parser/ok/0052_for_range_block.rast +++ b/crates/ra_syntax/test_data/parser/ok/0052_for_range_block.rast @@ -14,7 +14,7 @@ SOURCE_FILE@0..80 FOR_EXPR@14..77 FOR_KW@14..17 "for" WHITESPACE@17..18 " " - BIND_PAT@18..20 + IDENT_PAT@18..20 NAME@18..20 IDENT@18..20 "_x" WHITESPACE@20..21 " " diff --git a/crates/ra_syntax/test_data/parser/ok/0057_loop_in_call.rast b/crates/ra_syntax/test_data/parser/ok/0057_loop_in_call.rast index 53410a1ee..76301004a 100644 --- a/crates/ra_syntax/test_data/parser/ok/0057_loop_in_call.rast +++ b/crates/ra_syntax/test_data/parser/ok/0057_loop_in_call.rast @@ -7,7 +7,7 @@ SOURCE_FILE@0..50 PARAM_LIST@6..14 L_PAREN@6..7 "(" PARAM@7..13 - BIND_PAT@7..8 + IDENT_PAT@7..8 NAME@7..8 IDENT@7..8 "x" COLON@8..9 ":" diff --git a/crates/ra_syntax/test_data/parser/ok/0063_trait_fn_patterns.rast b/crates/ra_syntax/test_data/parser/ok/0063_trait_fn_patterns.rast index 9d88e4cbf..42680b283 100644 --- a/crates/ra_syntax/test_data/parser/ok/0063_trait_fn_patterns.rast +++ b/crates/ra_syntax/test_data/parser/ok/0063_trait_fn_patterns.rast @@ -18,12 +18,12 @@ SOURCE_FILE@0..170 PARAM@20..42 TUPLE_PAT@20..26 L_PAREN@20..21 "(" - BIND_PAT@21..22 + IDENT_PAT@21..22 NAME@21..22 IDENT@21..22 "a" COMMA@22..23 "," WHITESPACE@23..24 " " - BIND_PAT@24..25 + IDENT_PAT@24..25 NAME@24..25 IDENT@24..25 "b" R_PAREN@25..26 ")" @@ -68,13 +68,13 @@ SOURCE_FILE@0..170 L_CURLY@59..60 "{" WHITESPACE@60..61 " " RECORD_PAT_FIELD@61..62 - BIND_PAT@61..62 + IDENT_PAT@61..62 NAME@61..62 IDENT@61..62 "a" COMMA@62..63 "," WHITESPACE@63..64 " " RECORD_PAT_FIELD@64..65 - BIND_PAT@64..65 + IDENT_PAT@64..65 NAME@64..65 IDENT@64..65 "b" WHITESPACE@65..66 " " @@ -106,7 +106,7 @@ SOURCE_FILE@0..170 NAME_REF@85..92 IDENT@85..92 "NewType" L_PAREN@92..93 "(" - BIND_PAT@93..94 + IDENT_PAT@93..94 NAME@93..94 IDENT@93..94 "a" R_PAREN@94..95 ")" @@ -135,7 +135,7 @@ SOURCE_FILE@0..170 AMP@119..120 "&" REF_PAT@120..122 AMP@120..121 "&" - BIND_PAT@121..122 + IDENT_PAT@121..122 NAME@121..122 IDENT@121..122 "a" COLON@122..123 ":" @@ -175,7 +175,7 @@ SOURCE_FILE@0..170 COMMA@153..154 "," WHITESPACE@154..155 " " PARAM@155..165 - BIND_PAT@155..160 + IDENT_PAT@155..160 MUT_KW@155..158 "mut" WHITESPACE@158..159 " " NAME@159..160 diff --git a/crates/ra_syntax/test_data/parser/ok/0063_variadic_fun.rast b/crates/ra_syntax/test_data/parser/ok/0063_variadic_fun.rast index d8bf1f8c8..a132591f0 100644 --- a/crates/ra_syntax/test_data/parser/ok/0063_variadic_fun.rast +++ b/crates/ra_syntax/test_data/parser/ok/0063_variadic_fun.rast @@ -108,17 +108,17 @@ SOURCE_FILE@0..126 PARAM@106..120 SLICE_PAT@106..115 L_BRACK@106..107 "[" - BIND_PAT@107..108 + IDENT_PAT@107..108 NAME@107..108 IDENT@107..108 "w" COMMA@108..109 "," WHITESPACE@109..110 " " - BIND_PAT@110..111 + IDENT_PAT@110..111 NAME@110..111 IDENT@110..111 "t" COMMA@111..112 "," WHITESPACE@112..113 " " - BIND_PAT@113..114 + IDENT_PAT@113..114 NAME@113..114 IDENT@113..114 "f" R_BRACK@114..115 "]" diff --git a/crates/ra_syntax/test_data/parser/ok/0064_impl_fn_params.rast b/crates/ra_syntax/test_data/parser/ok/0064_impl_fn_params.rast index 087053f25..94260db7c 100644 --- a/crates/ra_syntax/test_data/parser/ok/0064_impl_fn_params.rast +++ b/crates/ra_syntax/test_data/parser/ok/0064_impl_fn_params.rast @@ -21,12 +21,12 @@ SOURCE_FILE@0..137 PARAM@19..41 TUPLE_PAT@19..25 L_PAREN@19..20 "(" - BIND_PAT@20..21 + IDENT_PAT@20..21 NAME@20..21 IDENT@20..21 "a" COMMA@21..22 "," WHITESPACE@22..23 " " - BIND_PAT@23..24 + IDENT_PAT@23..24 NAME@23..24 IDENT@23..24 "b" R_PAREN@24..25 ")" @@ -71,13 +71,13 @@ SOURCE_FILE@0..137 L_CURLY@58..59 "{" WHITESPACE@59..60 " " RECORD_PAT_FIELD@60..61 - BIND_PAT@60..61 + IDENT_PAT@60..61 NAME@60..61 IDENT@60..61 "a" COMMA@61..62 "," WHITESPACE@62..63 " " RECORD_PAT_FIELD@63..64 - BIND_PAT@63..64 + IDENT_PAT@63..64 NAME@63..64 IDENT@63..64 "b" WHITESPACE@64..65 " " @@ -109,7 +109,7 @@ SOURCE_FILE@0..137 NAME_REF@84..91 IDENT@84..91 "NewType" L_PAREN@91..92 "(" - BIND_PAT@92..93 + IDENT_PAT@92..93 NAME@92..93 IDENT@92..93 "a" R_PAREN@93..94 ")" @@ -138,7 +138,7 @@ SOURCE_FILE@0..137 AMP@118..119 "&" REF_PAT@119..121 AMP@119..120 "&" - BIND_PAT@120..121 + IDENT_PAT@120..121 NAME@120..121 IDENT@120..121 "a" COLON@121..122 ":" diff --git a/crates/ra_syntax/test_data/parser/ok/0067_where_for_pred.rast b/crates/ra_syntax/test_data/parser/ok/0067_where_for_pred.rast index a368ac1e8..fae9467fc 100644 --- a/crates/ra_syntax/test_data/parser/ok/0067_where_for_pred.rast +++ b/crates/ra_syntax/test_data/parser/ok/0067_where_for_pred.rast @@ -245,7 +245,7 @@ SOURCE_FILE@0..374 PARAM_LIST@239..247 L_PAREN@239..240 "(" PARAM@240..246 - BIND_PAT@240..242 + IDENT_PAT@240..242 NAME@240..242 IDENT@240..242 "_t" COLON@242..243 ":" diff --git a/xtask/src/ast_src.rs b/xtask/src/ast_src.rs index fbe36d2f5..2ff029158 100644 --- a/xtask/src/ast_src.rs +++ b/xtask/src/ast_src.rs @@ -126,7 +126,7 @@ pub(crate) const KINDS_SRC: KindsSrc = KindsSrc { "PAREN_PAT", "REF_PAT", "BOX_PAT", - "BIND_PAT", + "IDENT_PAT", "WILDCARD_PAT", "DOT_DOT_PAT", "PATH_PAT", diff --git a/xtask/src/codegen/rust.ungram b/xtask/src/codegen/rust.ungram index 7c814240a..7685f4f06 100644 --- a/xtask/src/codegen/rust.ungram +++ b/xtask/src/codegen/rust.ungram @@ -497,7 +497,7 @@ TypeBound = | '?'? Type Pat = - BindPat + IdentPat | BoxPat | DotDotPat | LiteralPat @@ -516,7 +516,7 @@ Pat = LiteralPat = Literal -BindPat = +IdentPat = Attr* 'ref'? 'mut'? Name ('@' Pat)? WildcardPat = -- cgit v1.2.3