WIP Add explicit tasty context

Author: nicolasstucki

compiler/src/dotty/tools/dotc/core/quoted/PickledQuotes.scala

@@ -41,8 +41,7 @@ object PickledQuotes {
         case value: Class[_] => ref(defn.Predef_classOf).appliedToType(classToType(value))
         case value=> Literal(Constant(value))
       }
-    case expr: TreeExpr =>
-      dotty.tools.dotc.tasty.internal.Term.tree(expr.term)
+    case expr: TreeExpr[Tree, Context] @unchecked => expr.tree
     case expr: FunctionAppliedTo[_, _] =>
       functionAppliedTo(quotedExprToTree(expr.f), quotedExprToTree(expr.x))
   }
@@ -51,7 +50,7 @@ object PickledQuotes {
   def quotedTypeToTree(expr: quoted.Type[_])(implicit ctx: Context): Tree = expr match {
     case expr: TastyType[_] => unpickleType(expr)
     case expr: TaggedType[_] => classTagToTypeTree(expr.ct)
-    case expr: TreeType => dotty.tools.dotc.tasty.internal.TypeTree.tree(expr.tpe)
+    case expr: TreeType[TypeTree, Context] @unchecked => expr.typeTree
   }
 
   /** Unpickle the tree contained in the TastyExpr */

compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala

@@ -1141,8 +1141,8 @@ class TreeUnpickler(reader: TastyReader,
       val args = until(end)(readTerm())
       val splice = splices(idx)
       def wrap(arg: Tree) =
-        if (arg.isTerm) new TreeExpr(dotty.tools.dotc.tasty.internal.Term(arg))
-        else new TreeType(dotty.tools.dotc.tasty.internal.TypeTree(arg))
+        if (arg.isTerm) new TreeExpr(arg, ctx)
+        else new TreeType(arg, ctx)
       val reifiedArgs = args.map(wrap)
       if (isType) {
         val quotedType =

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

@@ -2,8 +2,10 @@ package dotty.tools.dotc.quoted
 
 import dotty.tools.dotc.ast.tpd
 import dotty.tools.dotc.core.Constants._
+import dotty.tools.dotc.core.Contexts.Context
 import dotty.tools.dotc.printing.RefinedPrinter
 import dotty.tools.dotc.tasty.internal
+import dotty.tools.dotc.tasty.internal.TastyContext
 
 import scala.quoted.{Expr, Type}
 import scala.quoted.Exprs.{LiftedExpr, TreeExpr}
@@ -44,14 +46,20 @@ object Toolbox {
       case _ => new QuoteDriver().show(expr, showSettings)
     }
 
-    def toTasty(expr: Expr[T]): trees.Term = expr match {
-      case expr: TreeExpr => expr.term
-      case _ => new QuoteDriver().withTree(expr, (tree, ctx) => internal.Term(tree)(ctx), Settings.run())
+    def toTasty(expr: Expr[T]): (trees.Term, scala.tasty.Context) = {
+      def box(tree: Tree, ctx: Context) = (internal.Term(tree),  new internal.TastyContext(ctx))
+      expr match {
+        case expr: TreeExpr[Tree, Context] @unchecked => box(expr.tree, expr.ctx)
+        case _ => new QuoteDriver().withTree(expr, (tree, ctx) => box(tree, ctx), Settings.run())
+      }
     }
 
-    def toTasty(tpe: Type[T]): trees.TypeTree = tpe match {
-      case expr: TreeType => expr.tpe
-      case _ => new QuoteDriver().withTypeTree(tpe, (tpt, ctx) => internal.TypeTree(tpt)(ctx), Settings.run())
+    def toTasty(tpe: Type[T]): (trees.TypeTree, scala.tasty.Context) = {
+      def box(tree: TypTree, ctx: Context) = (internal.TypeTree(tree), new internal.TastyContext(ctx))
+      tpe match {
+        case typeTree: TreeType[TypeTree, Context] @unchecked => box(typeTree.typeTree, typeTree.ctx)
+        case _ => new QuoteDriver().withTypeTree(tpe, (tpt, ctx) => box(tpt, ctx), Settings.run())
+      }
     }
   }
 

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

@@ -3,27 +3,18 @@ package internal
 
 import dotty.tools.dotc.core.Contexts.Context
 import dotty.tools.dotc.core.Annotations.Annotation
-import dotty.tools.dotc.core.Decorators.sourcePos
 
 import scala.tasty.modifiers
 
 object AnnotationModifier {
 
-  def apply(tree: Annotation)(implicit ctx: Context): modifiers.Modifier = new Impl(tree)
+  def apply(tree: Annotation): modifiers.Annotation = new Impl(tree)
 
-  def unapplyAnnotation(arg: Impl): Option[modifiers.Annotation.Data] = {
-    implicit val ctx: Context = arg.ctx
+  def unapplyAnnotation(arg: Impl)(implicit ctx: Context): Option[modifiers.Annotation.Data] = {
     Some(Term(arg.annot.tree))
   }
 
-  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))
-
-    override def toString: String = {
-      import Toolbox.extractor
-      val modifiers.Annotation(annot) = this
-      s"Annotation($annot)"
-    }
+  private[tasty] class Impl(val annot: Annotation) extends modifiers.Annotation {
+    override def toString: String = "Annotation"
   }
 }

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

@@ -9,19 +9,14 @@ import scala.tasty.trees
 
 object CaseDef {
 
-  def apply(tree: tpd.CaseDef)(implicit ctx: Context): trees.CaseDef = new Impl(tree)
+  def apply(tree: tpd.CaseDef): trees.CaseDef = new Impl(tree)
 
-  def unapplyCaseDef(arg: Impl): Option[trees.CaseDef.Data] = {
-    implicit val ctx: Context = arg.ctx
+  def unapplyCaseDef(arg: Impl)(implicit ctx: Context): Option[trees.CaseDef.Data] = {
     val Trees.CaseDef(pat, guard, body) = arg.tree
     Some(Pattern(pat), if (guard.isEmpty) None else Some(Term(guard)), Term(body))
   }
 
-  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
-      s"CaseDef($pat, $guard, $body)"
-    }
+  private[tasty] class Impl(val tree: tpd.CaseDef) extends trees.CaseDef with Positioned {
+    override def toString: String = "CaseDef"
   }
 }

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

@@ -11,7 +11,7 @@ import scala.tasty.types
 
 object ClassDef {
 
-  def apply(tree: tpd.TypeDef)(implicit ctx: Context): trees.ClassDef = new Impl(tree)
+  def apply(tree: tpd.TypeDef): trees.ClassDef = new Impl(tree)
 
   def apply(sym: ClassSymbol)(implicit ctx: Context): trees.ClassDef = {
     def toTree(sym: ClassSymbol): tpd.TypeDef = {
@@ -28,8 +28,7 @@ object ClassDef {
     new Impl(toTree(sym))
   }
 
-  def unapplyClassDef(arg: Impl): Option[trees.ClassDef.Data] = {
-    implicit val ctx: Context = arg.ctx
+  def unapplyClassDef(arg: Impl)(implicit ctx: Context): Option[trees.ClassDef.Data] = {
     val Trees.TypeDef(name, impl@Trees.Template(constr, parents, self, _)) = arg.tree
     val className = TypeName(name)
     val constructor = DefDef(constr)
@@ -40,17 +39,16 @@ object ClassDef {
     Some((className, constructor, classParents, selfVal, body, mods))
   }
 
-  private[tasty] class Impl(val tree: tpd.TypeDef)(implicit val ctx: Context) extends trees.ClassDef with Positioned {
+  private[tasty] class Impl(val tree: tpd.TypeDef) extends trees.ClassDef with Positioned {
 
-    def tpe: types.Type = Type(tree.tpe)(ctx)
+    def tpe: types.Type = Type(tree.tpe)
 
-    def owner: trees.Definition = Definition(tree.symbol.owner)
-
-    override def toString: String = {
-      import Toolbox.extractor
-      val trees.ClassDef(name, constructor, parents, self, body, mods) = this
-      s"ClassDef($name, $constructor, $parents, $self, $body, $mods)"
+    def owner(implicit tctx: scala.tasty.Context): trees.Definition = {
+      implicit val ctx = tctx.asInstanceOf[TastyContext].ctx
+      Definition(tree.symbol.owner)
     }
+
+    override def toString: String = "ClassDef"
   }
 
 }

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

@@ -53,21 +53,6 @@ object Constant {
 
     def value: Any = const.value
 
-    override def toString: String = {
-      import Toolbox.extractor
-      this match {
-        case constants.Unit() => "Unit()"
-        case constants.Null() => "Null()"
-        case constants.Boolean(value) => s"Boolean($value)"
-        case constants.Byte(value) => s"Byte($value)"
-        case constants.Short(value) => s"Short($value)"
-        case constants.Char(value) => s"Char('$value')"
-        case constants.Int(value) => s"Int($value)"
-        case constants.Long(value) => s"Long($value)"
-        case constants.Float(value) => s"Float($value)"
-        case constants.Double(value) => s"Double($value)"
-        case constants.String(value) => s"""String("$value")"""
-      }
-    }
+    override def toString: String = "Constant"
   }
 }

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

@@ -10,27 +10,25 @@ import scala.tasty.types
 
 object DefDef {
 
-  def apply(tree: tpd.DefDef)(implicit ctx: Context): trees.DefDef = new Impl(tree)
+  def apply(tree: tpd.DefDef): trees.DefDef = new Impl(tree)
 
   def apply(sym: TermSymbol)(implicit ctx: Context): trees.DefDef = new Impl(tpd.DefDef(sym))
 
-  def unapplyDefDef(arg: Impl): Option[trees.DefDef.Data] = {
+  def unapplyDefDef(arg: Impl)(implicit ctx: Context): 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[tasty] class Impl(val tree: tpd.DefDef)(implicit val ctx: Context) extends trees.DefDef with Positioned {
+  private[tasty] class Impl(val tree: tpd.DefDef) extends trees.DefDef with Positioned {
 
-    def tpe: types.Type = Type(tree.tpe)(ctx)
+    def tpe: types.Type = Type(tree.tpe)
 
-    def owner: trees.Definition = Definition(tree.symbol.owner)
-
-    override def toString: String = {
-      import Toolbox.extractor
-      val trees.DefDef(name, typeParams, paramss, returnTpt, rhs, mods) = this
-      s"DefDef($name, $typeParams, $paramss, $returnTpt, $rhs, $mods)"
+    def owner(implicit tctx: scala.tasty.Context): trees.Definition = {
+      implicit val ctx = tctx.asInstanceOf[TastyContext].ctx
+      Definition(tree.symbol.owner)
     }
+
+    override def toString: String = "DefDef"
   }
 
 }

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

@@ -26,9 +26,9 @@ object Definition {
   }
 
   private[tasty] object NoDefinition extends trees.Definition {
-    override def owner: trees.Definition = NoDefinition
+    def owner(implicit tctx: scala.tasty.Context): trees.Definition = NoDefinition
 
-    override def pos: scala.tasty.Position = ???
+    def pos(implicit ctx: scala.tasty.Context): scala.tasty.Position = ???
 
     override def toString: String = "NoDefinition"
   }