TS expand selection is "dumb" (at least in Rust)

[eulerdisk]

Suppose we have this:
(|...| delimits the selection)

let r = test(0, 2).saturating_|a|dd(3).saturating_sub(4);

This is what TS "expand selection to parent syntax node" currently does:

let r = test(1, 2).|saturating_add|(3).saturating_sub(4);
let r = |test(1, 2).saturating_add|(3).saturating_sub(4);
let r = |test(1, 2).saturating_add(3)|.saturating_sub(4);
let r = |test(1, 2).saturating_add(3).saturating_sub|(4);
let r = |test(1, 2).saturating_add(3).saturating_sub(4)|;

That's not very useful.
This is what I would expect:

let r = test(1, 2).|saturating_add|(3).saturating_sub(4);
let r = test(1, 2).|saturating_add(3)|.saturating_sub(4);
let r = test(1, 2).|saturating_add(3).saturating_sub|(4);
let r = test(1, 2).|saturating_add(3).saturating_sub(4)|;
let r = test|(1, 2).saturating_add(3).saturating_sub(4)|;

// Or
let r = test(1, 2).|saturating_add|(3).saturating_sub(4);
let r = test(1, 2).|saturating_add(3)|.saturating_sub(4);
let r = test(1, 2).|saturating_add(3).saturating_sub(4)|;
let r = |test(1, 2).saturating_add(3).saturating_sub(4)|;

You get the idea.
This is only the first example that comes to my mind, there are other similar
situations where TS expand goes the "wrong way", at least in Rust.

Would be possible to make the expand selection more smarter?

[the-mikedavis]

expand_selection expands the current selection to the parent node in the syntax tree which is parsed by tree-sitter-rust. You can view the syntax tree under the primary selection with :tree-sitter-subtree.

Your examples have the syntax tree organized so that method calls are right-associative rather than left but method calls in Rust are left-associative. tree-sitter-rust is correct in this case: if you rewrote the expression with explicit parentheses, it would be:

let r = (((test(1, 2).saturating_add(3)).saturating_sub(4));

[eulerdisk]

Yes, I know. The problem is that way is not useful.
If you have a method chain like the one above, 99% of time you want to change the right side of the chain, not the left one.
Often expanding the selection strictly following the grammar structure as TS does is not what you want when you are editing code.
If I remember correctly expand selection for Kotlin in IntelliJ goes to the right which is very very handy, it was my favorite feature (even if Kotlin expression are left-associative as in Rust)

LSP has the expand-selection feature, maybe language servers can hardcode better ways to expand selection. Unfortunately as of today rust-analyzer does as TS.

Maybe I will open an issue for RA as well.

[jcornaz]

I agree, the selection expansion feels odd with helix, even if I understand the rationale behind it. I can rarely use it, and I have to resort to manually selecting what I need instead.

As I remember, I also preferred the selection expansion in IntelliJ, I quickly tried to see how it actually behaves there. But no, @eulerdisk, IntelliJ also expands to the left (even in Kotlin).

However, it does have a more useful expansion IMO, here is what it does:

let r = test(0, 2).saturating_|a|dd(3).saturating_sub(4);
let r = test(0, 2).|saturating_add|(3).saturating_sub(4);
let r = test(0, 2).|saturating_add(3)|.saturating_sub(4); // <-- A lot more useful! It is really annoying to get that selection with helix.

Another annoying behavior of the selection expansion inside parenthesis or curly braces as helix will immediately include the surrounding brackets in the selection. Though very often I want to select the content of the selection.

foo("hel|l|o");
foo(|"hello"|); // <-- Immediately includes the double quotes :-/
foo|("hello")|; // <-- Immediately includes the parenthesis :-/

Again IntelliJ has a far better behavior there (IMO):

foo("hel|l|o");
foo("|hello|"); // <-- Much better!
foo(|"hello"|);
foo|("hello")|;
|foo("hello")|;
|foo("hello");|

Of course, I know I can use the mi" or mi( to select the inner content of something without its surrounding. But that is not really helpful when there are a lot of nested groups.

In the following example, If my cursor is in the inner group, and I want to select the content of minus, then an expansions selection that does not immediately select the surrounding bracket would be a lot more comfortable IMO.

Expression::minus(
    Expression::plus(
        Expression::value(3),
        Expression::div(
            Expression::mul(Expression::value(4), Expression::value(5)),
            Expression::mul(Expression::value(6), Expression::value(2))
        )
    ),
    Expression::value(-71),
)

[eulerdisk]

As I remember, I also preferred the selection expansion in IntelliJ, I quickly tried to see how it actually behaves there. But no, @eulerdisk, IntelliJ also expands to the left (even in Kotlin).

Ok, I misremembered that particular thing.
The only thing I remember is that it was very handy, I used it all time time. You did a better job providing examples on why IntelliJ expansion is much better, those use cases are exactly what I had in mind.
On the contrary, every time I use TS expansion I get surprised and frustrated.