array literals uses typed arrays; fix a jsgen bug

[ringabout]

Ref timotheecour#557

when true:
  proc main()=
    var b: array[10, byte]
    var b2 = [byte(1), 2]
    doAssert (b, b2) == ([byte(0), 0, 0, 0, 0, 0, 0, 0, 0, 0], [byte(1), 2])
  main()

Before this PR:

function main_369098753() {
  var b_369098754 = new Uint8Array(10);
  var b2_369098755 = [1, 2];
  if (!(HEX3DHEX3D_369098758({ Field0: nimCopy(null, b_369098754, NTI369098758), Field1: nimCopy(null, b2_369098755, NTI369098759) }, { Field0: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], Field1: [1, 2] }))) {
    failedAssertImpl_218103865(makeNimstrLit("play.nim(5, 14) `(b, b2) == ([byte(0), 0, 0, 0, 0, 0, 0, 0, 0, 0], [byte(1), 2])` "));
  }
}
main_369098753();

After

function main_369098753() {
  var b_369098754 = new Uint8Array(10);
  var b2_369098755 = new Uint8Array([1, 2]);
  if (!(HEX3DHEX3D_369098758({ Field0: nimCopy(null, b_369098754, NTI369098758), Field1: nimCopy(null, b2_369098755, NTI369098759) }, { Field0: new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), Field1: new Uint8Array([1, 2]) }))) {
    failedAssertImpl_218103865(makeNimstrLit("play.nim(5, 14) `(b, b2) == ([byte(0), 0, 0, 0, 0, 0, 0, 0, 0, 0], [byte(1), 2])` "));
  }
}
main_369098753();

[timotheecour]

this needs a test.

• add this to lib/std/private/jsutils.nim:

proc jsTypeof*(a: auto): cstring =
  asm """`result` = typeof(`a`)"""

proc jsConstructorName*(a: auto): cstring =
  asm """`result` = `a`.constructor.name"""

(that file exists in devel but somehow not in your PR, which looks like it hasn't been rebased in a while?)

• and then add this somewhere (find an appropriate existing test file): (feel free to add as needed)

import std/private/jsutils
proc main()=
  template fn(a): untyped = jsConstructorName(a)
  doAssert fn(array[2, int8].default) == "Int8Array"
  doAssert fn(array[2, uint8].default) == "Uint8Array"
  doAssert fn(array[2, byte].default) == "Uint8Array"
  # doAssert fn(array[2, char].default) == "Uint8Array" # xxx fails; bug?
  doAssert fn(array[2, uint64].default) == "Array"
    # pending https://github.com/nim-lang/RFCs/issues/187 maybe use `BigUint64Array`
  doAssert fn([1'u8]) == "Uint8Array"
  doAssert fn([1'u16]) == "Uint16Array"
  doAssert fn([byte(1)]) == "Uint8Array"

main()

[ringabout]

I find a bug

proc hello(): array[5, int] = discard
var x = @(hello())
x.add(2)
echo x

x_369098759[0].push(2);;
^

TypeError: x_369098759[0].push is not a function

[timotheecour]

@xflywind needs rebase

[timotheecour]

I'm still pondering the significance of timotheecour#567, IMO that benchmark i wrote is contrived/not representative but would still be nice to have at least 1 non-contribed benchmark which shows benefit of typed array (but in future work is fine)

bugfix: more type safe even in presence of casts

this PR fixes the following bug; we should add a test either in this PR or in followup PRs:

when true:
  import jsconsole
  template fn(a) =
    echo a
    console.log a
    var x = 257.2
    var b = cast[uint8](x)
    echo b
    a[0] = b
    echo a
    console.log a

  block:
    var a: array[3, uint8]
    a = [2'u8,4,5]
    fn(a)
  block:
    var a: array[3, uint8] = [2'u8,4,5]
    fn(a)

before PR: bug
[2, 4, 5]
Uint8Array(3) [ 2, 4, 5 ]
257
[1, 4, 5]
Uint8Array(3) [ 1, 4, 5 ]
[2, 4, 5]
[ 2, 4, 5 ]
257
[257, 4, 5]
[ 257.2, 4, 5 ]

after PR:
[2, 4, 5]
Uint8Array(3) [ 2, 4, 5 ]
257
[1, 4, 5]
Uint8Array(3) [ 1, 4, 5 ]
[2, 4, 5]
Uint8Array(3) [ 2, 4, 5 ]
257
[1, 4, 5]
Uint8Array(3) [ 1, 4, 5 ]

[Araq]

Is this still a draft?

[ringabout]

As https://stackoverflow.com/questions/13328658/are-the-advantages-of-typed-arrays-in-javascript-is-that-they-work-the-same-or-s said

This Chrome developer comment provides some guidance that worked as of June 2012:
Normal arrays can be as fast as typed arrays if you do a lot of sequential access. Random access outside the bounds of the array causes the array to grow.
Typed arrays are fast for access, but slow to be allocated. If you create temporary arrays frequently, avoid typed arrays. (Fixing this is possible, but it's low priority.)
Micro-benchmarks such as JSPerf are not reliable for real-world performance.

Typed arrays are fast for access, but slow to be allocated, and normal arrays can be as fast as typed arrays if you do a lot of sequential access. Random access outside the bounds of the array causes the array to grow.

This PR is ready to review.