Remove all case classes from internal representation

Author: nicolasstucki

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

@@ -9,14 +9,14 @@ import scala.tasty.modifiers
 
 object AnnotationModifier {
 
-  def apply(tree: Annotation)(implicit ctx: Context): modifiers.Modifier = Impl(tree, ctx)
+  def apply(tree: Annotation)(implicit ctx: Context): modifiers.Modifier = new Impl(tree)
 
-  def unapplyAnnotation(mod: modifiers.Modifier): Option[modifiers.Annotation.Data] = mod match {
-    case Impl(annot, ctx) => Some(Term(annot.tree(ctx))(ctx))
-    case _ => None
+  def unapplyAnnotation(arg: Impl): Option[modifiers.Annotation.Data] = {
+    implicit val ctx: Context = arg.ctx
+    Some(Term(arg.annot.tree))
   }
 
-  private case class Impl(annot: Annotation, ctx: Context) extends modifiers.Modifier {
+  private[tasty] class Impl(val annot: Annotation)(implicit val ctx: Context) extends modifiers.Modifier {
 
     def pos: scala.tasty.Position = new Position(sourcePos(annot.tree(ctx).pos)(ctx))
 

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

@@ -9,15 +9,15 @@ import scala.tasty.trees
 
 object CaseDef {
 
-  def apply(tree: tpd.Tree)(implicit ctx: Context): trees.CaseDef = Impl(tree, ctx)
+  def apply(tree: tpd.CaseDef)(implicit ctx: Context): trees.CaseDef = new Impl(tree)
 
-  def unapplyCaseDef(tree: trees.Tree): Option[trees.CaseDef.Data] = tree match {
-    case Impl(Trees.CaseDef(pat, guard, body), ctx) =>
-      Some(Pattern(pat)(ctx), if (guard.isEmpty) None else Some(Term(guard)(ctx)), Term(body)(ctx))
-    case _ => None
+  def unapplyCaseDef(arg: Impl): Option[trees.CaseDef.Data] = {
+    implicit val ctx: Context = arg.ctx
+    val Trees.CaseDef(pat, guard, body) = arg.tree
+    Some(Pattern(pat), if (guard.isEmpty) None else Some(Term(guard)), Term(body))
   }
 
-  private case class Impl(tree: tpd.Tree, ctx: Context) extends trees.CaseDef with Positioned {
+  private[tasty] class Impl(val tree: tpd.CaseDef)(implicit val ctx: Context) extends trees.CaseDef with Positioned {
     override def toString: String = {
       import Toolbox.extractor
       val trees.CaseDef(pat, guard, body) = this

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

@@ -9,25 +9,21 @@ import scala.tasty.types
 
 object ClassDef {
 
-  def apply(tree: tpd.TypeDef)(implicit ctx: Context): trees.ClassDef = Impl(tree, ctx)
-
-  def unapplyClassDef(tree: trees.Tree): Option[trees.ClassDef.Data] = tree match {
-    case Impl(cdef @ Trees.TypeDef(name, impl@Trees.Template(constr, parents, self, _)), ctx) =>
-      implicit val ctx_ = ctx
-      if (cdef.symbol.isClass) {
-        val className = TypeName(name)
-        val constructor = DefDef(constr)
-        val classParents = parents.map(p => if (!p.isType) Term(p) else TypeTree(p))
-        val selfVal = if (self.isEmpty) None else Some(ValDef(self))
-        val body = impl.body.map(Statement(_))
-        val mods = Modifiers(cdef)
-        Some((className, constructor, classParents, selfVal, body, mods))
-      }
-      else None
-    case _ => None
+  def apply(tree: tpd.TypeDef)(implicit ctx: Context): trees.ClassDef = new Impl(tree)
+
+  def unapplyClassDef(arg: Impl): Option[trees.ClassDef.Data] = {
+    implicit val ctx: Context = arg.ctx
+    val Trees.TypeDef(name, impl@Trees.Template(constr, parents, self, _)) = arg.tree
+    val className = TypeName(name)
+    val constructor = DefDef(constr)
+    val classParents = parents.map(p => if (!p.isType) Term(p) else TypeTree(p))
+    val selfVal = if (self.isEmpty) None else Some(ValDef(self))
+    val body = impl.body.map(Statement(_))
+    val mods = Modifiers(arg.tree)
+    Some((className, constructor, classParents, selfVal, body, mods))
   }
 
-  private case class Impl(tree: tpd.TypeDef, ctx: Context) extends trees.ClassDef with Positioned {
+  private[tasty] class Impl(val tree: tpd.TypeDef)(implicit val ctx: Context) extends trees.ClassDef with Positioned {
 
     def tpe: types.Type = Type(tree.tpe)(ctx)
 

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

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

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

@@ -9,16 +9,15 @@ import scala.tasty.types
 
 object DefDef {
 
-  def apply(tree: tpd.DefDef)(implicit ctx: Context): trees.DefDef = Impl(tree, ctx)
+  def apply(tree: tpd.DefDef)(implicit ctx: Context): trees.DefDef = new Impl(tree)
 
-  def unapplyDefDef(tree: trees.Tree): Option[trees.DefDef.Data] = tree match {
-    case Impl(ddef, ctx) =>
-      implicit val localContext = ctx.withOwner(ddef.symbol(ctx))
-      Some((TermName(ddef.name), ddef.tparams.map(TypeDef(_)), ddef.vparamss.map(_.map(ValDef(_))), TypeTree(ddef.tpt), if (ddef.rhs.isEmpty) None else Some(Term(ddef.rhs)), Modifiers(ddef)))
-    case _ => None
+  def unapplyDefDef(arg: Impl): Option[trees.DefDef.Data] = {
+    val ddef = arg.tree
+    implicit val localContext: Context = arg.ctx.withOwner(ddef.symbol(arg.ctx))
+    Some((TermName(ddef.name), ddef.tparams.map(TypeDef(_)), ddef.vparamss.map(_.map(ValDef(_))), TypeTree(ddef.tpt), if (ddef.rhs.isEmpty) None else Some(Term(ddef.rhs)), Modifiers(ddef)))
   }
 
-  private case class Impl(tree: tpd.DefDef, ctx: Context) extends trees.DefDef with Positioned {
+  private[tasty] class Impl(val tree: tpd.DefDef)(implicit val ctx: Context) extends trees.DefDef with Positioned {
 
     def tpe: types.Type = Type(tree.tpe)(ctx)
 

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

@@ -8,14 +8,15 @@ import scala.tasty.trees
 
 object Import {
 
-  def apply(tree: tpd.Tree)(implicit ctx: Context): trees.Import = Impl(tree, ctx)
+  def apply(tree: tpd.Tree)(implicit ctx: Context): trees.Import = new Impl(tree)
 
-  def unapplyImport(tree: trees.Tree): Option[trees.Import.Data] = tree match {
-    case Impl(Trees.Import(expr, selectors), ctx) => Some(Term(expr)(ctx), selectors.map(ImportSelector(_)(ctx)))
-    case _ => None
+  def unapplyImport(arg: Impl): Option[trees.Import.Data] = {
+    implicit val ctx: Context = arg.ctx
+    val Trees.Import(expr, selectors) = arg.tree
+    Some(Term(expr), selectors.map(ImportSelector(_)))
   }
 
-  private case class Impl(tree: tpd.Tree, ctx: Context) extends trees.Import with Positioned {
+  private[tasty] class Impl(val tree: tpd.Tree)(implicit val ctx: Context) extends trees.Import with Positioned {
     override def toString: String = {
       import Toolbox.extractor
       val trees.Import(pkg, body) = this

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

@@ -9,24 +9,30 @@ import scala.tasty.trees
 
 object ImportSelector {
 
-  def apply(tree: untpd.Tree)(implicit ctx: Context): trees.ImportSelector = Impl(tree, ctx)
+  def apply(tree: untpd.Tree)(implicit ctx: Context): trees.ImportSelector = new Impl(tree)
 
-  def unapplySimpleSelector(tree: trees.ImportSelector): Option[trees.SimpleSelector.Data] = tree match {
-    case Impl(id@Trees.Ident(_), ctx) => Some(Id(id)(ctx))
+  def unapplySimpleSelector(arg: Impl): Option[trees.SimpleSelector.Data] = arg.tree match {
+    case id@Trees.Ident(_) =>
+      implicit val ctx: Context = arg.ctx
+      Some(Id(id))
     case _ => None
   }
 
-  def unapplyRenameSelector(tree: trees.ImportSelector): Option[trees.RenameSelector.Data] = tree match {
-    case Impl(Trees.Thicket((id1@Trees.Ident(_)) :: (id2@Trees.Ident(_)) :: Nil), ctx) if id2.name != nme.WILDCARD => Some(Id(id1)(ctx), Id(id2)(ctx))
+  def unapplyRenameSelector(arg: Impl): Option[trees.RenameSelector.Data] = arg.tree match {
+    case Trees.Thicket((id1@Trees.Ident(_)) :: (id2@Trees.Ident(_)) :: Nil) if id2.name != nme.WILDCARD =>
+      implicit val ctx: Context = arg.ctx
+      Some(Id(id1), Id(id2))
     case _ => None
   }
 
-  def unapplyOmitSelector(tree: trees.ImportSelector): Option[trees.OmitSelector.Data] = tree match {
-    case Impl(Trees.Thicket((id@Trees.Ident(_)) :: Trees.Ident(nme.WILDCARD) :: Nil), ctx) => Some(Id(id)(ctx))
+  def unapplyOmitSelector(arg: Impl): Option[trees.OmitSelector.Data] = arg.tree match {
+    case Trees.Thicket((id@Trees.Ident(_)) :: Trees.Ident(nme.WILDCARD) :: Nil) =>
+      implicit val ctx: Context = arg.ctx
+      Some(Id(id))
     case _ => None
   }
 
-  private case class Impl(tree: untpd.Tree, ctx: Context) extends trees.ImportSelector {
+  private[tasty] class Impl(val tree: untpd.Tree)(implicit val ctx: Context) extends trees.ImportSelector {
     override def toString: String = {
       import Toolbox.extractor
       this match {

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

@@ -10,17 +10,15 @@ object MethodType {
 
   // TODO make sure all extractors are tested
 
-  def apply(tpe: Types.MethodType)(implicit ctx: Context): types.MethodType = Impl(tpe, ctx)
-
-  def unapplyMethodType(tpe: types.MaybeType): Option[types.MethodType.Data] = tpe match {
-    case Impl(meth: Types.MethodType, ctx) =>
-      implicit val ctx_ = ctx
-      // TODO add companion
-      Some((meth.paramNames.map(TermName(_)), meth.paramInfos.map(Type(_)), Type(meth.resType)))
-    case _ => None
+  def apply(tpe: Types.MethodType)(implicit ctx: Context): types.MethodType = new Impl(tpe)
+
+  def unapplyMethodType(arg: Impl): Option[types.MethodType.Data] = {
+    implicit val ctx: Context = arg.ctx
+    val meth = arg.meth
+    Some((meth.paramNames.map(TermName(_)), meth.paramInfos.map(Type(_)), Type(meth.resType)))
   }
 
-  private case class Impl(meth: Types.MethodType, ctx: Context) extends types.MethodType {
+  private[tasty] class Impl(val meth: Types.MethodType)(implicit val ctx: Context) extends types.MethodType {
 
     override def isImplicit: Boolean = meth.isImplicitMethod
     override def isErased: Boolean = meth.isErasedMethod

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

@@ -10,16 +10,15 @@ object PackageDef {
 
   // TODO make sure all extractors are tested
 
-  def apply(tree: tpd.Tree)(implicit ctx: Context): trees.PackageDef = Impl(tree, ctx)
+  def apply(tree: tpd.PackageDef)(implicit ctx: Context): trees.PackageDef = new Impl(tree)
 
-  def unapplyPackageDef(tree: trees.Tree): Option[trees.PackageDef.Data] = tree match {
-    case Impl(pkgDef@Trees.PackageDef(pkg, body), ctx) =>
-      val localContext = ctx.withOwner(pkgDef.symbol(ctx))
-      Some(Term(pkg)(ctx), body.map(TopLevelStatement(_)(localContext)))
-    case _ => None
+  def unapplyPackageDef(arg: Impl): Option[trees.PackageDef.Data] = {
+    implicit val ctx: Context = arg.ctx
+    val localContext = ctx.withOwner(arg.tree.symbol)
+    Some(Term(arg.tree.pid), arg.tree.stats.map(TopLevelStatement(_)(localContext)))
   }
 
-  private case class Impl(tree: tpd.Tree, ctx: Context) extends trees.PackageDef with Positioned {
+  private[tasty] class Impl(val tree: tpd.PackageDef)(implicit val ctx: Context) extends trees.PackageDef with Positioned {
     override def toString: String = {
       import Toolbox.extractor
       val trees.PackageDef(pkg, body) = this

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

@@ -10,37 +10,48 @@ import scala.tasty.types
 
 object Pattern {
 
-  def apply(tree: tpd.Tree)(implicit ctx: Context): trees.Pattern = Impl(tree, ctx)
+  def apply(tree: tpd.Tree)(implicit ctx: Context): trees.Pattern = new Impl(tree)
 
-  def unapplyValue(tree: trees.Tree): Option[trees.Value.Data] = tree match {
-    case Impl(lit: tpd.Literal, ctx) => Some(Term(lit)(ctx))
-    case Impl(ident: tpd.Ident, ctx) => Some(Term(ident)(ctx))
-    case _ => None
+  def unapplyValue(arg: Impl): Option[trees.Value.Data] = {
+    implicit val ctx: Context = arg.ctx
+    arg.tree match {
+      case lit: tpd.Literal => Some(Term(lit))
+      case ident: tpd.Ident => Some(Term(ident))
+      case _ => None
+    }
   }
 
-  def unapplyBind(tree: trees.Tree): Option[trees.Bind.Data] = tree match {
-    case Impl(Trees.Bind(name: Names.TermName, body), ctx) => Some(TermName(name), Pattern(body)(ctx))
+  def unapplyBind(arg: Impl): Option[trees.Bind.Data] = arg.tree match {
+    case Trees.Bind(name: Names.TermName, body) =>
+      implicit val ctx: Context = arg.ctx
+      Some(TermName(name), Pattern(body))
     case _ => None
   }
 
-  def unapplyUnapply(tree: trees.Tree): Option[trees.Unapply.Data] = tree match {
-    case Impl(Trees.UnApply(fun, implicits, patterns), ctx) => Some((Term(fun)(ctx), implicits.map(Term(_)(ctx)), patterns.map(Pattern(_)(ctx))))
+  def unapplyUnapply(arg: Impl): Option[trees.Unapply.Data] = arg.tree match {
+    case Trees.UnApply(fun, implicits, patterns) =>
+      implicit val ctx: Context = arg.ctx
+      Some((Term(fun), implicits.map(Term(_)), patterns.map(Pattern(_))))
     case _ => None
   }
 
-  def unapplyAlternative(tree: trees.Tree): Option[trees.Alternative.Data] = tree match {
-    case Impl(Trees.Alternative(patterns), ctx) => Some(patterns.map(Pattern(_)(ctx)))
+  def unapplyAlternative(arg: Impl): Option[trees.Alternative.Data] = arg.tree match {
+    case Trees.Alternative(patterns) =>
+      implicit val ctx: Context = arg.ctx
+      Some(patterns.map(Pattern(_)))
     case _ => None
   }
 
-  def unapplyTypeTest(tree: trees.Tree): Option[trees.TypeTest.Data] = tree match {
-    case Impl(Trees.Typed(_, tpt), ctx) => Some(TypeTree(tpt)(ctx))
+  def unapplyTypeTest(arg: Impl): Option[trees.TypeTest.Data] = arg.tree match {
+    case Trees.Typed(_, tpt) =>
+      implicit val ctx: Context = arg.ctx
+      Some(TypeTree(tpt))
     case _ => None
   }
 
-  private case class Impl(tree: tpd.Tree, ctx: Context) extends trees.Pattern with Positioned {
+  private[tasty] class Impl(val tree: tpd.Tree)(implicit val ctx: Context) extends trees.Pattern with Positioned {
 
-    def tpe: types.Type = Type(tree.tpe)(ctx)
+    def tpe: types.Type = Type(tree.tpe)
 
     override def toString: String = {
       import Toolbox.extractor