From 25fca0475343170b8398f5c87c76c455205ed3c4 Mon Sep 17 00:00:00 2001
From: Aleksey Kladov <aleksey.kladov@gmail.com>
Date: Wed, 25 Sep 2019 15:09:03 +0300
Subject: cleaned up record field builder

---
 crates/ra_assists/src/ast_builder.rs | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

(limited to 'crates/ra_assists/src/ast_builder.rs')

diff --git a/crates/ra_assists/src/ast_builder.rs b/crates/ra_assists/src/ast_builder.rs
index e4ea1fca9..9b9158ae2 100644
--- a/crates/ra_assists/src/ast_builder.rs
+++ b/crates/ra_assists/src/ast_builder.rs
@@ -1,6 +1,5 @@
 use itertools::Itertools;
 
-use hir::Name;
 use ra_syntax::{ast, AstNode, SourceFile};
 
 pub struct AstBuilder<N: AstNode> {
@@ -8,15 +7,11 @@ pub struct AstBuilder<N: AstNode> {
 }
 
 impl AstBuilder<ast::RecordField> {
-    pub fn from_name(name: &Name) -> ast::RecordField {
-        ast_node_from_file_text(&format!("fn f() {{ S {{ {}: (), }} }}", name))
-    }
-
     fn from_text(text: &str) -> ast::RecordField {
         ast_node_from_file_text(&format!("fn f() {{ S {{ {}, }} }}", text))
     }
 
-    pub fn from_pieces(name: &ast::NameRef, expr: Option<&ast::Expr>) -> ast::RecordField {
+    pub fn from_pieces(name: ast::NameRef, expr: Option<ast::Expr>) -> ast::RecordField {
         match expr {
             Some(expr) => Self::from_text(&format!("{}: {}", name.syntax(), expr.syntax())),
             None => Self::from_text(&name.syntax().to_string()),
-- 
cgit v1.2.3


From 546f031e4e643c7cc4df44a2a09ac7c4af5e5ad7 Mon Sep 17 00:00:00 2001
From: Aleksey Kladov <aleksey.kladov@gmail.com>
Date: Wed, 25 Sep 2019 15:16:18 +0300
Subject: minor builder cleanups

---
 crates/ra_assists/src/ast_builder.rs | 102 +++++++++++++++++------------------
 1 file changed, 51 insertions(+), 51 deletions(-)

(limited to 'crates/ra_assists/src/ast_builder.rs')

diff --git a/crates/ra_assists/src/ast_builder.rs b/crates/ra_assists/src/ast_builder.rs
index 9b9158ae2..171b1c936 100644
--- a/crates/ra_assists/src/ast_builder.rs
+++ b/crates/ra_assists/src/ast_builder.rs
@@ -7,33 +7,29 @@ pub struct AstBuilder<N: AstNode> {
 }
 
 impl AstBuilder<ast::RecordField> {
-    fn from_text(text: &str) -> ast::RecordField {
-        ast_node_from_file_text(&format!("fn f() {{ S {{ {}, }} }}", text))
-    }
-
     pub fn from_pieces(name: ast::NameRef, expr: Option<ast::Expr>) -> ast::RecordField {
         match expr {
             Some(expr) => Self::from_text(&format!("{}: {}", name.syntax(), expr.syntax())),
             None => Self::from_text(&name.syntax().to_string()),
         }
     }
+
+    fn from_text(text: &str) -> ast::RecordField {
+        ast_node_from_file_text(&format!("fn f() {{ S {{ {}, }} }}", text))
+    }
 }
 
 impl AstBuilder<ast::Block> {
-    fn from_text(text: &str) -> ast::Block {
-        ast_node_from_file_text(&format!("fn f() {}", text))
+    pub fn single_expr(e: ast::Expr) -> ast::Block {
+        Self::from_text(&format!("{{ {} }}", e.syntax()))
     }
 
-    pub fn single_expr(e: &ast::Expr) -> ast::Block {
-        Self::from_text(&format!("{{ {} }}", e.syntax()))
+    fn from_text(text: &str) -> ast::Block {
+        ast_node_from_file_text(&format!("fn f() {}", text))
     }
 }
 
 impl AstBuilder<ast::Expr> {
-    fn from_text(text: &str) -> ast::Expr {
-        ast_node_from_file_text(&format!("const C: () = {};", text))
-    }
-
     pub fn unit() -> ast::Expr {
         Self::from_text("()")
     }
@@ -41,6 +37,10 @@ impl AstBuilder<ast::Expr> {
     pub fn unimplemented() -> ast::Expr {
         Self::from_text("unimplemented!()")
     }
+
+    fn from_text(text: &str) -> ast::Expr {
+        ast_node_from_file_text(&format!("const C: () = {};", text))
+    }
 }
 
 impl AstBuilder<ast::NameRef> {
@@ -50,10 +50,6 @@ impl AstBuilder<ast::NameRef> {
 }
 
 impl AstBuilder<ast::Path> {
-    fn from_text(text: &str) -> ast::Path {
-        ast_node_from_file_text(text)
-    }
-
     pub fn from_name(name: ast::Name) -> ast::Path {
         let name = name.syntax().to_string();
         Self::from_text(name.as_str())
@@ -62,91 +58,91 @@ impl AstBuilder<ast::Path> {
     pub fn from_pieces(enum_name: ast::Name, var_name: ast::Name) -> ast::Path {
         Self::from_text(&format!("{}::{}", enum_name.syntax(), var_name.syntax()))
     }
-}
 
-impl AstBuilder<ast::BindPat> {
-    fn from_text(text: &str) -> ast::BindPat {
-        ast_node_from_file_text(&format!("fn f({}: ())", text))
+    fn from_text(text: &str) -> ast::Path {
+        ast_node_from_file_text(text)
     }
+}
 
-    pub fn from_name(name: &ast::Name) -> ast::BindPat {
+impl AstBuilder<ast::BindPat> {
+    pub fn from_name(name: ast::Name) -> ast::BindPat {
         Self::from_text(name.text())
     }
-}
 
-impl AstBuilder<ast::PlaceholderPat> {
-    fn from_text(text: &str) -> ast::PlaceholderPat {
+    fn from_text(text: &str) -> ast::BindPat {
         ast_node_from_file_text(&format!("fn f({}: ())", text))
     }
+}
 
+impl AstBuilder<ast::PlaceholderPat> {
     pub fn placeholder() -> ast::PlaceholderPat {
         Self::from_text("_")
     }
-}
 
-impl AstBuilder<ast::TupleStructPat> {
-    fn from_text(text: &str) -> ast::TupleStructPat {
+    fn from_text(text: &str) -> ast::PlaceholderPat {
         ast_node_from_file_text(&format!("fn f({}: ())", text))
     }
+}
 
+impl AstBuilder<ast::TupleStructPat> {
     pub fn from_pieces(
-        path: &ast::Path,
+        path: ast::Path,
         pats: impl Iterator<Item = ast::Pat>,
     ) -> ast::TupleStructPat {
         let pats_str = pats.map(|p| p.syntax().to_string()).collect::<Vec<_>>().join(", ");
         Self::from_text(&format!("{}({})", path.syntax(), pats_str))
     }
-}
 
-impl AstBuilder<ast::RecordPat> {
-    fn from_text(text: &str) -> ast::RecordPat {
+    fn from_text(text: &str) -> ast::TupleStructPat {
         ast_node_from_file_text(&format!("fn f({}: ())", text))
     }
+}
 
-    pub fn from_pieces(path: &ast::Path, pats: impl Iterator<Item = ast::Pat>) -> ast::RecordPat {
+impl AstBuilder<ast::RecordPat> {
+    pub fn from_pieces(path: ast::Path, pats: impl Iterator<Item = ast::Pat>) -> ast::RecordPat {
         let pats_str = pats.map(|p| p.syntax().to_string()).collect::<Vec<_>>().join(", ");
         Self::from_text(&format!("{}{{ {} }}", path.syntax(), pats_str))
     }
-}
 
-impl AstBuilder<ast::PathPat> {
-    fn from_text(text: &str) -> ast::PathPat {
+    fn from_text(text: &str) -> ast::RecordPat {
         ast_node_from_file_text(&format!("fn f({}: ())", text))
     }
+}
 
-    pub fn from_path(path: &ast::Path) -> ast::PathPat {
+impl AstBuilder<ast::PathPat> {
+    pub fn from_path(path: ast::Path) -> ast::PathPat {
         let path_str = path.syntax().text().to_string();
         Self::from_text(path_str.as_str())
     }
-}
 
-impl AstBuilder<ast::MatchArm> {
-    fn from_text(text: &str) -> ast::MatchArm {
-        ast_node_from_file_text(&format!("fn f() {{ match () {{{}}} }}", text))
+    fn from_text(text: &str) -> ast::PathPat {
+        ast_node_from_file_text(&format!("fn f({}: ())", text))
     }
+}
 
-    pub fn from_pieces(pats: impl Iterator<Item = ast::Pat>, expr: &ast::Expr) -> ast::MatchArm {
+impl AstBuilder<ast::MatchArm> {
+    pub fn from_pieces(pats: impl Iterator<Item = ast::Pat>, expr: ast::Expr) -> ast::MatchArm {
         let pats_str = pats.map(|p| p.syntax().to_string()).join(" | ");
         Self::from_text(&format!("{} => {}", pats_str, expr.syntax()))
     }
-}
 
-impl AstBuilder<ast::MatchArmList> {
-    fn from_text(text: &str) -> ast::MatchArmList {
+    fn from_text(text: &str) -> ast::MatchArm {
         ast_node_from_file_text(&format!("fn f() {{ match () {{{}}} }}", text))
     }
+}
 
+impl AstBuilder<ast::MatchArmList> {
     pub fn from_arms(arms: impl Iterator<Item = ast::MatchArm>) -> ast::MatchArmList {
         let arms_str = arms.map(|arm| format!("\n    {}", arm.syntax())).join(",");
         Self::from_text(&format!("{},\n", arms_str))
     }
-}
 
-impl AstBuilder<ast::WherePred> {
-    fn from_text(text: &str) -> ast::WherePred {
-        ast_node_from_file_text(&format!("fn f() where {} {{ }}", text))
+    fn from_text(text: &str) -> ast::MatchArmList {
+        ast_node_from_file_text(&format!("fn f() {{ match () {{{}}} }}", text))
     }
+}
 
+impl AstBuilder<ast::WherePred> {
     pub fn from_pieces(
         path: ast::Path,
         bounds: impl Iterator<Item = ast::TypeBound>,
@@ -154,17 +150,21 @@ impl AstBuilder<ast::WherePred> {
         let bounds = bounds.map(|b| b.syntax().to_string()).collect::<Vec<_>>().join(" + ");
         Self::from_text(&format!("{}: {}", path.syntax(), bounds))
     }
-}
 
-impl AstBuilder<ast::WhereClause> {
-    fn from_text(text: &str) -> ast::WhereClause {
+    fn from_text(text: &str) -> ast::WherePred {
         ast_node_from_file_text(&format!("fn f() where {} {{ }}", text))
     }
+}
 
+impl AstBuilder<ast::WhereClause> {
     pub fn from_predicates(preds: impl Iterator<Item = ast::WherePred>) -> ast::WhereClause {
         let preds = preds.map(|p| p.syntax().to_string()).collect::<Vec<_>>().join(", ");
         Self::from_text(preds.as_str())
     }
+
+    fn from_text(text: &str) -> ast::WhereClause {
+        ast_node_from_file_text(&format!("fn f() where {} {{ }}", text))
+    }
 }
 
 fn ast_node_from_file_text<N: AstNode>(text: &str) -> N {
-- 
cgit v1.2.3


From 32843ae6f7f91cea88edcec428cb5bad07bd5e98 Mon Sep 17 00:00:00 2001
From: Aleksey Kladov <aleksey.kladov@gmail.com>
Date: Wed, 25 Sep 2019 15:28:26 +0300
Subject: shorten AstBuilder names

---
 crates/ra_assists/src/ast_builder.rs | 48 ++++++++++++++++--------------------
 1 file changed, 21 insertions(+), 27 deletions(-)

(limited to 'crates/ra_assists/src/ast_builder.rs')

diff --git a/crates/ra_assists/src/ast_builder.rs b/crates/ra_assists/src/ast_builder.rs
index 171b1c936..f6409085a 100644
--- a/crates/ra_assists/src/ast_builder.rs
+++ b/crates/ra_assists/src/ast_builder.rs
@@ -2,12 +2,12 @@ use itertools::Itertools;
 
 use ra_syntax::{ast, AstNode, SourceFile};
 
-pub struct AstBuilder<N: AstNode> {
+pub struct Make<N: AstNode> {
     _phantom: std::marker::PhantomData<N>,
 }
 
-impl AstBuilder<ast::RecordField> {
-    pub fn from_pieces(name: ast::NameRef, expr: Option<ast::Expr>) -> ast::RecordField {
+impl Make<ast::RecordField> {
+    pub fn from(name: ast::NameRef, expr: Option<ast::Expr>) -> ast::RecordField {
         match expr {
             Some(expr) => Self::from_text(&format!("{}: {}", name.syntax(), expr.syntax())),
             None => Self::from_text(&name.syntax().to_string()),
@@ -19,7 +19,7 @@ impl AstBuilder<ast::RecordField> {
     }
 }
 
-impl AstBuilder<ast::Block> {
+impl Make<ast::Block> {
     pub fn single_expr(e: ast::Expr) -> ast::Block {
         Self::from_text(&format!("{{ {} }}", e.syntax()))
     }
@@ -29,7 +29,7 @@ impl AstBuilder<ast::Block> {
     }
 }
 
-impl AstBuilder<ast::Expr> {
+impl Make<ast::Expr> {
     pub fn unit() -> ast::Expr {
         Self::from_text("()")
     }
@@ -43,19 +43,19 @@ impl AstBuilder<ast::Expr> {
     }
 }
 
-impl AstBuilder<ast::NameRef> {
+impl Make<ast::NameRef> {
     pub fn new(text: &str) -> ast::NameRef {
         ast_node_from_file_text(&format!("fn f() {{ {}; }}", text))
     }
 }
 
-impl AstBuilder<ast::Path> {
+impl Make<ast::Path> {
     pub fn from_name(name: ast::Name) -> ast::Path {
         let name = name.syntax().to_string();
         Self::from_text(name.as_str())
     }
 
-    pub fn from_pieces(enum_name: ast::Name, var_name: ast::Name) -> ast::Path {
+    pub fn from(enum_name: ast::Name, var_name: ast::Name) -> ast::Path {
         Self::from_text(&format!("{}::{}", enum_name.syntax(), var_name.syntax()))
     }
 
@@ -64,7 +64,7 @@ impl AstBuilder<ast::Path> {
     }
 }
 
-impl AstBuilder<ast::BindPat> {
+impl Make<ast::BindPat> {
     pub fn from_name(name: ast::Name) -> ast::BindPat {
         Self::from_text(name.text())
     }
@@ -74,7 +74,7 @@ impl AstBuilder<ast::BindPat> {
     }
 }
 
-impl AstBuilder<ast::PlaceholderPat> {
+impl Make<ast::PlaceholderPat> {
     pub fn placeholder() -> ast::PlaceholderPat {
         Self::from_text("_")
     }
@@ -84,11 +84,8 @@ impl AstBuilder<ast::PlaceholderPat> {
     }
 }
 
-impl AstBuilder<ast::TupleStructPat> {
-    pub fn from_pieces(
-        path: ast::Path,
-        pats: impl Iterator<Item = ast::Pat>,
-    ) -> ast::TupleStructPat {
+impl Make<ast::TupleStructPat> {
+    pub fn from(path: ast::Path, pats: impl Iterator<Item = ast::Pat>) -> ast::TupleStructPat {
         let pats_str = pats.map(|p| p.syntax().to_string()).collect::<Vec<_>>().join(", ");
         Self::from_text(&format!("{}({})", path.syntax(), pats_str))
     }
@@ -98,8 +95,8 @@ impl AstBuilder<ast::TupleStructPat> {
     }
 }
 
-impl AstBuilder<ast::RecordPat> {
-    pub fn from_pieces(path: ast::Path, pats: impl Iterator<Item = ast::Pat>) -> ast::RecordPat {
+impl Make<ast::RecordPat> {
+    pub fn from(path: ast::Path, pats: impl Iterator<Item = ast::Pat>) -> ast::RecordPat {
         let pats_str = pats.map(|p| p.syntax().to_string()).collect::<Vec<_>>().join(", ");
         Self::from_text(&format!("{}{{ {} }}", path.syntax(), pats_str))
     }
@@ -109,7 +106,7 @@ impl AstBuilder<ast::RecordPat> {
     }
 }
 
-impl AstBuilder<ast::PathPat> {
+impl Make<ast::PathPat> {
     pub fn from_path(path: ast::Path) -> ast::PathPat {
         let path_str = path.syntax().text().to_string();
         Self::from_text(path_str.as_str())
@@ -120,8 +117,8 @@ impl AstBuilder<ast::PathPat> {
     }
 }
 
-impl AstBuilder<ast::MatchArm> {
-    pub fn from_pieces(pats: impl Iterator<Item = ast::Pat>, expr: ast::Expr) -> ast::MatchArm {
+impl Make<ast::MatchArm> {
+    pub fn from(pats: impl Iterator<Item = ast::Pat>, expr: ast::Expr) -> ast::MatchArm {
         let pats_str = pats.map(|p| p.syntax().to_string()).join(" | ");
         Self::from_text(&format!("{} => {}", pats_str, expr.syntax()))
     }
@@ -131,7 +128,7 @@ impl AstBuilder<ast::MatchArm> {
     }
 }
 
-impl AstBuilder<ast::MatchArmList> {
+impl Make<ast::MatchArmList> {
     pub fn from_arms(arms: impl Iterator<Item = ast::MatchArm>) -> ast::MatchArmList {
         let arms_str = arms.map(|arm| format!("\n    {}", arm.syntax())).join(",");
         Self::from_text(&format!("{},\n", arms_str))
@@ -142,11 +139,8 @@ impl AstBuilder<ast::MatchArmList> {
     }
 }
 
-impl AstBuilder<ast::WherePred> {
-    pub fn from_pieces(
-        path: ast::Path,
-        bounds: impl Iterator<Item = ast::TypeBound>,
-    ) -> ast::WherePred {
+impl Make<ast::WherePred> {
+    pub fn from(path: ast::Path, bounds: impl Iterator<Item = ast::TypeBound>) -> ast::WherePred {
         let bounds = bounds.map(|b| b.syntax().to_string()).collect::<Vec<_>>().join(" + ");
         Self::from_text(&format!("{}: {}", path.syntax(), bounds))
     }
@@ -156,7 +150,7 @@ impl AstBuilder<ast::WherePred> {
     }
 }
 
-impl AstBuilder<ast::WhereClause> {
+impl Make<ast::WhereClause> {
     pub fn from_predicates(preds: impl Iterator<Item = ast::WherePred>) -> ast::WhereClause {
         let preds = preds.map(|p| p.syntax().to_string()).collect::<Vec<_>>().join(", ");
         Self::from_text(preds.as_str())
-- 
cgit v1.2.3


From efeae82f5221d2fdeeeed0bc67a2234647e160dd Mon Sep 17 00:00:00 2001
From: Aleksey Kladov <aleksey.kladov@gmail.com>
Date: Wed, 25 Sep 2019 15:58:40 +0300
Subject: clean up naming

---
 crates/ra_assists/src/ast_builder.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'crates/ra_assists/src/ast_builder.rs')

diff --git a/crates/ra_assists/src/ast_builder.rs b/crates/ra_assists/src/ast_builder.rs
index f6409085a..9a62b96b3 100644
--- a/crates/ra_assists/src/ast_builder.rs
+++ b/crates/ra_assists/src/ast_builder.rs
@@ -44,7 +44,7 @@ impl Make<ast::Expr> {
 }
 
 impl Make<ast::NameRef> {
-    pub fn new(text: &str) -> ast::NameRef {
+    pub fn from(text: &str) -> ast::NameRef {
         ast_node_from_file_text(&format!("fn f() {{ {}; }}", text))
     }
 }
-- 
cgit v1.2.3