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.rs288
1 files changed, 268 insertions, 20 deletions
diff --git a/crates/syntax/src/ast/syntax_factory/constructors.rs b/crates/syntax/src/ast/syntax_factory/constructors.rs
index 572622db54..85393ca5b4 100644
--- a/crates/syntax/src/ast/syntax_factory/constructors.rs
+++ b/crates/syntax/src/ast/syntax_factory/constructors.rs
@@ -129,7 +129,7 @@ impl SyntaxFactory {
if let Some(mut mapping) = self.mappings() {
let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
- builder.map_children(input.into_iter(), ast.segments().map(|it| it.syntax().clone()));
+ builder.map_children(input, ast.segments().map(|it| it.syntax().clone()));
builder.finish(&mut mapping);
}
@@ -156,6 +156,32 @@ impl SyntaxFactory {
make::literal_pat(text).clone_for_update()
}
+ pub fn slice_pat(&self, pats: impl IntoIterator<Item = ast::Pat>) -> ast::SlicePat {
+ let (pats, input) = iterator_input(pats);
+ let ast = make::slice_pat(pats).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 tuple_pat(&self, pats: impl IntoIterator<Item = ast::Pat>) -> ast::TuplePat {
+ let (pats, input) = iterator_input(pats);
+ let ast = make::tuple_pat(pats).clone_for_update();
+
+ if let Some(mut mapping) = self.mappings() {
+ let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
+ builder.map_children(input, ast.fields().map(|it| it.syntax().clone()));
+ builder.finish(&mut mapping);
+ }
+
+ ast
+ }
+
pub fn tuple_struct_pat(
&self,
path: ast::Path,
@@ -167,13 +193,103 @@ impl SyntaxFactory {
if let Some(mut mapping) = self.mappings() {
let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
builder.map_node(path.syntax().clone(), ast.path().unwrap().syntax().clone());
- builder.map_children(input.into_iter(), ast.fields().map(|it| it.syntax().clone()));
+ builder.map_children(input, ast.fields().map(|it| it.syntax().clone()));
builder.finish(&mut mapping);
}
ast
}
+ pub fn record_pat_with_fields(
+ &self,
+ path: ast::Path,
+ fields: ast::RecordPatFieldList,
+ ) -> ast::RecordPat {
+ let ast = make::record_pat_with_fields(path.clone(), fields.clone()).clone_for_update();
+
+ if let Some(mut mapping) = self.mappings() {
+ let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
+ builder.map_node(path.syntax().clone(), ast.path().unwrap().syntax().clone());
+ builder.map_node(
+ fields.syntax().clone(),
+ ast.record_pat_field_list().unwrap().syntax().clone(),
+ );
+ builder.finish(&mut mapping);
+ }
+
+ ast
+ }
+
+ pub fn record_pat_field_list(
+ &self,
+ fields: impl IntoIterator<Item = ast::RecordPatField>,
+ rest_pat: Option<ast::RestPat>,
+ ) -> ast::RecordPatFieldList {
+ let (fields, input) = iterator_input(fields);
+ let ast = make::record_pat_field_list(fields, rest_pat.clone()).clone_for_update();
+
+ if let Some(mut mapping) = self.mappings() {
+ let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
+ builder.map_children(input, ast.fields().map(|it| it.syntax().clone()));
+ if let Some(rest_pat) = rest_pat {
+ builder
+ .map_node(rest_pat.syntax().clone(), ast.rest_pat().unwrap().syntax().clone());
+ }
+ builder.finish(&mut mapping);
+ }
+
+ ast
+ }
+
+ pub fn record_pat_field(self, name_ref: ast::NameRef, pat: ast::Pat) -> ast::RecordPatField {
+ let ast = make::record_pat_field(name_ref.clone(), 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.name_ref().unwrap().syntax().clone());
+ builder.map_node(pat.syntax().clone(), ast.pat().unwrap().syntax().clone());
+ builder.finish(&mut mapping);
+ }
+
+ 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();
+
+ 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.finish(&mut mapping);
+ }
+
+ ast
+ }
+
+ pub fn path_pat(&self, path: ast::Path) -> ast::Pat {
+ let ast = make::path_pat(path.clone()).clone_for_update();
+
+ match &ast {
+ ast::Pat::PathPat(ast) => {
+ if let Some(mut mapping) = self.mappings() {
+ let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
+ builder.map_node(path.syntax().clone(), ast.path().unwrap().syntax().clone());
+ builder.finish(&mut mapping)
+ }
+ }
+ ast::Pat::IdentPat(ast) => {
+ if let Some(mut mapping) = self.mappings() {
+ let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
+ builder.map_node(path.syntax().clone(), ast.name().unwrap().syntax().clone());
+ builder.finish(&mut mapping)
+ }
+ }
+ _ => unreachable!(),
+ }
+
+ ast
+ }
+
pub fn block_expr(
&self,
statements: impl IntoIterator<Item = ast::Stmt>,
@@ -199,10 +315,7 @@ impl SyntaxFactory {
builder.map_node(last_stmt, ast_tail.syntax().clone());
}
- builder.map_children(
- input.into_iter(),
- stmt_list.statements().map(|it| it.syntax().clone()),
- );
+ builder.map_children(input, stmt_list.statements().map(|it| it.syntax().clone()));
builder.finish(&mut mapping);
}
@@ -214,13 +327,28 @@ impl SyntaxFactory {
make::expr_empty_block().clone_for_update()
}
+ pub fn expr_paren(&self, expr: ast::Expr) -> ast::ParenExpr {
+ // FIXME: `make::expr_paren` should return a `ParenExpr`, not just an `Expr`
+ let ast::Expr::ParenExpr(ast) = make::expr_paren(expr.clone()).clone_for_update() else {
+ unreachable!()
+ };
+
+ if let Some(mut mapping) = self.mappings() {
+ let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
+ builder.map_node(expr.syntax().clone(), ast.expr().unwrap().syntax().clone());
+ builder.finish(&mut mapping);
+ }
+
+ ast
+ }
+
pub fn expr_tuple(&self, fields: impl IntoIterator<Item = ast::Expr>) -> ast::TupleExpr {
let (fields, input) = iterator_input(fields);
let ast = make::expr_tuple(fields).clone_for_update();
if let Some(mut mapping) = self.mappings() {
let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
- builder.map_children(input.into_iter(), ast.fields().map(|it| it.syntax().clone()));
+ builder.map_children(input, ast.fields().map(|it| it.syntax().clone()));
builder.finish(&mut mapping);
}
@@ -292,13 +420,38 @@ impl SyntaxFactory {
ast
}
+ pub fn expr_method_call(
+ &self,
+ receiver: ast::Expr,
+ method: ast::NameRef,
+ arg_list: ast::ArgList,
+ ) -> ast::MethodCallExpr {
+ // FIXME: `make::expr_method_call` should return a `MethodCallExpr`, not just an `Expr`
+ let ast::Expr::MethodCallExpr(ast) =
+ make::expr_method_call(receiver.clone(), method.clone(), arg_list.clone())
+ .clone_for_update()
+ else {
+ unreachable!()
+ };
+
+ if let Some(mut mapping) = self.mappings() {
+ let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
+ builder.map_node(receiver.syntax().clone(), ast.receiver().unwrap().syntax().clone());
+ builder.map_node(method.syntax().clone(), ast.name_ref().unwrap().syntax().clone());
+ builder.map_node(arg_list.syntax().clone(), ast.arg_list().unwrap().syntax().clone());
+ builder.finish(&mut mapping);
+ }
+
+ ast
+ }
+
pub fn arg_list(&self, args: impl IntoIterator<Item = ast::Expr>) -> ast::ArgList {
let (args, input) = iterator_input(args);
let ast = make::arg_list(args).clone_for_update();
if let Some(mut mapping) = self.mappings() {
let mut builder = SyntaxMappingBuilder::new(ast.syntax.clone());
- builder.map_children(input.into_iter(), ast.args().map(|it| it.syntax().clone()));
+ builder.map_children(input, ast.args().map(|it| it.syntax().clone()));
builder.finish(&mut mapping);
}
@@ -320,6 +473,31 @@ impl SyntaxFactory {
ast.into()
}
+ pub fn expr_closure(
+ &self,
+ pats: impl IntoIterator<Item = ast::Param>,
+ expr: ast::Expr,
+ ) -> ast::ClosureExpr {
+ let (args, input) = iterator_input(pats);
+ // FIXME: `make::expr_paren` should return a `ClosureExpr`, not just an `Expr`
+ let ast::Expr::ClosureExpr(ast) = make::expr_closure(args, expr.clone()).clone_for_update()
+ else {
+ unreachable!()
+ };
+
+ if let Some(mut mapping) = self.mappings() {
+ let mut builder = SyntaxMappingBuilder::new(ast.syntax.clone());
+ builder.map_children(
+ input,
+ ast.param_list().unwrap().params().map(|param| param.syntax().clone()),
+ );
+ builder.map_node(expr.syntax().clone(), ast.body().unwrap().syntax().clone());
+ builder.finish(&mut mapping);
+ }
+
+ ast
+ }
+
pub fn expr_return(&self, expr: Option<ast::Expr>) -> ast::ReturnExpr {
let ast::Expr::ReturnExpr(ast) = make::expr_return(expr.clone()).clone_for_update() else {
unreachable!()
@@ -448,7 +626,7 @@ impl SyntaxFactory {
if let Some(mut mapping) = self.mappings() {
let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
- builder.map_children(input.into_iter(), ast.arms().map(|it| it.syntax().clone()));
+ builder.map_children(input, ast.arms().map(|it| it.syntax().clone()));
builder.finish(&mut mapping);
}
@@ -571,6 +749,19 @@ impl SyntaxFactory {
ast
}
+ pub fn param(&self, pat: ast::Pat, ty: ast::Type) -> ast::Param {
+ let ast = make::param(pat.clone(), ty.clone());
+
+ 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.map_node(ty.syntax().clone(), ast.ty().unwrap().syntax().clone());
+ builder.finish(&mut mapping);
+ }
+
+ ast
+ }
+
pub fn generic_arg_list(
&self,
generic_args: impl IntoIterator<Item = ast::GenericArg>,
@@ -585,10 +776,7 @@ impl SyntaxFactory {
if let Some(mut mapping) = self.mappings() {
let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
- builder.map_children(
- input.into_iter(),
- ast.generic_args().map(|arg| arg.syntax().clone()),
- );
+ builder.map_children(input, ast.generic_args().map(|arg| arg.syntax().clone()));
builder.finish(&mut mapping);
}
@@ -605,7 +793,7 @@ impl SyntaxFactory {
if let Some(mut mapping) = self.mappings() {
let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
- builder.map_children(input.into_iter(), ast.fields().map(|it| it.syntax().clone()));
+ builder.map_children(input, ast.fields().map(|it| it.syntax().clone()));
builder.finish(&mut mapping);
}
@@ -650,7 +838,7 @@ impl SyntaxFactory {
if let Some(mut mapping) = self.mappings() {
let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
- builder.map_children(input.into_iter(), ast.fields().map(|it| it.syntax().clone()));
+ builder.map_children(input, ast.fields().map(|it| it.syntax().clone()));
builder.finish(&mut mapping);
}
@@ -745,7 +933,7 @@ impl SyntaxFactory {
if let Some(mut mapping) = self.mappings() {
let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
- builder.map_children(input.into_iter(), ast.variants().map(|it| it.syntax().clone()));
+ builder.map_children(input, ast.variants().map(|it| it.syntax().clone()));
builder.finish(&mut mapping);
}
@@ -797,6 +985,69 @@ impl SyntaxFactory {
ast
}
+ pub fn fn_(
+ &self,
+ visibility: Option<ast::Visibility>,
+ fn_name: ast::Name,
+ type_params: Option<ast::GenericParamList>,
+ where_clause: Option<ast::WhereClause>,
+ params: ast::ParamList,
+ body: ast::BlockExpr,
+ ret_type: Option<ast::RetType>,
+ is_async: bool,
+ is_const: bool,
+ is_unsafe: bool,
+ is_gen: bool,
+ ) -> ast::Fn {
+ let ast = make::fn_(
+ visibility.clone(),
+ fn_name.clone(),
+ type_params.clone(),
+ where_clause.clone(),
+ params.clone(),
+ body.clone(),
+ ret_type.clone(),
+ is_async,
+ is_const,
+ is_unsafe,
+ is_gen,
+ );
+
+ if let Some(mut mapping) = self.mappings() {
+ let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
+
+ if let Some(visibility) = visibility {
+ builder.map_node(
+ visibility.syntax().clone(),
+ ast.visibility().unwrap().syntax().clone(),
+ );
+ }
+ builder.map_node(fn_name.syntax().clone(), ast.name().unwrap().syntax().clone());
+ if let Some(type_params) = type_params {
+ builder.map_node(
+ type_params.syntax().clone(),
+ ast.generic_param_list().unwrap().syntax().clone(),
+ );
+ }
+ if let Some(where_clause) = where_clause {
+ builder.map_node(
+ where_clause.syntax().clone(),
+ ast.where_clause().unwrap().syntax().clone(),
+ );
+ }
+ builder.map_node(params.syntax().clone(), ast.param_list().unwrap().syntax().clone());
+ builder.map_node(body.syntax().clone(), ast.body().unwrap().syntax().clone());
+ if let Some(ret_type) = ret_type {
+ builder
+ .map_node(ret_type.syntax().clone(), ast.ret_type().unwrap().syntax().clone());
+ }
+
+ builder.finish(&mut mapping);
+ }
+
+ ast
+ }
+
pub fn token_tree(
&self,
delimiter: SyntaxKind,
@@ -809,10 +1060,7 @@ impl SyntaxFactory {
if let Some(mut mapping) = self.mappings() {
let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
- builder.map_children(
- input.into_iter(),
- ast.token_trees_and_tokens().filter_map(only_nodes),
- );
+ builder.map_children(input, ast.token_trees_and_tokens().filter_map(only_nodes));
builder.finish(&mut mapping);
}