Use symbol instead of definition tree in TASTy reflect

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

@@ -9,7 +9,7 @@ trait ContextOpsImpl extends scala.tasty.reflect.ContextOps with TastyCoreImpl {
   val rootContext: Contexts.Context
 
   def ContextDeco(ctx: Context): ContextAPI = new ContextAPI {
-    def owner: Definition = definitionFromSym(ctx.owner)(ctx)
+    def owner: Symbol = ctx.owner
 
     def source: java.nio.file.Path = ctx.compilationUnit.source.file.jpath
   }

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

@@ -11,54 +11,58 @@ trait StandardDefinitions extends scala.tasty.reflect.StandardDefinitions {
 
   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] =
+    def RootPackage: Symbol = defn.RootPackage
+    def RootClass: Symbol = defn.RootClass
+
+    def EmptyPackageClass: Symbol = defn.EmptyPackageClass
+
+    def ScalaPackage: Symbol = defn.ScalaPackageVal
+    def ScalaPackageClass: Symbol = defn.ScalaPackageClass
+
+    def AnyClass: Symbol = defn.AnyClass
+    def AnyValClass: Symbol = defn.AnyValClass
+    def ObjectClass: Symbol = defn.ObjectClass
+    def AnyRefClass: Symbol = defn.AnyRefAlias
+    def NullClass: Symbol = defn.AnyClass
+    def NothingClass: Symbol = defn.NothingClass
+    def UnitClass: Symbol = defn.UnitClass
+    def ByteClass: Symbol = defn.ByteClass
+    def ShortClass: Symbol = defn.ShortClass
+    def CharClass: Symbol = defn.CharClass
+    def IntClass: Symbol = defn.IntClass
+    def LongClass: Symbol = defn.LongClass
+    def FloatClass: Symbol = defn.FloatClass
+    def DoubleClass: Symbol = defn.DoubleClass
+    def BooleanClass: Symbol = defn.BooleanClass
+    def StringClass: Symbol = defn.StringClass
+    def ClassClass: Symbol = defn.ClassClass
+    def ArrayClass: Symbol = defn.ArrayClass
+    def PredefModule: Symbol = defn.ScalaPredefModule.asTerm
+
+    def JavaLangPackage: Symbol = defn.JavaLangPackageVal
+
+    def ArrayModule: Symbol = defn.ArrayClass.companionModule.asTerm
+
+    def Array_apply: Symbol = defn.Array_apply.asTerm
+    def Array_clone: Symbol = defn.Array_clone.asTerm
+    def Array_length: Symbol = defn.Array_length.asTerm
+    def Array_update: Symbol = defn.Array_update.asTerm
+
+    def RepeatedParamClass: Symbol = defn.RepeatedParamClass
+
+    def OptionClass: Symbol = defn.OptionClass
+    def NoneModule: Symbol = defn.NoneClass.companionModule.asTerm
+    def SomeModule: Symbol = defn.SomeClass.companionModule.asTerm
+
+    def ProductClass: Symbol = defn.ProductClass
+    def FunctionClass(arity: Int, isImplicit: Boolean = false, isErased: Boolean = false): Symbol =
+      defn.FunctionClass(arity, isImplicit, isErased).asClass
+    def TupleClass(arity: Int): Symbol = defn.TupleType(arity).classSymbol.asClass
+
+
+    def ScalaPrimitiveValueClasses: List[Symbol] =
       UnitClass :: BooleanClass :: ScalaNumericValueClasses
-    def ScalaNumericValueClasses: List[ClassDef] =
+    def ScalaNumericValueClasses: List[Symbol] =
       ByteClass :: ShortClass :: IntClass :: LongClass :: FloatClass :: DoubleClass :: CharClass :: Nil
 
     def UnitType: Type = defn.UnitType

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

@@ -1,14 +1,49 @@
-package dotty.tools.dotc.tastyreflect
+package dotty.tools.dotc
+package tastyreflect
 
 import dotty.tools.dotc.core.Symbols._
 
 trait SymbolOpsImpl extends scala.tasty.reflect.SymbolOps with TastyCoreImpl {
 
   def SymbolDeco(symbol: Symbol): SymbolAPI = new SymbolAPI {
-    def isEmpty: Boolean = symbol eq NoSymbol
-    def localContext(implicit ctx: Context): Context = ctx.withOwner(symbol)
+
+    def isEmpty(implicit ctx: Context): Boolean = symbol eq NoSymbol
+    def isClass(implicit ctx: Context): Boolean = symbol.isClass
+
+    def flags(implicit ctx: Context): FlagSet = new FlagSet(symbol.flags)
+
+    def privateWithin(implicit ctx: Context): Option[Type] = {
+      val within = symbol.privateWithin
+      if (within.exists && !symbol.is(core.Flags.Protected)) Some(within.typeRef)
+      else None
+    }
+
+    def protectedWithin(implicit ctx: Context): Option[Type] = {
+      val within = symbol.privateWithin
+      if (within.exists && symbol.is(core.Flags.Protected)) Some(within.typeRef)
+      else None
+    }
+
+    def name(implicit ctx: Context): String = symbol.name.toString
+    def fullName(implicit ctx: Context): String = symbol.fullName.toString
+
+    def owner(implicit ctx: Context): Symbol = symbol.owner
+
+    def localContext(implicit ctx: Context): Context = {
+      if (symbol.exists) ctx.withOwner(symbol)
+      else ctx
+    }
+
     def tree(implicit ctx: Context): Option[Definition] =
       if (isEmpty) None else Some(FromSymbol.definitionFromSym(symbol))
+
+    def annots(implicit ctx: Context): List[Term] = {
+      symbol.annotations.flatMap {
+        case _: core.Annotations.LazyBodyAnnotation => Nil
+        case annot => annot.tree :: Nil
+      }
+    }
+
   }
 
 }

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

@@ -60,36 +60,7 @@ trait TreeOpsImpl extends scala.tasty.reflect.TreeOps with TastyCoreImpl with He
   }
 
   def DefinitionDeco(definition: Definition): DefinitionAPI = new DefinitionAPI {
-
     def name(implicit ctx: Context): String = definition.symbol.name.toString
-
-    def owner(implicit ctx: Context): Definition = definitionFromSym(definition.symbol.owner)
-
-    def flags(implicit ctx: Context): FlagSet =
-      new FlagSet(definition.symbol.flags)
-
-    def privateWithin(implicit ctx: Context): Option[Type] = {
-      val within = definition.symbol.privateWithin
-      if (within.exists && !definition.symbol.is(core.Flags.Protected)) Some(within.typeRef)
-      else None
-    }
-
-    def protectedWithin(implicit ctx: Context): Option[Type] = {
-      val within = definition.symbol.privateWithin
-      if (within.exists && definition.symbol.is(core.Flags.Protected)) Some(within.typeRef)
-      else None
-    }
-
-    def annots(implicit ctx: Context): List[Term] = {
-      definition.symbol.annotations.flatMap {
-        case _: core.Annotations.LazyBodyAnnotation => Nil
-        case annot => annot.tree :: Nil
-      }
-    }
-
-    def localContext(implicit ctx: Context): Context =
-      if (definition.hasType && definition.symbol.exists) ctx.withOwner(definition.symbol)
-      else ctx
   }
 
   // ClassDef

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

@@ -51,10 +51,10 @@ trait TypeOrBoundsOpsImpl extends scala.tasty.reflect.TypeOrBoundsOps with Tasty
     }
 
     object SymRef extends SymRefExtractor {
-      def unapply(x: TypeOrBounds)(implicit ctx: Context): Option[(Definition, TypeOrBounds /* Type | NoPrefix */)] = x  match {
+      def unapply(x: TypeOrBounds)(implicit ctx: Context): Option[(Symbol, TypeOrBounds /* Type | NoPrefix */)] = x  match {
         case tp: Types.NamedType =>
           tp.designator match {
-            case sym: Symbol => Some((definitionFromSym(sym), tp.prefix))
+            case sym: Symbol => Some((sym, tp.prefix))
             case _ => None
           }
         case _ => None

library/src/scala/tasty/reflect/ContextOps.scala

@@ -4,7 +4,7 @@ package reflect
 trait ContextOps extends TastyCore {
 
   trait ContextAPI {
-    def owner: Definition
+    def owner: Symbol
 
     /** Returns the source file being compiled. The path is relative to the current working directory. */
     def source: java.nio.file.Path