Constructors are not inherited anymore at the IR level.

In JVM bytecode, constructors are not inherited. Due to historical
reasons, the Scala.js IR has supported inherited constructors, and
the compiler avoided generating so-called "trivial" constructors,
which only call their super constructor.

In this commit, we change the specification of the IR so that
constructors are not inherited anymore. For backward binary
compatibility, the analyzer still tolerates not to find a constructor
in the class where it is looked for. If it finds one in an inherited
class, the linker synthesizes the missing constructor.

As is, this introduces more code in the generated JavaScript files,
since no effort is made to avoid emitting useless JavaScript init
methods. This will be addressed in a follow up commit at the class
emitter level.

This commit does not modify the compiler yet (it still avoids
trivial constructors in the IR) so that we can test the backward
binary compatibility hack.

Author: sjrd

ci/checksizes.sh

@@ -34,20 +34,20 @@ REVERSI_OPT_GZ_SIZE=$(stat '-c%s' "$REVERSI_OPT.gz")
 
 case $FULLVER in
   2.10.2)
-    REVERSI_PREOPT_EXPECTEDSIZE=533000
-    REVERSI_OPT_EXPECTEDSIZE=120000
+    REVERSI_PREOPT_EXPECTEDSIZE=537000
+    REVERSI_OPT_EXPECTEDSIZE=121000
     REVERSI_PREOPT_GZ_EXPECTEDSIZE=72000
     REVERSI_OPT_GZ_EXPECTEDSIZE=32000
     ;;
   2.11.7)
-    REVERSI_PREOPT_EXPECTEDSIZE=535000
-    REVERSI_OPT_EXPECTEDSIZE=122000
+    REVERSI_PREOPT_EXPECTEDSIZE=540000
+    REVERSI_OPT_EXPECTEDSIZE=124000
     REVERSI_PREOPT_GZ_EXPECTEDSIZE=73000
     REVERSI_OPT_GZ_EXPECTEDSIZE=33000
     ;;
   2.12.0-M3)
-    REVERSI_PREOPT_EXPECTEDSIZE=531000
-    REVERSI_OPT_EXPECTEDSIZE=122000
+    REVERSI_PREOPT_EXPECTEDSIZE=535000
+    REVERSI_OPT_EXPECTEDSIZE=124000
     REVERSI_PREOPT_GZ_EXPECTEDSIZE=73000
     REVERSI_OPT_GZ_EXPECTEDSIZE=33000
     ;;

test-suite/js/src/test/scala/org/scalajs/testsuite/library/StackTraceTest.scala

