rust/crates/syntax/src/ast/edit.rs

762 lines
25 KiB
Rust
Raw Normal View History

2019-09-26 14:08:44 -05:00
//! This module contains functions for editing syntax trees. As the trees are
//! immutable, all function here return a fresh copy of the tree, instead of
//! doing an in-place modification.
2020-05-19 16:12:01 -05:00
use std::{
fmt, iter,
ops::{self, RangeInclusive},
};
2019-09-26 14:08:44 -05:00
use arrayvec::ArrayVec;
use crate::{
2020-04-09 15:22:58 -05:00
algo::{self, neighbor, SyntaxRewriter},
ast::{
self,
make::{self, tokens},
2020-09-03 06:46:28 -05:00
AstNode, GenericParamsOwner, NameOwner, TypeBoundsOwner,
},
2019-11-23 23:14:57 -06:00
AstToken, Direction, InsertPosition, SmolStr, SyntaxElement, SyntaxKind,
2019-09-28 11:50:16 -05:00
SyntaxKind::{ATTR, COMMENT, WHITESPACE},
2019-10-12 14:07:47 -05:00
SyntaxNode, SyntaxToken, T,
2019-09-26 14:08:44 -05:00
};
2019-11-23 23:14:57 -06:00
impl ast::BinExpr {
#[must_use]
pub fn replace_op(&self, op: SyntaxKind) -> Option<ast::BinExpr> {
let op_node: SyntaxElement = self.op_details()?.0.into();
2020-01-15 11:14:49 -06:00
let to_insert: Option<SyntaxElement> = Some(make::token(op).into());
Some(self.replace_children(single_node(op_node), to_insert))
2019-11-23 23:14:57 -06:00
}
}
2020-07-30 07:51:08 -05:00
impl ast::Fn {
2019-09-26 14:08:44 -05:00
#[must_use]
2020-07-30 07:51:08 -05:00
pub fn with_body(&self, body: ast::BlockExpr) -> ast::Fn {
2019-09-26 14:08:44 -05:00
let mut to_insert: ArrayVec<[SyntaxElement; 2]> = ArrayVec::new();
let old_body_or_semi: SyntaxElement = if let Some(old_body) = self.body() {
old_body.syntax().clone().into()
2020-04-10 03:11:05 -05:00
} else if let Some(semi) = self.semicolon_token() {
2019-09-26 14:08:44 -05:00
to_insert.push(make::tokens::single_space().into());
2020-04-10 03:11:05 -05:00
semi.into()
2019-09-26 14:08:44 -05:00
} else {
to_insert.push(make::tokens::single_space().into());
to_insert.push(body.syntax().clone().into());
return self.insert_children(InsertPosition::Last, to_insert);
2019-09-26 14:08:44 -05:00
};
to_insert.push(body.syntax().clone().into());
self.replace_children(single_node(old_body_or_semi), to_insert)
2019-09-26 14:08:44 -05:00
}
2020-09-03 06:46:28 -05:00
#[must_use]
2020-09-04 07:24:36 -05:00
pub fn with_generic_param_list(&self, generic_args: ast::GenericParamList) -> ast::Fn {
2020-09-03 06:46:28 -05:00
if let Some(old) = self.generic_param_list() {
return self.replace_descendant(old, generic_args);
}
let anchor = self.name().expect("The function must have a name").syntax().clone();
let mut to_insert: ArrayVec<[SyntaxElement; 1]> = ArrayVec::new();
to_insert.push(generic_args.syntax().clone().into());
self.insert_children(InsertPosition::After(anchor.into()), to_insert)
}
2019-09-26 14:08:44 -05:00
}
fn make_multiline<N>(node: N) -> N
where
N: AstNode + Clone,
{
let l_curly = match node.syntax().children_with_tokens().find(|it| it.kind() == T!['{']) {
Some(it) => it,
None => return node,
};
let sibling = match l_curly.next_sibling_or_token() {
Some(it) => it,
None => return node,
};
let existing_ws = match sibling.as_token() {
None => None,
Some(tok) if tok.kind() != WHITESPACE => None,
Some(ws) => {
if ws.text().contains('\n') {
return node;
}
Some(ws.clone())
}
};
let indent = leading_indent(node.syntax()).unwrap_or_default();
let ws = tokens::WsBuilder::new(&format!("\n{}", indent));
let to_insert = iter::once(ws.ws().into());
match existing_ws {
None => node.insert_children(InsertPosition::After(l_curly), to_insert),
Some(ws) => node.replace_children(single_node(ws), to_insert),
}
}
impl ast::Impl {
#[must_use]
pub fn with_assoc_item_list(&self, items: ast::AssocItemList) -> ast::Impl {
let mut to_insert: ArrayVec<[SyntaxElement; 2]> = ArrayVec::new();
if let Some(old_items) = self.assoc_item_list() {
let to_replace: SyntaxElement = old_items.syntax().clone().into();
to_insert.push(items.syntax().clone().into());
self.replace_children(single_node(to_replace), to_insert)
} else {
to_insert.push(make::tokens::single_space().into());
to_insert.push(items.syntax().clone().into());
self.insert_children(InsertPosition::Last, to_insert)
}
}
}
2020-07-30 04:42:51 -05:00
impl ast::AssocItemList {
#[must_use]
2020-07-30 04:42:51 -05:00
pub fn append_items(
&self,
items: impl IntoIterator<Item = ast::AssocItem>,
) -> ast::AssocItemList {
let mut res = self.clone();
if !self.syntax().text().contains_char('\n') {
res = make_multiline(res);
}
2020-03-30 05:28:22 -05:00
items.into_iter().for_each(|it| res = res.append_item(it));
res.fixup_trailing_whitespace().unwrap_or(res)
}
#[must_use]
2020-07-30 04:42:51 -05:00
pub fn append_item(&self, item: ast::AssocItem) -> ast::AssocItemList {
let (indent, position, whitespace) = match self.assoc_items().last() {
Some(it) => (
leading_indent(it.syntax()).unwrap_or_default().to_string(),
InsertPosition::After(it.syntax().clone().into()),
"\n\n",
),
None => match self.l_curly_token() {
Some(it) => (
" ".to_string() + &leading_indent(self.syntax()).unwrap_or_default(),
2020-04-10 03:27:23 -05:00
InsertPosition::After(it.into()),
"\n",
),
None => return self.clone(),
},
};
let ws = tokens::WsBuilder::new(&format!("{}{}", whitespace, indent));
let to_insert: ArrayVec<[SyntaxElement; 2]> =
[ws.ws().into(), item.syntax().clone().into()].into();
self.insert_children(position, to_insert)
}
/// Remove extra whitespace between last item and closing curly brace.
fn fixup_trailing_whitespace(&self) -> Option<ast::AssocItemList> {
2020-08-17 03:36:46 -05:00
let first_token_after_items =
self.assoc_items().last()?.syntax().next_sibling_or_token()?;
let last_token_before_curly = self.r_curly_token()?.prev_sibling_or_token()?;
if last_token_before_curly != first_token_after_items {
// there is something more between last item and
// right curly than just whitespace - bail out
return None;
}
2020-08-17 03:36:46 -05:00
let whitespace =
last_token_before_curly.clone().into_token().and_then(ast::Whitespace::cast)?;
let text = whitespace.syntax().text();
2020-09-30 14:22:49 -05:00
let newline = text.rfind('\n')?;
let keep = tokens::WsBuilder::new(&text[newline..]);
2020-08-17 03:36:46 -05:00
Some(self.replace_children(
first_token_after_items..=last_token_before_curly,
std::iter::once(keep.ws().into()),
))
}
}
2020-07-30 09:21:30 -05:00
impl ast::RecordExprFieldList {
2019-09-30 01:27:26 -05:00
#[must_use]
2020-07-30 09:21:30 -05:00
pub fn append_field(&self, field: &ast::RecordExprField) -> ast::RecordExprFieldList {
2019-09-30 01:27:26 -05:00
self.insert_field(InsertPosition::Last, field)
}
#[must_use]
pub fn insert_field(
&self,
2020-07-30 09:21:30 -05:00
position: InsertPosition<&'_ ast::RecordExprField>,
field: &ast::RecordExprField,
) -> ast::RecordExprFieldList {
2019-09-30 01:27:26 -05:00
let is_multiline = self.syntax().text().contains_char('\n');
let ws;
let space = if is_multiline {
ws = tokens::WsBuilder::new(&format!(
"\n{} ",
2019-12-20 08:43:30 -06:00
leading_indent(self.syntax()).unwrap_or_default()
2019-09-30 01:27:26 -05:00
));
ws.ws()
} else {
tokens::single_space()
};
let mut to_insert: ArrayVec<[SyntaxElement; 4]> = ArrayVec::new();
to_insert.push(space.into());
to_insert.push(field.syntax().clone().into());
2020-03-06 08:38:48 -06:00
to_insert.push(make::token(T![,]).into());
2019-09-30 01:27:26 -05:00
macro_rules! after_l_curly {
() => {{
let anchor = match self.l_curly_token() {
2020-04-10 03:27:23 -05:00
Some(it) => it.into(),
2019-09-30 01:27:26 -05:00
None => return self.clone(),
};
InsertPosition::After(anchor)
}};
}
macro_rules! after_field {
($anchor:expr) => {
if let Some(comma) = $anchor
.syntax()
.siblings_with_tokens(Direction::Next)
.find(|it| it.kind() == T![,])
{
InsertPosition::After(comma)
} else {
2020-03-06 08:38:48 -06:00
to_insert.insert(0, make::token(T![,]).into());
2019-09-30 01:27:26 -05:00
InsertPosition::After($anchor.syntax().clone().into())
}
};
2021-01-02 13:48:39 -06:00
}
2019-09-30 01:27:26 -05:00
let position = match position {
InsertPosition::First => after_l_curly!(),
InsertPosition::Last => {
if !is_multiline {
// don't insert comma before curly
to_insert.pop();
}
match self.fields().last() {
Some(it) => after_field!(it),
None => after_l_curly!(),
}
}
InsertPosition::Before(anchor) => {
InsertPosition::Before(anchor.syntax().clone().into())
}
InsertPosition::After(anchor) => after_field!(anchor),
};
self.insert_children(position, to_insert)
2019-09-30 01:27:26 -05:00
}
}
2020-07-30 08:25:46 -05:00
impl ast::TypeAlias {
2020-07-14 06:33:37 -05:00
#[must_use]
2020-07-30 08:25:46 -05:00
pub fn remove_bounds(&self) -> ast::TypeAlias {
2020-07-14 06:33:37 -05:00
let colon = match self.colon_token() {
Some(it) => it,
None => return self.clone(),
};
let end = match self.type_bound_list() {
Some(it) => it.syntax().clone().into(),
None => colon.clone().into(),
};
self.replace_children(colon.into()..=end, iter::empty())
}
}
2019-09-30 01:56:20 -05:00
impl ast::TypeParam {
2019-09-30 02:08:28 -05:00
#[must_use]
2019-09-30 01:56:20 -05:00
pub fn remove_bounds(&self) -> ast::TypeParam {
let colon = match self.colon_token() {
2019-09-30 01:56:20 -05:00
Some(it) => it,
None => return self.clone(),
};
let end = match self.type_bound_list() {
Some(it) => it.syntax().clone().into(),
None => colon.clone().into(),
2019-09-30 01:56:20 -05:00
};
self.replace_children(colon.into()..=end, iter::empty())
2019-09-30 01:56:20 -05:00
}
}
2020-01-15 11:48:28 -06:00
impl ast::Path {
#[must_use]
pub fn with_segment(&self, segment: ast::PathSegment) -> ast::Path {
if let Some(old) = self.segment() {
return self.replace_children(
2020-01-15 11:48:28 -06:00
single_node(old.syntax().clone()),
iter::once(segment.syntax().clone().into()),
);
}
self.clone()
}
}
impl ast::PathSegment {
#[must_use]
2020-09-03 05:18:46 -05:00
pub fn with_generic_args(&self, type_args: ast::GenericArgList) -> ast::PathSegment {
self._with_generic_args(type_args, false)
2020-01-15 11:48:28 -06:00
}
#[must_use]
2020-07-31 11:29:29 -05:00
pub fn with_turbo_fish(&self, type_args: ast::GenericArgList) -> ast::PathSegment {
2020-09-03 05:18:46 -05:00
self._with_generic_args(type_args, true)
2020-01-15 11:48:28 -06:00
}
2020-09-03 05:18:46 -05:00
fn _with_generic_args(&self, type_args: ast::GenericArgList, turbo: bool) -> ast::PathSegment {
2020-07-31 11:29:29 -05:00
if let Some(old) = self.generic_arg_list() {
return self.replace_children(
2020-01-15 11:48:28 -06:00
single_node(old.syntax().clone()),
iter::once(type_args.syntax().clone().into()),
);
}
let mut to_insert: ArrayVec<[SyntaxElement; 2]> = ArrayVec::new();
if turbo {
to_insert.push(make::token(T![::]).into());
}
to_insert.push(type_args.syntax().clone().into());
self.insert_children(InsertPosition::Last, to_insert)
2020-01-15 11:48:28 -06:00
}
}
2020-07-30 07:12:04 -05:00
impl ast::Use {
2020-03-05 11:38:52 -06:00
#[must_use]
2020-07-30 07:12:04 -05:00
pub fn with_use_tree(&self, use_tree: ast::UseTree) -> ast::Use {
2020-03-05 11:38:52 -06:00
if let Some(old) = self.use_tree() {
2020-03-27 06:12:17 -05:00
return self.replace_descendant(old, use_tree);
2020-03-05 11:38:52 -06:00
}
self.clone()
}
pub fn remove(&self) -> SyntaxRewriter<'static> {
let mut res = SyntaxRewriter::default();
res.delete(self.syntax());
let next_ws = self
.syntax()
.next_sibling_or_token()
.and_then(|it| it.into_token())
.and_then(ast::Whitespace::cast);
if let Some(next_ws) = next_ws {
let ws_text = next_ws.syntax().text();
if ws_text.starts_with('\n') {
let rest = &ws_text[1..];
if rest.is_empty() {
res.delete(next_ws.syntax())
} else {
res.replace(next_ws.syntax(), &make::tokens::whitespace(rest));
}
}
}
res
}
2020-03-05 11:38:52 -06:00
}
impl ast::UseTree {
#[must_use]
pub fn with_path(&self, path: ast::Path) -> ast::UseTree {
if let Some(old) = self.path() {
2020-03-27 06:12:17 -05:00
return self.replace_descendant(old, path);
}
self.clone()
}
#[must_use]
pub fn with_use_tree_list(&self, use_tree_list: ast::UseTreeList) -> ast::UseTree {
if let Some(old) = self.use_tree_list() {
2020-03-27 06:12:17 -05:00
return self.replace_descendant(old, use_tree_list);
}
self.clone()
}
/// Splits off the given prefix, making it the path component of the use tree, appending the rest of the path to all UseTreeList items.
#[must_use]
pub fn split_prefix(&self, prefix: &ast::Path) -> ast::UseTree {
2020-08-12 11:49:43 -05:00
let suffix = if self.path().as_ref() == Some(prefix) && self.use_tree_list().is_none() {
make::path_unqualified(make::path_segment_self())
} else {
match split_path_prefix(&prefix) {
Some(it) => it,
None => return self.clone(),
}
};
2020-08-12 11:49:43 -05:00
2020-07-30 05:01:14 -05:00
let use_tree = make::use_tree(
suffix,
self.use_tree_list(),
self.rename(),
self.star_token().is_some(),
);
let nested = make::use_tree_list(iter::once(use_tree));
return make::use_tree(prefix.clone(), Some(nested), None, false);
fn split_path_prefix(prefix: &ast::Path) -> Option<ast::Path> {
let parent = prefix.parent_path()?;
let segment = parent.segment()?;
if algo::has_errors(segment.syntax()) {
return None;
}
let mut res = make::path_unqualified(segment);
for p in iter::successors(parent.parent_path(), |it| it.parent_path()) {
res = make::path_qualified(res, p.segment()?);
}
Some(res)
}
}
pub fn remove(&self) -> SyntaxRewriter<'static> {
let mut res = SyntaxRewriter::default();
res.delete(self.syntax());
for &dir in [Direction::Next, Direction::Prev].iter() {
if let Some(nb) = neighbor(self, dir) {
self.syntax()
.siblings_with_tokens(dir)
.skip(1)
.take_while(|it| it.as_node() != Some(nb.syntax()))
.for_each(|el| res.delete(&el));
return res;
}
}
res
}
}
impl ast::MatchArmList {
#[must_use]
2020-03-30 05:28:22 -05:00
pub fn append_arms(&self, items: impl IntoIterator<Item = ast::MatchArm>) -> ast::MatchArmList {
let mut res = self.clone();
res = res.strip_if_only_whitespace();
if !res.syntax().text().contains_char('\n') {
res = make_multiline(res);
}
2020-03-30 05:28:22 -05:00
items.into_iter().for_each(|it| res = res.append_arm(it));
res
}
fn strip_if_only_whitespace(&self) -> ast::MatchArmList {
let mut iter = self.syntax().children_with_tokens().skip_while(|it| it.kind() != T!['{']);
iter.next(); // Eat the curly
let mut inner = iter.take_while(|it| it.kind() != T!['}']);
if !inner.clone().all(|it| it.kind() == WHITESPACE) {
return self.clone();
}
let start = match inner.next() {
Some(s) => s,
None => return self.clone(),
};
let end = match inner.last() {
Some(s) => s,
None => start.clone(),
};
2020-03-29 06:32:01 -05:00
self.replace_children(start..=end, &mut iter::empty())
}
#[must_use]
pub fn remove_placeholder(&self) -> ast::MatchArmList {
let placeholder =
2020-07-31 13:07:21 -05:00
self.arms().find(|arm| matches!(arm.pat(), Some(ast::Pat::WildcardPat(_))));
if let Some(placeholder) = placeholder {
self.remove_arm(&placeholder)
} else {
self.clone()
}
}
#[must_use]
fn remove_arm(&self, arm: &ast::MatchArm) -> ast::MatchArmList {
let start = arm.syntax().clone();
let end = if let Some(comma) = start
.siblings_with_tokens(Direction::Next)
.skip(1)
.skip_while(|it| it.kind().is_trivia())
.next()
.filter(|it| it.kind() == T![,])
{
comma
} else {
start.clone().into()
};
self.replace_children(start.into()..=end, None)
}
#[must_use]
pub fn append_arm(&self, item: ast::MatchArm) -> ast::MatchArmList {
let r_curly = match self.syntax().children_with_tokens().find(|it| it.kind() == T!['}']) {
Some(t) => t,
None => return self.clone(),
};
let position = InsertPosition::Before(r_curly);
2020-03-29 06:45:15 -05:00
let arm_ws = tokens::WsBuilder::new(" ");
let match_indent = &leading_indent(self.syntax()).unwrap_or_default();
let match_ws = tokens::WsBuilder::new(&format!("\n{}", match_indent));
let to_insert: ArrayVec<[SyntaxElement; 3]> =
[arm_ws.ws().into(), item.syntax().clone().into(), match_ws.ws().into()].into();
2020-03-29 06:32:01 -05:00
self.insert_children(position, to_insert)
}
}
impl ast::GenericParamList {
#[must_use]
2020-09-03 06:46:28 -05:00
pub fn append_params(
&self,
params: impl IntoIterator<Item = ast::GenericParam>,
) -> ast::GenericParamList {
let mut res = self.clone();
params.into_iter().for_each(|it| res = res.append_param(it));
res
}
#[must_use]
2020-09-03 06:46:28 -05:00
pub fn append_param(&self, item: ast::GenericParam) -> ast::GenericParamList {
2020-09-04 07:24:36 -05:00
let space = tokens::single_space();
let mut to_insert: ArrayVec<[SyntaxElement; 4]> = ArrayVec::new();
2020-09-03 06:46:28 -05:00
if self.generic_params().next().is_some() {
to_insert.push(space.into());
}
to_insert.push(item.syntax().clone().into());
macro_rules! after_l_angle {
() => {{
let anchor = match self.l_angle_token() {
Some(it) => it.into(),
None => return self.clone(),
};
InsertPosition::After(anchor)
}};
}
macro_rules! after_field {
($anchor:expr) => {
if let Some(comma) = $anchor
.syntax()
.siblings_with_tokens(Direction::Next)
.find(|it| it.kind() == T![,])
{
InsertPosition::After(comma)
} else {
to_insert.insert(0, make::token(T![,]).into());
InsertPosition::After($anchor.syntax().clone().into())
}
};
2021-01-02 13:48:39 -06:00
}
let position = match self.generic_params().last() {
Some(it) => after_field!(it),
None => after_l_angle!(),
};
self.insert_children(position, to_insert)
}
}
2019-09-30 02:08:28 -05:00
#[must_use]
2020-03-24 06:56:07 -05:00
pub fn remove_attrs_and_docs<N: ast::AttrsOwner>(node: &N) -> N {
N::cast(remove_attrs_and_docs_inner(node.syntax().clone())).unwrap()
2019-09-28 11:50:16 -05:00
}
2020-03-24 06:56:07 -05:00
fn remove_attrs_and_docs_inner(mut node: SyntaxNode) -> SyntaxNode {
2019-09-28 11:50:16 -05:00
while let Some(start) =
node.children_with_tokens().find(|it| it.kind() == ATTR || it.kind() == COMMENT)
{
let end = match &start.next_sibling_or_token() {
Some(el) if el.kind() == WHITESPACE => el.clone(),
Some(_) | None => start.clone(),
};
2020-01-15 10:54:25 -06:00
node = algo::replace_children(&node, start..=end, &mut iter::empty());
2019-09-28 11:50:16 -05:00
}
node
}
2019-10-12 14:07:47 -05:00
#[derive(Debug, Clone, Copy)]
pub struct IndentLevel(pub u8);
impl From<u8> for IndentLevel {
fn from(level: u8) -> IndentLevel {
IndentLevel(level)
}
}
2020-05-19 16:12:01 -05:00
impl fmt::Display for IndentLevel {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let spaces = " ";
let buf;
let len = self.0 as usize * 4;
let indent = if len <= spaces.len() {
&spaces[..len]
} else {
buf = iter::repeat(' ').take(len).collect::<String>();
&buf
};
fmt::Display::fmt(indent, f)
}
}
impl ops::Add<u8> for IndentLevel {
type Output = IndentLevel;
fn add(self, rhs: u8) -> IndentLevel {
IndentLevel(self.0 + rhs)
}
}
2019-10-12 14:07:47 -05:00
impl IndentLevel {
pub fn from_node(node: &SyntaxNode) -> IndentLevel {
2021-02-24 13:25:10 -06:00
match node.first_token() {
Some(it) => Self::from_token(&it),
2019-10-12 14:07:47 -05:00
None => return IndentLevel(0),
2021-02-24 13:25:10 -06:00
}
}
pub fn from_token(token: &SyntaxToken) -> IndentLevel {
for ws in prev_tokens(token.clone()).filter_map(ast::Whitespace::cast) {
2019-10-12 14:07:47 -05:00
let text = ws.syntax().text();
if let Some(pos) = text.rfind('\n') {
let level = text[pos + 1..].chars().count() / 4;
return IndentLevel(level as u8);
}
}
IndentLevel(0)
}
2020-05-19 16:12:01 -05:00
/// XXX: this intentionally doesn't change the indent of the very first token.
/// Ie, in something like
/// ```
/// fn foo() {
/// 92
/// }
/// ```
/// if you indent the block, the `{` token would stay put.
2020-05-09 07:40:11 -05:00
fn increase_indent(self, node: SyntaxNode) -> SyntaxNode {
let mut rewriter = SyntaxRewriter::default();
node.descendants_with_tokens()
2019-10-12 14:07:47 -05:00
.filter_map(|el| el.into_token())
.filter_map(ast::Whitespace::cast)
.filter(|ws| {
let text = ws.syntax().text();
text.contains('\n')
})
.for_each(|ws| {
2020-05-19 16:12:01 -05:00
let new_ws = make::tokens::whitespace(&format!("{}{}", ws.syntax(), self,));
rewriter.replace(ws.syntax(), &new_ws)
});
rewriter.rewrite(&node)
2019-10-12 14:07:47 -05:00
}
2020-05-09 07:40:11 -05:00
fn decrease_indent(self, node: SyntaxNode) -> SyntaxNode {
let mut rewriter = SyntaxRewriter::default();
node.descendants_with_tokens()
.filter_map(|el| el.into_token())
.filter_map(ast::Whitespace::cast)
.filter(|ws| {
let text = ws.syntax().text();
text.contains('\n')
})
.for_each(|ws| {
let new_ws = make::tokens::whitespace(
2020-05-19 16:12:01 -05:00
&ws.syntax().text().replace(&format!("\n{}", self), "\n"),
);
rewriter.replace(ws.syntax(), &new_ws)
});
rewriter.rewrite(&node)
}
2019-10-12 14:07:47 -05:00
}
// FIXME: replace usages with IndentLevel above
fn leading_indent(node: &SyntaxNode) -> Option<SmolStr> {
2019-10-12 14:07:47 -05:00
for token in prev_tokens(node.first_token()?) {
if let Some(ws) = ast::Whitespace::cast(token.clone()) {
let ws_text = ws.text();
if let Some(pos) = ws_text.rfind('\n') {
return Some(ws_text[pos + 1..].into());
}
}
if token.text().contains('\n') {
break;
}
}
None
}
2019-10-12 14:07:47 -05:00
fn prev_tokens(token: SyntaxToken) -> impl Iterator<Item = SyntaxToken> {
iter::successors(Some(token), |token| token.prev_token())
}
2020-05-09 07:40:11 -05:00
pub trait AstNodeEdit: AstNode + Clone + Sized {
#[must_use]
fn insert_children(
&self,
position: InsertPosition<SyntaxElement>,
to_insert: impl IntoIterator<Item = SyntaxElement>,
) -> Self {
let new_syntax = algo::insert_children(self.syntax(), position, to_insert);
Self::cast(new_syntax).unwrap()
}
#[must_use]
fn replace_children(
&self,
to_replace: RangeInclusive<SyntaxElement>,
to_insert: impl IntoIterator<Item = SyntaxElement>,
) -> Self {
let new_syntax = algo::replace_children(self.syntax(), to_replace, to_insert);
Self::cast(new_syntax).unwrap()
}
2020-03-27 06:12:17 -05:00
#[must_use]
fn replace_descendant<D: AstNode>(&self, old: D, new: D) -> Self {
self.replace_descendants(iter::once((old, new)))
}
#[must_use]
fn replace_descendants<D: AstNode>(
&self,
replacement_map: impl IntoIterator<Item = (D, D)>,
) -> Self {
let mut rewriter = SyntaxRewriter::default();
for (from, to) in replacement_map {
rewriter.replace(from.syntax(), to.syntax())
}
rewriter.rewrite_ast(self)
}
2020-08-13 03:32:03 -05:00
fn indent_level(&self) -> IndentLevel {
IndentLevel::from_node(self.syntax())
}
2020-05-09 07:40:11 -05:00
#[must_use]
fn indent(&self, level: IndentLevel) -> Self {
Self::cast(level.increase_indent(self.syntax().clone())).unwrap()
2020-05-09 07:40:11 -05:00
}
#[must_use]
fn dedent(&self, level: IndentLevel) -> Self {
Self::cast(level.decrease_indent(self.syntax().clone())).unwrap()
}
#[must_use]
fn reset_indent(&self) -> Self {
let level = IndentLevel::from_node(self.syntax());
self.dedent(level)
2020-05-09 07:40:11 -05:00
}
2019-09-26 14:08:44 -05:00
}
2020-05-09 07:40:11 -05:00
impl<N: AstNode + Clone> AstNodeEdit for N {}
2020-01-15 10:56:25 -06:00
fn single_node(element: impl Into<SyntaxElement>) -> RangeInclusive<SyntaxElement> {
let element = element.into();
element.clone()..=element
}
2019-10-12 14:07:47 -05:00
#[test]
fn test_increase_indent() {
let arm_list = {
2020-08-05 12:29:24 -05:00
let arm = make::match_arm(iter::once(make::wildcard_pat().into()), make::expr_unit());
make::match_arm_list(vec![arm.clone(), arm])
2019-10-12 14:07:47 -05:00
};
assert_eq!(
arm_list.syntax().to_string(),
"{
_ => (),
_ => (),
}"
);
2020-05-09 07:40:11 -05:00
let indented = arm_list.indent(IndentLevel(2));
2019-10-12 14:07:47 -05:00
assert_eq!(
indented.syntax().to_string(),
"{
_ => (),
_ => (),
}"
);
}