Rename PalceholderPat -> WildcardPat

Author: matklad

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<MatchArm> = 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);
                 }

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)]

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));

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

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

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,

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 {

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

@@ -1175,10 +1175,10 @@ impl PathPat {
     pub fn path(&self) -> Option<Path> { 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<SyntaxToken> { 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<Self> {
         if Self::can_cast(syntax.kind()) {
             Some(Self { syntax })
@@ -3160,8 +3160,8 @@ impl From<ParenPat> for Pat {
 impl From<PathPat> for Pat {
     fn from(node: PathPat) -> Pat { Pat::PathPat(node) }
 }
-impl From<PlaceholderPat> for Pat {
-    fn from(node: PlaceholderPat) -> Pat { Pat::PlaceholderPat(node) }
+impl From<WildcardPat> for Pat {
+    fn from(node: WildcardPat) -> Pat { Pat::WildcardPat(node) }
 }
 impl From<RangePat> 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)
     }

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))
     }
 }

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 " "