sourcepath: support top-level definitions

If a top-level definition is found in a file that is part of the
sourcepath, create a symbol for the package object that will wrap the
top-level definitions.

Author: smarter

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

@@ -1220,6 +1220,29 @@ object desugar {
     else Apply(ref(tupleTypeRef.classSymbol.companionModule.termRef), ts)
   }
 
+  private def isTopLevelDef(stat: Tree)(given Context): Boolean = stat match
+    case _: ValDef | _: PatDef | _: DefDef | _: Export => true
+    case stat: ModuleDef =>
+      stat.mods.isOneOf(GivenOrImplicit)
+    case stat: TypeDef =>
+      !stat.isClassDef || stat.mods.isOneOf(GivenOrImplicit)
+    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.
+   */
+  def packageObjectName(src: SourceFile): TermName =
+    val fileName = src.file.name
+    val sourceName = fileName.take(fileName.lastIndexOf('.'))
+    (sourceName ++ str.TOPLEVEL_SUFFIX).toTermName
+
   /** Group all definitions that can't be at the toplevel in
    *  an object named `<source>$package` where `<source>` is the name of the source file.
    *  Definitions that can't be at the toplevel are:
@@ -1231,26 +1254,22 @@ object desugar {
    *     (i.e. objects having the same name as a wrapped type)
    */
   def packageDef(pdef: PackageDef)(implicit ctx: Context): PackageDef = {
-    def isWrappedType(stat: TypeDef): Boolean =
-      !stat.isClassDef || stat.mods.isOneOf(GivenOrImplicit)
     val wrappedTypeNames = pdef.stats.collect {
-      case stat: TypeDef if isWrappedType(stat) => stat.name
-    }
-    def needsObject(stat: Tree) = stat match {
-      case _: ValDef | _: PatDef | _: DefDef | _: Export => true
-      case stat: ModuleDef =>
-        stat.mods.isOneOf(GivenOrImplicit) ||
-        wrappedTypeNames.contains(stat.name.stripModuleClassSuffix.toTypeName)
-      case stat: TypeDef => isWrappedType(stat)
-      case _ => false
+      case stat: TypeDef if isTopLevelDef(stat) => stat.name
     }
-    val (nestedStats, topStats) = pdef.stats.partition(needsObject)
+    def inPackageObject(stat: Tree) =
+      isTopLevelDef(stat) || {
+        stat match
+          case stat: ModuleDef =>
+            wrappedTypeNames.contains(stat.name.stripModuleClassSuffix.toTypeName)
+          case _ =>
+            false
+      }
+    val (nestedStats, topStats) = pdef.stats.partition(inPackageObject)
     if (nestedStats.isEmpty) pdef
     else {
-      var fileName = ctx.source.file.name
-      val sourceName = fileName.take(fileName.lastIndexOf('.'))
-      val groupName = (sourceName ++ str.TOPLEVEL_SUFFIX).toTermName.asSimpleName
-      val grouped = ModuleDef(groupName, Template(emptyConstructor, Nil, Nil, EmptyValDef, nestedStats))
+      val name = packageObjectName(ctx.source)
+      val grouped = ModuleDef(name, Template(emptyConstructor, Nil, Nil, EmptyValDef, nestedStats))
       cpy.PackageDef(pdef)(pdef.pid, topStats :+ grouped)
     }
   }

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

@@ -18,6 +18,7 @@ import ast.Trees._
 import parsing.JavaParsers.OutlineJavaParser
 import parsing.Parsers.OutlineParser
 import reporting.trace
+import ast.desugar.{ packageObjectName, hasTopLevelDef }
 
 object SymbolLoaders {
   import ast.untpd._
@@ -124,7 +125,7 @@ object SymbolLoaders {
 
       def enterScanned(unit: CompilationUnit)(implicit ctx: Context) = {
 
-        def checkPathMatches(path: List[TermName], what: String, tree: MemberDef): Boolean = {
+        def checkPathMatches(path: List[TermName], what: String, tree: NameTree): Boolean = {
           val ok = filePath == path
           if (!ok)
             ctx.warning(i"""$what ${tree.name} is in the wrong directory.
@@ -135,8 +136,10 @@ object SymbolLoaders {
         }
 
         def traverse(tree: Tree, path: List[TermName]): Unit = tree match {
-          case PackageDef(pid, body) =>
+          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/completeFromSource/nested/toplevel1.scala

@@ -0,0 +1,9 @@
+package completeFromSource
+package nested
+
+val one: Int = 1
+
+type Hi = Int
+object Hi {
+  def hi: Hi = 2
+}

tests/pos-special/completeFromSource/toplevel2.scala

@@ -0,0 +1,7 @@
+package completeFromSource
+import nested._
+
+object toplevel2 {
+  val a: Int = one
+  val b: Hi = Hi.hi
+}