[BUG] Dependence of reactivity on the order of declaration

[rodshtein]

Reactive statement declaration through $: label before the second reactive statement that changes the first one through function is not reactive;

REPL: https://ru.svelte.dev/repl/7a9593fcd21848f7bdac90bd93fb2f9e?version=3.29.0

[pushkine]

duplicate #4516

[rodshtein]

duplicate #4516

I wouldn't be so sure.

---

To be clear: without function all works fine ↓

[pushkine]

yep my bad, it works as expected then,
there's two unintuitive things happening here, 1) the compiler does not link changes made in functions to the reactive declarations they're called from and 2) reactive declarations only run once per tick even if further updates happen within them

the compiler will try to re-order the executing order of declarations depending on each other ( so in the second screenshot, foo,bar++ is reordered to run first ) but doesn't in this case as it does not take into account mutations made within functions

You can check the executing order under the JS compiled tab at $$self.$$.update = () =>

[Conduitry]

Indeed, this is the expected behavior. When the compiler sorts reactive declarations/blocks according to dependencies, it only looks at variables referenced and assigned to within the block itself. This lets you specifically 'hide' references and updates from the compiler, and also makes the whole ordering process much more feasible.

[rodshtein]

Indeed, this is the expected behavior.

@Conduitry no is not. Is surprising behavior.
Why is't any word about in docs?

[PaulMaly]

@Conduitry I'm not sure, but I think you didn't catch the whole problem described by example. Perhaps, because this example doesn't fully reflect the problem and concentrates on unnecessary things.

Let's say, we've a much cleaner example:

<script>
  let foo = 0, 
      bar = 0;
	
  $: bar, alert();
  $: foo, func();

  function func() {
    bar += 2;
  } 
</script>

{foo} {bar}
<button on:click={e => ++foo}>
  Increment
</button>

The alert() will fire only once here, no matter that actual bar value will be changed as many times as you like. DOM updates will be performed as appropriate, but the reactive expression won't. So, here we can't say "alert() will be performed each time dependency (bar value) changed". But worst of all, if we swap these 2 reactive expressions, we'll get the converse effect.

I know why it's happening, but is it really not a problem? @Rich-Harris