Rethink about JS object method name encoding

[bobzhang]

relevant reasonml/reason#849
cc @chenglou @hhugo (Jordan name does not auto-complete..)

This is a design issue, lets not rush to make the decision. So currently the name mangling serves two purpose: (we currently reuse the same mangling scheme for the two different purposes which might not be good)

1. expression some properties not expressible due to lexical restrictions for example keyword keys like open
2. allow more expressivity to method overloading

With regard to purpose 2, we should de-mangling after type checking, otherwise it defeats the purpose of name mangling.

With regard to purpose 1, we also need consider when we do the de-mangling,

• Ideally we should de-mangling as soon as we can, for example if Reason allows x."Foo" and it is inferred as type { "Foo" } this binding
  can not be consumed on OCaml side, we have to write x##_Foo, but the type checker will refuse to type check those programs. (we can allow x##"Foo" too).

• But if we de-mangle at the syntax level, it will enforce us to provide a solution for type level de-mangling, currently user only need write < _Foo : .. > Js.t without ppx, in this case, we should ppx object types and class types (more complexity introduced), maybe we should completely hide Js.t by saying [%bs: < _Foo : > ]

Another issue is that current name mangling _ is too short that it is confusing to people since create_name is a normal name, maybe we should make it __ for purpose 2.

[bobzhang]

I think it is okay to consume reason bindings from OCaml even we de-mangling after type checking. Since reason bindings already provide types, so we only need expression to be capable of expressing keyword properties. In that case, I only need allow x##"open" which is not that bad (but types have to be declared on reason side)

[bobzhang]

current name mangling rules are documented here: http://bloomberg.github.io/bucklescript/Manual.html#_object_label_translation_convention

[bobzhang]

Based on what we described above:

We introduce two cases where name mangling will be introduced

1. single underscore followed by an OCaml keyword (does reason introduce new keywords?) or CAPITAL letter

_open -> open
_in -> in 
_mod -> mod 
_MAX_LENGTH -> MAX_LENGTH

2. double underscore for ad-hoc polymorphism

self##hey__     -->  self.hey
self##hey__two --> self.hey

note if it is a keyword, it is perfectly fine to have this

self##open__ --> self.open
self##open__two -> self.open

how about such cases, the simple rule is always apply rule 2 first, then rule 1

self##_Capital__  -> self.Capital
self##_open__ -> self.open