Update the compiler not to avoid emitting trivial constructors.

This is a follow up to the parent commit, which brings the
compiler up to date with the requirements of the IR. Since
constructors are not inherited anymore, the compiler is required
to emit all constructors, including so-called trivial constructors.

Naively, this would not change anything at this point, since
missing constructors would be recreated by the linker. However,
for module accessors with trivial constructors, the constructor
now contains a StoreModule instruction, in addition to the super
constructor call. We keep parity with the previous implementation
by adding a corresponding optimization that gets rid of unnecessary
StoreModule instructions. This optimization can be applied in a few
more cases than what the compiler did, since it also supports any
statements before the StoreModule, and any "trivial" statement after
it.

Author: sjrd

compiler/src/main/scala/org/scalajs/core/compiler/GenJSCode.scala

@@ -744,8 +744,6 @@ abstract class GenJSCode extends plugins.PluginComponent
               OptimizerHints.empty, None))
         } else if (isRawJSCtorDefaultParam(sym)) {
           None
-        } else if (isTrivialConstructor(sym, params, rhs)) {
-          None
         } else if (sym.isClassConstructor && isHijackedBoxedClass(sym.owner)) {
           None
         } else {
@@ -825,33 +823,6 @@ abstract class GenJSCode extends plugins.PluginComponent
         "scala.runtime.ScalaRunTime.arrayElementClass"
     )
 
-    private def isTrivialConstructor(sym: Symbol, params: List[Symbol],
-        rhs: Tree): Boolean = {
-      if (!sym.isClassConstructor || isScalaJSDefinedJSClass(sym.owner)) {
-        false
-      } else {
-        rhs match {
-          // Shape of a constructor that only calls super
-          case Block(List(Apply(fun @ Select(_: Super, _), args)), Literal(_)) =>
-            val callee = fun.symbol
-            implicit val dummyPos = NoPosition
-
-            // Does the callee have the same signature as sym
-            if (encodeMethodSym(sym) == encodeMethodSym(callee)) {
-              // Test whether args are trivial forwarders
-              assert(args.size == params.size, "Argument count mismatch")
-              params.zip(args) forall { case (param, arg) =>
-                arg.symbol == param
-              }
-            } else {
-              false
-            }
-
-          case _ => false
-        }
-      }
-    }
-
     /** Patches the mutable flags of selected locals in a [[js.MethodDef]].
      *
      *  @param patches  Map from local name to new value of the mutable flags.

tools/shared/src/main/scala/org/scalajs/core/tools/optimizer/OptimizerCore.scala

@@ -101,7 +101,7 @@ private[optimizer] abstract class OptimizerCore(
   def optimize(thisType: Type, originalDef: MethodDef): LinkedMember[MethodDef] = {
     try {
       val MethodDef(static, name, params, resultType, body) = originalDef
-      val (newParams, newBody) = try {
+      val (newParams, newBody1) = try {
         transformIsolatedBody(Some(myself), thisType, params, resultType, body)
       } catch {
         case _: TooManyRollbacksException =>
@@ -111,6 +111,9 @@ private[optimizer] abstract class OptimizerCore(
           disableOptimisticOptimizations = true
           transformIsolatedBody(Some(myself), thisType, params, resultType, body)
       }
+      val newBody =
+        if (name.name == "init___") tryElimStoreModule(newBody1)
+        else newBody1
       val m = MethodDef(static, name, newParams, resultType,
           newBody)(originalDef.optimizerHints, None)(originalDef.pos)
       val info = Infos.generateMethodInfo(m)
@@ -127,6 +130,33 @@ private[optimizer] abstract class OptimizerCore(
     }
   }
 
+  /** Try and eliminate a StoreModule followed only by trivial statements. */
+  private def tryElimStoreModule(body: Tree): Tree = {
+    implicit val pos = body.pos
+    body match {
+      case StoreModule(_, _) =>
+        Skip()
+      case Block(stats) =>
+        val (before, from) = stats.span(!_.isInstanceOf[StoreModule])
+        if (from.isEmpty) {
+          body
+        } else {
+          val after = from.tail
+          val afterIsTrivial = after.forall {
+            case Assign(Select(This(), Ident(_, _)),
+                _:Literal | _:VarRef) =>
+              true
+            case _ =>
+              false
+          }
+          if (afterIsTrivial) Block(before ::: after)
+          else body
+        }
+      case _ =>
+        body
+    }
+  }
+
   private def newSimpleState[A](initialValue: A): SimpleState[A] = {
     val state = new SimpleState[A](initialValue)
     statesInUse ::= state