Merge #5634

5634: Finish rename r=matklad a=matklad



bors r+
🤖

Co-authored-by: Aleksey Kladov <aleksey.kladov@gmail.com>

Author: bors[bot]

crates/ra_assists/src/handlers/early_return.rs

@@ -51,11 +51,11 @@ pub(crate) fn convert_to_guarded_return(acc: &mut Assists, ctx: &AssistContext)
     // Check if there is an IfLet that we can handle.
     let if_let_pat = match cond.pat() {
         None => None, // No IfLet, supported.
-        Some(ast::Pat::TupleStructPat(pat)) if pat.args().count() == 1 => {
+        Some(ast::Pat::TupleStructPat(pat)) if pat.fields().count() == 1 => {
             let path = pat.path()?;
             match path.qualifier() {
                 None => {
-                    let bound_ident = pat.args().next().unwrap();
+                    let bound_ident = pat.fields().next().unwrap();
                     Some((path, bound_ident))
                 }
                 Some(_) => return None,

crates/ra_hir_def/src/body/lower.rs

@@ -496,7 +496,7 @@ impl ExprCollector<'_> {
                 self.alloc_expr(Expr::BinaryOp { lhs, rhs, op }, syntax_ptr)
             }
             ast::Expr::TupleExpr(e) => {
-                let exprs = e.exprs().map(|expr| self.collect_expr(expr)).collect();
+                let exprs = e.fields().map(|expr| self.collect_expr(expr)).collect();
                 self.alloc_expr(Expr::Tuple { exprs }, syntax_ptr)
             }
             ast::Expr::BoxExpr(e) => {
@@ -762,7 +762,7 @@ impl ExprCollector<'_> {
             }
             ast::Pat::TupleStructPat(p) => {
                 let path = p.path().and_then(|path| self.expander.parse_path(path));
-                let (args, ellipsis) = self.collect_tuple_pat(p.args());
+                let (args, ellipsis) = self.collect_tuple_pat(p.fields());
                 Pat::TupleStruct { path, args, ellipsis }
             }
             ast::Pat::RefPat(p) => {
@@ -780,7 +780,7 @@ impl ExprCollector<'_> {
             }
             ast::Pat::ParenPat(p) => return self.collect_pat_opt(p.pat()),
             ast::Pat::TuplePat(p) => {
-                let (args, ellipsis) = self.collect_tuple_pat(p.args());
+                let (args, ellipsis) = self.collect_tuple_pat(p.fields());
                 Pat::Tuple { args, ellipsis }
             }
             ast::Pat::WildcardPat(_) => Pat::Wild,
@@ -809,7 +809,7 @@ impl ExprCollector<'_> {
             ast::Pat::SlicePat(p) => {
                 let SlicePatComponents { prefix, slice, suffix } = p.components();
 
-                // FIXME properly handle `DotDotPat`
+                // FIXME properly handle `RestPat`
                 Pat::Slice {
                     prefix: prefix.into_iter().map(|p| self.collect_pat(p)).collect(),
                     slice: slice.map(|p| self.collect_pat(p)),
@@ -827,9 +827,9 @@ impl ExprCollector<'_> {
                 }
             }
             ast::Pat::RestPat(_) => {
-                // `DotDotPat` requires special handling and should not be mapped
+                // `RestPat` requires special handling and should not be mapped
                 // to a Pat. Here we are using `Pat::Missing` as a fallback for
-                // when `DotDotPat` is mapped to `Pat`, which can easily happen
+                // when `RestPat` is mapped to `Pat`, which can easily happen
                 // when the source code being analyzed has a malformed pattern
                 // which includes `..` in a place where it isn't valid.
 

crates/ra_syntax/src/ast/generated/nodes.rs

@@ -893,7 +893,7 @@ pub struct TupleExpr {
 impl ast::AttrsOwner for TupleExpr {}
 impl TupleExpr {
     pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
-    pub fn exprs(&self) -> AstChildren<Expr> { support::children(&self.syntax) }
+    pub fn fields(&self) -> AstChildren<Expr> { support::children(&self.syntax) }
     pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -1210,7 +1210,7 @@ pub struct SlicePat {
 }
 impl SlicePat {
     pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }
-    pub fn args(&self) -> AstChildren<Pat> { support::children(&self.syntax) }
+    pub fn pats(&self) -> AstChildren<Pat> { support::children(&self.syntax) }
     pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -1219,7 +1219,7 @@ pub struct TuplePat {
 }
 impl TuplePat {
     pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
-    pub fn args(&self) -> AstChildren<Pat> { support::children(&self.syntax) }
+    pub fn fields(&self) -> AstChildren<Pat> { support::children(&self.syntax) }
     pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -1229,7 +1229,7 @@ pub struct TupleStructPat {
 impl TupleStructPat {
     pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
     pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
-    pub fn args(&self) -> AstChildren<Pat> { support::children(&self.syntax) }
+    pub fn fields(&self) -> AstChildren<Pat> { support::children(&self.syntax) }
     pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]

crates/ra_syntax/src/ast/node_ext.rs

@@ -290,7 +290,7 @@ pub struct SlicePatComponents {
 
 impl ast::SlicePat {
     pub fn components(&self) -> SlicePatComponents {
-        let mut args = self.args().peekable();
+        let mut args = self.pats().peekable();
         let prefix = args
             .peeking_take_while(|p| match p {
                 ast::Pat::RestPat(_) => false,

xtask/src/codegen/rust.ungram

@@ -1,3 +1,7 @@
+//*************************//
+// Names, Paths and Macros //
+//*************************//
+
 Name =
   'ident'
 
@@ -50,6 +54,10 @@ MacroStmts =
   statements:Stmt*
   Expr?
 
+//*************************//
+//          Items          //
+//*************************//
+
 SourceFile =
   'shebang'?
   Attr*
@@ -245,6 +253,10 @@ Visibility =
 Attr =
   '#' '!'? '[' Path ('=' Literal | TokenTree)? ']'
 
+//****************************//
+// Statements and Expressions //
+//****************************//
+
 Stmt =
   ExprStmt
 | Item
@@ -347,7 +359,7 @@ IndexExpr =
   Attr* base:Expr '[' index:Expr ']'
 
 TupleExpr =
-  Attr* '(' Attr* (Expr (',' Expr)* ','?)? ')'
+  Attr* '(' Attr* fields:(Expr (',' Expr)* ','?)? ')'
 
 RecordExpr =
   Path RecordExprFieldList
@@ -434,6 +446,10 @@ AwaitExpr =
 BoxExpr =
   Attr* 'box' Expr
 
+//*************************//
+//          Types          //
+//*************************//
+
 Type =
   ArrayType
 | DynTraitType
@@ -495,6 +511,10 @@ TypeBound =
   'lifetime'
 | '?'? Type
 
+//************************//
+//        Patterns        //
+//************************//
+
 Pat =
   IdentPat
 | BoxPat
@@ -540,16 +560,16 @@ RecordPatField =
   Attr* (NameRef ':')? Pat
 
 TupleStructPat =
-   Path '(' args:(Pat (',' Pat)* ','?)? ')'
+   Path '(' fields:(Pat (',' Pat)* ','?)? ')'
 
 TuplePat =
-   '(' args:(Pat (',' Pat)* ','?)? ')'
+   '(' fields:(Pat (',' Pat)* ','?)? ')'
 
 ParenPat =
   '(' Pat ')'
 
 SlicePat =
-  '[' args:(Pat (',' Pat)* ','?)? ']'
+  '[' (Pat (',' Pat)* ','?)? ']'
 
 PathPat =
   Path