Makes the references to local JS classes explicit and desugars calls to js.constructorOf.

It also makes explicit all references to inner JS classes, using the pointers created by ExplicitInnerJS, and otherwise makes sure the back-end will receive all the information it needs to translate inner- and local JS classes and objects.

Note that in this comment, by "class" we mean *only* classes. traits and objects are not implied.

Similarly to how ExplicitInnerJS creates explicit fields in the enclosing templates of inner JS classes to hold the JS class values, this phase creates local vals for local JS classes in the enclosing statement list.

For every local JS class of the form:

def outer() = {
  class Local extends ParentJSClass
}

this phase creates a local val Local$jslass in the body of outer() to hold the JS class value for Local. The rhs of that val is a call to a magic method, used to retain information that the back-end will need:

• A reified reference to class Local, in the form of a classOf
• An explicit reference to the super JS class value, i.e., the desugaring of js.constructorOf[ParentJSClass]
• An array of fake new expressions for all overloaded constructors.

The latter will be augmented by lambdalift with the appropriate actual parameters for the captures of Local, which will be needed by the back-end. In code, this looks like:

def outer() = {
  class Local extends ParentJSClass
  val Local$jsclass: AnyRef = createLocalJSClass(
      classOf[Local],
      js.constructorOf[ParentJSClass],
      Array[AnyRef](new Local(), ...))
}

Since we need to insert fake new Inner()s, this scheme does not work for abstract local classes. We therefore reject them as implementation restriction.

If the body of Local references itself, then the val Local$jsclass is instead declared as a var to work around the cyclic dependency:

def outer() = {
  var Local$jsclass: AnyRef = null
  class Local extends ParentJSClass {
    ...
  }
  Local$jsclass = createLocalJSClass(...)
}

In addition to the above, ExplicitLocalJS transforms all *call sites* of local JS classes *and* inner JS classes, so that they refer to the synthesized local vals and fields.

The primary transformation is the desugaring of js.constructorOf[C], which depends on the nature of C:

• If C is a statically accessible class, desugar to runtime.constructorOf(classOf[C]) so that the reified symbol survives erasure and reaches the back-end.
• If C is an inner JS class, it must be of the form path.D for some pair (path, D), and we desugar it to path.D$jsclass, using the field created by ExplicitInnerJS (it is an error if C is of the form Enclosing#D).
• If C is a local JS class, desugar to C$jsclass, using the local val created by this phase.

The other transformations build on top of the desugaring of js.constructorOf[C], and apply only to inner JS classes and local JS classes (not for statically accessible classes):

• x.isInstanceOf[C] desugars into js.special.instanceof(x, js.constructorOf[C]).
• new C(...args) desugars into withContextualJSClassValue(js.constructorOf[C], new C(...args)), so that the back-end receives a reified reference to the JS class value.
• In the same spirit, for D extends C, D.super.m(...args) desugars into withContextualJSClassValue(js.constructorOf[C], D.super.m(...args)).

Finally, for inner- and local JS *objects*, their (only) instantiation point of the form new O.type() is rewritten as withContextualJSClassValue(js.constructorOf[ParentClassOfO], new O.type()), so that the back-end receives a reified reference to the parent class of O. A similar treatment is applied on anonymous JS classes, which basically define something very similar to an object, although without its own JS class.