Merge pull request #5754 from dotty-staging/add-toplevel

Allow toplevel definitions

Author: odersky

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

@@ -9,6 +9,7 @@ import Decorators._, transform.SymUtils._
 import NameKinds.{UniqueName, EvidenceParamName, DefaultGetterName}
 import typer.FrontEnd
 import util.{Property, SourceFile, SourcePosition}
+import util.NameTransformer.avoidIllegalChars
 import collection.mutable.ListBuffer
 import reporting.diagnostic.messages._
 import reporting.trace
@@ -1025,6 +1026,37 @@ object desugar {
     else Apply(ref(tupleTypeRef.classSymbol.companionModule.termRef), ts)
   }
 
+  /** 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:
+   *
+   *   - all pattern, value and method definitions
+   *   - non-class type definitions
+   *   - implicit classes and objects
+   *   - companion objects of opaque types
+   */
+  def packageDef(pdef: PackageDef)(implicit ctx: Context): PackageDef = {
+    val opaqueNames = pdef.stats.collect {
+      case stat: TypeDef if stat.mods.is(Opaque) => stat.name
+    }
+    def needsObject(stat: Tree) = stat match {
+      case _: ValDef | _: PatDef | _: DefDef => true
+      case stat: ModuleDef =>
+        stat.mods.is(Implicit) || opaqueNames.contains(stat.name.stripModuleClassSuffix.toTypeName)
+      case stat: TypeDef => !stat.isClassDef || stat.mods.is(Implicit)
+      case _ => false
+    }
+    val (nestedStats, topStats) = pdef.stats.partition(needsObject)
+    if (nestedStats.isEmpty) pdef
+    else {
+      var fileName = ctx.source.file.name
+      val sourceName = fileName.take(fileName.lastIndexOf('.'))
+      val groupName = avoidIllegalChars((sourceName ++ str.TOPLEVEL_SUFFIX).toTermName.asSimpleName)
+      val grouped = ModuleDef(groupName, Template(emptyConstructor, Nil, Nil, EmptyValDef, nestedStats))
+      cpy.PackageDef(pdef)(pdef.pid, topStats :+ grouped)
+    }
+  }
+
   /** Make closure corresponding to function.
    *      params => body
    *  ==>

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

@@ -412,7 +412,7 @@ object Denotations {
         def precedes(sym1: Symbol, sym2: Symbol) = {
           def precedesIn(bcs: List[ClassSymbol]): Boolean = bcs match {
             case bc :: bcs1 => (sym1 eq bc) || !(sym2 eq bc) && precedesIn(bcs1)
-            case Nil => true
+            case Nil => false
           }
           (sym1 ne sym2) &&
             (sym1.derivesFrom(sym2) ||
@@ -1183,7 +1183,7 @@ object Denotations {
    */
   def isDoubleDef(sym1: Symbol, sym2: Symbol)(implicit ctx: Context): Boolean =
     (sym1.exists && sym2.exists &&
-    (sym1 ne sym2) && (sym1.owner eq sym2.owner) &&
+    (sym1 `ne` sym2) && (sym1.effectiveOwner `eq` sym2.effectiveOwner) &&
     !sym1.is(Bridge) && !sym2.is(Bridge))
 
   def doubleDefError(denot1: Denotation, denot2: Denotation, pre: Type = NoPrefix)(implicit ctx: Context): Nothing = {
@@ -1193,7 +1193,7 @@ object Denotations {
       throw new MergeError(sym1, sym2, sym1.info, sym2.info, pre) {
         override def addendum(implicit ctx: Context) =
           i"""
-             |they are both defined in ${sym1.owner} but have matching signatures
+             |they are both defined in ${sym1.effectiveOwner} but have matching signatures
              |  ${denot1.info} and
              |  ${denot2.info}${super.addendum}"""
         }
@@ -1227,7 +1227,7 @@ object Denotations {
   final case class DenotUnion(denot1: PreDenotation, denot2: PreDenotation) extends MultiPreDenotation {
     def exists: Boolean = true
     def toDenot(pre: Type)(implicit ctx: Context): Denotation =
-      (denot1 toDenot pre) & (denot2 toDenot pre, pre)
+      denot1.toDenot(pre).&(denot2.toDenot(pre), pre)
     def containsSym(sym: Symbol): Boolean =
       (denot1 containsSym sym) || (denot2 containsSym sym)
     type AsSeenFromResult = PreDenotation

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

@@ -87,6 +87,16 @@ object NameOps {
         false
     }
 
+    /** is this the name of an object enclosing packagel-level definitions? */
+    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,6 +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          = "$package"
     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
@@ -762,9 +759,7 @@ object SymDenotations {
              (  !(this is Local)
              || (owner is ImplClass) // allow private local accesses to impl class members
              || isCorrectThisType(pre)
-             ) &&
-             (!(this.is(Private) && owner.is(Package)) ||
-              owner == ctx.owner.enclosingPackageClass)
+             )
         || (this is Protected) &&
              (  superAccess
              || pre.isInstanceOf[ThisType]
@@ -1684,9 +1679,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
           }
@@ -1944,54 +1939,81 @@ 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
      *  is as follows:
      *
      *  If this is the scala package look in the package first, and if nothing is found
-     *  there, look in the package object second. Otherwise, look in the package object
-     *  first, and if nothing is found there, in the package second.
+     *  there, look in the package object second. Otherwise, look in the both the package object
+     *  and the package and form a union of the results.
      *
      *  The reason for the special treatment of the scala package is that if we
      *  complete it too early, we freeze its superclass Any, so that no members can
      *  be entered in it. As a consequence, there should be no entry in the scala package
      *  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 =>
+          val directMembers = super.computeNPMembersNamed(name)
+          if (acc.exists) acc.union(directMembers.filterWithPredicate(!_.symbol.isAbsent))
+          else directMembers
       }
+      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,
@@ -2003,7 +2025,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
     }
@@ -2353,5 +2375,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/SymbolLoaders.scala

@@ -8,6 +8,7 @@ import dotty.tools.io.{ ClassPath, ClassRepresentation, AbstractFile }
 import config.Config
 import Contexts._, Symbols._, Flags._, SymDenotations._, Types._, Scopes._, Names._
 import NameOps._
+import StdNames.str
 import Decorators.{PreNamedString, StringInterpolators}
 import classfile.ClassfileParser
 import util.Stats
@@ -236,11 +237,18 @@ object SymbolLoaders {
 
     private[core] val currentDecls: MutableScope = new PackageScope()
 
-    def isFlatName(name: SimpleName): Boolean = name.lastIndexOf('$', name.length - 2) >= 0
+    private def isFlatName(name: SimpleName): Boolean = {
+      val idx = name.lastIndexOf('$', name.length - 2)
+      idx >= 0 &&
+      (idx + str.TOPLEVEL_SUFFIX.length + 1 != name.length || !name.endsWith(str.TOPLEVEL_SUFFIX))
+    }
 
-    def isFlatName(classRep: ClassRepresentation): Boolean = {
-      val idx = classRep.name.indexOf('$')
-      idx >= 0 && idx < classRep.name.length - 1
+    /** Name of class contains `$`, excepted names ending in `$package` */
+    def hasFlatName(classRep: ClassRepresentation): Boolean = {
+      val name = classRep.name
+      val idx = name.lastIndexOf('$', name.length - 2)
+      idx >= 0 &&
+      (idx + str.TOPLEVEL_SUFFIX.length + 1 != name.length || !name.endsWith(str.TOPLEVEL_SUFFIX))
     }
 
     def maybeModuleClass(classRep: ClassRepresentation): Boolean = classRep.name.last == '$'
@@ -253,11 +261,11 @@ object SymbolLoaders {
         val classReps = classPath.list(packageName).classesAndSources
 
         for (classRep <- classReps)
-          if (!maybeModuleClass(classRep) && isFlatName(classRep) == flat &&
+          if (!maybeModuleClass(classRep) && hasFlatName(classRep) == flat &&
             (!flat || isAbsent(classRep))) // on 2nd enter of flat names, check that the name has not been entered before
             initializeFromClassPath(root.symbol, classRep)
         for (classRep <- classReps)
-          if (maybeModuleClass(classRep) && isFlatName(classRep) == flat &&
+          if (maybeModuleClass(classRep) && hasFlatName(classRep) == flat &&
               isAbsent(classRep))
             initializeFromClassPath(root.symbol, classRep)
       }

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

@@ -170,7 +170,15 @@ class MergeError(val sym1: Symbol, val sym2: Symbol, val tp1: Type, val tp2: Typ
   }
 
   protected def addendum(implicit ctx: Context): String =
-    if (prefix `eq` NoPrefix) "" else i"\nas members of type $prefix"
+    if (prefix `eq` NoPrefix) ""
+    else {
+      val owner = prefix match {
+        case prefix: ThisType => prefix.cls.show
+        case prefix: TermRef => prefix.symbol.show
+        case _ => i"type $prefix"
+      }
+      s"\nas members of $owner"
+    }
 
   override def toMessage(implicit ctx: Context): Message = {
     if (ctx.debug) printStackTrace()

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/core/tasty/TreeUnpickler.scala

@@ -1013,11 +1013,20 @@ class TreeUnpickler(reader: TastyReader,
         }
       }
 
-      def completeSelect(name: Name, tpf: Type => NamedType): Select = {
+      def completeSelect(name: Name, sig: Signature): Select = {
         val localCtx =
           if (name == nme.CONSTRUCTOR) ctx.addMode(Mode.InSuperCall) else ctx
         val qual = readTerm()(localCtx)
-        ConstFold(untpd.Select(qual, name).withType(tpf(qual.tpe.widenIfUnstable)))
+        var pre = qual.tpe.widenIfUnstable
+        val denot = accessibleDenot(pre, name, sig)
+        val owner = denot.symbol.maybeOwner
+        if (owner.isPackageObject && pre.termSymbol.is(Package))
+          pre = pre.select(owner.sourceModule)
+        val tpe = name match {
+          case name: TypeName => TypeRef(pre, name, denot)
+          case name: TermName => TermRef(pre, name, denot)
+        }
+        ConstFold(untpd.Select(qual, name).withType(tpe))
       }
 
       def readQualId(): (untpd.Ident, TypeRef) = {
@@ -1039,15 +1048,13 @@ class TreeUnpickler(reader: TastyReader,
         case IDENTtpt =>
           untpd.Ident(readName().toTypeName).withType(readType())
         case SELECT =>
-          def readRest(name: TermName, sig: Signature): Tree =
-            completeSelect(name, pre => TermRef(pre, name, accessibleDenot(pre, name, sig)))
           readName() match {
-            case SignedName(name, sig) => readRest(name, sig)
-            case name => readRest(name, Signature.NotAMethod)
+            case SignedName(name, sig) => completeSelect(name, sig)
+            case name => completeSelect(name, Signature.NotAMethod)
           }
         case SELECTtpt =>
           val name = readName().toTypeName
-          completeSelect(name, pre => TypeRef(pre, name, accessibleDenot(pre, name, Signature.NotAMethod)))
+          completeSelect(name, Signature.NotAMethod)
         case QUALTHIS =>
           val (qual, tref) = readQualId()
           untpd.This(qual).withType(ThisType.raw(tref))