Merge pull request #4895 from dotty-staging/add-tasty-reflect-std-definitions

Add standard definitions on Tasty reflect

Author: nicolasstucki

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

@@ -3,35 +3,39 @@ package dotty.tools.dotc.tastyreflect
 import dotty.tools.dotc.ast.tpd
 import dotty.tools.dotc.core.Contexts.Context
 import dotty.tools.dotc.core.Flags._
+import dotty.tools.dotc.core.StdNames._
 import dotty.tools.dotc.core.Symbols._
+import dotty.tools.dotc.core.Types._
 
 object FromSymbol {
 
-  def definition(sym: Symbol)(implicit ctx: Context): tpd.Tree = {
-    if (sym.is(Package)) packageDef(sym)
+  def definitionFromSym(sym: Symbol)(implicit ctx: Context): tpd.Tree = {
+    if (sym.is(Package)) packageDefFromSym(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)
+    else if (sym.isType) typeDefFromSym(sym.asType)
+    else if (sym.is(Method)) defDefFromSym(sym.asTerm)
+    else valDefFromSym(sym.asTerm)
   }
 
-  def packageDef(sym: Symbol)(implicit ctx: Context): PackageDefinition = PackageDefinitionImpl(sym)
+  def packageDefFromSym(sym: Symbol)(implicit ctx: Context): PackageDefinition = PackageDefinitionImpl(sym)
 
-  def classDef(cls: ClassSymbol)(implicit ctx: Context): tpd.Tree = {
-    val constrSym = cls.unforcedDecls.find(_.isPrimaryConstructor)
-    if (!constrSym.exists) return tpd.EmptyTree
+  def classDef(cls: ClassSymbol)(implicit ctx: Context): tpd.TypeDef = {
+    val constrSym = cls.unforcedDecls.find(_.isPrimaryConstructor).orElse(
+      // Dummy constructor for classes such as `<refinement>`
+      ctx.newSymbol(cls, nme.CONSTRUCTOR, EmptyFlags, NoType)
+    )
     val constr = tpd.DefDef(constrSym.asTerm)
     val parents = cls.classParents.map(tpd.TypeTree(_))
-    val body = cls.unforcedDecls.filter(!_.isPrimaryConstructor).map(s => definition(s))
+    val body = cls.unforcedDecls.filter(!_.isPrimaryConstructor).map(s => definitionFromSym(s))
     tpd.ClassDefWithParents(cls, constr, parents, body)
   }
 
-  def typeDef(sym: TypeSymbol)(implicit ctx: Context): tpd.TypeDef = tpd.TypeDef(sym)
+  def typeDefFromSym(sym: TypeSymbol)(implicit ctx: Context): tpd.TypeDef = tpd.TypeDef(sym)
 
-  def defDef(sym: TermSymbol)(implicit ctx: Context): tpd.DefDef = tpd.DefDef(sym)
+  def defDefFromSym(sym: TermSymbol)(implicit ctx: Context): tpd.DefDef = tpd.DefDef(sym)
 
-  def valDef(sym: TermSymbol)(implicit ctx: Context): tpd.ValDef = tpd.ValDef(sym)
+  def valDefFromSym(sym: TermSymbol)(implicit ctx: Context): tpd.ValDef = tpd.ValDef(sym)
 
 }

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

@@ -0,0 +1,80 @@
+package dotty.tools.dotc.tastyreflect
+
+import dotty.tools.dotc.core.Symbols._
+
+import dotty.tools.dotc.tastyreflect.FromSymbol._
+
+trait StandardDefinitions extends scala.tasty.reflect.StandardDefinitions {
+    tasty: TastyImpl =>
+
+  private implicit def ctx: Context = rootContext
+
+  val definitions: DefinitionsApi = new DefinitionsApi {
+
+    def RootPackage: PackageDef = packageDefFromSym(defn.RootPackage)
+
+    def ScalaPackage: PackageDef = packageDefFromSym(defn.ScalaPackageVal)
+
+    def AnyClass: ClassDef = classDef(defn.AnyClass)
+    def AnyValClass: ClassDef = classDef(defn.AnyValClass)
+    def ObjectClass: ClassDef = classDef(defn.ObjectClass)
+    def AnyRefClass: TypeDef = typeDefFromSym(defn.AnyRefAlias)
+    def NullClass: ClassDef = classDef(defn.AnyClass)
+    def NothingClass: ClassDef = classDef(defn.NothingClass)
+    def UnitClass: ClassDef = classDef(defn.UnitClass)
+    def ByteClass: ClassDef = classDef(defn.ByteClass)
+    def ShortClass: ClassDef = classDef(defn.ShortClass)
+    def CharClass: ClassDef = classDef(defn.CharClass)
+    def IntClass: ClassDef = classDef(defn.IntClass)
+    def LongClass: ClassDef = classDef(defn.LongClass)
+    def FloatClass: ClassDef = classDef(defn.FloatClass)
+    def DoubleClass: ClassDef = classDef(defn.DoubleClass)
+    def BooleanClass: ClassDef = classDef(defn.BooleanClass)
+    def StringClass: ClassDef = classDef(defn.StringClass)
+    def ClassClass: ClassDef = classDef(defn.ClassClass)
+    def ArrayClass: ClassDef = classDef(defn.ArrayClass)
+    def PredefModule: ValDef = valDefFromSym(defn.ScalaPredefModule.asTerm)
+
+    def JavaLangPackage: PackageDef = packageDefFromSym(defn.JavaLangPackageVal)
+
+    def ArrayModule: ValDef = valDefFromSym(defn.ArrayClass.companionModule.asTerm)
+
+    def Array_apply: DefDef = defDefFromSym(defn.Array_apply.asTerm)
+    def Array_clone: DefDef = defDefFromSym(defn.Array_clone.asTerm)
+    def Array_length: DefDef = defDefFromSym(defn.Array_length.asTerm)
+    def Array_update: DefDef = defDefFromSym(defn.Array_update.asTerm)
+
+    def RepeatedParamClass: ClassDef = classDef(defn.RepeatedParamClass)
+
+    def OptionClass: TypeDef = classDef(defn.OptionClass)
+    def NoneModule: ValDef = valDefFromSym(defn.NoneClass.companionModule.asTerm)
+    def SomeModule: ValDef = valDefFromSym(defn.SomeClass.companionModule.asTerm)
+
+    def ProductClass: ClassDef = classDef(defn.ProductClass)
+    def FunctionClass(arity: Int, isImplicit: Boolean = false, isErased: Boolean = false): ClassDef =
+      classDef(defn.FunctionClass(arity, isImplicit, isErased).asClass)
+    def TupleClass(arity: Int): ClassDef = classDef(defn.TupleType(arity).classSymbol.asClass)
+
+
+    def ScalaPrimitiveValueClasses: List[ClassDef] =
+      UnitClass :: BooleanClass :: ScalaNumericValueClasses
+    def ScalaNumericValueClasses: List[ClassDef] =
+      ByteClass :: ShortClass :: IntClass :: LongClass :: FloatClass :: DoubleClass :: CharClass :: Nil
+
+    def UnitType: Type = defn.UnitType
+    def ByteType: Type = defn.ByteType
+    def ShortType: Type = defn.ShortType
+    def CharType: Type = defn.CharType
+    def IntType: Type = defn.IntType
+    def LongType: Type = defn.LongType
+    def FloatType: Type = defn.FloatType
+    def DoubleType: Type = defn.DoubleType
+    def BooleanType: Type = defn.BooleanType
+    def AnyType: Type = defn.AnyType
+    def AnyValType: Type = defn.AnyValType
+    def AnyRefType: Type = defn.AnyRefType
+    def ObjectType: Type = defn.ObjectType
+    def NothingType: Type = defn.NothingType
+    def NullType: Type = defn.NullType
+  }
+}

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

@@ -15,7 +15,9 @@ import scala.quoted
 import scala.reflect.ClassTag
 import scala.tasty.util.{Show, ShowExtractors, ShowSourceCode}
 
-class TastyImpl(val rootContext: Contexts.Context) extends scala.tasty.Tasty { self =>
+import dotty.tools.dotc.tastyreflect.FromSymbol._
+
+class TastyImpl(val rootContext: Contexts.Context) extends scala.tasty.Tasty with StandardDefinitions { self =>
 
   // ===== Quotes ===================================================
 
@@ -40,7 +42,7 @@ class TastyImpl(val rootContext: Contexts.Context) extends scala.tasty.Tasty { s
   type Context = Contexts.Context
 
   def ContextDeco(ctx: Context): ContextAPI = new ContextAPI {
-    def owner: Definition = FromSymbol.definition(ctx.owner)(ctx)
+    def owner: Definition = definitionFromSym(ctx.owner)(ctx)
 
     def source: java.nio.file.Path = ctx.compilationUnit.source.file.jpath
   }
@@ -86,7 +88,7 @@ class TastyImpl(val rootContext: Contexts.Context) extends scala.tasty.Tasty { s
   }
 
   def PackageClauseDeco(pack: PackageClause): PackageClauseAPI = new PackageClauseAPI {
-    def definition(implicit ctx: Context): Definition = FromSymbol.packageDef(pack.symbol)
+    def definition(implicit ctx: Context): Definition = packageDefFromSym(pack.symbol)
   }
 
   // ----- Statements -----------------------------------------------
@@ -147,7 +149,7 @@ class TastyImpl(val rootContext: Contexts.Context) extends scala.tasty.Tasty { s
 
     def name(implicit ctx: Context): String = definition.symbol.name.toString
 
-    def owner(implicit ctx: Context): Definition = FromSymbol.definition(definition.symbol.owner)
+    def owner(implicit ctx: Context): Definition = definitionFromSym(definition.symbol.owner)
 
     def flags(implicit ctx: Context): FlagSet =
       new FlagSet(definition.symbol.flags)
@@ -264,11 +266,11 @@ class TastyImpl(val rootContext: Contexts.Context) extends scala.tasty.Tasty { s
 
   def PackageDefDeco(pdef: PackageDef): PackageDefAPI = new PackageDefAPI {
 
-    def owner(implicit ctx: Context): PackageDefinition = FromSymbol.packageDef(pdef.symbol.owner)
+    def owner(implicit ctx: Context): PackageDefinition = packageDefFromSym(pdef.symbol.owner)
 
     def members(implicit ctx: Context): List[Statement] = {
       if (pdef.symbol.is(core.Flags.JavaDefined)) Nil // FIXME should also support java packages
-      else pdef.symbol.info.decls.iterator.map(FromSymbol.definition).toList
+      else pdef.symbol.info.decls.iterator.map(definitionFromSym).toList
     }
   }
 
@@ -277,7 +279,7 @@ class TastyImpl(val rootContext: Contexts.Context) extends scala.tasty.Tasty { s
   object PackageDef extends PackageDefExtractor {
     def unapply(x: PackageDef)(implicit ctx: Context): Option[(String, PackageDef)] = x match {
       case x: PackageDefinition =>
-        Some((x.symbol.name.toString, FromSymbol.packageDef(x.symbol.owner)))
+        Some((x.symbol.name.toString, packageDefFromSym(x.symbol.owner)))
       case _ => None
     }
   }
@@ -825,7 +827,7 @@ class TastyImpl(val rootContext: Contexts.Context) extends scala.tasty.Tasty { s
       def unapply(x: Type)(implicit ctx: Context): Option[(Definition, TypeOrBounds /* Type | NoPrefix */)] = x  match {
         case tp: Types.NamedType =>
           tp.designator match {
-            case sym: Symbol => Some((FromSymbol.definition(sym), tp.prefix))
+            case sym: Symbol => Some((definitionFromSym(sym), tp.prefix))
             case _ => None
           }
         case _ => None

library/src/scala/tasty/Tasty.scala

@@ -1,9 +1,10 @@
 package scala.tasty
 
 import scala.reflect.ClassTag
+import scala.tasty.reflect.StandardDefinitions
 import scala.tasty.util.Show
 
-abstract class Tasty { tasty =>
+abstract class Tasty extends StandardDefinitions { tasty =>
 
   // ===== Quotes ===================================================