Packages

  • package root
    Definition Classes
    root
  • package org
    Definition Classes
    root
  • package scalajs
    Definition Classes
    org
  • package nscplugin
    Definition Classes
    scalajs
  • abstract class ExplicitLocalJS[G <: Global with Singleton] extends PluginComponent with Transform with TypingTransformers with CompatComponent

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

    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.

    Definition Classes
    nscplugin
  • BTypesCompat
  • ExplicitLocalJSTransformer
  • GlobalCompat
  • Phase
  • SAMFunctionAttachCompat
  • SAMFunctionAttachCompatDef
  • SAMFunctionCompatOps
  • StdPhase
  • StdTermNamesCompat
  • StdTypeNamesCompat
  • SymbolCompat
  • TypingTransformer
c

org.scalajs.nscplugin.ExplicitLocalJS

ExplicitLocalJSTransformer

class ExplicitLocalJSTransformer extends TypingTransformer

Linear Supertypes
ExplicitLocalJS.TypingTransformer, G.Transformer, G.Transformer, AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. ExplicitLocalJSTransformer
  2. TypingTransformer
  3. Transformer
  4. Transformer
  5. AnyRef
  6. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Instance Constructors

  1. new ExplicitLocalJSTransformer(unit: G.CompilationUnit)

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  4. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  5. def atOwner[A](tree: G.Tree, owner: G.Symbol)(trans: ⇒ A): A
    Definition Classes
    TypingTransformer
  6. final def atOwner[A](owner: G.Symbol)(trans: ⇒ A): A
    Definition Classes
    TypingTransformer → Transformer
  7. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... ) @native()
  8. var curTree: G.Tree
    Attributes
    protected
    Definition Classes
    TypingTransformer
  9. def currentClass: G.Symbol
    Attributes
    protected
    Definition Classes
    Transformer
  10. def currentMethod: G.Symbol
    Attributes
    protected
    Definition Classes
    Transformer
  11. var currentOwner: G.Symbol
    Attributes
    protected[scala]
    Definition Classes
    Transformer
  12. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  13. def equals(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  14. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  15. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  16. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  17. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  18. var localTyper: (G.analyzer)#Typer
    Definition Classes
    TypingTransformer
  19. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  20. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  21. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  22. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  23. def toString(): String
    Definition Classes
    AnyRef → Any
  24. def transform(tree: G.Tree): G.Tree

    The main transformation method.

    The main transformation method.

    Definition Classes
    ExplicitLocalJSTransformer → TypingTransformer → Transformer
  25. def transformCaseDefs(trees: List[G.CaseDef]): List[G.CaseDef]
    Definition Classes
    Transformer
  26. def transformIdents(trees: List[G.Ident]): List[G.Ident]
    Definition Classes
    Transformer
  27. def transformMemberDefs(trees: List[G.MemberDef]): List[G.MemberDef]
    Definition Classes
    Transformer
  28. def transformModifiers(mods: G.Modifiers): G.Modifiers
    Definition Classes
    Transformer
  29. def transformStats(stats: List[G.Tree], exprOwner: G.Symbol): List[G.Tree]
    Definition Classes
    Transformer
  30. def transformTemplate(tree: G.Template): G.Template
    Definition Classes
    Transformer
  31. def transformTrees(trees: List[G.Tree]): List[G.Tree]
    Definition Classes
    Transformer
  32. def transformTypeDefs(trees: List[G.TypeDef]): List[G.TypeDef]
    Definition Classes
    Transformer
  33. def transformUnit(unit: G.CompilationUnit): Unit
    Definition Classes
    ExplicitLocalJSTransformer → Transformer
  34. def transformValDef(tree: G.ValDef): G.ValDef
    Definition Classes
    Transformer
  35. def transformValDefs(trees: List[G.ValDef]): List[G.ValDef]
    Definition Classes
    Transformer
  36. def transformValDefss(treess: List[List[G.ValDef]]): List[List[G.ValDef]]
    Definition Classes
    Transformer
  37. val treeCopy: G.TreeCopier
    Definition Classes
    Transformer
  38. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  39. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  40. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... ) @native()

Inherited from ExplicitLocalJS.TypingTransformer

Inherited from G.Transformer

Inherited from G.Transformer

Inherited from AnyRef

Inherited from Any

Ungrouped