language-servers/rust-analyzer
1
0
Fork 0
mirror of https://github.com/rust-lang/rust-analyzer.git synced 2025-10-21 15:51:46 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

Merge pull request #19253 from ShoyuVanilla/migrate-convert-bool-then

Browse source 
internal: Migrate `convert_bool_then` to `SyntaxEditor`
This commit is contained in:
Lukas Wirth 2025-03-02 07:21:04 +00:00 • committed by GitHub
commit 1ce1f087da
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
4 changed files with 174 additions and 60 deletions
Download patch file Download diff file Expand all files Collapse all files

138
crates/syntax/src/ast/syntax_factory/constructors.rs
View file

@ -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);
}
@ -162,7 +162,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.pats().map(|it| it.syntax().clone()));
builder.map_children(input, ast.pats().map(|it| it.syntax().clone()));
builder.finish(&mut mapping);
}
@ -175,7 +175,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);
}
@ -193,7 +193,7 @@ 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);
}
@ -230,7 +230,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()));
if let Some(rest_pat) = rest_pat {
builder
.map_node(rest_pat.syntax().clone(), ast.rest_pat().unwrap().syntax().clone());
@ -315,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);
}
@ -351,7 +348,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);
}
@ -454,7 +451,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.args().map(|it| it.syntax().clone()));
builder.map_children(input, ast.args().map(|it| it.syntax().clone()));
builder.finish(&mut mapping);
}
@ -476,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!()
@ -604,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);
}
@ -727,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>,
@ -741,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);
}
@ -761,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);
}
@ -806,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);
}
@ -901,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);
}
@ -953,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,
@ -965,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);
}

6
crates/syntax/src/syntax_editor/mapping.rs
View file

@ -239,10 +239,10 @@ impl SyntaxMappingBuilder {
pub fn map_children(
&mut self,
input: impl Iterator<Item = SyntaxNode>,
output: impl Iterator<Item = SyntaxNode>,
input: impl IntoIterator<Item = SyntaxNode>,
output: impl IntoIterator<Item = SyntaxNode>,
) {
for pairs in input.zip_longest(output) {
for pairs in input.into_iter().zip_longest(output) {
let (input, output) = match pairs {
itertools::EitherOrBoth::Both(l, r) => (l, r),
itertools::EitherOrBoth::Left(_) => {