}

pub(super) fn clone_increase_indent(self, node: &SyntaxNode) -> SyntaxNode {

let tokens = node

.preorder_with_tokens()

.filter_map(|event| match event {

}

pub(super) fn clone_decrease_indent(self, node: &SyntaxNode) -> SyntaxNode {

let tokens = node

.preorder_with_tokens()

.filter_map(|event| match event {

impl<N: AstNode + Clone> AstNodeEdit for N {}

impl ast::IdentPat {

match pat {

None => {

if let Some(at_token) = self.at_token() {

.pat()

.map(|it| it.syntax().clone().into())

.unwrap_or_else(|| at_token.into());

// Remove any trailing ws

if let Some(last) =

Some(pat) => {

if let Some(old_pat) = self.pat() {

// Replace existing pattern

} else if let Some(at_token) = self.at_token() {

// Have an `@` token but not a pattern yet

} else {

// Don't have an `@`, should have a name

let name = self.name().unwrap();

let elements = vec![

pat.syntax().clone().into(),

];

if self.syntax().parent().is_none() {

let local_name = local_self.name().unwrap();

local.insert_all(Position::after(local_name.syntax()), elements);

let edit = local.finish();

return ast::IdentPat::cast(edit.new_root().clone()).unwrap();

} else {

}

}

}

//! [`SyntaxEditor`]: https://github.com/dotnet/roslyn/blob/43b0b05cc4f492fd5de00f6f6717409091df8daa/src/Workspaces/Core/Portable/Editing/SyntaxEditor.cs

use std::{

fmt, iter,

num::NonZeroU32,

ops::RangeInclusive,

#[derive(Debug)]

pub struct SyntaxEditor {

root: SyntaxNode,

make: SyntaxFactory,

}

let editor = Self {

root: root.clone(),

make: SyntaxFactory::with_mappings(),

};

&self.make

}

}

self.annotations

.extend(elements.into_iter().map(|e| e.syntax_element()).zip(iter::repeat(annotation)));

}

debug_assert!(

self.root == other.root || other.root.ancestors().any(|node| node == self.root),

"{:?} is not in the same tree as {:?}",

self.root

);

if let Some(mut m) = self.make.mappings() {

m.merge(other.make.take());

}

}

debug_assert!(is_ancestor_or_self(&position.parent(), &self.root));

}

debug_assert!(is_ancestor_or_self(&position.parent(), &self.root));

}

self.insert_all_with_whitespace(position, vec![element.syntax_element()])

}

if let Some(first) = elements.first()

&& let Some(ws) = ws_before(&position, first, &self.make)

{

self.insert_all(position, elements)

}

let element = element.syntax_element();

debug_assert!(is_ancestor_or_self_of_element(&element, &self.root));

debug_assert!(

!matches!(&element, SyntaxElement::Node(node) if node == &self.root),

"should not delete root node"

);

}

if range.start() == range.end() {

self.delete(range.start());

return;

}

debug_assert!(is_ancestor_or_self_of_element(range.start(), &self.root));

}

let old = old.syntax_element();

debug_assert!(is_ancestor_or_self_of_element(&old, &self.root));

}

let old = old.syntax_element();

debug_assert!(is_ancestor_or_self_of_element(&old, &self.root));

debug_assert!(

!(matches!(&old, SyntaxElement::Node(node) if node == &self.root) && new.len() > 1),

"cannot replace root node with many elements"

);

}

if range.start() == range.end() {

self.replace_with_many(range.start(), new);

return;

}

debug_assert!(is_ancestor_or_self_of_element(range.start(), &self.root));

}

pub fn finish(self) -> SyntaxEdit {

.into(),

);

let to_wrap = root.syntax().descendants().find_map(ast::TupleExpr::cast).unwrap();

let to_replace = root.syntax().descendants().find_map(ast::BinExpr::cast).unwrap();

editor.add_annotation(name.syntax(), placeholder_snippet);

editor.add_annotation(name_ref.syntax(), placeholder_snippet);

[editor

.make()

.let_stmt(

None,

Some(to_replace.clone().into()),

)

None,

);

let second_let = root.syntax().descendants().find_map(ast::LetStmt::cast).unwrap();

editor.insert(

Position::first_child_of(root.stmt_list().unwrap().syntax()),

);

editor.insert(

Position::after(second_let.syntax()),

);

let edit = editor.finish();

),

);

