"Extract..." refactorings not available on right side of addition/multiplication expression

[DanielRosenwasser]

Today, you can request "Extract..." refactorings on the left side of a chain of multiplications:

function multiply(a: number, b: number, c: number) {
    return [|a * b|] * c;
}

Most people consider * to be associative (even if it's not for IEEE-754 numbers). Unfortunately we strictly allow you to refactor expressions as-parsed, so the following doesn't work:

function multiply(a: number, b: number, c: number) {
    return a * [|b * c|];
}

Expected: Extract constant/function work on b * c

Actual:

{
    "name": "Extract Symbol",
    "description": "Extract function",
    "actions": [
        {
            "name": "Extract Function",
            "description": "Extract function",
            "kind": "refactor.extract.function",
            "notApplicableReason": "Cannot extract range."
        }
    ]
},
{
    "name": "Extract Symbol",
    "description": "Extract constant",
    "actions": [
        {
            "name": "Extract Constant",
            "description": "Extract constant",
            "kind": "refactor.extract.constant",
            "notApplicableReason": "Cannot extract range."
        }
    ]
},

[RyanCavanaugh]

At some point we had tried to fix this. This might be a regression

[idango10]

It seems the extraction fails at this part of the code:
https://github.com/microsoft/TypeScript/blob/main/src/services/refactors/extractSymbol.ts#L494-L497

// src/services/refactors/extractSymbol.ts

if (start.parent !== end.parent) {
    // start and end nodes belong to different subtrees
    return { errors: [createFileDiagnostic(sourceFile, span.start, length, Messages.cannotExtractRange)] };
}

This behavior aligns with the structure of the AST for the example provided:

// ...
ReturnStatement
    BinaryExpression // a * b * c
        BinaryExpression // a * b
            Identifier // a
            AsteriskToken // *
            Identifier // b
        AsteriskToken // *
        Identifier // c

In this tree, a and b are siblings under the same BinaryExpression node, which allows for successful extraction of a * b. However, b and c are in different subtrees. b is part of the inner BinaryExpression, while c is the right child of the top-level BinaryExpression. Therefore, attempting to extract b * c fails because the start and end nodes have different parents.

[DanielRosenwasser]

Yeah, I think it would be good for us to make an exception in the cases where there is a string of multiplication/addition expressions, though admittedly I haven't thought very hard about how to enable that.