Don't force BoxedUnitType when forcing UnitType

Otherwise we might end up trying to initialize UnitType recursively,
which happens to work with the current implementation of non-volatile
lazy vals, but won't work after the next commit.

Author: smarter

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

@@ -470,10 +470,10 @@ class Definitions {
   def ArrayModule(implicit ctx: Context): ClassSymbol = ArrayModuleType.symbol.moduleClass.asClass
 
 
-  lazy val UnitType: TypeRef = valueTypeRef("scala.Unit", BoxedUnitType, java.lang.Void.TYPE, UnitEnc, nme.specializedTypeNames.Void)
+  lazy val UnitType: TypeRef = valueTypeRef("scala.Unit", java.lang.Void.TYPE, UnitEnc, nme.specializedTypeNames.Void)
   def UnitClass(implicit ctx: Context): ClassSymbol = UnitType.symbol.asClass
   def UnitModuleClass(implicit ctx: Context): Symbol = UnitType.symbol.asClass.linkedClass
-  lazy val BooleanType: TypeRef = valueTypeRef("scala.Boolean", BoxedBooleanType, java.lang.Boolean.TYPE, BooleanEnc, nme.specializedTypeNames.Boolean)
+  lazy val BooleanType: TypeRef = valueTypeRef("scala.Boolean", java.lang.Boolean.TYPE, BooleanEnc, nme.specializedTypeNames.Boolean)
   def BooleanClass(implicit ctx: Context): ClassSymbol = BooleanType.symbol.asClass
     lazy val Boolean_notR: TermRef   = BooleanClass.requiredMethodRef(nme.UNARY_!)
     def Boolean_! : Symbol = Boolean_notR.symbol
@@ -492,13 +492,13 @@ class Definitions {
     })
     def Boolean_!= : Symbol = Boolean_neqeqR.symbol
 
-  lazy val ByteType: TypeRef = valueTypeRef("scala.Byte", BoxedByteType, java.lang.Byte.TYPE, ByteEnc, nme.specializedTypeNames.Byte)
+  lazy val ByteType: TypeRef = valueTypeRef("scala.Byte", java.lang.Byte.TYPE, ByteEnc, nme.specializedTypeNames.Byte)
   def ByteClass(implicit ctx: Context): ClassSymbol = ByteType.symbol.asClass
-  lazy val ShortType: TypeRef = valueTypeRef("scala.Short", BoxedShortType, java.lang.Short.TYPE, ShortEnc, nme.specializedTypeNames.Short)
+  lazy val ShortType: TypeRef = valueTypeRef("scala.Short", java.lang.Short.TYPE, ShortEnc, nme.specializedTypeNames.Short)
   def ShortClass(implicit ctx: Context): ClassSymbol = ShortType.symbol.asClass
-  lazy val CharType: TypeRef = valueTypeRef("scala.Char", BoxedCharType, java.lang.Character.TYPE, CharEnc, nme.specializedTypeNames.Char)
+  lazy val CharType: TypeRef = valueTypeRef("scala.Char", java.lang.Character.TYPE, CharEnc, nme.specializedTypeNames.Char)
   def CharClass(implicit ctx: Context): ClassSymbol = CharType.symbol.asClass
-  lazy val IntType: TypeRef = valueTypeRef("scala.Int", BoxedIntType, java.lang.Integer.TYPE, IntEnc, nme.specializedTypeNames.Int)
+  lazy val IntType: TypeRef = valueTypeRef("scala.Int", java.lang.Integer.TYPE, IntEnc, nme.specializedTypeNames.Int)
   def IntClass(implicit ctx: Context): ClassSymbol = IntType.symbol.asClass
     lazy val Int_minusR: TermRef   = IntClass.requiredMethodRef(nme.MINUS, List(IntType))
     def Int_- : Symbol = Int_minusR.symbol
