Desugar toplevel definitions

Author: odersky

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

@@ -1022,6 +1022,26 @@ object desugar {
     else Apply(ref(tupleTypeRef.classSymbol.companionModule.termRef), ts)
   }
 
+  /** Group all patterm, value and method definitions and all non-class type definitions
+   *  in an object named `<source>$object` where `<source>` is the name of the source file.
+   */
+  def packageDef(pdef: PackageDef)(implicit ctx: Context): PackageDef = {
+    def needsObject(stat: Tree) = stat match {
+      case _: ValDef | _: PatDef | _: DefDef => true
+      case stat: TypeDef => !stat.isClassDef
+      case _ => false
+    }
+    val (nestedStats, topStats) = pdef.stats.partition(needsObject)
+    if (nestedStats.isEmpty) pdef
+    else {
+      val sourceName = ctx.source.file.name.takeWhile(_ != '.')
+      val groupName = (sourceName ++ str.TOPLEVEL_SUFFIX).toTermName
+      val templ = Template(emptyConstructor, Nil, Nil, EmptyValDef, nestedStats)
+      val grouped = ModuleDef(groupName, templ)
+      cpy.PackageDef(pdef)(pdef.pid, grouped :: topStats)
+    }
+  }
+
   /** Make closure corresponding to function.
    *      params => body
    *  ==>

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          = "$object"
     final val NAME_JOIN                = "$"
     final val DEFAULT_GETTER           = "$default$"
     final val LOCALDUMMY_PREFIX        = "<local "       // owner of local blocks

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

@@ -416,17 +416,22 @@ class Namer { typer: Typer =>
   }
 
   /** Expand tree and store in `expandedTree` */
-  def expand(tree: Tree)(implicit ctx: Context): Unit = tree match {
-    case mdef: DefTree =>
-      val expanded = desugar.defTree(mdef)
-      typr.println(i"Expansion: $mdef expands to $expanded")
-      if (expanded ne mdef) mdef.pushAttachment(ExpandedTree, expanded)
-    case _ =>
+  def expand(tree: Tree)(implicit ctx: Context): Unit = {
+    def record(expanded: Tree) =
+      if (expanded `ne` tree) {
+        typr.println(i"Expansion: $tree expands to $expanded")
+        tree.pushAttachment(ExpandedTree, expanded)
+      }
+    tree match {
+      case tree: DefTree => record(desugar.defTree(tree))
+      case tree: PackageDef => record(desugar.packageDef(tree))
+      case _ =>
+    }
   }
 
   /** The expanded version of this tree, or tree itself if not expanded */
   def expanded(tree: Tree)(implicit ctx: Context): Tree = tree match {
-    case ddef: DefTree => ddef.attachmentOrElse(ExpandedTree, ddef)
+    case _: DefTree | _: PackageDef => tree.attachmentOrElse(ExpandedTree, tree)
     case _ => tree
   }
 

tests/run/toplevel-defs/defs.scala

@@ -0,0 +1 @@
+def hello(name: String) = s"hello, $name"