Split the defintion of tasty reflect

Author: nicolasstucki

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

@@ -0,0 +1,26 @@
+package dotty.tools.dotc.tastyreflect
+
+import dotty.tools.dotc.ast.tpd
+
+import scala.tasty.util.Show
+
+trait CaseDefsImpl extends scala.tasty.reflect.CaseDefs { tasty: TastyImpl =>
+
+  type CaseDef = tpd.CaseDef
+
+  def CaseDefDeco(caseDef: CaseDef): CaseDefAPI = new CaseDefAPI {
+    def show(implicit ctx: Context, s: Show[tasty.type]): String = s.showCaseDef(caseDef)
+    def pattern(implicit ctx: Context): Pattern = caseDef.pat
+    def guard(implicit ctx: Context): Option[Term] = optional(caseDef.guard)
+    def rhs(implicit ctx: Context): Term = caseDef.body
+  }
+
+  object CaseDef extends CaseDefExtractor {
+    def unapply(x: CaseDef): Option[(Pattern, Option[Term], Term)] = x match {
+      case x: tpd.CaseDef @unchecked =>
+        Some(x.pat, optional(x.guard), x.body)
+      case _ => None
+    }
+  }
+
+}

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

@@ -0,0 +1,110 @@
+package dotty.tools.dotc.tastyreflect
+
+import dotty.tools.dotc.core.Constants
+
+import scala.tasty.util.Show
+
+trait ConstantsImpl extends scala.tasty.reflect.Constants { tasty: TastyImpl =>
+
+  type Constant = Constants.Constant
+
+  def ConstantDeco(const: Constant): ConstantAPI = new ConstantAPI {
+    def show(implicit ctx: Context, s: Show[tasty.type]): String = s.showConstant(const)
+    def value: Any = const.value
+  }
+
+  object Constant extends ConstantModule {
+
+    object Unit extends UnitExtractor {
+      def unapply(x: Constant): Boolean = x match {
+        case x: Constants.Constant => x.tag == Constants.UnitTag
+        case _ => false
+      }
+    }
+
+    object Null extends NullExtractor {
+      def unapply(x: Constant): Boolean =  x match {
+        case x: Constants.Constant => x.tag == Constants.NullTag
+        case _ => false
+      }
+    }
+
+    object Boolean extends BooleanExtractor {
+      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 ByteExtractor {
+      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 ShortExtractor {
+      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 CharExtractor {
+      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 IntExtractor {
+      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 LongExtractor {
+      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 FloatExtractor {
+      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 DoubleExtractor {
+      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 StringExtractor {
+      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 ClassTagExtractor {
+      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 SymbolExtractor {
+      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/ContextsImpl.scala

@@ -0,0 +1,21 @@
+package dotty.tools.dotc.tastyreflect
+
+import dotty.tools.dotc.core.Contexts
+import dotty.tools.dotc.tastyreflect.FromSymbol.definitionFromSym
+import dotty.tools.dotc.util.{Positions, SourcePosition}
+
+trait ContextsImpl extends scala.tasty.reflect.Contexts { tasty: TastyImpl =>
+
+  type Context = Contexts.Context
+
+  val rootContext: Contexts.Context
+
+  def ContextDeco(ctx: Context): ContextAPI = new ContextAPI {
+    def owner: Definition = definitionFromSym(ctx.owner)(ctx)
+
+    def source: java.nio.file.Path = ctx.compilationUnit.source.file.jpath
+  }
+
+  def rootPosition: SourcePosition = SourcePosition(rootContext.source, Positions.NoPosition)
+
+}

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

@@ -3,7 +3,7 @@ package dotty.tools.dotc.tastyreflect
 import dotty.tools.dotc.core.Flags
 import dotty.tools.dotc.core.Flags._
 
-class FlagSet(flags: Flags.FlagSet) extends scala.tasty.FlagSet {
+class FlagSet(flags: Flags.FlagSet) extends scala.tasty.reflect.FlagSet {
 
   def isProtected: Boolean = flags.is(Protected)
   def isAbstract: Boolean = flags.is(Abstract)

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

@@ -0,0 +1,20 @@
+package dotty.tools.dotc.tastyreflect
+
+import dotty.tools.dotc.ast.untpd
+
+import dotty.tools.dotc.core.Decorators._
+
+trait IdsImpl extends scala.tasty.reflect.Ids { tasty: TastyImpl =>
+
+  type Id = untpd.Ident
+
+  def IdDeco(id: Id): IdAPI = new IdAPI {
+    def pos(implicit ctx: Context): Position = id.pos
+    def name(implicit ctx: Context): String = id.name.toString
+  }
+
+  object Id extends IdExtractor {
+    def unapply(id: Id): Option[String] = Some(id.name.toString)
+  }
+
+}

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

@@ -0,0 +1,68 @@
+package dotty.tools.dotc.tastyreflect
+
+import dotty.tools.dotc.ast.{Trees, tpd}
+import dotty.tools.dotc.core.Decorators._
+import dotty.tools.dotc.core.Types
+
+import scala.tasty.util.Show
+
+trait PatternsImpl extends scala.tasty.reflect.Patterns { tasty: TastyImpl =>
+
+  // ----- Patterns -------------------------------------------------
+
+  type Pattern = tpd.Tree
+
+  def PatternDeco(pattern: Pattern): PatternAPI = new PatternAPI {
+    def show(implicit ctx: Context, s: Show[tasty.type]): String = s.showPattern(pattern)
+    def pos(implicit ctx: Context): Position = pattern.pos
+    def tpe(implicit ctx: Context): Types.Type = pattern.tpe.stripTypeVar
+  }
+
+  object Pattern extends PatternModule {
+
+    object Value extends ValueExtractor {
+      def unapply(x: Pattern)(implicit ctx: Context): Option[Term] = x match {
+        case lit: tpd.Literal @unchecked => Some(lit)
+        case ref: tpd.RefTree @unchecked if ref.isTerm => Some(ref)
+        case ths: tpd.This @unchecked => Some(ths)
+        case _ => None
+      }
+    }
+
+    object Bind extends BindExtractor {
+      def unapply(x: Pattern)(implicit ctx: Context): Option[(String, Pattern)] = x match {
+        case x: tpd.Bind @unchecked if x.name.isTermName => Some(x.name.toString, x.body)
+        case _ => None
+      }
+    }
+
+    object Unapply extends UnapplyExtractor {
+      def unapply(x: Pattern)(implicit ctx: Context): Option[(Term, List[Term], List[Pattern])] = x match {
+        case Trees.UnApply(fun, implicits, patterns) => Some((fun, implicits, effectivePatterns(patterns)))
+        case Trees.Typed(Trees.UnApply(fun, implicits, patterns), _) => Some((fun, implicits, effectivePatterns(patterns)))
+        case _ => None
+      }
+      private def effectivePatterns(patterns: List[Pattern]): List[Pattern] = patterns match {
+        case patterns0 :+ Trees.SeqLiteral(elems, _) => patterns0 ::: elems
+        case _ => patterns
+      }
+    }
+
+    object Alternative extends AlternativeExtractor {
+      def unapply(x: Pattern)(implicit ctx: Context): Option[List[Pattern]] = x match {
+        case x: tpd.Alternative @unchecked => Some(x.trees)
+        case _ => None
+      }
+    }
+
+    object TypeTest extends TypeTestExtractor {
+      def unapply(x: Pattern)(implicit ctx: Context): Option[TypeTree] = x match {
+        case Trees.Typed(Trees.UnApply(_, _, _), _) => None
+        case Trees.Typed(_, tpt) => Some(tpt)
+        case _ => None
+      }
+    }
+
+  }
+
+}

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

@@ -0,0 +1,22 @@
+package dotty.tools.dotc.tastyreflect
+
+import dotty.tools.dotc.util.SourcePosition
+
+trait PositionsImpl extends scala.tasty.reflect.Positions { tasty: TastyImpl =>
+
+  type Position = SourcePosition
+
+  def PositionDeco(pos: Position): PositionAPI = new PositionAPI {
+    def start: Int = pos.start
+    def end: Int = pos.end
+
+    def sourceFile: java.nio.file.Path = pos.source.file.jpath
+
+    def startLine: Int = pos.startLine
+    def endLine: Int = pos.endLine
+
+    def startColumn: Int = pos.startColumn
+    def endColumn: Int = pos.endColumn
+  }
+
+}

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

@@ -0,0 +1,20 @@
+package dotty.tools.dotc.tastyreflect
+
+import dotty.tools.dotc.core
+
+trait SignaturesImpl extends scala.tasty.reflect.Signatures { tasty: TastyImpl =>
+
+  type Signature = core.Signature
+
+  object Signature extends SignatureExtractor {
+    def unapply(x: Signature)(implicit ctx: Context): Option[(List[String], String)] = {
+      Some((x.paramsSig.map(_.toString), x.resSig.toString))
+    }
+  }
+
+  def SignatureDeco(sig: Signature): SignatureAPI = new SignatureAPI {
+    def paramSigs: List[String] = sig.paramsSig.map(_.toString)
+    def resultSig: String = sig.resSig.toString
+  }
+
+}