Treat toplevel objects as package objects

Author: odersky

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

@@ -87,6 +87,15 @@ object NameOps {
         false
     }
 
+    def isPackageObjectName: Boolean = name match {
+      case name: TermName => name == nme.PACKAGE || name.endsWith(str.TOPLEVEL_SUFFIX)
+      case name: TypeName =>
+        name.toTermName match {
+          case ModuleClassName(original) => original.isPackageObjectName
+          case _ => false
+        }
+    }
+
     /** Convert this module name to corresponding module class name */
     def moduleClassName: TypeName = name.derived(ModuleClassName).toTypeName
 

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

@@ -20,7 +20,7 @@ object StdNames {
     final val INITIALIZER_PREFIX       = "initial$"
     final val AVOID_CLASH_SUFFIX       = "$_avoid_name_clash_$"
     final val MODULE_SUFFIX            = "$"
-    final val TOPLEVEL_SUFFIX          = "$object"
+    final val TOPLEVEL_SUFFIX          = "__object"
     final val NAME_JOIN                = "$"
     final val DEFAULT_GETTER           = "$default$"
     final val LOCALDUMMY_PREFIX        = "<local "       // owner of local blocks

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

@@ -18,6 +18,7 @@ import config.Config
 import reporting.diagnostic.Message
 import reporting.diagnostic.messages.BadSymbolicReference
 import reporting.trace
+import collection.mutable
 
 import scala.annotation.internal.sharable
 
@@ -518,12 +519,8 @@ object SymDenotations {
       name == tpnme.REFINE_CLASS
 
     /** Is this symbol a package object or its module class? */
-    def isPackageObject(implicit ctx: Context): Boolean = {
-      val nameMatches =
-        if (isType) name == tpnme.PACKAGE.moduleClassName
-        else name == nme.PACKAGE
-      nameMatches && (owner is Package) && (this is Module)
-    }
+    def isPackageObject(implicit ctx: Context): Boolean =
+      name.isPackageObjectName && (owner is Package) && (this is Module)
 
     /** Is this symbol an abstract type? */
     final def isAbstractType(implicit ctx: Context): Boolean = this is DeferredType
@@ -1680,9 +1677,9 @@ object SymDenotations {
           val denots1 = collect(denots, ps)
           p.classSymbol.denot match {
             case parentd: ClassDenotation =>
-              denots1 union
+              denots1.union(
                 parentd.nonPrivateMembersNamed(name)
-                .mapInherited(ownDenots, denots1, thisType)
+                  .mapInherited(ownDenots, denots1, thisType))
             case _ =>
               denots1
           }
@@ -1940,17 +1937,39 @@ object SymDenotations {
     initPrivateWithin: Symbol)
     extends ClassDenotation(symbol, ownerIfExists, name, initFlags, initInfo, initPrivateWithin) {
 
-    private[this] var packageObjCache: SymDenotation = _
-    private[this] var packageObjRunId: RunId = NoRunId
-
-    /** The package object in this class, of one exists */
-    def packageObj(implicit ctx: Context): SymDenotation = {
-      if (packageObjRunId != ctx.runId) {
-        packageObjRunId = ctx.runId
-        packageObjCache = NoDenotation // break cycle in case we are looking for package object itself
-        packageObjCache = findMember(nme.PACKAGE, thisType, EmptyFlagConjunction, EmptyFlags).asSymDenotation
+    private[this] var packageObjsCache: List[ClassDenotation] = _
+    private[this] var packageObjsRunId: RunId = NoRunId
+
+    /** The package objects in this class */
+    def packageObjs(implicit ctx: Context): List[ClassDenotation] = {
+      if (packageObjsRunId != ctx.runId) {
+        packageObjsRunId = ctx.runId
+        packageObjsCache = Nil // break cycle in case we are looking for package object itself
+        packageObjsCache = {
+          val pkgObjBuf = new mutable.ListBuffer[ClassDenotation]
+          for (sym <- info.decls) { // don't use filter, since that loads classes with `$`s in their name
+            val denot = sym.lastKnownDenotation  // don't use `sym.denot`, as this brings forward classes too early
+            if (denot.isType && denot.name.isPackageObjectName)
+              pkgObjBuf += sym.asClass.classDenot
+          }
+          pkgObjBuf.toList
+        }
       }
-      packageObjCache
+      packageObjsCache
+    }
+
+    /** The package object (as a term symbol) in this package that might contain
+     *  `sym` as a member.
+     */
+    def packageObjFor(sym: Symbol)(implicit ctx: Context): Symbol = {
+      val owner = sym.maybeOwner
+      if (owner.is(Package)) NoSymbol
+      else if (owner.isPackageObject) owner.sourceModule
+      else // owner could be class inherited by package object (until package object inheritance is removed)
+        packageObjs.find(_.name == packageTypeName) match {
+          case Some(pobj) => pobj.sourceModule
+          case _ => NoSymbol
+        }
     }
 
     /** Looks in both the package object and the package for members. The precise algorithm
@@ -1966,28 +1985,31 @@ object SymDenotations {
      *  object that hides a class or object in the scala package of the same name, because
      *  the behavior would then be unintuitive for such members.
      */
-    override def computeNPMembersNamed(name: Name)(implicit ctx: Context): PreDenotation =
-      packageObj.moduleClass.denot match {
-        case pcls: ClassDenotation if !pcls.isCompleting =>
-          if (symbol eq defn.ScalaPackageClass) {
-            val denots = super.computeNPMembersNamed(name)
-            if (denots.exists) denots else pcls.computeNPMembersNamed(name)
-          }
-          else {
-            val denots = pcls.computeNPMembersNamed(name)
-            if (denots.exists) denots else super.computeNPMembersNamed(name)
-          }
-        case _ =>
-          super.computeNPMembersNamed(name)
+    override def computeNPMembersNamed(name: Name)(implicit ctx: Context): PreDenotation = {
+      def recur(pobjs: List[ClassDenotation], acc: PreDenotation): PreDenotation = pobjs match {
+        case pcls :: pobjs1 =>
+          if (pcls.isCompleting) recur(pobjs1, acc)
+          else recur(pobjs1, acc.union(pcls.computeNPMembersNamed(name)))
+        case nil =>
+          if (acc.exists) acc else super.computeNPMembersNamed(name)
       }
+      if (symbol `eq` defn.ScalaPackageClass) {
+        val denots = super.computeNPMembersNamed(name)
+        if (denots.exists) denots
+        else recur(packageObjs, NoDenotation)
+      }
+      else recur(packageObjs, NoDenotation)
+    }
 
     /** The union of the member names of the package and the package object */
     override def memberNames(keepOnly: NameFilter)(implicit onBehalf: MemberNames, ctx: Context): Set[Name] = {
-      val ownNames = super.memberNames(keepOnly)
-      packageObj.moduleClass.denot match {
-        case pcls: ClassDenotation => ownNames union pcls.memberNames(keepOnly)
-        case _ => ownNames
+      def recur(pobjs: List[ClassDenotation], acc: Set[Name]): Set[Name] = pobjs match {
+        case pcls :: pobjs1 =>
+          recur(pobjs1, acc.union(pcls.memberNames(keepOnly)))
+        case nil =>
+          acc
       }
+      recur(packageObjs, super.memberNames(keepOnly))
     }
 
     /** If another symbol with the same name is entered, unlink it,
@@ -1999,7 +2021,7 @@ object SymDenotations {
       if (entry != null) {
         if (entry.sym == sym) return false
         mscope.unlink(entry)
-        if (sym.name == nme.PACKAGE) packageObjRunId = NoRunId
+        if (sym.name.isPackageObjectName) packageObjsRunId = NoRunId
       }
       true
     }
@@ -2349,5 +2371,7 @@ object SymDenotations {
     def baseClasses: List[ClassSymbol] = classes
   }
 
+  private val packageTypeName = ModuleClassName(nme.PACKAGE).toTypeName
+
   @sharable private[this] var indent = 0 // for completions printing
 }

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

@@ -223,9 +223,10 @@ trait TypeOps { this: Context => // TODO: Make standalone object.
    */
   def makePackageObjPrefixExplicit(tpe: NamedType): Type = {
     def tryInsert(pkgClass: SymDenotation): Type = pkgClass match {
-      case pkgCls: PackageClassDenotation
-      if !tpe.symbol.maybeOwner.is(Package) && pkgCls.packageObj.exists =>
-        tpe.derivedSelect(pkgCls.packageObj.termRef)
+      case pkg: PackageClassDenotation =>
+        val pobj = pkg.packageObjFor(tpe.symbol)
+        if (pobj.exists) tpe.derivedSelect(pobj.termRef)
+        else tpe
       case _ =>
         tpe
     }

compiler/src/dotty/tools/dotc/transform/PostTyper.scala

@@ -119,14 +119,16 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
     private def transformSelect(tree: Select, targs: List[Tree])(implicit ctx: Context): Tree = {
       val qual = tree.qualifier
       qual.symbol.moduleClass.denot match {
-        case pkg: PackageClassDenotation if !tree.symbol.maybeOwner.is(Package) =>
-          transformSelect(cpy.Select(tree)(qual select pkg.packageObj.symbol, tree.name), targs)
+        case pkg: PackageClassDenotation =>
+          val pobj = pkg.packageObjFor(tree.symbol)
+          if (pobj.exists)
+            return transformSelect(cpy.Select(tree)(qual.select(pobj), tree.name), targs)
         case _ =>
-          val tree1 = super.transform(tree)
-          constToLiteral(tree1) match {
-            case _: Literal => tree1
-            case _ => superAcc.transformSelect(tree1, targs)
-          }
+      }
+      val tree1 = super.transform(tree)
+      constToLiteral(tree1) match {
+        case _: Literal => tree1
+        case _ => superAcc.transformSelect(tree1, targs)
       }
     }
 

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -256,7 +256,7 @@ class Typer extends Namer
           // the opposite: the last context before the package changes. This distinction
           // is made so that top-level imports following a package clause are
           // logically nested in that package clause. Finally, for the root package
-          // we switch back to the original test. This means that rop-level packages in
+          // we switch back to the original test. This means that top-level packages in
           // the root package take priority over root imports. For instance,
           // a top-level io package takes priority over scala.io.
           // It would be nice if we could drop all this complication, and

tests/run/toplevel-defs.check

@@ -0,0 +1,2 @@
+hello, Bill
+hello, Bob

tests/run/toplevel-defs/Test_2.scala

@@ -0,0 +1,4 @@
+object Test extends App {
+  println(hello("Bill"))
+  println(O.hi)
+}

tests/run/toplevel-defs/defs.scala

@@ -0,0 +1,5 @@
+def hello(name: String) = s"hello, $name"
+
+object O {
+  def hi = hello("Bob")
+}