WIP Move module methods implementations to kernel

Author: nicolasstucki

compiler/src/dotty/tools/dotc/tastyreflect/CaseDefOpsImpl.scala

@@ -4,23 +4,4 @@ import dotty.tools.dotc.ast.tpd
 
 trait CaseDefOpsImpl extends scala.tasty.reflect.CaseDefOps with CoreImpl with Helpers {
 
-  object CaseDef extends CaseDefModule {
-    def apply(pattern: Pattern, guard: Option[Term], body: Term)(implicit ctx: Context): CaseDef =
-      tpd.CaseDef(pattern, guard.getOrElse(tpd.EmptyTree), body)
-
-    def copy(original: CaseDef)(pattern: Pattern, guard: Option[Term], body: Term)(implicit ctx: Context): CaseDef =
-      tpd.cpy.CaseDef(original)(pattern, guard.getOrElse(tpd.EmptyTree), body)
-
-    def unapply(x: CaseDef): Some[(Pattern, Option[Term], Term)] = Some(x.pat, optional(x.guard), x.body)
-  }
-
-  object TypeCaseDef extends TypeCaseDefModule {
-    def apply(pattern: TypeTree, body: TypeTree)(implicit ctx: Context): TypeCaseDef =
-      tpd.CaseDef(pattern, tpd.EmptyTree, body)
-
-    def copy(original: TypeCaseDef)(pattern: TypeTree, body: TypeTree)(implicit ctx: Context): TypeCaseDef =
-      tpd.cpy.CaseDef(original)(pattern, tpd.EmptyTree, body)
-
-    def unapply(x: TypeCaseDef): Some[(TypeTree, TypeTree)] = Some((x.pat, x.body))
-  }
 }

compiler/src/dotty/tools/dotc/tastyreflect/ConstantOpsImpl.scala

@@ -5,105 +5,4 @@ import dotty.tools.dotc.core.Constants
 
 trait ConstantOpsImpl extends scala.tasty.reflect.ConstantOps with CoreImpl {
 
-  object Constant extends ConstantModule {
-
-    object Unit extends UnitModule {
-      def apply(): Constant = Constants.Constant(())
-      def unapply(x: Constant): Boolean = x.tag == Constants.UnitTag
-    }
-
-    object Null extends NullModule {
-      def apply(): Constant = Constants.Constant(null)
-      def unapply(x: Constant): Boolean = x.tag == Constants.NullTag
-    }
-
-    object Boolean extends BooleanModule {
-      def apply(x: Boolean): Constant = Constants.Constant(x)
-      def unapply(x: Constant): Option[Boolean] = x match {
-        case x: Constants.Constant if x.tag == Constants.BooleanTag => Some(x.booleanValue)
-        case _ => None
-      }
-    }
-
-    object Byte extends ByteModule {
-      def apply(x: Byte): Constant = Constants.Constant(x)
-      def unapply(x: Constant): Option[Byte] = x match {
-        case x: Constants.Constant if x.tag == Constants.ByteTag => Some(x.byteValue)
-        case _ => None
-      }
-    }
-
-    object Short extends ShortModule {
-      def apply(x: Short): Constant = Constants.Constant(x)
-      def unapply(x: Constant): Option[Short] = x match {
-        case x: Constants.Constant if x.tag == Constants.ShortTag => Some(x.shortValue)
-        case _ => None
-      }
-    }
-
-    object Char extends CharModule {
-      def apply(x: Char): Constant = Constants.Constant(x)
-      def unapply(x: Constant): Option[Char] = x match {
-        case x: Constants.Constant if x.tag == Constants.CharTag => Some(x.charValue)
-        case _ => None
-      }
-    }
-
-    object Int extends IntModule {
-      def apply(x: Int): Constant = Constants.Constant(x)
-      def unapply(x: Constant): Option[Int] = x match {
-        case x: Constants.Constant if x.tag == Constants.IntTag => Some(x.intValue)
-        case _ => None
-      }
-    }
-
-    object Long extends LongModule {
-      def apply(x: Long): Constant = Constants.Constant(x)
-      def unapply(x: Constant): Option[Long] = x match {
-        case x: Constants.Constant if x.tag == Constants.LongTag => Some(x.longValue)
-        case _ => None
-      }
-    }
-
-    object Float extends FloatModule {
-      def apply(x: Float): Constant = Constants.Constant(x)
-      def unapply(x: Constant): Option[Float] = x match {
-        case x: Constants.Constant if x.tag == Constants.FloatTag => Some(x.floatValue)
-        case _ => None
-      }
-    }
-
-    object Double extends DoubleModule {
-      def apply(x: Double): Constant = Constants.Constant(x)
-      def unapply(x: Constant): Option[Double] = x match {
-        case x: Constants.Constant if x.tag == Constants.DoubleTag => Some(x.doubleValue)
-        case _ => None
-      }
-    }
-
-    object String extends StringModule {
-      def apply(x: String): Constant = Constants.Constant(x)
-      def unapply(x: Constant): Option[String] = x match {
-        case x: Constants.Constant if x.tag == Constants.StringTag => Some(x.stringValue)
-        case _ => None
-      }
-    }
-
-    object ClassTag extends ClassTagModule {
-      def apply[T](implicit x: scala.reflect.ClassTag[T]): Constant = Constants.Constant(x)
-      def unapply(x: Constant): Option[Type] = x match {
-        case x: Constants.Constant if x.tag == Constants.ClazzTag => Some(x.typeValue)
-        case _ => None
-      }
-    }
-
-    object Symbol extends SymbolModule {
-      def apply(x: scala.Symbol): Constant = Constants.Constant(x)
-      def unapply(x: Constant): Option[scala.Symbol] = x match {
-        case x: Constants.Constant if x.tag == Constants.ScalaSymbolTag => Some(x.scalaSymbolValue)
-        case _ => None
-      }
-    }
-  }
-
 }

compiler/src/dotty/tools/dotc/tastyreflect/IdOpsImpl.scala

@@ -4,8 +4,4 @@ import dotty.tools.dotc.core.Decorators._
 
 trait IdOpsImpl extends scala.tasty.reflect.IdOps with CoreImpl {
 
-  object Id extends IdModule {
-    def unapply(id: Id): Option[String] = Some(id.name.toString)
-  }
-
 }

compiler/src/dotty/tools/dotc/tastyreflect/ImportSelectorOpsImpl.scala

@@ -6,25 +6,4 @@ import dotty.tools.dotc.core.Decorators._
 
 trait ImportSelectorOpsImpl extends scala.tasty.reflect.ImportSelectorOps with CoreImpl {
 
-  object SimpleSelector extends SimpleSelectorModule {
-    def unapply(x: ImportSelector)(implicit ctx: Context): Option[Id] = x match {
-      case x: untpd.Ident => Some(x)
-      case _ => None
-    }
-  }
-
-  object RenameSelector extends RenameSelectorModule {
-    def unapply(x: ImportSelector)(implicit ctx: Context): Option[(Id, Id)] = x match {
-      case Trees.Thicket((id1: untpd.Ident) :: (id2: untpd.Ident) :: Nil) if id2.name != nme.WILDCARD => Some(id1, id2)
-      case _ => None
-    }
-  }
-
-  object OmitSelector extends OmitSelectorModule {
-    def unapply(x: ImportSelector)(implicit ctx: Context): Option[Id] = x match {
-      case Trees.Thicket((id: untpd.Ident) :: Trees.Ident(nme.WILDCARD) :: Nil) => Some(id)
-      case _ => None
-    }
-  }
-
 }