Produce expanded names.

In the absence of semantic names, this is kludgey. But we need to do it because
otherwise the ExpandedName flag is not correctly set.

7 files changed, 32 insertions, 15 deletions

diff --git a/src/dotty/tools/dotc/core/NameOps.scala b/src/dotty/tools/dotc/core/NameOps.scala
index 60e429bb3..13ff92a8a 100644
--- a/src/dotty/tools/dotc/core/NameOps.scala
+++ b/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)
 
diff --git a/src/dotty/tools/dotc/core/pickling/NameBuffer.scala b/src/dotty/tools/dotc/core/pickling/NameBuffer.scala
index be557f0b1..a60767fe6 100644
--- a/src/dotty/tools/dotc/core/pickling/NameBuffer.scala
+++ b/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) }
diff --git a/src/dotty/tools/dotc/core/pickling/TastyName.scala b/src/dotty/tools/dotc/core/pickling/TastyName.scala
index 8508d7ffa..e8f30a234 100644
--- a/src/dotty/tools/dotc/core/pickling/TastyName.scala
+++ b/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
diff --git a/src/dotty/tools/dotc/core/pickling/TastyPrinter.scala b/src/dotty/tools/dotc/core/pickling/TastyPrinter.scala
index 91cc168ea..a3d30b9b2 100644
--- a/src/dotty/tools/dotc/core/pickling/TastyPrinter.scala
+++ b/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
diff --git a/src/dotty/tools/dotc/core/pickling/TastyUnpickler.scala b/src/dotty/tools/dotc/core/pickling/TastyUnpickler.scala
index e5eabaf36..b5e978afa 100644
--- a/src/dotty/tools/dotc/core/pickling/TastyUnpickler.scala
+++ b/src/dotty/tools/dotc/core/pickling/TastyUnpickler.scala
@@ -51,7 +51,7 @@ class TastyUnpickler(reader: TastyReader) {
         val params = until(end)(readNameRef())
         Signed(original, params, result)
       case EXPANDED =>
-        Expanded(readNameRef())
+        Expanded(readNameRef(), readNameRef())
       case OBJECTCLASS =>
         ModuleClass(readNameRef())
       case SUPERACCESSOR =>
diff --git a/src/dotty/tools/dotc/core/pickling/TreePickler.scala b/src/dotty/tools/dotc/core/pickling/TreePickler.scala
index c5e07ffa9..14a92e8e6 100644
--- a/src/dotty/tools/dotc/core/pickling/TreePickler.scala
+++ b/src/dotty/tools/dotc/core/pickling/TreePickler.scala
@@ -8,6 +8,7 @@ import PickleFormat._
 import core._
 import Contexts._, Symbols._, Types._, Names._, Constants._, Decorators._, Annotations._, StdNames.tpnme, NameOps._
 import collection.mutable
+import NameOps._
 import TastyBuffer._
 
 class TreePickler(pickler: TastyPickler) {
@@ -61,13 +62,19 @@ class TreePickler(pickler: TastyPickler) {
     }
   }
 
-  private def pickleName(name: Name) = writeNat(nameIndex(name).index)
-  private def pickleName(name: TastyName) = writeNat(nameIndex(name).index)
+  private def pickleName(name: Name): Unit = writeNat(nameIndex(name).index)
+  private def pickleName(name: TastyName): Unit = writeNat(nameIndex(name).index)
   private def pickleNameAndSig(name: Name, sig: Signature) = {
     val Signature(params, result) = sig
     pickleName(TastyName.Signed(nameIndex(name), params.map(fullNameIndex), fullNameIndex(result)))
   }
-
+  
+  private def pickleName(sym: Symbol)(implicit ctx: Context): Unit =
+    if (sym is Flags.ExpandedName) 
+      pickleName(TastyName.Expanded(
+        nameIndex(sym.name.expandedPrefix), nameIndex(sym.name.unexpandedName)))
+    else pickleName(sym.name)
+      
   private def pickleSymRef(sym: Symbol)(implicit ctx: Context) = symRefs.get(sym) match {
     case Some(label) =>
       if (label != NoAddr) writeRef(label) else pickleForwardSymRef(sym)
@@ -464,7 +471,7 @@ class TreePickler(pickler: TastyPickler) {
       registerDef(sym)
       writeByte(tag)
       withLength {
-        pickleName(sym.name)
+        pickleName(sym)
         pickleParams
         tpt match {
           case tpt: TypeTree => pickleTpt(tpt)
diff --git a/src/dotty/tools/dotc/core/pickling/TreeUnpickler.scala b/src/dotty/tools/dotc/core/pickling/TreeUnpickler.scala
index 3d4ac4684..ed0841e3a 100644
--- a/src/dotty/tools/dotc/core/pickling/TreeUnpickler.scala
+++ b/src/dotty/tools/dotc/core/pickling/TreeUnpickler.scala
@@ -70,7 +70,7 @@ class TreeUnpickler(reader: TastyReader, tastyName: TastyName.Table) {
     case Qualified(qual, name) => toTermName(qual) ++ "." ++ toTermName(name)
     case Signed(original, params, result) => toTermName(original)
     case Shadowed(original) => toTermName(original).shadowedName
-    case Expanded(original) => ???
+    case Expanded(prefix, original) => toTermName(original).expandedName(toTermName(prefix)) 
     case ModuleClass(original) => toTermName(original).moduleClassName.toTermName
     case SuperAccessor(accessed) => ???
     case DefaultGetter(meth, num) => ???
@@ -334,7 +334,7 @@ class TreeUnpickler(reader: TastyReader, tastyName: TastyName.Table) {
         flags = flags | (if (tag == VALDEF) ModuleCreationFlags else ModuleClassCreationFlags)
       if (ctx.mode.is(Mode.InSuperCall) && !flags.is(ParamOrAccessor)) flags |= InSuperCall
       if (ctx.owner.isClass) {
-        if (tag == TYPEPARAM) flags |= Param | ExpandedName // TODO check name to determine ExpandedName
+        if (tag == TYPEPARAM) flags |= Param
         else if (tag == PARAM) flags |= ParamAccessor
       }
       else if (isParamTag(tag)) flags |= Param
@@ -348,7 +348,9 @@ class TreeUnpickler(reader: TastyReader, tastyName: TastyName.Table) {
       val start = currentAddr
       val tag = readByte()
       val end = readEnd()
-      val name = if (tag == TYPEDEF || tag == TYPEPARAM) readName().toTypeName else readName()
+      val rawName = tastyName(readNameRef())
+      var name: Name = toTermName(rawName)
+      if (tag == TYPEDEF || tag == TYPEPARAM) name = name.toTypeName
       skipParams()
       val isAbstractType = nextByte == TYPEBOUNDS
       val isClass = nextByte == TEMPLATE
@@ -357,8 +359,9 @@ class TreeUnpickler(reader: TastyReader, tastyName: TastyName.Table) {
       val rhsIsEmpty = noRhs(end)
       if (!rhsIsEmpty) skipTree()
       val (givenFlags, annots, privateWithin) = readModifiers(end)
+      val expandedFlag = if (rawName.isInstanceOf[TastyName.Expanded]) ExpandedName else EmptyFlags
       pickling.println(i"creating symbol $name at $start with flags $givenFlags")
-      val flags = normalizeFlags(tag, givenFlags, name, isAbstractType, rhsIsEmpty)
+      val flags = normalizeFlags(tag, givenFlags | expandedFlag, name, isAbstractType, rhsIsEmpty)
       def adjustIfModule(completer: LazyType) = 
         if (flags is Module) ctx.adjustModuleCompleter(completer, name) else completer
       val sym =