Remove dead code

 - unexpandedName in names that cannot be expanded
 - meregTypeParamsAndAliases in TreeUnpickler (there are no such aliases anymore).
 - ModuleVarName

Author: odersky

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

@@ -67,7 +67,7 @@ class Definitions {
     enterTypeField(cls, name, flags | ClassTypeParamCreationFlags, scope)
 
   private def enterSyntheticTypeParam(cls: ClassSymbol, paramFlags: FlagSet, scope: MutableScope, suffix: String = "T0") =
-    enterTypeParam(cls, suffix.toTypeName.expandedName(cls), paramFlags, scope)
+    enterTypeParam(cls, suffix.toTypeName, paramFlags, scope)
 
   // NOTE: Ideally we would write `parentConstrs: => Type*` but SIP-24 is only
   // implemented in Dotty and not in Scala 2.

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

@@ -358,7 +358,6 @@ object NameKinds {
       override def mkString(underlying: TermName, info: ThisInfo) = underlying.toString
   }
   val ExtMethName = new SuffixNameKind(EXTMETH, "$extension")
-  val ModuleVarName = new SuffixNameKind(OBJECTVAR, "$module")
   val ModuleClassName = new SuffixNameKind(OBJECTCLASS, "$", optInfoString = "ModuleClass")
   val ImplMethName = new SuffixNameKind(IMPLMETH, "$")
   val AdaptedClosureName = new SuffixNameKind(ADAPTEDCLOSURE, "$adapted") { override def definesNewName = true }

compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala

@@ -198,7 +198,7 @@ class ClassfileParser(
     var sym = classRoot.owner
     while (sym.isClass && !(sym is Flags.ModuleClass)) {
       for (tparam <- sym.typeParams) {
-        classTParams = classTParams.updated(tparam.name.unexpandedName, tparam)
+        classTParams = classTParams.updated(tparam.name, tparam)
       }
       sym = sym.owner
     }

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

@@ -763,20 +763,9 @@ class TreeUnpickler(reader: TastyReader, nameAtRef: NameRef => TermName, posUnpi
       cls.setNoInitsFlags(fork.indexStats(end))
       val constr = readIndexedDef().asInstanceOf[DefDef]
 
-      def mergeTypeParamsAndAliases(tparams: List[TypeDef], stats: List[Tree])(implicit ctx: Context): (List[Tree], List[Tree]) =
-        (tparams, stats) match {
-          case (tparam :: tparams1, (alias: TypeDef) :: stats1)
-          if tparam.name == alias.name.expandedName(cls) =>
-            val (tas, stats2) = mergeTypeParamsAndAliases(tparams1, stats1)
-            (tparam :: alias :: tas, stats2)
-          case _ =>
-            (tparams, stats)
-        }
-
       val lazyStats = readLater(end, rdr => implicit ctx => {
-        val stats0 = rdr.readIndexedStats(localDummy, end)
-        val (tparamsAndAliases, stats) = mergeTypeParamsAndAliases(tparams, stats0)
-        tparamsAndAliases ++ vparams ++ stats
+        val stats = rdr.readIndexedStats(localDummy, end)
+        tparams ++ vparams ++ stats
       })
       setPos(start,
         untpd.Template(constr, parents, self, lazyStats)

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

@@ -656,7 +656,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
     if (tree.exists(!_.isEmpty)) encl(blockText(tree)) else ""
 
   override protected def ParamRefNameString(name: Name): String =
-    name.unexpandedName.invariantName.toString
+    name.invariantName.toString
 
   override protected def treatAsTypeParam(sym: Symbol): Boolean = sym is TypeParam
 

compiler/src/dotty/tools/dotc/transform/FullParameterization.scala

@@ -98,7 +98,7 @@ trait FullParameterization {
       case _ => (0, info)
     }
     val ctparams = if (abstractOverClass) clazz.typeParams else Nil
-    val ctnames = ctparams.map(_.name.unexpandedName)
+    val ctnames = ctparams.map(_.name)
     val ctvariances = ctparams.map(_.variance)
 
     /** The method result type */