From 183a38fb50f284de1ca02c05ed945e240f3c0274 Mon Sep 17 00:00:00 2001
From: Aleksey Kladov <aleksey.kladov@gmail.com>
Date: Thu, 26 Sep 2019 12:18:26 +0300
Subject: keep ast creation API simple

---
 crates/ra_syntax/src/ast/make.rs | 135 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 135 insertions(+)
 create mode 100644 crates/ra_syntax/src/ast/make.rs

(limited to 'crates/ra_syntax/src/ast/make.rs')

diff --git a/crates/ra_syntax/src/ast/make.rs b/crates/ra_syntax/src/ast/make.rs
new file mode 100644
index 000000000..c06c62b3b
--- /dev/null
+++ b/crates/ra_syntax/src/ast/make.rs
@@ -0,0 +1,135 @@
+//! This module contains free-standing functions for creating AST fragments out
+//! of smaller pieces.
+use itertools::Itertools;
+
+use crate::{ast, AstNode, SourceFile};
+
+pub fn name_ref(text: &str) -> ast::NameRef {
+    ast_from_text(&format!("fn f() {{ {}; }}", text))
+}
+
+pub fn path_from_name_ref(name_ref: ast::NameRef) -> ast::Path {
+    path_from_text(&name_ref.syntax().to_string())
+}
+pub fn path_qualified(qual: ast::Path, name_ref: ast::NameRef) -> ast::Path {
+    path_from_text(&format!("{}::{}", qual.syntax(), name_ref.syntax()))
+}
+fn path_from_text(text: &str) -> ast::Path {
+    ast_from_text(text)
+}
+
+pub fn record_field(name: ast::NameRef, expr: Option<ast::Expr>) -> ast::RecordField {
+    return match expr {
+        Some(expr) => from_text(&format!("{}: {}", name.syntax(), expr.syntax())),
+        None => from_text(&name.syntax().to_string()),
+    };
+
+    fn from_text(text: &str) -> ast::RecordField {
+        ast_from_text(&format!("fn f() {{ S {{ {}, }} }}", text))
+    }
+}
+
+pub fn block_from_expr(e: ast::Expr) -> ast::Block {
+    return from_text(&format!("{{ {} }}", e.syntax()));
+
+    fn from_text(text: &str) -> ast::Block {
+        ast_from_text(&format!("fn f() {}", text))
+    }
+}
+
+pub fn expr_unit() -> ast::Expr {
+    expr_from_text("()")
+}
+pub fn expr_unimplemented() -> ast::Expr {
+    expr_from_text("unimplemented!()")
+}
+fn expr_from_text(text: &str) -> ast::Expr {
+    ast_from_text(&format!("const C: () = {};", text))
+}
+
+pub fn bind_pat(name: ast::Name) -> ast::BindPat {
+    return from_text(name.text());
+
+    fn from_text(text: &str) -> ast::BindPat {
+        ast_from_text(&format!("fn f({}: ())", text))
+    }
+}
+
+pub fn placeholder_pat() -> ast::PlaceholderPat {
+    return from_text("_");
+
+    fn from_text(text: &str) -> ast::PlaceholderPat {
+        ast_from_text(&format!("fn f({}: ())", text))
+    }
+}
+
+pub fn tuple_struct_pat(
+    path: ast::Path,
+    pats: impl Iterator<Item = ast::Pat>,
+) -> ast::TupleStructPat {
+    let pats_str = pats.map(|p| p.syntax().to_string()).join(", ");
+    return from_text(&format!("{}({})", path.syntax(), pats_str));
+
+    fn from_text(text: &str) -> ast::TupleStructPat {
+        ast_from_text(&format!("fn f({}: ())", text))
+    }
+}
+
+pub fn record_pat(path: ast::Path, pats: impl Iterator<Item = ast::Pat>) -> ast::RecordPat {
+    let pats_str = pats.map(|p| p.syntax().to_string()).join(", ");
+    return from_text(&format!("{}{{ {} }}", path.syntax(), pats_str));
+
+    fn from_text(text: &str) -> ast::RecordPat {
+        ast_from_text(&format!("fn f({}: ())", text))
+    }
+}
+
+pub fn path_pat(path: ast::Path) -> ast::PathPat {
+    let path_str = path.syntax().text().to_string();
+    return from_text(path_str.as_str());
+    fn from_text(text: &str) -> ast::PathPat {
+        ast_from_text(&format!("fn f({}: ())", text))
+    }
+}
+
+pub fn match_arm(pats: impl Iterator<Item = ast::Pat>, expr: ast::Expr) -> ast::MatchArm {
+    let pats_str = pats.map(|p| p.syntax().to_string()).join(" | ");
+    return from_text(&format!("{} => {}", pats_str, expr.syntax()));
+
+    fn from_text(text: &str) -> ast::MatchArm {
+        ast_from_text(&format!("fn f() {{ match () {{{}}} }}", text))
+    }
+}
+
+pub fn match_arm_list(arms: impl Iterator<Item = ast::MatchArm>) -> ast::MatchArmList {
+    let arms_str = arms.map(|arm| format!("\n    {}", arm.syntax())).join(",");
+    return from_text(&format!("{},\n", arms_str));
+
+    fn from_text(text: &str) -> ast::MatchArmList {
+        ast_from_text(&format!("fn f() {{ match () {{{}}} }}", text))
+    }
+}
+
+pub fn where_pred(path: ast::Path, bounds: impl Iterator<Item = ast::TypeBound>) -> ast::WherePred {
+    let bounds = bounds.map(|b| b.syntax().to_string()).join(" + ");
+    return from_text(&format!("{}: {}", path.syntax(), bounds));
+
+    fn from_text(text: &str) -> ast::WherePred {
+        ast_from_text(&format!("fn f() where {} {{ }}", text))
+    }
+}
+
+pub fn where_clause(preds: impl Iterator<Item = ast::WherePred>) -> ast::WhereClause {
+    let preds = preds.map(|p| p.syntax().to_string()).join(", ");
+    return from_text(preds.as_str());
+
+    fn from_text(text: &str) -> ast::WhereClause {
+        ast_from_text(&format!("fn f() where {} {{ }}", text))
+    }
+}
+
+fn ast_from_text<N: AstNode>(text: &str) -> N {
+    let parse = SourceFile::parse(text);
+    let res = parse.tree().syntax().descendants().find_map(N::cast).unwrap();
+    res
+}
-- 
cgit v1.2.3