Use direct extractors for tasty trees

Author: nicolasstucki

compiler/src/dotty/tools/dotc/core/Definitions.scala

@@ -667,11 +667,11 @@ class Definitions {
   def Unpickler_liftedExpr = ctx.requiredMethod("scala.runtime.quoted.Unpickler.liftedExpr")
   def Unpickler_unpickleType = ctx.requiredMethod("scala.runtime.quoted.Unpickler.unpickleType")
 
-  lazy val TastyContextModule = ctx.requiredModule("scala.tasty.Context")
-  def TastyContextModuleClass(implicit ctx: Context) = TastyContextModule.symbol.asClass
+  lazy val TastyUniverseModule = ctx.requiredModule("scala.tasty.Universe")
+  def TastyUniverseModuleClass(implicit ctx: Context) = TastyUniverseModule.symbol.asClass
 
-    lazy val TastyContext_compilationContextR = TastyContextModule.requiredMethod("compilationContext")
-    def TastyContext_compilationContext(implicit ctx: Context) = TastyContext_compilationContextR.symbol
+    lazy val TastyUniverse_compilationUniverseR = TastyUniverseModule.requiredMethod("compilationUniverse")
+    def TastyUniverse_compilationUniverse(implicit ctx: Context) = TastyUniverse_compilationUniverseR.symbol
 
   lazy val EqType = ctx.requiredClassRef("scala.Eq")
   def EqClass(implicit ctx: Context) = EqType.symbol.asClass

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

@@ -0,0 +1,7 @@
+package dotty.tools.dotc.tasty
+
+import dotty.tools.dotc.core.Contexts.Context
+
+class CompilationUniverse(val context: Context) extends scala.tasty.Universe {
+  val tasty: TastyImpl.type = TastyImpl
+}

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

@@ -0,0 +1,66 @@
+package dotty.tools.dotc.tasty
+
+import dotty.tools.dotc.core.Flags
+import dotty.tools.dotc.core.Flags._
+
+class FlagSet(flags: Flags.FlagSet) extends scala.tasty.FlagSet {
+
+  def isProtected: Boolean = flags.is(Protected)
+  def isAbstract: Boolean = flags.is(Abstract)
+  def isFinal: Boolean = flags.is(Final)
+  def isSealed: Boolean = flags.is(Sealed)
+  def isCase: Boolean = flags.is(Case)
+  def isImplicit: Boolean = flags.is(Implicit)
+  def isErased: Boolean = flags.is(Erased)
+  def isLazy: Boolean = flags.is(Lazy)
+  def isOverride: Boolean = flags.is(Override)
+  def isInline: Boolean = flags.is(Inline)
+  def isMacro: Boolean = flags.is(Macro)
+  def isStatic: Boolean = flags.is(JavaStatic)
+  def isObject: Boolean = flags.is(Module)
+  def isTrait: Boolean = flags.is(Trait)
+  def isLocal: Boolean = flags.is(Local)
+  def isSynthetic: Boolean = flags.is(Synthetic)
+  def isArtifact: Boolean = flags.is(Artifact)
+  def isMutable: Boolean = flags.is(Mutable)
+  def isLabel: Boolean = flags.is(Label)
+  def isFieldAccessor: Boolean = flags.is(Accessor)
+  def isCaseAcessor: Boolean = flags.is(CaseAccessor)
+  def isCovariant: Boolean = flags.is(Covariant)
+  def isContravariant: Boolean = flags.is(Contravariant)
+  def isScala2X: Boolean = flags.is(Scala2x)
+  def isDefaultParameterized: Boolean = flags.is(DefaultParameterized)
+  def isStable: Boolean = flags.is(Stable)
+
+  override def toString: String = {
+    val flags = List.newBuilder[String]
+    if (isProtected) flags += "protected "
+    if (isAbstract) flags += "abstract"
+    if (isFinal) flags += "final"
+    if (isSealed) flags += "sealed"
+    if (isCase) flags += "case"
+    if (isImplicit) flags += "implicit"
+    if (isErased) flags += "erased"
+    if (isLazy) flags += "lazy"
+    if (isOverride) flags += "override"
+    if (isInline) flags += "inline"
+    if (isMacro) flags += "macro"
+    if (isStatic) flags += "javaStatic"
+    if (isObject) flags += "module"
+    if (isTrait) flags += "trait"
+    if (isLocal) flags += "local"
+    if (isSynthetic) flags += "synthetic"
+    if (isArtifact) flags += "artifact"
+    if (isMutable) flags += "mutable"
+    if (isLabel) flags += "label"
+    if (isFieldAccessor) flags += "accessor"
+    if (isCaseAcessor) flags += "caseAccessor"
+    if (isCovariant) flags += "covariant"
+    if (isContravariant) flags += "contravariant"
+    if (isScala2X) flags += "scala2x"
+    if (isDefaultParameterized) flags += "defaultParameterized"
+    if (isStable) flags += "stable"
+    flags.result().mkString("<", ",", ">")
+  }
+
+}

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

@@ -0,0 +1,37 @@
+package dotty.tools.dotc.tasty
+
+import dotty.tools.dotc.ast.tpd
+import dotty.tools.dotc.core.Contexts.Context
+import dotty.tools.dotc.core.Symbols._
+import dotty.tools.dotc.core.Flags._
+
+
+object FromSymbol {
+
+  def definition(sym: Symbol)(implicit ctx: Context): tpd.Tree = {
+    if (sym.is(Package)) packageDef(sym)
+    else if (sym == defn.AnyClass) tpd.EmptyTree // FIXME
+    else if (sym == defn.NothingClass) tpd.EmptyTree // FIXME
+    else if (sym.isClass) classDef(sym.asClass)
+    else if (sym.isType) typeDef(sym.asType)
+    else if (sym.is(Method)) defDef(sym.asTerm)
+    else valDef(sym.asTerm)
+  }
+
+  def packageDef(sym: Symbol)(implicit ctx: Context): tpd.PackageDef =
+    tpd.PackageDef(tpd.Ident(sym.typeRef), Nil)
+
+  def classDef(cls: ClassSymbol)(implicit ctx: Context): tpd.Tree = {
+    val constr = tpd.DefDef(cls.unforcedDecls.find(_.isPrimaryConstructor).asTerm)
+    val body = cls.unforcedDecls.filter(!_.isPrimaryConstructor).map(s => definition(s))
+    val superArgs = Nil // TODO
+    tpd.ClassDef(cls, constr, body, superArgs)
+  }
+
+  def typeDef(sym: TypeSymbol)(implicit ctx: Context): tpd.TypeDef = tpd.TypeDef(sym)
+
+  def defDef(sym: TermSymbol)(implicit ctx: Context): tpd.DefDef = tpd.DefDef(sym)
+
+  def valDef(sym: TermSymbol)(implicit ctx: Context): tpd.ValDef = tpd.ValDef(sym)
+
+}