abstract classExplicitLocalJS extends PluginComponent with Transform with TypingTransformers with CompatComponent
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 = nullclass 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.
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*
class
es.trait
s andobject
s 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:
this phase creates a local
val Local$jslass
in the body ofouter()
to hold the JS class value forLocal
. The rhs of that val is a call to a magic method, used to retain information that the back-end will need:class Local
, in the form of aclassOf
js.constructorOf[ParentJSClass]
new
expressions for all overloaded constructors.The latter will be augmented by
lambdalift
with the appropriate actual parameters for the captures ofLocal
, which will be needed by the back-end. In code, this looks like: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 theval Local$jsclass
is instead declared as avar
to work around the cyclic dependency: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 ofC
:C
is a statically accessible class, desugar toruntime.constructorOf(classOf[C])
so that the reified symbol survives erasure and reaches the back-end.C
is an inner JS class, it must be of the formpath.D
for some pair (path
,D
), and we desugar it topath.D$jsclass
, using the field created byExplicitInnerJS
(it is an error ifC
is of the formEnclosing#D
).C
is a local JS class, desugar toC$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 intojs.special.instanceof(x, js.constructorOf[C])
.new C(...args)
desugars intowithContextualJSClassValue(js.constructorOf[C], new C(...args))
, so that the back-end receives a reified reference to the JS class value.D extends C
,D.super.m(...args)
desugars intowithContextualJSClassValue(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 aswithContextualJSClassValue(js.constructorOf[ParentClassOfO], new O.type())
, so that the back-end receives a reified reference to the parent class ofO
. A similar treatment is applied on anonymous JS classes, which basically define something very similar to anobject
, although without its own JS class.