Add Variant NameInfo

Plus further bug fixes.

Author: odersky

compiler/src/dotty/tools/dotc/core/NameInfos.scala

@@ -20,8 +20,9 @@ object NameInfo {
 
   val TermNameKind = 0
   val QualifiedKind = 1
-  val ModuleClassKind = 2
   val DefaultGetterKind = 3
+  val VariantKind = 4
+  val ModuleClassKind = 10
 
   val qualifier: Map[String, SimpleTermName => Qualified] =
     Map("."  -> Select,
@@ -81,9 +82,18 @@ object NameInfo {
     }
   }
 
+  case class Variant(val num: Int) extends Numbered {
+    def kind = VariantKind
+    def mkString(underlying: TermName) = varianceToPrefix(num).toString + underlying
+  }
+
   val ModuleClass = new NameInfo {
     def kind = ModuleClassKind
     def mkString(underlying: TermName) = underlying + "$"
     override def toString = "ModuleClass"
   }
+
+  /** Map between variances and name prefixes */
+  val varianceToPrefix = Map(-1 -> '-', 0 -> '=', 1 -> '+')
+  val prefixToVariance = Map('-' -> -1, '=' -> 0, '+' -> 1)
 }

compiler/src/dotty/tools/dotc/core/Names.scala

@@ -482,8 +482,9 @@ object Names {
   val CONSTRUCTOR: TermName = termName("<init>")
   val STATIC_CONSTRUCTOR: TermName = termName("<clinit>")
   val EMPTY_PACKAGE: TermName = termName("<empty>")
+  val REFINEMENT: TermName = termName("<refinement>")
 
-  val dontEncode = Set(CONSTRUCTOR, EMPTY_PACKAGE)
+  val dontEncode = Set(CONSTRUCTOR, EMPTY_PACKAGE, REFINEMENT)
 
   def termNameBuilder: Builder[Char, TermName] =
     StringBuilder.newBuilder.mapResult(termName)

compiler/src/dotty/tools/dotc/core/StdNames.scala

@@ -544,7 +544,7 @@ object StdNames {
 
     val nothingClass: N         = "Nothing$"
     val nullClass: N            = "Null$"
-    
+
     val falseModuleClassNames = Set(nothingClass, nullClass, nothingRuntimeClass, nullRuntimeClass)
 
     // unencoded operators

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

@@ -388,21 +388,18 @@ object SymDenotations {
      *  enclosing packages do not form part of the name.
      */
     def fullNameSeparated(separator: String)(implicit ctx: Context): Name = {
-      var sep = separator
-      var stopAtPackage = false
-      if (sep.isEmpty) {
-        sep = "$"
-        stopAtPackage = true
-      }
+      val stopAtPackage = separator.isEmpty
+      val sep = if (stopAtPackage) "$" else separator
       if (symbol == NoSymbol ||
           owner == NoSymbol ||
           owner.isEffectiveRoot ||
           stopAtPackage && owner.is(PackageClass)) name
       else {
+        var filler = ""
         var encl = owner
         while (!encl.isClass && !encl.isPackageObject) {
           encl = encl.owner
-          sep += "~"
+          filler += "~"
         }
         var prefix = encl.fullNameSeparated(separator)
         val fn =
@@ -411,14 +408,17 @@ object SymDenotations {
               // duplicate scalac's behavior: don't write a double '$$' for module class members.
               prefix = prefix.exclude(NameInfo.ModuleClassKind)
             name rewrite {
-              case n: SimpleTermName => prefix.derived(NameInfo.qualifier(sep)(n))
+              case n: SimpleTermName =>
+                val n1 = if (filler.isEmpty) n else termName(filler ++ n)
+                prefix.derived(NameInfo.qualifier(sep)(n1))
             }
           }
           else {
-            if (owner.is(ModuleClass, butNot = Package) && sep == "$")
-              // duplicate scalac's behavior: don't write a double '$$' for module class members.
-              sep = ""
-            prefix ++ sep ++ name
+            val sep1 =
+              if (owner.is(ModuleClass, butNot = Package) && sep == "$") ""
+              else sep
+            // duplicate scalac's behavior: don't write a double '$$' for module class members.
+            prefix ++ sep1 ++ name
           }
         if (isType) fn.toTypeName else fn.toTermName
       }

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

@@ -1793,7 +1793,7 @@ object Types {
     override def newLikeThis(prefix: Type)(implicit ctx: Context): TermRef =
       fixDenot(TermRef.withSig(prefix, name, sig), prefix)
 
-    override def shadowed(implicit ctx: Context): NamedType = 
+    override def shadowed(implicit ctx: Context): NamedType =
       fixDenot(TermRef.withSig(prefix, name.shadowedName, sig), prefix)
 
     override def equals(that: Any) = that match {

compiler/src/dotty/tools/dotc/core/tasty/NameBuffer.scala

@@ -38,6 +38,8 @@ class NameBuffer extends TastyBuffer(10000) {
         tcon(nameIndex(prefix, toTasty), nameIndex(qual.name))
       case DerivedTermName(prefix, NameInfo.DefaultGetter(num)) =>
         DefaultGetter(nameIndex(prefix, toTasty), num)
+      case DerivedTermName(prefix, NameInfo.Variant(sign)) =>
+        Variant(nameIndex(prefix, toTasty), sign)
       case name1 =>
         if (name1.isShadowedName) Shadowed(nameIndex(name1.revertShadowed, toTasty))
         else toTasty(name1.asSimpleName)
@@ -102,6 +104,9 @@ class NameBuffer extends TastyBuffer(10000) {
     case Shadowed(original) =>
       writeByte(SHADOWED)
       withLength { writeNameRef(original) }
+    case Variant(original, sign) =>
+      writeByte(VARIANT)
+      withLength { writeNameRef(original); writeNat(sign + 1) }
   }
 
   override def assemble(): Unit = {

compiler/src/dotty/tools/dotc/core/tasty/TastyFormat.scala

@@ -228,6 +228,7 @@ object TastyFormat {
   final val SUPERACCESSOR = 7
   final val DEFAULTGETTER = 8
   final val SHADOWED = 9
+  final val VARIANT = 10
 
   // AST tags
 
@@ -410,11 +411,14 @@ object TastyFormat {
   def nameTagToString(tag: Int): String = tag match {
     case UTF8 => "UTF8"
     case QUALIFIED => "QUALIFIED"
-    case SIGNED => "SIGNED"
+    case FLATTENED => "FLATTENED"
     case EXPANDED => "EXPANDED"
+    case SIGNED => "SIGNED"
     case OBJECTCLASS => "OBJECTCLASS"
     case SUPERACCESSOR => "SUPERACCESSOR"
     case DEFAULTGETTER => "DEFAULTGETTER"
+    case SHADOWED => "SHADOWED"
+    case VARIANT => "VARIANT"
   }
 
   def astTagToString(tag: Int): String = tag match {
@@ -547,8 +551,4 @@ object TastyFormat {
     case POLYtype | METHODtype => -1
     case _ => 0
   }
-
-  /** Map between variances and name prefixes */
-  val varianceToPrefix = Map(-1 -> '-', 0 -> '=', 1 -> '+')
-  val prefixToVariance = Map('-' -> -1, '=' -> 0, '+' -> 1)
 }

compiler/src/dotty/tools/dotc/core/tasty/TastyName.scala

@@ -21,6 +21,7 @@ object TastyName {
   case class SuperAccessor(accessed: NameRef) extends TastyName
   case class DefaultGetter(method: NameRef, num: Int) extends TastyName
   case class Shadowed(original: NameRef) extends TastyName
+  case class Variant(original: NameRef, sign: Int) extends TastyName
 
   class Table extends (NameRef => TastyName) {
     private val names = new mutable.ArrayBuffer[TastyName]

compiler/src/dotty/tools/dotc/core/tasty/TastyUnpickler.scala

@@ -62,6 +62,8 @@ class TastyUnpickler(reader: TastyReader) {
         DefaultGetter(readNameRef(), readNat())
       case SHADOWED =>
         Shadowed(readNameRef())
+      case VARIANT =>
+        Variant(readNameRef(), readNat() - 1)
     }
     assert(currentAddr == end, s"bad name $result $start $currentAddr $end")
     result

compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala

@@ -13,6 +13,7 @@ import NameOps._
 import StdNames.nme
 import TastyBuffer._
 import TypeApplications._
+import config.Config
 
 class TreePickler(pickler: TastyPickler) {
   val buf = new TreeBuffer
@@ -256,7 +257,10 @@ class TreePickler(pickler: TastyPickler) {
     case tpe: PolyType =>
       writeByte(POLYtype)
       val paramNames = tpe.typeParams.map(tparam =>
-        (varianceToPrefix(tparam.paramVariance) +: tparam.paramName.toString).toTypeName)
+        if (Config.semanticNames)
+          tparam.paramName.derived(NameInfo.Variant(tparam.paramVariance))
+        else
+          (NameInfo.varianceToPrefix(tparam.paramVariance) +: tparam.paramName.toString).toTypeName)
       pickleMethodic(tpe.resultType, paramNames, tpe.paramBounds)
     case tpe: MethodType if richTypes =>
       writeByte(METHODtype)

compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala

@@ -91,6 +91,7 @@ class TreeUnpickler(reader: TastyReader, tastyName: TastyName.Table, posUnpickle
     case ModuleClass(original) => toTermName(original).moduleClassName.toTermName
     case SuperAccessor(accessed) => toTermName(accessed).superName
     case DefaultGetter(meth, num) => toTermName(meth).defaultGetterName(num)
+    case Variant(original, sign) => toTermName(original).derived(NameInfo.Variant(sign))
   }
 
   private def qualTermName(qual: NameRef, name: NameRef, sep: String) =
@@ -280,8 +281,14 @@ class TreeUnpickler(reader: TastyReader, tastyName: TastyName.Table, posUnpickle
               TypeRef.withFixedSym(NoPrefix, sym.name, sym)
             case POLYtype =>
               val (rawNames, paramReader) = readNamesSkipParams
-              val (variances, paramNames) = rawNames
-                .map(name => (prefixToVariance(name.head), name.tail.toTypeName)).unzip
+              val (variances, paramNames) = rawNames // !!! check integration with lambdas
+                .map(name =>
+                  if (Config.semanticNames) {
+                    val DerivedTermName(n, NameInfo.Variant(v)) = name
+                    (v, n.toTypeName)
+                  }
+                  else
+                    (NameInfo.prefixToVariance(name.head), name.tail.toTypeName)).unzip
               val result = PolyType(paramNames, variances)(
                 pt => registeringType(pt, paramReader.readParamTypes[TypeBounds](end)),
                 pt => readType())

compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala

@@ -97,11 +97,7 @@ class PlainPrinter(_ctx: Context) extends Printer {
     || (sym.name == nme.PACKAGE)               // package
   )
 
-  def nameString(name: Name): String = name.toString + {
-    if (ctx.settings.debugNames.value)
-      if (name.isTypeName) "/T" else "/V"
-    else ""
-  }
+  def nameString(name: Name): String = name.toString
 
   def toText(name: Name): Text = Str(nameString(name))