Generates the Scala.js IR for a compilation unit This method iterates over all the class and interface definitions found in the compilation unit and emits their IR (.sjsir).

Some classes are never actually emitted:

• Classes representing primitive types
• The scala.Array class
• Implementation classes for JS traits

Some classes representing anonymous functions are not actually emitted. Instead, a temporary representation of their apply method is built and recorded, so that it can be inlined as a JavaScript anonymous function in the method that instantiates it.

Other ClassDefs are emitted according to their nature: * Non-native JS class -> genNonNativeJSClass() * Other JS type (<: js.Any) -> genJSClassData() * Interface -> genInterface() * Normal class -> genClass()

Ensures that the value of the given tree is boxed.

Extracts a value typed as Any to the given type after posterasure.

Generate an instance of an anonymous (non-lambda) JS class inline

Gen JS code for an Apply node (method call)

There's a whole bunch of varieties of Apply nodes: regular method calls, super calls, constructor calls, isInstanceOf/asInstanceOf, primitives, JS calls, etc. They are further dispatched in here.

Gen definitions for the fields of a class. The fields are initialized with the zero of their types.

Gen JS code for a JS function class.

This is called when emitting a ClassDef that represents an anonymous class extending js.FunctionN. These are generated by the SAM synthesizer when the target type is a js.FunctionN. Since JS functions are not classes, we deconstruct the ClassDef, then reconstruct it to be a genuine Closure.

Compared to tryGenAnonFunctionClass(), this function must always succeed, because we really cannot afford keeping them as anonymous classes. The good news is that it can do so, because the body of SAM lambdas is hoisted in the enclosing class. Hence, the apply() method is just a forwarder to calling that hoisted method.

From a class looking like this:

final class <anon>(outer, capture1, ..., captureM) extends js.FunctionN[...] { def apply(param1, ..., paramN) = { outer.lambdaImpl(param1, ..., paramN, capture1, ..., captureM) } } new <anon>(o, c1, ..., cM)

we generate a function:

lambda<o, c1, ..., cM>[notype]( outer, capture1, ..., captureM, param1, ..., paramN) { outer.lambdaImpl(param1, ..., paramN, capture1, ..., captureM) }

Gen JS code for LabelDef The only LabelDefs that can reach here are the desugaring of while and do..while loops. All other LabelDefs (for tail calls or matches) are caught upstream and transformed in ad hoc ways.

So here we recognize all the possible forms of trees that can result of while or do..while loops, and we reconstruct the loop for emission to JS.

Generate loading of a module value.

Can be given either the module symbol or its module class symbol.

If the module we load refers to the global scope (i.e., it is annotated with @JSGlobalScope), report a compile error specifying that a global scope object should only be used as the qualifier of a .-selection.

Generate loading of a module value or the global scope.

Can be given either the module symbol of its module class symbol.

Unlike genLoadModule, this method does not fail if the module we load refers to the global scope.

Gen JS code for a Match, i.e., a switch-able pattern match.

In most cases, this straightforwardly translates to a Match in the IR, which will eventually become a switch in JavaScript.

However, sometimes there is a guard in here, despite the fact that matches cannot have guards (in the JVM nor in the IR). The JVM backend emits a jump to the default clause when a guard is not fulfilled. We cannot do that, since we do not have arbitrary jumps. We therefore use a funny encoding with two nested Labeled blocks. For example,

x match {
  case 1 if y > 0 => a
  case 2          => b
  case _          => c
}

arrives at the back-end as

x match {
  case 1 =>
    if (y > 0)
      a
    else
      default()
  case 2 =>
    b
  case _ =>
    default() {
      c
    }
}

which we then translate into the following IR:

matchResult[I]: {
  default[V]: {
    x match {
      case 1 =>
        return(matchResult) if (y > 0)
          a
        else
          return(default) (void 0)
      case 2 =>
        return(matchResult) b
      case _ =>
        ()
    }
  }
  c
}

Generates exported methods and properties for a class.

Generates the MethodDef of a (non-constructor) method

Most normal methods are emitted straightforwardly. If the result type is Unit, then the body is emitted as a statement. Otherwise, it is emitted as an expression.

The additional complexity of this method handles the transformation of a peculiarity of recursive tail calls: the local ValDef that replaces this.

Gen JS code for a method definition in a class or in an impl class. On the JS side, method names are mangled to encode the full signature of the Scala method, as described in JSEncoding, to support overloading.

Some methods are not emitted at all: * Primitives, since they are never actually called (with exceptions) * Abstract methods * Constructors of hijacked classes * Methods with the

@JavaDefaultMethod

annotation mixed in classes.

Constructors are emitted by generating their body as a statement.

Interface methods with the

@JavaDefaultMethod

annotation produce default methods forwarding to the trait impl class method.

Other (normal) methods are emitted with genMethodDef().

@JavaDefaultMethod }}} default methods forwarding to the trait impl class method.

Other (normal) methods are emitted with genMethodDef().

@JavaDefaultMethod }}}

Constructors are emitted by generating their body as a statement.

Interface methods with the

@JavaDefaultMethod

annotation produce default methods forwarding to the trait impl class method.

Other (normal) methods are emitted with genMethodDef().

@JavaDefaultMethod }}} default methods forwarding to the trait impl class method.

Other (normal) methods are emitted with genMethodDef().

Gen JS code for a Labeled block from a pattern match'es match-end, while trying to optimize it away as an If chain.

It is important to do so at compile-time because, when successful, the resulting IR can be much better optimized by the optimizer.

The optimizer also does something similar, but *after* it has processed the body of the Labeled block, at which point it has already lost any information about stack-allocated values.

!!! There is quite of bit of code duplication with OptimizerCore.tryOptimizePatternMatch.

Gen JS code for a tree in statement or expression position (in the IR).

This is the main transformation method. Each node of the Scala AST is transformed into an equivalent portion of the JS AST.

Gen the static forwarders to the members of a class or interface for methods of its companion object.

This is only done if there exists a companion object and it is not a JS type.

Precondition: isCandidateForForwarders(sym) is true

Gen the static forwarders for the methods of a module class.

Precondition: isCandidateForForwarders(moduleClass) is true

Gen JS code for a translated match

This implementation relies heavily on the patterns of trees emitted by the pattern match phase, including its variants across versions of scalac that we support.

The trees output by the pattern matcher are assumed to follow these rules: * Each case LabelDef (in cases) must not take any argument. * The last one must be a catch-all (case _ =>) that never falls through. * Jumps to the matchEnd are allowed anywhere in the body of the corresponding case label-defs, but not outside. * Jumps to case label-defs are restricted to jumping to the very next case, and only in positions denoted by <jump> in: <case-body> ::= If(_, <case-body>, <case-body>) | Block(_, <case-body>) | <jump> | _ These restrictions, together with the fact that we are in statement position (thanks to the above transformation), mean that they can be simply replaced by skip.

To implement jumps to matchEnd, which have one argument which is the result of the match, we enclose all the cases in one big labeled block. Jumps are then compiled as returns out of the block.

Gen JS code for a try..catch or try..finally block

try..finally blocks are compiled straightforwardly to try..finally blocks of JS.

try..catch blocks are a bit more subtle, as JS does not have type-based selection of exceptions to catch. We thus encode explicitly the type tests, like in:

try { ... } catch (e) { if (e.isInstanceOf[IOException]) { ... } else if (e.isInstanceOf[Exception]) { ... } else { throw e; // default, re-throw } }