Fix #8521: Remove PackageDef and use Symbol directly

PackageDef was originally added to try to encode trees in the API without the use of symbols. Now that we have symbols all the package def logic is redundant.
At the time we assumed that we would be able to have a tree for all Symbol, but this has not been the case since the introduction of NoSymbol.
Now we handle the `tree` of a package def the same way we did the one of a NoSymbol.

* Remove `PackageDef`
* Add `members` method on `Symbol`
* Disallow package symbols in `Symbol.tree` as done with `NoSymbol`

Author: nicolasstucki

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

@@ -11,7 +11,6 @@ import dotty.tools.dotc.core.NameKinds
 import dotty.tools.dotc.core.StdNames._
 import dotty.tools.dotc.quoted.reflect._
 import dotty.tools.dotc.core.Decorators._
-import dotty.tools.dotc.quoted.reflect.FromSymbol.{definitionFromSym, packageDefFromSym}
 import dotty.tools.dotc.typer.Implicits
 
 import scala.quoted.QuoteContext
@@ -154,13 +153,12 @@ class QuoteContextImpl private (ctx: Context) extends QuoteContext:
         case _ => None
     end StatementTypeTest
 
-    type Definition = tpd.Tree
+    type Definition = tpd.MemberDef
 
     object DefinitionTypeTest extends TypeTest[Tree, Definition]:
       def runtimeClass: Class[?] = classOf[Definition]
       override def unapply(x: Any): Option[Definition] = x match
         case x: tpd.MemberDef @unchecked => Some(x)
-        case x: PackageDefinition @unchecked => Some(x)
         case _ => None
     end DefinitionTypeTest
 
@@ -170,7 +168,6 @@ class QuoteContextImpl private (ctx: Context) extends QuoteContext:
       extension (self: Definition):
         def name: String = self match
           case self: tpd.MemberDef => self.name.toString
-          case self: PackageDefinition => self.symbol.name.toString // TODO make PackageDefinition a MemberDef or NameTree
       end extension
     end DefinitionMethodsImpl
 
@@ -284,29 +281,6 @@ class QuoteContextImpl private (ctx: Context) extends QuoteContext:
       end extension
     end TypeDefMethodsImpl
 
-    type PackageDef = PackageDefinition
-
-    object PackageDefTypeTest extends TypeTest[Tree, PackageDef]:
-      def runtimeClass: Class[?] = classOf[PackageDef]
-      override def unapply(x: Any): Option[PackageDef] = x match
-        case x: PackageDefinition @unchecked => Some(x)
-        case _ => None
-    end PackageDefTypeTest
-
-    object PackageDef extends PackageDefModule:
-      def unapply(tree: PackageDef): Option[(String, PackageDef)] =
-        Some((tree.name, tree.owner))
-    end PackageDef
-
-    object PackageDefMethodsImpl extends PackageDefMethods:
-      extension (self: PackageDef):
-        def owner: PackageDef = packageDefFromSym(self.symbol.owner)
-        def members: List[Statement] =
-          if (self.symbol.is(JavaDefined)) Nil // FIXME should also support java packages
-          else self.symbol.info.decls.iterator.map(definitionFromSym).toList
-      end extension
-    end PackageDefMethodsImpl
-
     type Term = tpd.Tree
 
     object TermTypeTest extends TypeTest[Tree, Term]:
@@ -1137,13 +1111,13 @@ class QuoteContextImpl private (ctx: Context) extends QuoteContext:
       def copy(original: Tree)(tpt: TypeTree, refinements: List[Definition]): Refined =
         tpd.cpy.RefinedTypeTree(original)(tpt, refinements)
       def unapply(x: Refined): Option[(TypeTree, List[Definition])] =
-        Some((x.tpt, x.refinements))
+        Some((x.tpt, x.refinements.asInstanceOf[List[Definition]]))
     end Refined
 
     object RefinedMethodsImpl extends RefinedMethods:
       extension (self: Refined):
         def tpt: TypeTree = self.tpt
