Package denotations are never transformed

Packages should always have a single denotation, which is invariant for all transformations.
Package members should always be entered in the first phase, and should never be entered
after a given phase.

This reflects the fact that package members correspond to classfiles. Once you create a classfile, it
stays around and is available from the start of the next run. Also, we need to prevent multiple
denotation versions of packages from hanging on to stale symbols. It would not be enough to replace
a package member by a newly compiled one; if packages had multiple denotations we'd have to do this
for all of them.

Author: odersky

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

@@ -553,7 +553,9 @@ object Denotations {
                 startPid = cur.validFor.firstPhaseId
               else {
                 next match {
-                  case next: ClassDenotation => next.resetFlag(Frozen)
+                  case next: ClassDenotation =>
+                    assert(!next.is(Package), s"illegal transfomation of package denotation by transformer ${ctx.withPhase(transformer).phase}")
+                    next.resetFlag(Frozen)
                   case _ =>
                 }
                 next.nextInRun = cur.nextInRun

src/dotty/tools/dotc/core/Symbols.scala

@@ -382,7 +382,11 @@ object Symbols {
      */
     def enteredAfter(phase: DenotTransformer)(implicit ctx: Context): this.type = {
       val nextCtx = ctx.withPhase(phase.next)
-      this.owner.asClass.ensureFreshScopeAfter(phase)(nextCtx)
+      if (this.owner.is(Package)) {
+        denot.validFor |= InitialPeriod
+        if (this is Module) this.moduleClass.validFor |= InitialPeriod
+      }
+      else this.owner.asClass.ensureFreshScopeAfter(phase)(nextCtx)
       entered(nextCtx)
     }
 

src/dotty/tools/dotc/core/transform/Erasure.scala

@@ -145,12 +145,15 @@ class Erasure(isJava: Boolean, isSemi: Boolean, isConstructor: Boolean, wildcard
     case tp: PolyType =>
       this(tp.resultType)
     case tp @ ClassInfo(pre, cls, classParents, decls, _) =>
-      def eraseTypeRef(p: TypeRef) = this(p).asInstanceOf[TypeRef]
-      val parents: List[TypeRef] =
-        if ((cls eq defn.ObjectClass) || cls.isPrimitiveValueClass) Nil
-        else if (cls eq defn.ArrayClass) defn.ObjectClass.typeRef :: Nil
-        else removeLaterObjects(classParents.mapConserve(eraseTypeRef))
-      tp.derivedClassInfo(this(pre), parents, decls, this(tp.selfType))
+      if (cls is Package) tp
+      else {
+        def eraseTypeRef(p: TypeRef) = this(p).asInstanceOf[TypeRef]
+        val parents: List[TypeRef] =
+          if ((cls eq defn.ObjectClass) || cls.isPrimitiveValueClass) Nil
+          else if (cls eq defn.ArrayClass) defn.ObjectClass.typeRef :: Nil
+          else removeLaterObjects(classParents.mapConserve(eraseTypeRef))
+        tp.derivedClassInfo(this(pre), parents, decls, this(tp.selfType))
+      }
     case NoType | NoPrefix | ErrorType =>
       tp
     case tp: WildcardType if wildcardOK =>

src/dotty/tools/dotc/printing/RefinedPrinter.scala

@@ -109,7 +109,8 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
           return (toTextLocal(tycon) ~ "[" ~ Text(args map argText, ", ") ~ "]").close
         }
       case tp: TypeRef =>
-        if ((tp.symbol is TypeParam | TypeArgument | ExpandedName) && !ctx.phase.erasedTypes && !tp.symbol.isCompleting) {
+        val hideType = tp.symbol is TypeParam | TypeArgument | ExpandedName
+        if (hideType && !ctx.phase.erasedTypes && !tp.symbol.isCompleting) {
           tp.info match {
             case TypeAlias(hi) => return toText(hi)
             case _ => if (tp.prefix.isInstanceOf[ThisType]) return nameString(tp.symbol)