ide_assists/handlers/
flip_comma.rs

1use syntax::{
2    AstNode, Direction, NodeOrToken, SyntaxKind, SyntaxToken, T,
3    algo::non_trivia_sibling,
4    ast::{self, syntax_factory::SyntaxFactory},
5    syntax_editor::SyntaxMapping,
6};
7
8use crate::{AssistContext, AssistId, Assists};
9
10// Assist: flip_comma
11//
12// Flips two comma-separated items.
13//
14// ```
15// fn main() {
16//     ((1, 2),$0 (3, 4));
17// }
18// ```
19// ->
20// ```
21// fn main() {
22//     ((3, 4), (1, 2));
23// }
24// ```
25pub(crate) fn flip_comma(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option<()> {
26    let comma = ctx.find_token_syntax_at_offset(T![,])?;
27    let prev = non_trivia_sibling(comma.clone().into(), Direction::Prev)?;
28    let next = non_trivia_sibling(comma.clone().into(), Direction::Next)?;
29
30    // Don't apply a "flip" in case of a last comma
31    // that typically comes before punctuation
32    if next.kind().is_punct() {
33        return None;
34    }
35
36    // Don't apply a "flip" inside the macro call
37    // since macro input are just mere tokens
38    if comma.parent_ancestors().any(|it| it.kind() == SyntaxKind::MACRO_CALL) {
39        return None;
40    }
41
42    let target = comma.text_range();
43    acc.add(AssistId::refactor_rewrite("flip_comma"), "Flip comma", target, |builder| {
44        let parent = comma.parent().unwrap();
45        let mut editor = builder.make_editor(&parent);
46
47        if let Some(parent) = ast::TokenTree::cast(parent) {
48            // An attribute. It often contains a path followed by a
49            // token tree (e.g. `align(2)`), so we have to be smarter.
50            let (new_tree, mapping) = flip_tree(parent.clone(), comma);
51            editor.replace(parent.syntax(), new_tree.syntax());
52            editor.add_mappings(mapping);
53        } else {
54            editor.replace(prev.clone(), next.clone());
55            editor.replace(next.clone(), prev.clone());
56        }
57
58        builder.add_file_edits(ctx.vfs_file_id(), editor);
59    })
60}
61
62fn flip_tree(tree: ast::TokenTree, comma: SyntaxToken) -> (ast::TokenTree, SyntaxMapping) {
63    let mut tree_iter = tree.token_trees_and_tokens();
64    let before: Vec<_> =
65        tree_iter.by_ref().take_while(|it| it.as_token() != Some(&comma)).collect();
66    let after: Vec<_> = tree_iter.collect();
67
68    let not_ws = |element: &NodeOrToken<_, SyntaxToken>| match element {
69        NodeOrToken::Token(token) => token.kind() != SyntaxKind::WHITESPACE,
70        NodeOrToken::Node(_) => true,
71    };
72
73    let is_comma = |element: &NodeOrToken<_, SyntaxToken>| match element {
74        NodeOrToken::Token(token) => token.kind() == T![,],
75        NodeOrToken::Node(_) => false,
76    };
77
78    let prev_start_untrimmed = match before.iter().rposition(is_comma) {
79        Some(pos) => pos + 1,
80        None => 1,
81    };
82    let prev_end = 1 + before.iter().rposition(not_ws).unwrap();
83    let prev_start = prev_start_untrimmed
84        + before[prev_start_untrimmed..prev_end].iter().position(not_ws).unwrap();
85
86    let next_start = after.iter().position(not_ws).unwrap();
87    let next_end_untrimmed = match after.iter().position(is_comma) {
88        Some(pos) => pos,
89        None => after.len() - 1,
90    };
91    let next_end = 1 + after[..next_end_untrimmed].iter().rposition(not_ws).unwrap();
92
93    let result = [
94        &before[1..prev_start],
95        &after[next_start..next_end],
96        &before[prev_end..],
97        &[NodeOrToken::Token(comma)],
98        &after[..next_start],
99        &before[prev_start..prev_end],
100        &after[next_end..after.len() - 1],
101    ]
102    .concat();
103
104    let make = SyntaxFactory::with_mappings();
105    let new_token_tree = make.token_tree(tree.left_delimiter_token().unwrap().kind(), result);
106    (new_token_tree, make.finish_with_mappings())
107}
108
109#[cfg(test)]
110mod tests {
111    use super::*;
112
113    use crate::tests::{check_assist, check_assist_not_applicable, check_assist_target};
114
115    #[test]
116    fn flip_comma_works_for_function_parameters() {
117        check_assist(
118            flip_comma,
119            r#"fn foo(x: i32,$0 y: Result<(), ()>) {}"#,
120            r#"fn foo(y: Result<(), ()>, x: i32) {}"#,
121        )
122    }
123
124    #[test]
125    fn flip_comma_target() {
126        check_assist_target(flip_comma, r#"fn foo(x: i32,$0 y: Result<(), ()>) {}"#, ",")
127    }
128
129    #[test]
130    fn flip_comma_before_punct() {
131        // See https://github.com/rust-lang/rust-analyzer/issues/1619
132        // "Flip comma" assist shouldn't be applicable to the last comma in enum or struct
133        // declaration body.
134        check_assist_not_applicable(flip_comma, "pub enum Test { A,$0 }");
135        check_assist_not_applicable(flip_comma, "pub struct Test { foo: usize,$0 }");
136    }
137
138    #[test]
139    fn flip_comma_works() {
140        check_assist(
141            flip_comma,
142            r#"fn main() {((1, 2),$0 (3, 4));}"#,
143            r#"fn main() {((3, 4), (1, 2));}"#,
144        )
145    }
146
147    #[test]
148    fn flip_comma_not_applicable_for_macro_input() {
149        // "Flip comma" assist shouldn't be applicable inside the macro call
150        // See https://github.com/rust-lang/rust-analyzer/issues/7693
151        check_assist_not_applicable(flip_comma, r#"bar!(a,$0 b)"#);
152    }
153
154    #[test]
155    fn flip_comma_attribute() {
156        check_assist(
157            flip_comma,
158            r#"#[repr(align(2),$0 C)] struct Foo;"#,
159            r#"#[repr(C, align(2))] struct Foo;"#,
160        );
161        check_assist(
162            flip_comma,
163            r#"#[foo(bar, baz(1 + 1),$0 qux, other)] struct Foo;"#,
164            r#"#[foo(bar, qux, baz(1 + 1), other)] struct Foo;"#,
165        );
166    }
167
168    #[test]
169    fn flip_comma_attribute_incomplete() {
170        check_assist_not_applicable(flip_comma, r#"#[repr(align(2),$0)] struct Foo;"#);
171    }
172}
ide_assists/handlers/flip_comma.rs

ide_assists/handlers/
flip_comma.rs