-        def refinements: List[Definition] = self.refinements
+        def refinements: List[Definition] = self.refinements.asInstanceOf[List[Definition]]
       end extension
     end RefinedMethodsImpl
 
@@ -2288,6 +2262,9 @@ class QuoteContextImpl private (ctx: Context) extends QuoteContext:
             case sym if isMethod(sym) => sym.asTerm
           }.toList
 
+        def members: List[Symbol] =
+          self.typeRef.info.decls.toList
+
         def typeMembers: List[Symbol] =
           self.unforcedDecls.filter(_.isType)
 

compiler/src/dotty/tools/dotc/quoted/reflect/FromSymbol.scala

@@ -12,18 +12,16 @@ import dotty.tools.dotc.core.Types._
 object FromSymbol {
 
   def definitionFromSym(sym: Symbol)(using Context): tpd.Tree = {
-    assert(sym.exists)
-    if (sym.is(Package)) packageDefFromSym(sym)
-    else if (sym.isClass) classDef(sym.asClass)
+    assert(sym.exists, "Cannot get tree of no symbol")
+    assert(!sym.is(Package), "Cannot get tree of package symbol")
+    if (sym.isClass) classDef(sym.asClass)
     else if (sym.isType && sym.is(Case)) typeBindFromSym(sym.asType)
     else if (sym.isType) typeDefFromSym(sym.asType)
     else if (sym.is(Method)) defDefFromSym(sym.asTerm)
     else if (sym.is(Case)) bindFromSym(sym.asTerm)
     else valDefFromSym(sym.asTerm)
   }
 
-  def packageDefFromSym(sym: Symbol)(using Context): PackageDefinition = PackageDefinitionImpl(sym)
-
   def classDef(cls: ClassSymbol)(using Context): tpd.TypeDef = cls.defTree match {
     case tree: tpd.TypeDef => tree
     case tpd.EmptyTree =>

compiler/src/dotty/tools/dotc/quoted/reflect/package.scala

@@ -20,8 +20,7 @@ import scala.tasty.reflect._
  *
  *  +- Tree -+- PackageClause
  *           +- Import
- *           +- Statement -+- Definition --+- PackageDef
- *           |             |               +- ClassDef
+ *           +- Statement -+- Definition --+- ClassDef
  *           |             |               +- TypeDef
  *           |             |               +- DefDef
  *           |             |               +- ValDef
@@ -225,7 +224,7 @@ trait Reflection { reflection =>
 
   // ----- Definitions ----------------------------------------------
 
-  /** Tree representing a definition in the source code. It can be `PackageDef`, `ClassDef`, `TypeDef`, `DefDef` or `ValDef` */
+  /** Tree representing a definition in the source code. It can be `ClassDef`, `TypeDef`, `DefDef` or `ValDef` */
   type Definition <: Statement
 
   given TypeTest[Tree, Definition] = DefinitionTypeTest
@@ -352,29 +351,6 @@ trait Reflection { reflection =>
     end extension
   end TypeDefMethods
 
-  // PackageDef
-
-  /** Tree representing a package definition. This includes definitions in all source files */
-  type PackageDef <: Definition
-
-  given TypeTest[Tree, PackageDef] = PackageDefTypeTest
-  protected val PackageDefTypeTest: TypeTest[Tree, PackageDef]
-
-  val PackageDef: PackageDefModule
-
-  trait PackageDefModule { this: PackageDef.type =>
-    def unapply(tree: PackageDef): Option[(String, PackageDef)]
-  }
-
-  given PackageDefMethods as PackageDefMethods = PackageDefMethodsImpl
-  protected val PackageDefMethodsImpl: PackageDefMethods
-
-  trait PackageDefMethods:
-    extension (self: PackageDef):
-      def owner: PackageDef
-      def members: List[Statement]
-    end extension
-  end PackageDefMethods
 
   // ----- Terms ----------------------------------------------------
 
@@ -2555,14 +2531,14 @@ trait Reflection { reflection =>
       def comment: Option[Comment]
 
       /** Tree of this definition
-        *
-        * if this symbol `isPackageDef` it will return a `PackageDef`,
-        * if this symbol `isClassDef` it will return a `ClassDef`,
-        * if this symbol `isTypeDef` it will return a `TypeDef`,
-        * if this symbol `isValDef` it will return a `ValDef`,
-        * if this symbol `isDefDef` it will return a `DefDef`
-        * if this symbol `isBind` it will return a `Bind`
-        */
+       *
+       *  If this symbol `isClassDef` it will return `a `ClassDef`,
+       *  if this symbol `isTypeDef` it will return `a `TypeDef`,
+       *  if this symbol `isValDef` it will return `a `ValDef`,
+       *  if this symbol `isDefDef` it will return `a `DefDef`
+       *  if this symbol `isBind` it will return `a `Bind`,
+       *  else will throw
+       */
       def tree: Tree
 
       /** Annotations attached to this symbol */
@@ -2626,6 +2602,9 @@ trait Reflection { reflection =>
       /** Type member with the given name directly declared in the class */
       def typeMember(name: String): Symbol
 
+      /** All members directly declared in the class */
+      def members: List[Symbol]
+
       /** Get named non-private methods declared or inherited */
       def method(name: String): List[Symbol]
 

library/src/scala/tasty/Reflection.scala

@@ -118,8 +118,6 @@ class ExtractorsPrinter[R <: Reflection & Singleton](val tasty: R) extends Print
         this += ", "
         visitList[TypeTree](derived, visitTree)
         this += ", " += self += ", " ++= body += ")"
-      case PackageDef(name, owner) =>
-        this += "PackageDef(\"" += name += "\", " += owner += ")"
       case Import(expr, selectors) =>
         this += "Import(" += expr += ", " ++= selectors += ")"
       case PackageClause(pid, stats) =>

library/src/scala/tasty/reflect/ExtractorsPrinter.scala

@@ -1228,12 +1228,11 @@ class SourceCodePrinter[R <: Reflection & Singleton](val tasty: R)(syntaxHighlig
       case RenameSelector(name, newName) => this += name += " => " += newName
     }
 
-    def printDefinitionName(sym: Definition): Buffer = sym match {
+    def printDefinitionName(tree: Definition): Buffer = tree match {
       case ValDef(name, _, _) => this += highlightValDef(name)
       case DefDef(name, _, _, _, _) => this += highlightValDef(name)
       case ClassDef(name, _, _, _, _, _) => this += highlightTypeDef(name.stripSuffix("$"))
       case TypeDef(name, _) => this += highlightTypeDef(name)
-      case PackageDef(name, _) => this += highlightTypeDef(name)
     }
 
     def printAnnotation(annot: Term)(using elideThis: Option[Symbol]): Buffer = {

library/src/scala/tasty/reflect/SourceCodePrinter.scala

@@ -0,0 +1,26 @@
+import scala.quoted._
+
+object Foo {
+  inline def foo[T <: AnyKind]: String = ${ bar[T] }
+
+  def bar[T <: AnyKind : Type](using qctx: QuoteContext): Expr[String] = {
+    import qctx.tasty.{Type => _, _}
+
+    def packageToName(sym: Symbol): Unit = {
+      if sym.isPackageDef then
+        packageToName(sym.owner)
+    }
+
+    val sym = implicitly[Type[T]].unseal.symbol
+    if (!sym.isNoSymbol) {
+      sym.tree match {
+        case c: ClassDef =>
+          if (!sym.maybeOwner.isNoSymbol) {
+            if sym.maybeOwner.isPackageDef then
+              packageToName(sym.maybeOwner)
+          }
+      }
+    }
+    Expr("")
+  }
+}

tests/pos-macros/i8521/Macro_1.scala

@@ -0,0 +1,5 @@
+class A
+
+object Test {
+  def test = Foo.foo[A]
+}