@@ -514,7 +514,7 @@ class Definitions {
     def Int_>= : Symbol = Int_geR.symbol
     lazy val Int_leR: TermRef   = IntClass.requiredMethodRef(nme.LE, List(IntType))
     def Int_<= : Symbol = Int_leR.symbol
-  lazy val LongType: TypeRef = valueTypeRef("scala.Long", BoxedLongType, java.lang.Long.TYPE, LongEnc, nme.specializedTypeNames.Long)
+  lazy val LongType: TypeRef = valueTypeRef("scala.Long", java.lang.Long.TYPE, LongEnc, nme.specializedTypeNames.Long)
   def LongClass(implicit ctx: Context): ClassSymbol = LongType.symbol.asClass
     lazy val Long_XOR_Long: Symbol = LongType.member(nme.XOR).requiredSymbol("method", nme.XOR, LongType.denot)(
       x => (x is Method) && (x.info.firstParamTypes.head isRef defn.LongClass)
@@ -529,9 +529,9 @@ class Definitions {
     lazy val Long_divR: TermRef   = LongClass.requiredMethodRef(nme.DIV, List(LongType))
     def Long_/ : Symbol = Long_divR.symbol
 
-  lazy val FloatType: TypeRef = valueTypeRef("scala.Float", BoxedFloatType, java.lang.Float.TYPE, FloatEnc, nme.specializedTypeNames.Float)
+  lazy val FloatType: TypeRef = valueTypeRef("scala.Float", java.lang.Float.TYPE, FloatEnc, nme.specializedTypeNames.Float)
   def FloatClass(implicit ctx: Context): ClassSymbol = FloatType.symbol.asClass
-  lazy val DoubleType: TypeRef = valueTypeRef("scala.Double", BoxedDoubleType, java.lang.Double.TYPE, DoubleEnc, nme.specializedTypeNames.Double)
+  lazy val DoubleType: TypeRef = valueTypeRef("scala.Double", java.lang.Double.TYPE, DoubleEnc, nme.specializedTypeNames.Double)
   def DoubleClass(implicit ctx: Context): ClassSymbol = DoubleType.symbol.asClass
 
   lazy val BoxedUnitType: TypeRef = ctx.requiredClassRef("scala.runtime.BoxedUnit")
@@ -1361,23 +1361,23 @@ class Definitions {
 
   private lazy val ScalaNumericValueTypes: collection.Set[TypeRef] = ScalaNumericValueTypeList.toSet
   private lazy val ScalaValueTypes: collection.Set[TypeRef] = ScalaNumericValueTypes + UnitType + BooleanType
-  private lazy val ScalaBoxedTypes = ScalaValueTypes map (t => boxedTypes(t.name))
 
   val ScalaNumericValueClasses: PerRun[collection.Set[Symbol]] = new PerRun(implicit ctx => ScalaNumericValueTypes.map(_.symbol))
   val ScalaValueClasses: PerRun[collection.Set[Symbol]]        = new PerRun(implicit ctx => ScalaValueTypes.map(_.symbol))
-  val ScalaBoxedClasses: PerRun[collection.Set[Symbol]]        = new PerRun(implicit ctx => ScalaBoxedTypes.map(_.symbol))
 
-  private val boxedTypes = mutable.Map[TypeName, TypeRef]()
+  val ScalaBoxedClasses: PerRun[collection.Set[Symbol]] = new PerRun(implicit ctx =>
+    Set(BoxedByteClass, BoxedShortClass, BoxedCharClass, BoxedIntClass, BoxedLongClass, BoxedFloatClass, BoxedDoubleClass, BoxedUnitClass, BoxedBooleanClass)
+  )
+
   private val valueTypeEnc = mutable.Map[TypeName, PrimitiveClassEnc]()
   private val typeTags = mutable.Map[TypeName, Name]().withDefaultValue(nme.specializedTypeNames.Object)
 
 //  private val unboxedTypeRef = mutable.Map[TypeName, TypeRef]()
 //  private val javaTypeToValueTypeRef = mutable.Map[Class[_], TypeRef]()
 //  private val valueTypeNamesToJavaType = mutable.Map[TypeName, Class[_]]()
 
-  private def valueTypeRef(name: String, boxed: TypeRef, jtype: Class[_], enc: Int, tag: Name): TypeRef = {
+  private def valueTypeRef(name: String, jtype: Class[_], enc: Int, tag: Name): TypeRef = {
     val vcls = ctx.requiredClassRef(name)
-    boxedTypes(vcls.name) = boxed
     valueTypeEnc(vcls.name) = enc
     typeTags(vcls.name) = tag
 //    unboxedTypeRef(boxed.name) = vcls
@@ -1387,7 +1387,19 @@ class Definitions {
   }
 
   /** The type of the boxed class corresponding to primitive value type `tp`. */
-  def boxedType(tp: Type)(implicit ctx: Context): TypeRef = boxedTypes(scalaClassName(tp))
+  def boxedType(tp: Type)(implicit ctx: Context): TypeRef = {
+    val cls = tp.classSymbol
+    if (cls eq ByteClass)         BoxedByteType
+    else if (cls eq ShortClass)   BoxedShortType
+    else if (cls eq CharClass)    BoxedCharType
+    else if (cls eq IntClass)     BoxedIntType
+    else if (cls eq LongClass)    BoxedLongType
+    else if (cls eq FloatClass)   BoxedFloatType
+    else if (cls eq DoubleClass)  BoxedDoubleType
+    else if (cls eq UnitClass)    BoxedUnitType
+    else if (cls eq BooleanClass) BoxedBooleanType
+    else sys.error(s"Not a primitive value type: $tp")
+  }
 
   /** The JVM tag for `tp` if it's a primitive, `java.lang.Object` otherwise. */
   def typeTag(tp: Type)(implicit ctx: Context): Name = typeTags(scalaClassName(tp))