bendns' repos / rust-analyzer
Unnamed repository; edit this file 'description' to name the repository.
Diffstat (limited to 'crates/syntax/src/ast/syntax_factory/constructors.rs')
-rw-r--r--crates/syntax/src/ast/syntax_factory/constructors.rs124
1 files changed, 120 insertions, 4 deletions
diff --git a/crates/syntax/src/ast/syntax_factory/constructors.rs b/crates/syntax/src/ast/syntax_factory/constructors.rs
index 1854000d3d..8dee3964d4 100644
--- a/crates/syntax/src/ast/syntax_factory/constructors.rs
+++ b/crates/syntax/src/ast/syntax_factory/constructors.rs
@@ -3,7 +3,7 @@ use crate::{
AstNode, NodeOrToken, SyntaxKind, SyntaxNode, SyntaxToken,
ast::{
self, HasArgList, HasGenericArgs, HasGenericParams, HasLoopBody, HasName, HasTypeBounds,
- HasVisibility, make,
+ HasVisibility, RangeItem, make,
},
syntax_editor::SyntaxMappingBuilder,
};
@@ -107,6 +107,20 @@ impl SyntaxFactory {
ast
}
+ pub fn use_(&self, visibility: Option<ast::Visibility>, use_tree: ast::UseTree) -> ast::Use {
+ make::use_(visibility, use_tree).clone_for_update()
+ }
+
+ pub fn use_tree(
+ &self,
+ path: ast::Path,
+ use_tree_list: Option<ast::UseTreeList>,
+ alias: Option<ast::Rename>,
+ add_star: bool,
+ ) -> ast::UseTree {
+ make::use_tree(path, use_tree_list, alias, add_star).clone_for_update()
+ }
+
pub fn path_unqualified(&self, segment: ast::PathSegment) -> ast::Path {
let ast = make::path_unqualified(segment.clone()).clone_for_update();
@@ -254,12 +268,12 @@ impl SyntaxFactory {
ast
}
- pub fn record_pat_field_shorthand(&self, name_ref: ast::NameRef) -> ast::RecordPatField {
- let ast = make::record_pat_field_shorthand(name_ref.clone()).clone_for_update();
+ pub fn record_pat_field_shorthand(&self, pat: ast::Pat) -> ast::RecordPatField {
+ let ast = make::record_pat_field_shorthand(pat.clone()).clone_for_update();
if let Some(mut mapping) = self.mappings() {
let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
- builder.map_node(name_ref.syntax().clone(), ast.pat().unwrap().syntax().clone());
+ builder.map_node(pat.syntax().clone(), ast.pat().unwrap().syntax().clone());
builder.finish(&mut mapping);
}
@@ -294,6 +308,76 @@ impl SyntaxFactory {
make::rest_pat().clone_for_update()
}
+ pub fn or_pat(
+ &self,
+ pats: impl IntoIterator<Item = ast::Pat>,
+ leading_pipe: bool,
+ ) -> ast::OrPat {
+ let (pats, input) = iterator_input(pats);
+ let ast = make::or_pat(pats, leading_pipe).clone_for_update();
+
+ if let Some(mut mapping) = self.mappings() {
+ let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
+ builder.map_children(input, ast.pats().map(|it| it.syntax().clone()));
+ builder.finish(&mut mapping);
+ }
+
+ ast
+ }
+
+ pub fn box_pat(&self, pat: ast::Pat) -> ast::BoxPat {
+ let ast = make::box_pat(pat.clone()).clone_for_update();
+
+ if let Some(mut mapping) = self.mappings() {
+ let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
+ builder.map_node(pat.syntax().clone(), ast.pat().unwrap().syntax().clone());
+ builder.finish(&mut mapping);
+ }
+
+ ast
+ }
+
+ pub fn paren_pat(&self, pat: ast::Pat) -> ast::ParenPat {
+ let ast = make::paren_pat(pat.clone()).clone_for_update();
+
+ if let Some(mut mapping) = self.mappings() {
+ let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
+ builder.map_node(pat.syntax().clone(), ast.pat().unwrap().syntax().clone());
+ builder.finish(&mut mapping);
+ }
+
+ ast
+ }
+
+ pub fn range_pat(&self, start: Option<ast::Pat>, end: Option<ast::Pat>) -> ast::RangePat {
+ let ast = make::range_pat(start.clone(), end.clone()).clone_for_update();
+
+ if let Some(mut mapping) = self.mappings() {
+ let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
+ if let Some(start) = start {
+ builder.map_node(start.syntax().clone(), ast.start().unwrap().syntax().clone());
+ }
+ if let Some(end) = end {
+ builder.map_node(end.syntax().clone(), ast.end().unwrap().syntax().clone());
+ }
+ builder.finish(&mut mapping);
+ }
+
+ ast
+ }
+
+ pub fn ref_pat(&self, pat: ast::Pat) -> ast::RefPat {
+ let ast = make::ref_pat(pat.clone()).clone_for_update();
+
+ if let Some(mut mapping) = self.mappings() {
+ let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
+ builder.map_node(pat.syntax().clone(), ast.pat().unwrap().syntax().clone());
+ builder.finish(&mut mapping);
+ }
+
+ ast
+ }
+
pub fn block_expr(
&self,
statements: impl IntoIterator<Item = ast::Stmt>,
@@ -673,6 +757,38 @@ impl SyntaxFactory {
ast
}
+ pub fn let_else_stmt(
+ &self,
+ pattern: ast::Pat,
+ ty: Option<ast::Type>,
+ initializer: ast::Expr,
+ diverging: ast::BlockExpr,
+ ) -> ast::LetStmt {
+ let ast = make::let_else_stmt(
+ pattern.clone(),
+ ty.clone(),
+ initializer.clone(),
+ diverging.clone(),
+ )
+ .clone_for_update();
+
+ if let Some(mut mapping) = self.mappings() {
+ let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
+ builder.map_node(pattern.syntax().clone(), ast.pat().unwrap().syntax().clone());
+ if let Some(input) = ty {
+ builder.map_node(input.syntax().clone(), ast.ty().unwrap().syntax().clone());
+ }
+ builder.map_node(
+ initializer.syntax().clone(),
+ ast.initializer().unwrap().syntax().clone(),
+ );
+ builder.map_node(diverging.syntax().clone(), ast.let_else().unwrap().syntax().clone());
+ builder.finish(&mut mapping);
+ }
+
+ ast
+ }
+
pub fn type_arg(&self, ty: ast::Type) -> ast::TypeArg {
let ast = make::type_arg(ty.clone()).clone_for_update();