Merge pull request #465 from dotty-staging/fix/pickling

Fix/pickling

Author: DarkDimius

src/dotty/tools/dotc/config/JavaPlatform.scala

@@ -4,9 +4,8 @@ package config
 
 import io.{AbstractFile,ClassPath,JavaClassPath,MergedClassPath,DeltaClassPath}
 import ClassPath.{ JavaContext, DefaultJavaContext }
-import core.Contexts._
-import core.SymDenotations._, core.Symbols._, dotty.tools.dotc.core._
-import Types._, Contexts._, Symbols._, Denotations._, SymDenotations._, StdNames._, Names._
+import core._
+import Symbols._, Types._, Contexts._, Denotations._, SymDenotations._, StdNames._, Names._
 import Flags._, Scopes._, Decorators._, NameOps._, util.Positions._
 
 class JavaPlatform extends Platform {

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

@@ -476,12 +476,14 @@ object Denotations {
     /** The version of this SingleDenotation that was valid in the first phase
      *  of this run.
      */
-    def initial: SingleDenotation = {
-      var current = nextInRun
-      while (current.validFor.code > this.myValidFor.code) current = current.nextInRun
-      current
-    }
-
+    def initial: SingleDenotation = 
+      if (validFor == Nowhere) this
+      else {
+        var current = nextInRun
+        while (current.validFor.code > this.myValidFor.code) current = current.nextInRun
+        current
+      }
+      
     def history: List[SingleDenotation] = {
       val b = new ListBuffer[SingleDenotation]
       var current = initial
@@ -493,6 +495,9 @@ object Denotations {
       b.toList
     }
 
+    /** Invalidate all caches and fields that depend on base classes and their contents */
+    def invalidateInheritedInfo(): Unit = ()
+ 
     /** Move validity period of this denotation to a new run. Throw a StaleSymbol error
      *  if denotation is no longer valid.
      */
@@ -502,9 +507,10 @@ object Denotations {
         var d: SingleDenotation = denot
         do {
           d.validFor = Period(ctx.period.runId, d.validFor.firstPhaseId, d.validFor.lastPhaseId)
+          d.invalidateInheritedInfo()
           d = d.nextInRun
         } while (d ne denot)
-        syncWithParents
+        this
       case _ =>
         if (coveredInterval.containsPhaseId(ctx.phaseId)) staleSymbolError
         else NoDenotation
@@ -611,16 +617,13 @@ object Denotations {
         val current = symbol.current
         // println(s"installing $this after $phase/${phase.id}, valid = ${current.validFor}")
         // printPeriods(current)
-        if (current.nextInRun ne current)
-          this.nextInRun = current.nextInRun
-        else
-          this.nextInRun = this
         this.validFor = Period(ctx.runId, targetId, current.validFor.lastPhaseId)
         if (current.validFor.firstPhaseId == targetId) {
           // replace current with this denotation
           var prev = current
           while (prev.nextInRun ne current) prev = prev.nextInRun
           prev.nextInRun = this
+          this.nextInRun = current.nextInRun
           current.validFor = Nowhere
         } else {
           // insert this denotation after current

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

@@ -147,20 +147,26 @@ object NameOps {
     /** The superaccessor for method with given name */
     def superName: TermName =  (nme.SUPER_PREFIX ++ name).toTermName
 
-    /** The expanded name of `name` relative to this class `base` with given `separator`
+    /** The expanded name of `name` relative to given class `base`.
      */
     def expandedName(base: Symbol)(implicit ctx: Context): N =
       expandedName(if (base is Flags.ExpandedName) base.name else base.fullNameSeparated('$'))
 
     /** The expanded name of `name` relative to `basename` with given `separator`
      */
-    def expandedName(prefix: Name)(implicit ctx: Context): N =
+    def expandedName(prefix: Name): N =
       name.fromName(prefix ++ nme.EXPAND_SEPARATOR ++ name).asInstanceOf[N]
 
     def unexpandedName: N = {
       val idx = name.lastIndexOfSlice(nme.EXPAND_SEPARATOR)
       if (idx < 0) name else (name drop (idx + nme.EXPAND_SEPARATOR.length)).asInstanceOf[N]
     }
+    
+    def expandedPrefix: N = {
+      val idx = name.lastIndexOfSlice(nme.EXPAND_SEPARATOR)
+      assert(idx >= 0)
+      name.take(idx).asInstanceOf[N]
+    }
 
     def shadowedName: N = likeTyped(nme.SHADOWED ++ name)
 

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

@@ -41,15 +41,19 @@ trait SymDenotations { this: Context =>
 
   def stillValid(denot: SymDenotation): Boolean =
     if (denot is ValidForever) true
-    else try {
-      val owner = denot.owner.denot
-      stillValid(owner) && (
-           !owner.isClass
-        || (owner.unforcedDecls.lookupAll(denot.name) contains denot.symbol)
-        || denot.isSelfSym
-        )
-    } catch {
-      case ex: StaleSymbol => false
+    else {
+      val initial = denot.initial
+      if (initial ne denot) 
+        ctx.withPhase(initial.validFor.firstPhaseId).stillValid(initial.asSymDenotation)
+      else try {
+        val owner = denot.owner.denot
+        stillValid(owner) && (
+          !owner.isClass
+          || (owner.unforcedDecls.lookupAll(denot.name) contains denot.symbol)
+          || denot.isSelfSym)
+      } catch {
+        case ex: StaleSymbol => false
+      }
     }
 }
 
@@ -70,6 +74,12 @@ object SymDenotations {
 
     override def hasUniqueSym: Boolean = exists
 
+    /** Debug only
+    override def validFor_=(p: Period) = {
+      super.validFor_=(p)
+    }
+    */
+    
     // ------ Getting and setting fields -----------------------------
 
     private[this] var myFlags: FlagSet = adaptFlags(initFlags)
@@ -171,13 +181,13 @@ object SymDenotations {
       myInfo = tp
     }
 
-    /** The name, except 
-     *   - if this is a module class, strip the module class suffix 
-     *   - if this is a companion object with a clash-avoiding name, strip the 
+    /** The name, except
+     *   - if this is a module class, strip the module class suffix
+     *   - if this is a companion object with a clash-avoiding name, strip the
      *     "avoid clash" suffix
      */
     def effectiveName(implicit ctx: Context) =
-      if (this is ModuleClass) name.stripModuleClassSuffix 
+      if (this is ModuleClass) name.stripModuleClassSuffix
       else name.stripAvoidClashSuffix
 
     /** The privateWithin boundary, NoSymbol if no boundary is given.
@@ -195,7 +205,7 @@ object SymDenotations {
 
     /** Update the annotations of this denotation */
     private[core] final def annotations_=(annots: List[Annotation]): Unit =
-       myAnnotations = annots
+      myAnnotations = annots
 
     /** Does this denotation have an annotation matching the given class symbol? */
     final def hasAnnotation(cls: Symbol)(implicit ctx: Context) =
@@ -241,9 +251,9 @@ object SymDenotations {
     /** The symbols defined in this class or object.
      *  Careful! This does not force the type, so is compilation order dependent.
      *  This method should be used only in the following circumstances:
-     *  
-     *  1. When accessing type parameters or type parameter accessors (both are entered before 
-     *     completion). 
+     *
+     *  1. When accessing type parameters or type parameter accessors (both are entered before
+     *     completion).
      *  2. When obtaining the current scope in order to enter, rename or delete something there.
      *  3. When playing it safe in order not to raise CylicReferences, e.g. for printing things
      *     or taking more efficient shortcuts (e.g. the stillValid test).
@@ -292,7 +302,6 @@ object SymDenotations {
         if (isType) fn.toTypeName else fn.toTermName
       }
 
-
     /** The encoded flat name of this denotation, where joined names are separated by `separator` characters. */
     def flatName(separator: Char = '$')(implicit ctx: Context): Name =
       if (symbol == NoSymbol || owner == NoSymbol || owner.isEffectiveRoot || (owner is PackageClass)) name
@@ -457,7 +466,7 @@ object SymDenotations {
     }
 
     /** Is this a user defined "def" method? Excluded are accessors and anonymous functions. */
-    final def isSourceMethod(implicit ctx: Context) = 
+    final def isSourceMethod(implicit ctx: Context) =
       this.is(Method, butNot = AccessorOrLabel) && !isAnonymousFunction
 
     /** Is this a setter? */
@@ -649,7 +658,7 @@ object SymDenotations {
      */
     /** The class implementing this module, NoSymbol if not applicable. */
     final def moduleClass(implicit ctx: Context): Symbol = {
-      def notFound = {println(s"missing module class for $name: $myInfo"); NoSymbol}
+      def notFound = { println(s"missing module class for $name: $myInfo"); NoSymbol }
       if (this is ModuleVal)
         myInfo match {
           case info: TypeRef           => info.symbol
@@ -1002,7 +1011,7 @@ object SymDenotations {
       s"$kindString $name"
     }
 
-    def debugString = toString+"#"+symbol.id // !!! DEBUG
+    def debugString = toString + "#" + symbol.id // !!! DEBUG
 
     // ----- copies and transforms  ----------------------------------------
 
@@ -1097,8 +1106,8 @@ object SymDenotations {
 
     private var firstRunId: RunId = initRunId
 
-    /** If caches influenced by parent classes are still valid, the denotation
-     *  itself, otherwise a freshly initialized copy.
+    /** invalidate caches influenced by parent classes if one of the parents
+     *  is younger than the denotation itself.
      */
     override def syncWithParents(implicit ctx: Context): SingleDenotation = {
       def isYounger(tref: TypeRef) = tref.symbol.denot match {
@@ -1124,7 +1133,7 @@ object SymDenotations {
     }
 
     /** Invalidate all caches and fields that depend on base classes and their contents */
-    private def invalidateInheritedInfo(): Unit = {
+    override def invalidateInheritedInfo(): Unit = {
       myBaseClasses = null
       mySuperClassBits = null
       myMemberFingerPrint = FingerPrint.unknown
@@ -1168,7 +1177,7 @@ object SymDenotations {
     private[this] var myBaseClasses: List[ClassSymbol] = null
     private[this] var mySuperClassBits: BitSet = null
 
-	  /** Invalidate baseTypeRefCache, baseClasses and superClassBits on new run */
+    /** Invalidate baseTypeRefCache, baseClasses and superClassBits on new run */
     private def checkBasesUpToDate()(implicit ctx: Context) =
       if (baseTypeRefValid != ctx.runId) {
         baseTypeRefCache = new java.util.HashMap[CachedType, Type]

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

@@ -191,6 +191,17 @@ class TypeApplications(val self: Type) extends AnyVal {
       if (res.isInstantiatedLambda) res.select(tpnme.Apply) else res
     }
   }
+  
+  /** Simplify a fully instantiated type of the form `LambdaX{... type Apply = T } # Apply` to `T`. 
+   */
+  def simplifyApply(implicit ctx: Context): Type = self match {
+    case self @ TypeRef(prefix, tpnme.Apply) if prefix.isInstantiatedLambda =>
+      prefix.member(tpnme.Apply).info match {
+        case TypeAlias(alias) => alias
+        case _ => self
+      }
+    case _ => self
+  }
 
   final def appliedTo(arg: Type)(implicit ctx: Context): Type = appliedTo(arg :: Nil)
   final def appliedTo(arg1: Type, arg2: Type)(implicit ctx: Context): Type = appliedTo(arg1 :: arg2 :: Nil)

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

@@ -480,7 +480,7 @@ object Types {
       case ex: MergeError =>
         throw new MergeError(s"${ex.getMessage} as members of type ${pre.show}")
       case ex: Throwable =>
-        println(i"findMember exception for $this: ${this.widen} member $name")
+        println(s"findMember exception for $this member $name")
         throw ex // DEBUG
     } finally {
       recCount -= 1
@@ -1158,7 +1158,7 @@ object Types {
     private[this] var lastDenotation: Denotation = _
     private[this] var lastSymbol: Symbol = _
     private[this] var checkedPeriod = Nowhere
-
+    
     // Invariants:
     // (1) checkedPeriod != Nowhere  =>  lastDenotation != null
     // (2) lastDenotation != null    =>  lastSymbol != null
@@ -1238,8 +1238,7 @@ object Types {
           // phase but a defined denotation earlier (e.g. a TypeRef to an abstract type
           // is undefined after erasure.) We need to be able to do time travel back and
           // forth also in these cases.
-          lastDenotation = d
-          lastSymbol = d.symbol
+          setDenot(d)
           checkedPeriod = ctx.period
         }
         d
@@ -1256,9 +1255,14 @@ object Types {
     private def checkSymAssign(sym: Symbol)(implicit ctx: Context) =
       assert(
         (lastSymbol eq sym) ||
-        (lastSymbol eq null) ||
-        (lastSymbol.defRunId != sym.defRunId) ||
-        (lastSymbol.defRunId == NoRunId) ||
+        (lastSymbol eq null) || {
+          val lastDefRunId = lastDenotation match {
+            case d: SymDenotation => d.validFor.runId
+            case _ => lastSymbol.defRunId
+          }
+          (lastDefRunId != sym.defRunId) ||
+          (lastDefRunId == NoRunId)
+        } ||
         (lastSymbol.infoOrCompleter == ErrorType ||
         defn.overriddenBySynthetic.contains(lastSymbol)
           // for overriddenBySynthetic symbols a TermRef such as SomeCaseClass.this.hashCode
@@ -1280,6 +1284,9 @@ object Types {
       if (Config.checkNoDoubleBindings)
         if (ctx.settings.YnoDoubleBindings.value)
           checkSymAssign(denot.symbol)
+
+      // additional checks that intercept `denot` can be added here
+      
       lastDenotation = denot
       lastSymbol = denot.symbol
     }

src/dotty/tools/dotc/core/pickling/NameBuffer.scala

@@ -65,9 +65,9 @@ class NameBuffer extends TastyBuffer(100000) {
     case Signed(original, params, result) => 
       writeByte(SIGNED)
       withLength { writeNameRef(original); writeNameRef(result); params.foreach(writeNameRef) }
-    case Expanded(original) =>
+    case Expanded(prefix, original) =>
       writeByte(EXPANDED)
-      withLength { writeNameRef(original) }
+      withLength { writeNameRef(prefix); writeNameRef(original) }
     case ModuleClass(module) =>
       writeByte(OBJECTCLASS)
       withLength { writeNameRef(module) }

src/dotty/tools/dotc/core/pickling/PickleFormat.scala

@@ -269,7 +269,7 @@ object PickleFormat {
   final val DOUBLEconst = 76
   final val STRINGconst = 77
   final val IMPORTED = 78
-  
+
   final val THIS = 96
   final val CLASSconst = 97
   final val ENUMconst = 98

src/dotty/tools/dotc/core/pickling/TastyName.scala

@@ -15,7 +15,7 @@ object TastyName {
   case class Simple(name: TermName) extends TastyName
   case class Qualified(qualified: NameRef, selector: NameRef) extends TastyName
   case class Signed(original: NameRef, params: List[NameRef], result: NameRef) extends TastyName 
-  case class Expanded(original: NameRef) extends TastyName
+  case class Expanded(prefix: NameRef, original: NameRef) extends TastyName
   case class ModuleClass(module: NameRef) extends TastyName
   case class SuperAccessor(accessed: NameRef) extends TastyName
   case class DefaultGetter(method: NameRef, num: Int) extends TastyName

src/dotty/tools/dotc/core/pickling/TastyPrinter.scala

@@ -5,6 +5,7 @@ package pickling
 import Contexts._, Decorators._
 import printing.Texts._
 import TastyName._
+import StdNames._
 import TastyUnpickler._
 import TastyBuffer.Addr
 import util.Positions.{Position, offsetToInt}
@@ -20,7 +21,7 @@ class TastyPrinter(bytes: Array[Byte])(implicit ctx: Context) {
     case Qualified(qual, name) => nameRefToString(qual) + "." + nameRefToString(name)
     case Signed(original, params, result) => 
       i"${nameRefToString(original)}@${params.map(nameRefToString)}%,%:${nameRefToString(result)}"
-    case Expanded(original) => nameRefToString(original) + "/EXPANDED"
+    case Expanded(prefix, original) => s"$prefix${nme.EXPAND_SEPARATOR}$original"
     case ModuleClass(original) => nameRefToString(original) + "/MODULECLASS"
     case SuperAccessor(accessed) => nameRefToString(accessed) + "/SUPERACCESSOR"
     case DefaultGetter(meth, num) => nameRefToString(meth) + "/DEFAULTGETTER" + num