sourcepath: fix handling of top-level definitions

5c2a2d5 was a bit too clever: instead
of running the desugaring of top-level definitions, it manually checked
if such a desugaring was needed and then entered the package object if
needed and traversed the non-desugared package statements, but in a
situation like this:

  package foo
  type Foo
  object Foo

The desugaring will move `object Foo` inside the package object,
so by traversing the non-desugared tree, we were creating a symbol
for Foo at the wrong level.

This commit fixes this by simply calling the appropriate desugaring
method before doing any traversal. Unfortunately I wasn't able to
manufacture a testcase where this makes a difference, but this
fixes some issues I saw when compiling dotty-library itself.

Author: smarter

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -1229,12 +1229,6 @@ object desugar {
     case _ =>
       false
 
-  /** Does this package contains at least one top-level definition
-   *  that will require a wrapping object ?
-   */
-  def hasTopLevelDef(pdef: PackageDef)(given Context): Boolean =
-    pdef.stats.exists(isTopLevelDef)
-
   /** Assuming `src` contains top-level definition, returns the name that should
    *  be using for the package object that will wrap them.
    */

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

@@ -18,7 +18,7 @@ import ast.Trees._
 import parsing.JavaParsers.OutlineJavaParser
 import parsing.Parsers.OutlineParser
 import reporting.trace
-import ast.desugar.{ packageObjectName, hasTopLevelDef }
+import ast.desugar
 
 object SymbolLoaders {
   import ast.untpd._
@@ -135,21 +135,26 @@ object SymbolLoaders {
           ok
         }
 
-        def traverse(tree: Tree, path: List[TermName]): Unit = tree match {
-          case tree @ PackageDef(pid, body) =>
-            val path1 = addPrefix(pid, path)
-            if hasTopLevelDef(tree) && checkPathMatches(path1, "package", pid)
-              enterModule(owner, packageObjectName(unit.source), completer, scope = scope)
-            for (stat <- body) traverse(stat, path1)
-          case tree: TypeDef if tree.isClassDef =>
-            if (checkPathMatches(path, "class", tree))
-              // It might be a case class or implicit class,
-              // so enter class and module to be on the safe side
-              enterClassAndModule(owner, tree.name, completer, scope = scope)
-          case tree: ModuleDef =>
-            if (checkPathMatches(path, "object", tree))
-              enterModule(owner, tree.name, completer, scope = scope)
+        /** Run the subset of desugaring necessary to record the correct symbols */
+        def simpleDesugar(tree: Tree): Tree = tree match
+          case tree: PackageDef =>
+            desugar.packageDef(tree)
           case _ =>
+            tree
+
+        def traverse(tree: Tree, path: List[TermName]): Unit = simpleDesugar(tree) match {
+            case tree @ PackageDef(pid, body) =>
+              val path1 = addPrefix(pid, path)
+              for (stat <- body) traverse(stat, path1)
+            case tree: TypeDef if tree.isClassDef =>
+              if (checkPathMatches(path, "class", tree))
+                // It might be a case class or implicit class,
+                // so enter class and module to be on the safe side
+                enterClassAndModule(owner, tree.name, completer, scope = scope)
+            case tree: ModuleDef =>
+              if (checkPathMatches(path, "object", tree))
+                enterModule(owner, tree.name, completer, scope = scope)
+            case _ =>
         }
 
         traverse(