let inner_block =

root.syntax().descendants().flat_map(ast::BlockExpr::cast).nth(1).unwrap();

let second_let = root.syntax().descendants().find_map(ast::LetStmt::cast).unwrap();

make::ext::simple_ident_pat(make::name("first")).into(),

None,

Some(make::expr_literal("1").into()),

);

make::ext::simple_ident_pat(make::name("third")).into(),

None,

Some(make::expr_literal("3").into()),

None,

);

let inner_block = root;

make::ext::simple_ident_pat(make::name("first")).into(),

None,

Some(make::expr_literal("1").into()),

false,

);

if let Some(ret_ty) = parent_fn.ret_type() {

editor.delete(ret_ty.syntax().clone());

let arg_list =

make::arg_list([make::expr_literal("1").into(), make::expr_literal("2").into()]);

let target_expr = make::token(parser::SyntaxKind::UNDERSCORE);

let arg_list =

make::arg_list([make::expr_literal("1").into(), make::expr_literal("2").into()]);

let target_expr = make::expr_literal("3").clone_for_update();

let arg_list =

make::arg_list([make::expr_literal("1").into(), make::expr_literal("2").into()]);

let target_expr = make::ext::expr_unit().clone_for_update();

// - changed nodes become part of the changed node set (useful for the formatter to only change those parts)

// - Propagate annotations

let mappings = make.take();

let mut node_depths = FxHashMap::<SyntaxNode, usize>::default();

fn get_or_create_where_clause(

&self,

new_preds: impl Iterator<Item = ast::WherePred>,

) {

let existing = self.where_clause();

let all_preds: Vec<_> =

existing.iter().flat_map(|wc| wc.predicates()).chain(new_preds).collect();

if let Some(existing) = &existing {

editor.replace(existing.syntax(), new_where.syntax());

} else if let Some(pos) = self.where_clause_position() {

editor.insert_all(

pos,

);

}

}

impl SyntaxEditor {

/// Adds a new generic param to the function using `SyntaxEditor`

match function.generic_param_list() {

Some(generic_param_list) => match generic_param_list.generic_params().last() {

Some(last_param) => {

}

}

match syntax

.siblings_with_tokens(Direction::Next)

.filter_map(|it| it.into_token())

{

Some(it) => it,

None => {

editor.insert(Position::after(syntax), &comma);

comma

}

///

/// Attention! This function does align the first line of `item` with respect to `self`,

/// but it does _not_ change indentation of other lines (if any).

let (indent, position, whitespace) = match self.assoc_items().last() {

Some(last_item) => (

IndentLevel::from_node(last_item.syntax()),

impl ast::Impl {

pub fn get_or_create_assoc_item_list_with_editor(

&self,

) -> ast::AssocItemList {

if let Some(list) = self.assoc_item_list() {

list

} else {

editor.insert_all(

Position::last_child_of(self.syntax()),

);

list

}

}

impl ast::VariantList {

let (indent, position) = match self.variants().last() {

Some(last_item) => (

IndentLevel::from_node(last_item.syntax()),

},

};

let elements: Vec<SyntaxElement> = vec![

variant.syntax().clone().into(),

];

editor.insert_all(position, elements);

}

}

impl ast::Fn {

if let Some(old_body) = self.body() {

editor.replace(old_body.syntax(), body.syntax());

} else {

}

}

let l = node

.children_with_tokens()

.filter_map(|it| it.into_token())

match l.next_sibling_or_token() {

Some(ws) if ws.kind() == SyntaxKind::WHITESPACE => {

if ws.next_sibling_or_token()?.into_token()? == r {

}

}

Some(ws) if ws.kind() == T!['}'] => {

}

_ => (),

}

}

pub trait Removable: AstNode {

}

impl Removable for ast::TypeBoundList {

match self.syntax().siblings_with_tokens(Direction::Prev).find(|it| it.kind() == T![:]) {

Some(colon) => editor.delete_all(colon..=self.syntax().clone().into()),

None => editor.delete(self.syntax()),

}

impl Removable for ast::Use {

let next_ws = self

.syntax()

.next_sibling_or_token()

if rest.is_empty() {

editor.delete(next_ws.syntax());

} else {

}

}

}

}

impl Removable for ast::UseTree {

for dir in [Direction::Next, Direction::Prev] {

if let Some(next_use_tree) = neighbor(self, dir) {

let separators = self