`=destroy` doesn't work in VM or js

[timotheecour]

originally reported here: #17230 (comment)

=destroy should work the same on all backends otherwise assumptions are broken when using code written for a backend on another backend, leading to not just bugs but silent bugs.

Example 1

when true:
  type
    A = object
      id: int
    B = object
      a: A
  proc `=destroy`(a: var A) = echo a.id
  template main =
    var x = A(id: 1)
    var y = B(a: A(id: 2))
    `=destroy`(x)
    `=destroy`(y)
    echo "here"
  static: main()
  main()

nim r main

Current Output

both with and without --gc:arc:

ct:
1
here

rt:
1
2
here
2
1

Expected Output

ct:
1
2
here
2
1

rt:
1
2
here
2
1

Example 2

ditto with with -b:js

ct:
1
here

rt:
1
2
here

expected output: same as previous Expected Output

Additional Information

1.5.1 02f4464

related

• regression(0.20) destructor not called in VM #11612
• Enable manual destructor invocation for implicitly generated destructors #5342 which was fixed (for c backend)

[quantimnot]

There are 3 separate bugs here:

• (VM) generated destructor calls aren't called unless first used in a proc/func
• (VM) destructor calls aren't injected and called at scope close
• (JS) global destructor calls aren't injected and called

Can this issue please be split up?
There is already an issue for VM destructors not being called #11612.
I stumbled upon the cause of the JS destructors not getting injected. I will make a PR soon.

Here is a test case for both of the VM bugs:

discard """
  action: compile
  matrix: "--verbosity:0 --mm:refc; --verbosity:0 --mm:arc"
  joinable: false
  output: '''
A
B_A
B_A
A
--
A
B_A
B_A
A
--
A
C_A
C_A
A
--
'''
"""

type
  A = object
    id: string
  B = object
    a: A
  C = object
    a: A

proc `=destroy`(a: var A) = echo a.id

# NOTE:
# If a destructor is manually defined for `C`,
# then the second manual destructor call in `acTemplate` will work.
# proc `=destroy`(c: var C) = echo c.a.id

template abTemplate =
  var x = A(id: "A")
  var y = B(a: A(id: "B_A"))
  `=destroy`(x)
  `=destroy`(y)

template acTemplate =
  var x = A(id: "A")
  var y = C(a: A(id: "C_A"))
  `=destroy`(x)
  `=destroy`(y)

proc abProc =
  abTemplate()
  # the destructors should be called here when the scope closes

# NOTE:
# If `acTemplate` is used in a proc like this,
# then the second manual destructor call in `acTemplate` will work.
# proc acProc =
#  acTemplate() <- this will fix the missing C_A

static: # TODO: Does `static` create a scope? Should destructors get called when it closes?
  abProc()
  # A
  # B_A
  # B_A
  # A
  echo "--"
  # --
  abTemplate()
  # the destructors should be called here when the scope closes
  # A
  # B_A
  # B_A
  # A
static:
  echo "--"
  # --
static:
  acTemplate()
  # the destructors should be called here when the scope closes
  # A
  # C_A
  # C_A
  # A
static:
  echo "--"
  # --