@@ -69,26 +69,34 @@ object StackTraceTest extends JasmineTest {
     when("nodejs").
     unlessAny("fullopt-stage", "strong-mode").
     it("decode class name and method name") {
-      verifyClassMethodNames("Foo" -> "f") {
-        new Foo().f(25)
-      }
+      val Error = js.constructorOf[js.Error]
+      val oldStackTraceLimit = Error.stackTraceLimit
+      Error.stackTraceLimit = 20
 
-      verifyClassMethodNames("Foo" -> "f", "Bar" -> "g") {
-        new Bar().g(7)
-      }
+      try {
+        verifyClassMethodNames("Foo" -> "f") {
+          new Foo().f(25)
+        }
 
-      verifyClassMethodNames("Foo" -> "f", "FooTrait$class" -> "h") {
-        new Foo().h(78)
-      }
+        verifyClassMethodNames("Foo" -> "f", "Bar" -> "g") {
+          new Bar().g(7)
+        }
 
-      verifyClassMethodNames("Foo" -> "f", "FooTrait$class" -> "h",
-          "Baz" -> "<init>") {
-        new Baz()
-      }
+        verifyClassMethodNames("Foo" -> "f", "FooTrait$class" -> "h") {
+          new Foo().h(78)
+        }
 
-      verifyClassMethodNames("Foo" -> "f", "Bar" -> "g",
-          "Foobar$" -> "<clinit>", "Foobar$" -> "<init>") {
-        Foobar.z
+        verifyClassMethodNames("Foo" -> "f", "FooTrait$class" -> "h",
+            "Baz" -> "<init>") {
+          new Baz()
+        }
+
+        verifyClassMethodNames("Foo" -> "f", "Bar" -> "g",
+            "Foobar$" -> "<clinit>", "Foobar$" -> "<init>") {
+          Foobar.z
+        }
+      } finally {
+        Error.stackTraceLimit = oldStackTraceLimit
       }
     }
 

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

@@ -66,6 +66,15 @@ object Analysis {
     def calledFrom: Seq[From]
     def instantiatedSubclasses: Seq[ClassInfo]
     def nonExistent: Boolean
+    def syntheticKind: MethodSyntheticKind
+  }
+
+  sealed trait MethodSyntheticKind
+
+  object MethodSyntheticKind {
+    final case object None extends MethodSyntheticKind
+    // TODO Get rid of InheritedConstructor when we can break binary compat
+    final case object InheritedConstructor extends MethodSyntheticKind
   }
 
   sealed trait Error {

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

@@ -23,10 +23,16 @@ import org.scalajs.core.tools.javascript.{LongImpl, OutputMode}
 import ScalaJSOptimizer._
 
 final class Analyzer(semantics: Semantics, outputMode: OutputMode,
-    reachOptimizerSymbols: Boolean) extends Analysis {
+    reachOptimizerSymbols: Boolean, initialLink: Boolean) extends Analysis {
   import Analyzer._
   import Analysis._
 
+  @deprecated("Use the overload with an explicit `initialLink` flag", "0.6.6")
+  def this(semantics: Semantics, outputMode: OutputMode,
+      reachOptimizerSymbols: Boolean) = {
+    this(semantics, outputMode, reachOptimizerSymbols, initialLink = true)
+  }
+
   @deprecated("Use the overload with an explicit output mode", "0.6.3")
   def this(semantics: Semantics, reachOptimizerSymbols: Boolean) =
     this(semantics, OutputMode.ECMAScript51Isolated, reachOptimizerSymbols)
@@ -283,16 +289,50 @@ final class Analyzer(semantics: Semantics, outputMode: OutputMode,
       (mutable.Map(methodInfos: _*), mutable.Map(staticMethodInfos: _*))
     }
 
+    def lookupConstructor(ctorName: String): MethodInfo = {
+      /* As of 0.6.6, constructors are not inherited, and so must be found
+       * directly in this class. However, to be able to read sjsir files from
+       * before 0.6.6, we tolerate finding it in a superclass, in which case
+       * we materialize a new constructor in this class. We only allow this
+       * during the initial link. In a refiner, this must not happen anymore.
+       */
+      methodInfos.get(ctorName).getOrElse {
+        if (!initialLink) {
+          createNonExistentMethod(ctorName)
+        } else {
+          val inherited = lookupMethod(ctorName)
+          if (inherited.owner eq this) {
+            // Can happen only for non-existent constructors, at this point
+            assert(inherited.nonExistent)
+            inherited
+          } else {
+            val syntheticInfo = Infos.MethodInfo(
+                encodedName = ctorName,
+                methodsCalledStatically = Map(
+                    superClass.encodedName -> List(ctorName)))
+            val m = new MethodInfo(this, syntheticInfo)
+            m.syntheticKind = MethodSyntheticKind.InheritedConstructor
+            methodInfos += ctorName -> m
+            m
+          }
+        }
+      }
+    }
+
     def lookupMethod(methodName: String): MethodInfo = {
       tryLookupMethod(methodName).getOrElse {
-        val syntheticData = createMissingMethodInfo(methodName)
-        val m = new MethodInfo(this, syntheticData)
-        m.nonExistent = true
-        methodInfos += methodName -> m
-        m
+        createNonExistentMethod(methodName)
       }
     }
 
+    private def createNonExistentMethod(methodName: String): MethodInfo = {
+      val syntheticData = createMissingMethodInfo(methodName)
+      val m = new MethodInfo(this, syntheticData)
+      m.nonExistent = true
+      methodInfos += methodName -> m
+      m
+    }
+
     def tryLookupMethod(methodName: String): Option[MethodInfo] = {
       assert(isScalaClass,
           s"Cannot call lookupMethod($methodName) on non Scala class $this")
@@ -416,7 +456,7 @@ final class Analyzer(semantics: Semantics, outputMode: OutputMode,
         // constructors must always be called statically
         assert(statically,
             s"Trying to call dynamically the constructor $this.$methodName from $from")
-        lookupMethod(methodName).reachStatic()
+        lookupConstructor(methodName).reachStatic()
       } else if (statically) {
         assert(!isReflProxyName(methodName),
             s"Trying to call statically refl proxy $this.$methodName")
@@ -460,6 +500,8 @@ final class Analyzer(semantics: Semantics, outputMode: OutputMode,
 
     var nonExistent: Boolean = false
 
+    var syntheticKind: MethodSyntheticKind = MethodSyntheticKind.None
+
     override def toString(): String = s"$owner.$encodedName"
 
     def reachStatic()(implicit from: From): Unit = {

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

@@ -9,6 +9,8 @@
 
 package org.scalajs.core.tools.optimizer
 
+import scala.annotation.tailrec
+
 import scala.collection.mutable
 import scala.collection.immutable.{Seq, Traversable}
 
@@ -19,7 +21,8 @@ import org.scalajs.core.tools.io._
 
 import org.scalajs.core.ir
 import ir.Infos
-import ir.Trees.ClassDef
+import ir.Trees._
+import ir.Types._
 import ir.ClassKind
 import ir.Hashers
 import ir.Position
@@ -91,7 +94,8 @@ final class Linker(semantics: Semantics, outputMode: OutputMode,
     }
 
     val analysis = logTime(logger, "Linker: Compute reachability") {
-      val analyzer = new Analyzer(semantics, outputMode, reachOptimizerSymbols)
+      val analyzer = new Analyzer(semantics, outputMode, reachOptimizerSymbols,
+          initialLink = true)
       analyzer.computeReachability(infoInput)
     }
 
@@ -134,7 +138,7 @@ final class Linker(semantics: Semantics, outputMode: OutputMode,
       infoByName.get(encodedName).map { info =>
         val (tree, version) = getTree(encodedName)
         val newVersion = version.map("real" + _) // avoid collision with dummy
-        linkedClassDef(info, tree, analyzerInfo, newVersion)
+        linkedClassDef(info, tree, analyzerInfo, newVersion, getTree, analysis)
       }.orElse(optDummyParent)
     }
 
@@ -150,7 +154,8 @@ final class Linker(semantics: Semantics, outputMode: OutputMode,
   /** Takes a Infos, a ClassDef and DCE infos to construct a stripped down
    *  LinkedClassDef */
   private def linkedClassDef(info: Infos.ClassInfo, classDef: ClassDef,
-      analyzerInfo: Analysis.ClassInfo, version: Option[String]) = {
+      analyzerInfo: Analysis.ClassInfo, version: Option[String],
+      getTree: TreeProvider, analysis: Analysis) = {
     import ir.Trees._
 
     val memberInfoByName = Map(info.methods.map(m => m.encodedName -> m): _*)
@@ -173,6 +178,12 @@ final class Linker(semantics: Semantics, outputMode: OutputMode,
       new LinkedMember(info, p, None)
     }
 
+    def linkedSyntheticMethod(m: MethodDef) = {
+      val info = Infos.generateMethodInfo(m)
+      val version = m.hash.map(Hashers.hashAsVersion(_, considerPositions))
+      new LinkedMember(info, m, version)
+    }
+
     classDef.defs.foreach {
       // Static methods
       case m: MethodDef if m.static =>
@@ -212,6 +223,22 @@ final class Linker(semantics: Semantics, outputMode: OutputMode,
         sys.error(s"Illegal tree in ClassDef of class ${tree.getClass}")
     }
 
+    // Synthetic members
+    for {
+      m <- analyzerInfo.methodInfos.valuesIterator
+      if m.isReachable
+    } {
+      m.syntheticKind match {
+        case MethodSyntheticKind.None =>
+          // nothing to do
+
+        case MethodSyntheticKind.InheritedConstructor =>
+          val syntheticMDef = synthesizeInheritedConstructor(
+              analyzerInfo, m, getTree, analysis)(classDef.pos)
+          memberMethods += linkedSyntheticMethod(syntheticMDef)
+      }
+    }
+
     val classExportInfo =
       memberInfoByName.get(Definitions.ExportedConstructorsName)
 
@@ -243,6 +270,43 @@ final class Linker(semantics: Semantics, outputMode: OutputMode,
         version)
   }
 
+  private def synthesizeInheritedConstructor(
+      classInfo: Analysis.ClassInfo, methodInfo: Analysis.MethodInfo,
+      getTree: TreeProvider, analysis: Analysis)(
+      implicit pos: Position): MethodDef = {
+    val encodedName = methodInfo.encodedName
+
+    @tailrec
+    def findInheritedMethodDef(ancestorInfo: Analysis.ClassInfo): MethodDef = {
+      val inherited = ancestorInfo.methodInfos(methodInfo.encodedName)
+      if (inherited.syntheticKind == MethodSyntheticKind.None) {
+        val (classDef, _) = getTree(ancestorInfo.encodedName)
+        classDef.defs.collectFirst {
+          case mDef: MethodDef if mDef.name.name == encodedName => mDef
+        }.getOrElse {
+          throw new AssertionError(
+              s"Cannot find $encodedName in ${ancestorInfo.encodedName}")
+        }
+      } else {
+        findInheritedMethodDef(ancestorInfo.superClass)
+      }
+    }
+
+    val inheritedMDef = findInheritedMethodDef(classInfo.superClass)
+
+    val origName = inheritedMDef.name.asInstanceOf[Ident].originalName
+    val ctorIdent = Ident(encodedName, origName)
+    val params = inheritedMDef.args.map(_.copy()) // for the new pos
+    val currentClassType = ClassType(classInfo.encodedName)
+    val superClassType = ClassType(classInfo.superClass.encodedName)
+    MethodDef(static = false, ctorIdent,
+        params, NoType,
+        ApplyStatically(This()(currentClassType),
+            superClassType, ctorIdent, params.map(_.ref))(NoType))(
+        OptimizerHints.empty,
+        inheritedMDef.hash) // over-approximation
+  }
+
   private def startRun(): Unit = {
     statsReused = 0
     statsInvalidated = 0

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

@@ -16,11 +16,17 @@ final class Refiner(semantics: Semantics, outputMode: OutputMode) {
   def refine(unit: LinkingUnit, logger: Logger): LinkingUnit = {
     val analysis = logTime(logger, "Refiner: Compute reachability") {
       val analyzer = new Analyzer(semantics, outputMode,
-          reachOptimizerSymbols = false)
+          reachOptimizerSymbols = false, initialLink = false)
       analyzer.computeReachability(unit.infos.values.toList)
     }
 
-    // Note: We ignore all errors of the analysis
+    /* There really should not be linking errors at this point. If there are,
+     * it is most likely a bug in the optimizer. We should crash here, but we
+     * used to silently ignore any errors before 0.6.6. So currently we only
+     * warn, not to break compatibility.
+     * TODO Issue errors when we can break backward compatibility.
+     */
+    analysis.errors.foreach(Analysis.logError(_, logger, Level.Warn))
 
     logTime(logger, "Refiner: Assemble LinkedClasses") {
       val linkedClassesByName =