Make enums compatible with the new constructor hijack

Author: anatoliykmetyuk

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

@@ -224,7 +224,7 @@ class BTypesFromSymbols[I <: BackendInterface](val int: I) extends BTypes {
       if (sym.isVarargsMethod) ACC_VARARGS else 0,
       if (sym.isSynchronized) ACC_SYNCHRONIZED else 0,
       if (sym.isDeprecated) asm.Opcodes.ACC_DEPRECATED else 0,
-      if (sym.isEnum) asm.Opcodes.ACC_ENUM else 0
+      if (sym.isJavaEnum) asm.Opcodes.ACC_ENUM else 0
     )
   }
 

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

@@ -512,7 +512,7 @@ abstract class BackendInterface extends BackendInterfaceDefinitions {
     def isJavaDefaultMethod: Boolean
     def isClassConstructor: Boolean
     def isSerializable: Boolean
-    def isEnum: Boolean
+    def isJavaEnum: Boolean
 
     /**
      * True for module classes of modules that are top-level or owned only by objects. Module classes

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

@@ -703,7 +703,7 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
     def shouldEmitForwarders: Boolean =
       (sym is Flags.Module) && sym.isStatic
     def isJavaEntryPoint: Boolean = CollectEntryPoints.isJavaEntryPoint(sym)
-    def isEnum = sym.is(Flags.Enum, butNot = Flags.Case) && sym.info.parents.exists(p => p.typeSymbol == defn.JEnumClass)
+    def isJavaEnum = sym.is(Flags.Enum, butNot = Flags.Case) && sym.info.parents.exists(p => p.typeSymbol == defn.JavaEnumClass)
 
     def isClassConstructor: Boolean = toDenot(sym).isClassConstructor
     def isSerializable: Boolean = toDenot(sym).isSerializable

compiler/src/dotty/tools/dotc/ast/DesugarEnums.scala

@@ -101,16 +101,16 @@ object DesugarEnums {
         .withFlags(Private)
 
     val valuesOfExnMessage = Apply(
-      Select(Literal(Constant("key not found: ")), "concat".toTermName)
-    , Ident(nme.nameDollar) :: Nil)
+      Select(Literal(Constant("key not found: ")), "concat".toTermName),
+      Ident(nme.nameDollar) :: Nil)
     val valuesOfBody = Try(
-      expr = Apply(valuesDot("fromName"), Ident(nme.nameDollar) :: Nil)
-    , cases = CaseDef(
-        pat = Typed(Ident(nme.DEFAULT_EXCEPTION_NAME), TypeTree(defn.NoSuchElementExceptionType))
-      , guard = EmptyTree
-      , body = Throw(New(TypeTree(defn.IllegalArgumentExceptionType), List(valuesOfExnMessage :: Nil)))
-      ) :: Nil
-    , finalizer = EmptyTree
+      expr = Apply(valuesDot("fromName"), Ident(nme.nameDollar) :: Nil),
+      cases = CaseDef(
+        pat = Typed(Ident(nme.DEFAULT_EXCEPTION_NAME), TypeTree(defn.NoSuchElementExceptionType)),
+        guard = EmptyTree,
+        body = Throw(New(TypeTree(defn.IllegalArgumentExceptionType), List(valuesOfExnMessage :: Nil)))
+      ) :: Nil,
+      finalizer = EmptyTree
     )
     val valueOfDef = DefDef(nme.valueOf, Nil, List(param(nme.nameDollar, defn.StringType) :: Nil),
       TypeTree(), valuesOfBody)

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

@@ -605,9 +605,9 @@ class Definitions {
   @threadUnsafe lazy val SystemClass: ClassSymbol               = ctx.requiredClass("java.lang.System")
   @threadUnsafe lazy val SystemModule: Symbol              = SystemClass.linkedClass
 
-  lazy val NoSuchElementExceptionClass = ctx.requiredClass("java.util.NoSuchElementException")
+  @threadUnsafe lazy val NoSuchElementExceptionClass = ctx.requiredClass("java.util.NoSuchElementException")
   def NoSuchElementExceptionType = NoSuchElementExceptionClass.typeRef
-  lazy val IllegalArgumentExceptionClass = ctx.requiredClass("java.lang.IllegalArgumentException")
+  @threadUnsafe lazy val IllegalArgumentExceptionClass = ctx.requiredClass("java.lang.IllegalArgumentException")
   def IllegalArgumentExceptionType = IllegalArgumentExceptionClass.typeRef
 
   // in scalac modified to have Any as parent
@@ -708,8 +708,6 @@ class Definitions {
   def EnumClass(implicit ctx: Context): ClassSymbol = EnumType.symbol.asClass
     @threadUnsafe lazy val Enum_ordinalR: TermRef = EnumClass.requiredMethodRef(nme.ordinal)
     def Enum_ordinal(implicit ctx: Context): Symbol = Enum_ordinalR.symbol
-  @threadUnsafe lazy val JEnumType: TypeRef                   = ctx.requiredClassRef("scala.compat.JEnum")
-  def JEnumClass(implicit ctx: Context): ClassSymbol = JEnumType.symbol.asClass
   @threadUnsafe lazy val EnumValuesType: TypeRef              = ctx.requiredClassRef("scala.runtime.EnumValues")
   def EnumValuesClass(implicit ctx: Context): ClassSymbol = EnumValuesType.symbol.asClass
   @threadUnsafe lazy val ProductType: TypeRef                 = ctx.requiredClassRef("scala.Product")