Implement TASTy reflect constructors

Author: nicolasstucki

compiler/src/dotty/tools/dotc/ast/Trees.scala

@@ -975,13 +975,13 @@ object Trees {
      * so that they selectively retype themselves. Retyping needs a context.
      */
     abstract class TreeCopier {
-      def postProcess(tree: Tree, copied: untpd.Tree): copied.ThisTree[T]
-      def postProcess(tree: Tree, copied: untpd.MemberDef): copied.ThisTree[T]
+      protected def postProcess(tree: Tree, copied: untpd.Tree): copied.ThisTree[T]
+      protected def postProcess(tree: Tree, copied: untpd.MemberDef): copied.ThisTree[T]
 
-      def finalize(tree: Tree, copied: untpd.Tree): copied.ThisTree[T] =
+      protected def finalize(tree: Tree, copied: untpd.Tree): copied.ThisTree[T] =
         postProcess(tree, copied.withPos(tree.pos).withAttachmentsFrom(tree))
 
-      def finalize(tree: Tree, copied: untpd.MemberDef): copied.ThisTree[T] =
+      protected def finalize(tree: Tree, copied: untpd.MemberDef): copied.ThisTree[T] =
         postProcess(tree, copied.withPos(tree.pos).withAttachmentsFrom(tree))
 
       def Ident(tree: Tree)(name: Name): Ident = tree match {

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

@@ -1,5 +1,6 @@
 package dotty.tools.dotc.tastyreflect
 
+import dotty.tools.dotc.ast.tpd
 
 trait CaseDefOpsImpl extends scala.tasty.reflect.CaseDefOps with CoreImpl with Helpers {
 
@@ -10,6 +11,11 @@ trait CaseDefOpsImpl extends scala.tasty.reflect.CaseDefOps with CoreImpl with H
   }
 
   object CaseDef extends CaseDefModule {
+    def apply(pat: Pattern, guard: Option[Term], body: Term)(implicit ctx: Context): CaseDef = ???
+
+    def copy(original: CaseDef)(pat: Pattern, guard: Option[Term], body: Term)(implicit ctx: Context): CaseDef =
+      tpd.cpy.CaseDef(original)(pat, guard.getOrElse(tpd.EmptyTree), body)
+
     def unapply(x: CaseDef): Some[(Pattern, Option[Term], Term)] = Some(x.pat, optional(x.guard), x.body)
   }
 

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

@@ -26,8 +26,9 @@ trait CoreImpl extends scala.tasty.reflect.Core {
       type Term = tpd.Tree
       val Term: TermCoreModuleImpl
       trait TermCoreModuleImpl extends TermCoreModule {
-        type Ident = tpd.Ident
-        type Select = tpd.Select
+        type Ref = tpd.RefTree
+          type Ident = tpd.Ident
+          type Select = tpd.Select
         type Literal = tpd.Literal
         type This = tpd.This
         type New = tpd.New
@@ -56,8 +57,8 @@ trait CoreImpl extends scala.tasty.reflect.Core {
   type Pattern = tpd.Tree
     type Value = tpd.Tree
     type Bind = tpd.Bind
-    type Unapply = tpd.Tree
-    type Alternative = tpd.Alternative
+    type Unapply = tpd.UnApply
+    type Alternatives = tpd.Alternative
     type TypeTest = tpd.Typed
 
   type TypeOrBoundsTree = tpd.Tree
@@ -77,8 +78,8 @@ trait CoreImpl extends scala.tasty.reflect.Core {
       type MatchType = tpd.MatchTypeTree
       type ByName = tpd.ByNameTypeTree
       type LambdaTypeTree = tpd.LambdaTypeTree
-      type Bind = tpd.Bind
-      type Block = tpd.Block
+      type TypeBind = tpd.Bind
+      type TypeBlock = tpd.Block
     }
     type TypeBoundsTree = tpd.TypeBoundsTree
     type WildcardType = tpd.TypeTree

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

@@ -1,10 +1,35 @@
 package dotty.tools.dotc.tastyreflect
 
 import dotty.tools.dotc.ast.{Trees, tpd}
+import dotty.tools.dotc.core.Contexts
 import dotty.tools.dotc.core.Decorators._
 
 trait PatternOpsImpl extends scala.tasty.reflect.PatternOps with CoreImpl {
 
+  def ValueDeco(value: Value): Pattern.ValueAPI = new Pattern.ValueAPI {
+    def value(implicit ctx: Context): Term = ???
+  }
+  def BindDeco(bind: Bind): Pattern.BindAPI = new Pattern.BindAPI {
+    def name(implicit ctx: Context): String = ???
+    def pattern(implicit ctx: Context): Pattern = ???
+  }
+  def UnapplyDeco(unapply: Unapply): Pattern.UnapplyAPI = new Pattern.UnapplyAPI {
+    def fun(implicit ctx: Context): Term = unapply.fun
+    def implicits(implicit ctx: Context): List[Term] = unapply.implicits
+    def patterns(implicit ctx: Context): List[Pattern] = effectivePatterns(unapply.patterns)
+
+    private def effectivePatterns(patterns: List[Pattern]): List[Pattern] = patterns match {
+      case patterns0 :+ Trees.SeqLiteral(elems, _) => patterns0 ::: elems
+      case _ => patterns
+    }
+  }
+  def AlternativeDeco(alternatives: Alternatives): Pattern.AlternativesAPI = new Pattern.AlternativesAPI {
+    def patterns(implicit ctx: Context): List[Pattern] = alternatives.trees
+  }
+  def TypeTestDeco(typeTest: TypeTest): Pattern.TypeTestAPI = new Pattern.TypeTestAPI {
+    def tpt(implicit ctx: Context): TypeTree = typeTest.tpt
+  }
+
   // ----- Patterns -------------------------------------------------
 
   def PatternDeco(pattern: Pattern): PatternAPI = new PatternAPI {
@@ -14,42 +39,79 @@ trait PatternOpsImpl extends scala.tasty.reflect.PatternOps with CoreImpl {
 
   object Pattern extends PatternModule {
 
-    object Value extends ValueModule {
-      def unapply(x: Pattern)(implicit ctx: Context): Option[Term] = x match {
+    object IsValue extends IsValueModule {
+      def unapply(pattern: Pattern)(implicit ctx: Context): Option[Value] = pattern match {
         case lit: tpd.Literal => Some(lit)
         case ref: tpd.RefTree if ref.isTerm => Some(ref)
         case ths: tpd.This => Some(ths)
         case _ => None
       }
     }
 
+    object Value extends ValueModule {
+      def apply(tpt: Term): Value = ???
+      def copy(original: Value)(tpt: Term): Value = ???
+      def unapply(x: Pattern)(implicit ctx: Context): Option[Term] = IsValue.unapply(x)
+    }
+
+    object IsBind extends IsBindModule {
+      def unapply(x: Pattern)(implicit ctx: Context): Option[Bind] = x match {
+        case x: tpd.Bind if x.name.isTermName => Some(x)
+        case _ => None
+      }
+    }
+
     object Bind extends BindModule {
-      def unapply(x: Pattern)(implicit ctx: Context): Option[(String, Pattern)] = x match {
-        case x: tpd.Bind if x.name.isTermName => Some(x.name.toString, x.body)
+      def apply(name: String, pattern: Pattern): Bind = ???
+      def copy(original: Bind)(name: String, pattern: Pattern): Bind = ???
+      def unapply(pattern: Pattern)(implicit ctx: Context): Option[(String, Pattern)] = pattern match {
+        case IsBind(pattern) => Some((pattern.name.toString, pattern.body))
+        case _ => None
+      }
+    }
+
+    object IsUnapply extends IsUnapplyModule {
+      def unapply(pattern: Pattern)(implicit ctx: Context): Option[Unapply] = pattern match {
+        case pattern @ Trees.UnApply(_, _, _) => Some(pattern)
+        case Trees.Typed(pattern @ Trees.UnApply(_, _, _), _) => Some(pattern)
         case _ => None
       }
     }
 
     object Unapply extends UnapplyModule {
+      def apply(fun: Term, implicits: List[Term], patterns: List[Pattern]): Unapply = ???
+      def copy(original: Unapply)(fun: Term, implicits: List[Term], patterns: List[Pattern]): Unapply =
+        tpd.cpy.UnApply(original)(fun, implicits, patterns)
       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 IsUnapply(x) => Some((x.fun, x.implicits, UnapplyDeco(x).patterns))
         case _ => None
       }
-      private def effectivePatterns(patterns: List[Pattern]): List[Pattern] = patterns match {
-        case patterns0 :+ Trees.SeqLiteral(elems, _) => patterns0 ::: elems
-        case _ => patterns
+    }
+
+    object IsAlternatives extends IsAlternativesModule {
+      def unapply(pattern: Pattern)(implicit ctx: Context): Option[Alternatives] = pattern match {
+        case pattern: tpd.Alternative => Some(pattern)
+        case _ => None
       }
     }
 
-    object Alternative extends AlternativeModule {
+    object Alternatives extends AlternativesModule {
+      def apply(patterns: List[Pattern]): Alternatives = ???
+      def copy(original: Alternatives)(patterns: List[Pattern]): Alternatives =
+        tpd.cpy.Alternative(original)(patterns)
       def unapply(x: Pattern)(implicit ctx: Context): Option[List[Pattern]] = x match {
         case x: tpd.Alternative => Some(x.trees)
         case _ => None
       }
     }
 
+    object IsTypeTest extends IsTypeTestModule {
+      def unapply(pattern: Pattern)(implicit ctx: Context): Option[TypeTest] = ???
+    }
+
     object TypeTest extends TypeTestModule {
+      def apply(tpt: List[TypeTree]): TypeTest = ???
+      def copy(original: TypeTest)(tpt: List[TypeTree]): TypeTest = ???
       def unapply(x: Pattern)(implicit ctx: Context): Option[TypeTree] = x match {
         case Trees.Typed(Trees.UnApply(_, _, _), _) => None
         case Trees.Typed(_, tpt) => Some(tpt)