sourcepath: Fix handling of top-level definitions and user-written package objects

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

@@ -804,6 +804,26 @@ object desugar {
     flatTree(cdef1 :: companions ::: implicitWrappers)
   }.reporting(i"desugared: $result", Printers.desugar)
 
+  /** Expand
+   *
+   *    package object name { body }
+   *
+   *  to:
+   *
+   *    package name {
+   *      object `package` { body }
+   *    }
+   */
+  def packageModuleDef(mdef: ModuleDef)(implicit ctx: Context): Tree =
+    val impl = mdef.impl
+    val mods = mdef.mods
+    val moduleName = normalizeName(mdef, impl).asTermName
+    if (mods.is(Package))
+      PackageDef(Ident(moduleName),
+        cpy.ModuleDef(mdef)(nme.PACKAGE, impl).withMods(mods &~ Package) :: Nil)
+    else
+      mdef
+
   /** Expand
    *
    *    object name extends parents { self => body }
@@ -854,7 +874,7 @@ object desugar {
       ctx.warning(em"${hl("final")} modifier is redundant for objects", flagSourcePos(Final))
 
     if (mods.is(Package))
-      PackageDef(Ident(moduleName), cpy.ModuleDef(mdef)(nme.PACKAGE, impl).withMods(mods &~ Package) :: Nil)
+      packageModuleDef(mdef)
     else if (isEnumCase) {
       typeParamIsReferenced(enumClass.typeParams, Nil, Nil, impl.parents)
         // used to check there are no illegal references to enum's type parameters in parents
@@ -1229,12 +1249,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,11 +135,18 @@ object SymbolLoaders {
           ok
         }
 
-        def traverse(tree: Tree, path: List[TermName]): Unit = tree match {
+        /** 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: ModuleDef =>
+            desugar.packageModuleDef(tree)
+          case _ =>
+            tree
+
+        def traverse(tree: Tree, path: List[TermName]): Unit = simpleDesugar(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))

tests/pos-special/sourcepath/outer/nested2/package.scala

@@ -0,0 +1,5 @@
+package outer
+
+package object nested2 {
+  val x: Int = 1
+}

tests/pos-special/sourcepath/outer/pkg.scala

@@ -0,0 +1,5 @@
+package outer
+
+object pkg {
+  val y: Int = nested2.x
+}