Write generic java signatures to classfiles

The code has been ported from scalac.

Author: Duhemm

compiler/src/dotty/tools/backend/jvm/DottyBackendInterface.scala

@@ -477,8 +477,86 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
 
   def getSingleOutput: Option[AbstractFile] = None // todo: implement
 
+  // @M don't generate java generics sigs for (members of) implementation
+  // classes, as they are monomorphic (TODO: ok?)
+  private final def needsGenericSignature(sym: Symbol): Boolean = !(
+    // pp: this condition used to include sym.hasexpandedname, but this leads
+    // to the total loss of generic information if a private member is
+    // accessed from a closure: both the field and the accessor were generated
+    // without it.  This is particularly bad because the availability of
+    // generic information could disappear as a consequence of a seemingly
+    // unrelated change.
+       ctx.base.settings.YnoGenericSig.value
+    || sym.is(Flags.Artifact)
+    || sym.is(Flags.allOf(Flags.Method, Flags.Lifted))
+    || sym.is(Flags.Bridge)
+  )
+
+  private def verifySignature(sym: Symbol, sig: String)(implicit ctx: Context): Unit = {
+    import scala.tools.asm.util.CheckClassAdapter
+    def wrap(body: => Unit): Boolean =
+      try { body; true }
+      catch { case ex: Throwable => println(ex.getMessage); false }
+
+    val valid = wrap {
+      if (sym.is(Flags.Method)) {
+        CheckClassAdapter.checkMethodSignature(sig)
+      }
+      else if (sym.isTerm) {
+        CheckClassAdapter.checkFieldSignature(sig)
+      }
+      else {
+        CheckClassAdapter.checkClassSignature(sig)
+      }
+    }
+
+    if(!valid) {
+      ctx.warning(
+        i"""|compiler bug: created invalid generic signature for $sym in ${sym.denot.owner.showFullName}
+            |signature: $sig
+            |if this is reproducible, please report bug at https://github.com/lampepfl/dotty/issues
+        """.trim, sym.pos)
+    }
+  }
+
+  /**
+   * Generates the generic signature for `sym` before erasure.
+   *
+   * @param sym   The symbol for which to generate a signature.
+   * @param owner The owner of `sym`.
+   * @return The generic signature of `sym` before erasure, as specified in the Java Virtual
+   *         Machine Specification, §4.3.4, or `null` if `sym` doesn't need a generic signature.
+   * @see https://docs.oracle.com/javase/specs/jvms/se7/html/jvms-4.html#jvms-4.3.4
+   */
+  def getGenericSignature(sym: Symbol, owner: Symbol): String = {
+    ctx.atPhase(ctx.erasurePhase) { implicit ctx =>
+      val memberTpe =
+        if (sym.is(Flags.Method)) sym.denot.info
+        else owner.denot.thisType.memberInfo(sym)
+      getGenericSignature(sym, owner, memberTpe).orNull
+    }
+  }
+
+  private def getGenericSignature(sym: Symbol, owner: Symbol, memberTpe: Type)(implicit ctx: Context): Option[String] =
+    if (needsGenericSignature(sym)) {
+      val erasedTypeSym = sym.denot.info.typeSymbol
+      if (erasedTypeSym.isPrimitiveValueClass) {
+        None
+      } else {
+        val jsOpt =
+          ctx.atPhase(ctx.erasurePhase) { implicit ctx =>
+            Erasure.javaSig(sym, memberTpe, _ => ())
+          }
 
-  def getGenericSignature(sym: Symbol, owner: Symbol): String = null // todo: implement
+        if (ctx.settings.XverifySignatures.value) {
+          jsOpt.foreach(verifySignature(sym, _))
+        }
+
+        jsOpt
+      }
+    } else {
+      None
+    }
 
   def getStaticForwarderGenericSignature(sym: Symbol, moduleClass: Symbol): String = null // todo: implement
 

compiler/src/dotty/tools/dotc/config/ScalaSettings.scala

