(fix) destructuring inside $

[dummdidumm]

#444

TODOs:

• don't remove the ( ) around the expression if there is no transformation from $: ... to let ...
• remove the ( ) in such a way that the inner transformations are preserved and not removed as well

[jasonlyu123]

Also

let a = [1, 2, 3]
$: [ first ] = a

it would be nice if we can find the equivalent of this line in typescript
https://github.com/sveltejs/svelte/blob/f739b4772a4ad32c0fd337afb9d5594ebd776073/src/compiler/compile/Component.ts#L607

I looked into typescript.d.ts 'MemberExpression' seems to be the base interface of four other expressions in typescript

[dummdidumm]

Good point, forgot about them. If you like you can take over, not going to work in this today anymore.

[tanhauhau]

you can use periscopic#extract_names https://github.com/Rich-Harris/periscopic#extract_identifiers-and-extract_names to get all the identifier names within the assignment

[dummdidumm]

Oh that's a nice way of getting it, but we are using the typescript AST here so we cannot use this.

[jasonlyu123]

I think we could just recreate that function for typescript AST. Another option would be using typescript-eslint parser to transform AST to estree compliant but that seems a little bit too overkill

[jasonlyu123]

When looking into the solution, I found another issue. Because we're transforming this:

$: a = b

to

let a = b

to infer type for a. So when one of the destructured identifiers is already defined but others don't, how do we transform it to do an assignment as well as declaration.

like this:

let a: number;
$: ({ a, c } = b);

[dummdidumm]

This situation came to my mind, too, and my current solution for it is "that's such a corner case, just don't try to infer the type" 😄
So I would just transform it to

let a; // <- no type
$: ({a, c} = b);

[jasonlyu123]

Oh! I just thought like "what about this situation you wrote?" 😂

[dummdidumm]

Oooh you mean a different situation, I get it now. What if the user has defined one of them ... well yes, we somehow would have to add the other let. Maybe like this:

User:

let a: number;
$: ({a,b} = c);

Gets transformed to:

let a: number;
let b;
$: ({a,b} = c);

Sorry for the confusion 😄

[dummdidumm]

So to summarize the cases:

No let x; by user

Input

$: ({a,b} = c);

Output:

let {a,b} = c;

At least one let x; defined by user

Input:

let a: number;
$: ({a,b} = c);

Output

let a: number;
let b; // <- we don't infer the type, too much work for such an edge case
$: ({a,b} = c);

Same goes for $: ([a, b] = c);

[jasonlyu123]

I added a ts version of Rich's extract_identifiers in my branch
https://github.com/jasonlyu123/language-tools/tree/fix-destructuring-inside-himBHsj

[dummdidumm]

Oh that's great 👍 I'll incorporate it into my changes.

[dummdidumm]

Thanks a lot for that adapted method @jasonlyu123 ! Tests are passing now for both object and array destructuring. Could you take one more look at the code if everything is okay?

[jasonlyu123]

Found some issue need some tweak

[jasonlyu123]

That's a clever workaround 👍