Use more conditions on symbols

Author: nicolasstucki

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

@@ -11,9 +11,15 @@ trait StandardDefinitions extends scala.tasty.reflect.StandardDefinitions {
 
   val definitions: DefinitionsApi = new DefinitionsApi {
 
+    // TODO return Symbols instead of Definitions
+
     def RootPackage: PackageDef = packageDefFromSym(defn.RootPackage)
+    def RootClass: Symbol = defn.RootClass
+
+    def EmptyPackageClass: Symbol = defn.EmptyPackageClass
 
-    def ScalaPackage: PackageDef = packageDefFromSym(defn.ScalaPackageVal)
+    def ScalaPackage: Symbol = defn.ScalaPackageVal
+    def ScalaPackageClass: Symbol = defn.ScalaPackageClass
 
     def AnyClass: ClassDef = classDef(defn.AnyClass)
     def AnyValClass: ClassDef = classDef(defn.AnyValClass)
@@ -44,7 +50,7 @@ trait StandardDefinitions extends scala.tasty.reflect.StandardDefinitions {
     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 RepeatedParamClass: Symbol = defn.RepeatedParamClass
 
     def OptionClass: TypeDef = classDef(defn.OptionClass)
     def NoneModule: ValDef = valDefFromSym(defn.NoneClass.companionModule.asTerm)

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

@@ -7,6 +7,7 @@ trait SymbolOpsImpl extends scala.tasty.reflect.SymbolOps with TastyCoreImpl {
   def SymbolDeco(symbol: Symbol): SymbolAPI = new SymbolAPI {
     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 name(implicit ctx: Context): String = symbol.name.toString
     def fullName(implicit ctx: Context): String = symbol.fullName.toString
     def localContext(implicit ctx: Context): Context = ctx.withOwner(symbol)

library/src/scala/tasty/reflect/StandardDefinitions.scala

@@ -16,8 +16,17 @@ trait StandardDefinitions extends TastyCore {
     /** The module symbol of root package `_root_`. */
     def RootPackage: PackageDef
 
+    /** The class symbol of root package `_root_`. */
+    def RootClass: Symbol
+
+    /** The class symbol of empty package `_root_._empty_`. */
+    def EmptyPackageClass: Symbol
+
     /** The module symbol of package `scala`. */
-    def ScalaPackage: PackageDef
+    def ScalaPackage: Symbol
+
+    /** The class symbol of package `scala`. */
+    def ScalaPackageClass: Symbol
 
     /** The class symbol of core class `scala.Any`. */
     def AnyClass   : ClassDef
@@ -97,7 +106,7 @@ trait StandardDefinitions extends TastyCore {
     /** A dummy class symbol that is used to indicate repeated parameters
       *  compiled by the Scala compiler.
       */
-    def RepeatedParamClass: ClassDef
+    def RepeatedParamClass: Symbol
 
     /** The class symbol of class `scala.Option`. */
     def OptionClass: ClassDef

library/src/scala/tasty/reflect/SymbolOps.scala

@@ -5,12 +5,19 @@ package reflect
 trait SymbolOps extends TastyCore {
 
   trait SymbolAPI {
+
     def isEmpty(implicit ctx: Context): Boolean
     def isClass(implicit ctx: Context): Boolean
+
+    def flags(implicit ctx: Context): FlagSet
+
     def name(implicit ctx: Context): String
     def fullName(implicit ctx: Context): String
+
     def localContext(implicit ctx: Context): Context
+
     def tree(implicit ctx: Context): Option[Definition]
+
   }
   implicit def SymbolDeco(symbol: Symbol): SymbolAPI
 

library/src/scala/tasty/util/ShowSourceCode.scala

@@ -743,7 +743,7 @@ class ShowSourceCode[T <: Tasty with Singleton](tasty0: T) extends Show[T](tasty
             printTypeAndAnnots(tp)
             this += " "
             printAnnotation(annot)
-          case Type.SymRef(sym, Type.ThisType(Type.SymRef(PackageDef("runtime", _), NoPrefix()))) if sym.symbol.isClass && (sym.symbol.name == "Null$" || sym.symbol.name == "Nothing$") =>
+          case Type.SymRef(sym, _) if sym.symbol.isClass && (sym.symbol.fullName == "scala.runtime.Null$" || sym.symbol.fullName == "scala.runtime.Nothing$") =>
             // scala.runtime.Null$ and scala.runtime.Nothing$ are not modules, those are their actual names
             printType(tpe)
           case tpe @ Type.SymRef(sym, _) if sym.symbol.isClass && sym.name.endsWith("$") =>
@@ -1122,7 +1122,7 @@ class ShowSourceCode[T <: Tasty with Singleton](tasty0: T) extends Show[T](tasty
     def unapply(arg: Tree)(implicit ctx: Context): Option[(String, List[Term])] = arg match {
       case IsTerm(arg @ Term.Apply(fn, args)) =>
         fn.tpe match {
-          case Type.SymRef(DefDef(op, _, _, _, _), Type.ThisType(Type.SymRef(sym, _))) if sym.name == "<special-ops>" =>
+          case Type.SymRef(DefDef(op, _, _, _, _), Type.ThisType(Type.SymRef(sym2, _))) if sym2.name == "<special-ops>" =>
             Some((op, args))
           case _ => None
         }
@@ -1158,21 +1158,21 @@ class ShowSourceCode[T <: Tasty with Singleton](tasty0: T) extends Show[T](tasty
 
     object ScalaPackage {
       def unapply(tpe: TypeOrBounds)(implicit ctx: Context): Boolean = tpe match {
-        case Type.SymRef(PackageDef("scala", _), Type.ThisType(RootPackage())) => true
+        case Type.SymRef(sym, _) => sym.symbol == definitions.ScalaPackage
         case _ => false
       }
     }
 
     object RootPackage {
       def unapply(tpe: TypeOrBounds)(implicit ctx: Context): Boolean = tpe match {
-        case Type.SymRef(PackageDef("<root>", _), NoPrefix()) => true
+        case Type.SymRef(sym, _) => sym.symbol == definitions.RootClass
         case _ => false
       }
     }
 
     object EmptyPackage {
       def unapply(tpe: TypeOrBounds)(implicit ctx: Context): Boolean = tpe match {
-        case Type.SymRef(PackageDef("<empty>", _), NoPrefix() | Type.ThisType(RootPackage())) => true
+        case Type.SymRef(sym, _) => sym.symbol == definitions.EmptyPackageClass
         case _ => false
       }
     }