@@ -61,6 +61,7 @@ class ScalaSettings extends Settings.SettingGroup {
   val XnoValueClasses = BooleanSetting("-Xno-value-classes", "Do not use value classes. Helps debugging.")
   val XreplLineWidth = IntSetting("-Xrepl-line-width", "Maximial number of columns per line for REPL output", 390)
   val XfatalWarnings = BooleanSetting("-Xfatal-warnings", "Fail the compilation if there are any warnings.")
+  val XverifySignatures = BooleanSetting("-Xverify-signatures", "Verify generic signatures in generated bytecode.")
 
   /** -Y "Private" settings */
   val overrideVars = BooleanSetting("-Yoverride-vars", "Allow vars to be overridden.")
@@ -79,6 +80,7 @@ class ScalaSettings extends Settings.SettingGroup {
   val YdisableFlatCpCaching  = BooleanSetting("-YdisableFlatCpCaching", "Do not cache flat classpath representation of classpath elements from jars across compiler instances.")
 
   val YnoImports = BooleanSetting("-Yno-imports", "Compile without importing scala.*, java.lang.*, or Predef.")
+  val YnoGenericSig = BooleanSetting("-Yno-generic-signatures", "Suppress generation of generic signatures for Java.")
   val YnoPredef = BooleanSetting("-Yno-predef", "Compile without importing Predef.")
   val Yskip = PhasesSetting("-Yskip", "Skip")
   val Ydumpclasses = StringSetting("-Ydump-classes", "dir", "Dump the generated bytecode to .class files (useful for reflective compilation that utilizes in-memory classloaders).", "")

compiler/src/dotty/tools/dotc/core/Definitions.scala

@@ -300,9 +300,11 @@ class Definitions {
   lazy val NothingClass: ClassSymbol = enterCompleteClassSymbol(
     ScalaPackageClass, tpnme.Nothing, AbstractFinal, List(AnyClass.typeRef))
   def NothingType = NothingClass.typeRef
+  lazy val RuntimeNothingModuleRef = ctx.requiredModuleRef("scala.runtime.Nothing")
   lazy val NullClass: ClassSymbol = enterCompleteClassSymbol(
     ScalaPackageClass, tpnme.Null, AbstractFinal, List(ObjectClass.typeRef))
   def NullType = NullClass.typeRef
+  lazy val RuntimeNullModuleRef = ctx.requiredModuleRef("scala.runtime.Null")
 
   lazy val ScalaPredefModuleRef = ctx.requiredModuleRef("scala.Predef")
   def ScalaPredefModule(implicit ctx: Context) = ScalaPredefModuleRef.symbol

compiler/src/dotty/tools/dotc/core/NameOps.scala

@@ -229,23 +229,8 @@ object NameOps {
 
     def specializedFor(classTargs: List[Types.Type], classTargsNames: List[Name], methodTargs: List[Types.Type], methodTarsNames: List[Name])(implicit ctx: Context): name.ThisName = {
 
-      def typeToTag(tp: Types.Type): Name = {
-        tp.classSymbol match {
-          case t if t eq defn.IntClass     => nme.specializedTypeNames.Int
-          case t if t eq defn.BooleanClass => nme.specializedTypeNames.Boolean
-          case t if t eq defn.ByteClass    => nme.specializedTypeNames.Byte
-          case t if t eq defn.LongClass    => nme.specializedTypeNames.Long
-          case t if t eq defn.ShortClass   => nme.specializedTypeNames.Short
-          case t if t eq defn.FloatClass   => nme.specializedTypeNames.Float
-          case t if t eq defn.UnitClass    => nme.specializedTypeNames.Void
-          case t if t eq defn.DoubleClass  => nme.specializedTypeNames.Double
-          case t if t eq defn.CharClass    => nme.specializedTypeNames.Char
-          case _                           => nme.specializedTypeNames.Object
-        }
-      }
-
-      val methodTags: Seq[Name] = (methodTargs zip methodTarsNames).sortBy(_._2).map(x => typeToTag(x._1))
-      val classTags: Seq[Name] = (classTargs zip classTargsNames).sortBy(_._2).map(x => typeToTag(x._1))
+      val methodTags: Seq[Name] = (methodTargs zip methodTarsNames).sortBy(_._2).map(x => x._1.toTag)
+      val classTags: Seq[Name] = (classTargs zip classTargsNames).sortBy(_._2).map(x => x._1.toTag)
 
       name.likeSpaced(name ++ nme.specializedTypeNames.prefix ++
         methodTags.fold(nme.EMPTY)(_ ++ _) ++ nme.specializedTypeNames.separator ++

compiler/src/dotty/tools/dotc/core/Symbols.scala

@@ -531,6 +531,18 @@ object Symbols {
     /** The current name of this symbol */
     final def name(implicit ctx: Context): ThisName = denot.name.asInstanceOf[ThisName]
 
+    def isHigherOrderTypeParameter(implicit ctx: Context): Boolean = this.maybeOwner.isTypeParameterOrSkolem
+    def isTypeParameterOrSkolem(implicit ctx: Context): Boolean = this.isTypeParam
+    def enclClassChain(implicit ctx: Context): List[Symbol] = this.maybeOwner.enclClassChain
+    final def isDerivedValueClass(implicit ctx: Context): Boolean =
+      isClass && !denot.is(Flags.Package) && !denot.is(Flags.Trait) &&
+        !ctx.phase.erasedTypes && denot.info.firstParent.typeSymbol == defn.AnyValClass && !denot.isPrimitiveValueClass
+
+    /** If this is a derived value class, return its unbox method
+     *  or NoSymbol if it does not exist.
+     */
+    def derivedValueClassUnbox(implicit ctx: Context): Symbol = NoSymbol
+
     /** The source or class file from which this class or
      *  the class containing this symbol was generated, null if not applicable.
      *  Overridden in ClassSymbol
@@ -637,17 +649,30 @@ object Symbols {
       denot.asInstanceOf[ClassDenotation]
 
     override protected def prefixString = "ClassSymbol"
+
+    override def enclClassChain(implicit ctx: Context): List[Symbol] =
+      if (this.is(Flags.PackageClass)) Nil
+      else this :: denot.owner.enclClassChain
+
+    override def derivedValueClassUnbox(implicit ctx: Context): Symbol =
+    // (info.decl(nme.unbox)) orElse      uncomment once we accept unbox methods
+      (denot.info.decls.find(_.denot.is(Flags.ParamAccessor | Flags.Method)))
+
   }
 
   class ErrorSymbol(val underlying: Symbol, msg: => String)(implicit ctx: Context) extends Symbol(NoCoord, ctx.nextId) {
     type ThisName = underlying.ThisName
     denot = underlying.denot
+
+    override def enclClassChain(implicit ctx: Context): List[Symbol] = Nil
   }
 
   @sharable object NoSymbol extends Symbol(NoCoord, 0) {
     denot = NoDenotation
     override def associatedFile(implicit ctx: Context): AbstractFile = NoSource.file
     override def recomputeDenot(lastd: SymDenotation)(implicit ctx: Context): SymDenotation = NoDenotation
+
+    override def enclClassChain(implicit ctx: Context): List[Symbol] = Nil
   }
 
   implicit class Copier[N <: Name](sym: Symbol { type ThisName = N })(implicit ctx: Context) {

compiler/src/dotty/tools/dotc/core/Types.scala

@@ -745,6 +745,24 @@ object Types {
       else ctx.asSeenFrom(this, pre, cls)
     }
 
+    /** The JVM tag for this type, if it's a primitive, `java.lang.Object` otherwise. */
+    final def toTag(implicit ctx: Context): Name = {
+      classSymbol match {
+        case t if t eq defn.IntClass     => nme.specializedTypeNames.Int
+        case t if t eq defn.BooleanClass => nme.specializedTypeNames.Boolean
+        case t if t eq defn.ByteClass    => nme.specializedTypeNames.Byte
+        case t if t eq defn.LongClass    => nme.specializedTypeNames.Long
+        case t if t eq defn.ShortClass   => nme.specializedTypeNames.Short
+        case t if t eq defn.FloatClass   => nme.specializedTypeNames.Float
+        case t if t eq defn.UnitClass    => nme.specializedTypeNames.Void
+        case t if t eq defn.DoubleClass  => nme.specializedTypeNames.Double
+        case t if t eq defn.CharClass    => nme.specializedTypeNames.Char
+        case _                           => nme.specializedTypeNames.Object
+      }
+    }
+
+
+
 // ----- Subtype-related --------------------------------------------
 
     /** Is this type a subtype of that type? */