Change scheme to name package object wrappers

It's now src$package instead of src#object

Author: odersky

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          = "$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/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)
       }

docs/docs/reference/dropped-features/package-objects.md

@@ -20,5 +20,4 @@ Package objects are no longer needed since all kinds of definitions and statemen
 ```
 There may be several source files in a package containing such toplevel definitions, and source files can freely mix toplevel value, method, and tyoe definitions with classes and objects.
 
-The compiler generates synthetic objects that wrap toplevel statements that are not imports, or class or object definitions. If a source file `src.scala` contains such toplevel statements, they will be put in a synthetic object named `src#object`. The wrapping is transparent, however. The definitions in `f` can still be accessed
-as members of the enclosing package.
+The compiler generates synthetic objects that wrap toplevel statements that are not imports, or class or object definitions. If a source file `src.scala` contains such toplevel statements, they will be put in a synthetic object named `src$package`. The wrapping is transparent, however. The definitions in `f` can still be accessed as members of the enclosing package.