Remove unnecessary objects

Author: nicolasstucki

compiler/src/dotty/tools/dotc/tasty/Toolbox.scala

@@ -86,17 +86,17 @@ object Toolbox {
 
     // Constants
 
-    override def unapplyUnit(arg: Constant) = internal.Constant.Unit.unapply(arg)
-    override def unapplyNull(arg: Constant) = internal.Constant.Null.unapply(arg)
-    override def unapplyBoolean(arg: Constant) = internal.Constant.Boolean.unapply(arg)
-    override def unapplyByte(arg: Constant) = internal.Constant.Byte.unapply(arg)
-    override def unapplyChar(arg: Constant) = internal.Constant.Char.unapply(arg)
-    override def unapplyShort(arg: Constant) = internal.Constant.Short.unapply(arg)
-    override def unapplyInt(arg: Constant) = internal.Constant.Int.unapply(arg)
-    override def unapplyLong(arg: Constant) = internal.Constant.Long.unapply(arg)
-    override def unapplyFloat(arg: Constant) = internal.Constant.Float.unapply(arg)
-    override def unapplyDouble(arg: Constant) = internal.Constant.Double.unapply(arg)
-    override def unapplyString(arg: Constant) = internal.Constant.String.unapply(arg)
+    override def unapplyUnit(arg: Constant) = internal.Constant.unapplyUnit(arg)
+    override def unapplyNull(arg: Constant) = internal.Constant.unapplyNull(arg)
+    override def unapplyBoolean(arg: Constant) = internal.Constant.unapplyBoolean(arg)
+    override def unapplyByte(arg: Constant) = internal.Constant.unapplyByte(arg)
+    override def unapplyChar(arg: Constant) = internal.Constant.unapplyChar(arg)
+    override def unapplyShort(arg: Constant) = internal.Constant.unapplyShort(arg)
+    override def unapplyInt(arg: Constant) = internal.Constant.unapplyInt(arg)
+    override def unapplyLong(arg: Constant) = internal.Constant.unapplyLong(arg)
+    override def unapplyFloat(arg: Constant) = internal.Constant.unapplyFloat(arg)
+    override def unapplyDouble(arg: Constant) = internal.Constant.unapplyDouble(arg)
+    override def unapplyString(arg: Constant) = internal.Constant.unapplyString(arg)
 
     // Types
 

compiler/src/dotty/tools/dotc/tasty/internal/Constant.scala

@@ -9,81 +9,59 @@ object Constant {
 
   def apply(constant: Constants.Constant): constants.Constant = Impl(constant)
 
-  object Unit {
-    def unapply(const: constants.Constant): Boolean = const match {
-      case Impl(const) => const.tag == Constants.UnitTag
-      case _ => false
-    }
+  def unapplyUnit(const: constants.Constant): Boolean = const match {
+    case Impl(const) => const.tag == Constants.UnitTag
+    case _ => false
   }
 
-  object Null {
-    def unapply(const: constants.Constant): Boolean = const match {
-      case Impl(const) => const.tag == Constants.NullTag
-      case _ => false
-    }
+  def unapplyNull(const: constants.Constant): Boolean = const match {
+    case Impl(const) => const.tag == Constants.NullTag
+    case _ => false
   }
 
-  object Boolean {
-    def unapply(const: constants.Constant): Option[Boolean] = const match {
-      case Impl(const) if const.tag == Constants.BooleanTag => Some(const.booleanValue)
-      case _ => None
-    }
+  def unapplyBoolean(const: constants.Constant): Option[Boolean] = const match {
+    case Impl(const) if const.tag == Constants.BooleanTag => Some(const.booleanValue)
+    case _ => None
   }
 
-  object Byte {
-    def unapply(const: constants.Constant): Option[Byte] = const match {
-      case Impl(const) if const.tag == Constants.ByteTag => Some(const.byteValue)
-      case _ => None
-    }
+  def unapplyByte(const: constants.Constant): Option[Byte] = const match {
+    case Impl(const) if const.tag == Constants.ByteTag => Some(const.byteValue)
+    case _ => None
   }
 
-  object Char {
-    def unapply(const: constants.Constant): Option[Char] = const match {
-      case Impl(const) if const.tag == Constants.CharTag => Some(const.charValue)
-      case _ => None
-    }
+  def unapplyChar(const: constants.Constant): Option[Char] = const match {
+    case Impl(const) if const.tag == Constants.CharTag => Some(const.charValue)
+    case _ => None
   }
 
-  object Short {
-    def unapply(const: constants.Constant): Option[Short] = const match {
-      case Impl(const) if const.tag == Constants.ShortTag => Some(const.shortValue)
-      case _ => None
-    }
+  def unapplyShort(const: constants.Constant): Option[Short] = const match {
+    case Impl(const) if const.tag == Constants.ShortTag => Some(const.shortValue)
+    case _ => None
   }
 
-  object Int {
-    def unapply(const: constants.Constant): Option[Int] = const match {
-      case Impl(const) if const.tag == Constants.IntTag => Some(const.intValue)
-      case _ => None
-    }
+  def unapplyInt(const: constants.Constant): Option[Int] = const match {
+    case Impl(const) if const.tag == Constants.IntTag => Some(const.intValue)
+    case _ => None
   }
 
-  object Long {
-    def unapply(const: constants.Constant): Option[Long] = const match {
-      case Impl(const) if const.tag == Constants.LongTag => Some(const.longValue)
-      case _ => None
-    }
+  def unapplyLong(const: constants.Constant): Option[Long] = const match {
+    case Impl(const) if const.tag == Constants.LongTag => Some(const.longValue)
+    case _ => None
   }
 
-  object Float {
-    def unapply(const: constants.Constant): Option[Float] = const match {
-      case Impl(const) if const.tag == Constants.FloatTag => Some(const.floatValue)
-      case _ => None
-    }
+  def unapplyFloat(const: constants.Constant): Option[Float] = const match {
+    case Impl(const) if const.tag == Constants.FloatTag => Some(const.floatValue)
+    case _ => None
   }
 
-  object Double {
-    def unapply(const: constants.Constant): Option[Double] = const match {
-      case Impl(const) if const.tag == Constants.DoubleTag => Some(const.doubleValue)
-      case _ => None
-    }
+  def unapplyDouble(const: constants.Constant): Option[Double] = const match {
+    case Impl(const) if const.tag == Constants.DoubleTag => Some(const.doubleValue)
+    case _ => None
   }
 
-  object String {
-    def unapply(const: constants.Constant): Option[String] = const match {
-      case Impl(const) if const.tag == Constants.StringTag => Some(const.stringValue)
-      case _ => None
-    }
+  def unapplyString(const: constants.Constant): Option[String] = const match {
+    case Impl(const) if const.tag == Constants.StringTag => Some(const.stringValue)
+    case _ => None
   }
 
   private[tasty] case class Impl(const: Constants.Constant) extends constants.Constant {