Drop Config.semanticNames option

We now handle only semantic names. Also, name extractor tags
and TASTY name tags are now aligned.

11 files changed, 97 insertions, 185 deletions

diff --git a/compiler/src/dotty/tools/dotc/config/Config.scala b/compiler/src/dotty/tools/dotc/config/Config.scala
index a225b3019..46b1896f1 100644
--- a/compiler/src/dotty/tools/dotc/config/Config.scala
+++ b/compiler/src/dotty/tools/dotc/config/Config.scala
@@ -10,8 +10,6 @@ object Config {
 
   final val checkCacheMembersNamed = false
 
-  final val semanticNames = true
-
   /** When updating a constraint bound, check that the constrained parameter
    *  does not appear at the top-level of either of its bounds.
    */
diff --git a/compiler/src/dotty/tools/dotc/core/NameExtractors.scala b/compiler/src/dotty/tools/dotc/core/NameExtractors.scala
index 2ffbf51e1..ec7f00d32 100644
--- a/compiler/src/dotty/tools/dotc/core/NameExtractors.scala
+++ b/compiler/src/dotty/tools/dotc/core/NameExtractors.scala
@@ -5,6 +5,7 @@ import Names._
 import NameOps._
 import StdNames._
 import util.DotClass
+import tasty.TastyFormat._
 
 object NameExtractors {
 
@@ -15,7 +16,7 @@ object NameExtractors {
   }
 
   val simpleTermNameInfo = new NameInfo {
-    def tag = 0
+    def tag = UTF8
     def mkString(underlying: TermName): String = unsupported("mkString")
   }
 
@@ -94,19 +95,19 @@ object NameExtractors {
     }
   }
 
-  object QualifiedName   extends QualifiedNameExtractor(1, ".", "Qualified")
-  object FlattenedName   extends QualifiedNameExtractor(2, "$", "Flattened")
-  object XpandedName    extends QualifiedNameExtractor(3, str.EXPAND_SEPARATOR, "Expanded")
-  object TraitSetterName extends QualifiedNameExtractor(4, str.TRAIT_SETTER_SEPARATOR, "TraitSetter")
+  object QualifiedName   extends QualifiedNameExtractor(QUALIFIED, ".", "Qualified")
+  object FlattenedName   extends QualifiedNameExtractor(FLATTENED, "$", "Flattened")
+  object XpandedName    extends QualifiedNameExtractor(EXPANDED, str.EXPAND_SEPARATOR, "Expanded")
+  object TraitSetterName extends QualifiedNameExtractor(TRAITSETTER, str.TRAIT_SETTER_SEPARATOR, "TraitSetter")
 
-  object DefaultGetterName extends NumberedNameExtractor(5, "DefaultGetter") {
+  object DefaultGetterName extends NumberedNameExtractor(DEFAULTGETTER, "DefaultGetter") {
     def mkString(underlying: TermName, info: ThisInfo) = {
       val prefix = if (underlying.isConstructorName) nme.DEFAULT_GETTER_INIT else underlying
       prefix.toString + nme.DEFAULT_GETTER + (info.num + 1)
     }
   }
 
-  object VariantName extends NumberedNameExtractor(6, "Variant") {
+  object VariantName extends NumberedNameExtractor(VARIANT, "Variant") {
     val varianceToPrefix = Map(-1 -> '-', 0 -> '=', 1 -> '+')
     val prefixToVariance = Map('-' -> -1, '=' -> 0, '+' -> 1)
     def mkString(underlying: TermName, info: ThisInfo) = {
@@ -114,10 +115,10 @@ object NameExtractors {
     }
   }
 
-  val SuperAccessorName = new PrefixNameExtractor(7, str.SUPER_PREFIX, "SuperAccessor")
-  val InitializerName = new PrefixNameExtractor(8, str.INITIALIZER_PREFIX, "Initializer")
-  val ShadowedName = new PrefixNameExtractor(9, str.SHADOWED_PREFIX, "Shadowed")
-  val ModuleClassName = new SuffixNameExtractor(10, "$", "ModuleClass")
+  val SuperAccessorName = new PrefixNameExtractor(SUPERACCESSOR, str.SUPER_PREFIX, "SuperAccessor")
+  val InitializerName = new PrefixNameExtractor(INITIALIZER, str.INITIALIZER_PREFIX, "Initializer")
+  val ShadowedName = new PrefixNameExtractor(SHADOWED, str.SHADOWED_PREFIX, "Shadowed")
+  val ModuleClassName = new SuffixNameExtractor(OBJECTCLASS, "$", "ModuleClass")
 
   object SignedName extends NameExtractor(63) {
 
diff --git a/compiler/src/dotty/tools/dotc/core/NameOps.scala b/compiler/src/dotty/tools/dotc/core/NameOps.scala
index b51955d9d..c837bc25c 100644
--- a/compiler/src/dotty/tools/dotc/core/NameOps.scala
+++ b/compiler/src/dotty/tools/dotc/core/NameOps.scala
@@ -49,26 +49,6 @@ object NameOps {
     }
   }
 
-  class PrefixNameExtractor(pre: TermName, bldr: NameExtractors.PrefixNameExtractor) {
-    def apply(name: TermName): TermName =
-      if (Config.semanticNames) bldr(name) else pre ++ name
-
-    def unapply(name: TermName): Option[TermName] =
-      if (Config.semanticNames)
-        name match {
-          case bldr(original) => Some(original)
-          case _ => None
-        }
-      else tryUnmangle(name)
-
-    def tryUnmangle(name: TermName): Option[TermName] =
-      if (name startsWith pre) Some(name.drop(pre.length).asTermName)
-      else None
-  }
-
-  object SuperAccessorName extends PrefixNameExtractor(nme.SUPER_PREFIX, NameExtractors.SuperAccessorName)
-  object InitializerName extends PrefixNameExtractor(nme.INITIALIZER_PREFIX, NameExtractors.InitializerName)
-
   implicit class NameDecorator[N <: Name](val name: N) extends AnyVal {
     import nme._
 
@@ -82,14 +62,8 @@ object NameOps {
     def isLoopHeaderLabel = (name startsWith WHILE_PREFIX) || (name startsWith DO_WHILE_PREFIX)
     def isProtectedAccessorName = name startsWith PROTECTED_PREFIX
     def isReplWrapperName = name.toSimpleName containsSlice INTERPRETER_IMPORT_WRAPPER
-    def isTraitSetterName =
-      if (Config.semanticNames) name.is(TraitSetterName)
-      else name containsSlice TRAIT_SETTER_SEPARATOR
     def isSetterName = name endsWith SETTER_SUFFIX
     def isSingletonName = name endsWith SINGLETON_SUFFIX
-    def isModuleClassName =
-      if (Config.semanticNames) name.is(ModuleClassName)
-      else name endsWith MODULE_SUFFIX
     def isAvoidClashName = name endsWith AVOID_CLASH_SUFFIX
     def isImportName = name startsWith IMPORT
     def isFieldName = name endsWith LOCAL_SUFFIX
@@ -137,19 +111,13 @@ object NameOps {
     }
 
     /** Convert this module name to corresponding module class name */
-    def moduleClassName: TypeName =
-      if (Config.semanticNames) name.derived(ModuleClassName).toTypeName
-      else (name ++ tpnme.MODULE_SUFFIX).toTypeName
+    def moduleClassName: TypeName = name.derived(ModuleClassName).toTypeName
 
     /** Convert this module class name to corresponding source module name */
     def sourceModuleName: TermName = stripModuleClassSuffix.toTermName
 
     /** If name ends in module class suffix, drop it */
-    def stripModuleClassSuffix: Name =
-      if (isModuleClassName)
-        if (Config.semanticNames) name.exclude(ModuleClassName)
-        else name dropRight MODULE_SUFFIX.length
-      else name
+    def stripModuleClassSuffix: Name = name.exclude(ModuleClassName)
 
     /** Append a suffix so that this name does not clash with another name in the same scope */
     def avoidClashName: TermName = (name ++ AVOID_CLASH_SUFFIX).toTermName
@@ -165,9 +133,7 @@ object NameOps {
     }.asInstanceOf[N]
 
     /** The superaccessor for method with given name */
-    def superName: TermName =
-      if (Config.semanticNames) SuperAccessorName(name.toTermName)
-      else (nme.SUPER_PREFIX ++ name).toTermName
+    def superName: TermName = SuperAccessorName(name.toTermName)
 
     /** The expanded name of `name` relative to given class `base`.
      */
@@ -179,34 +145,24 @@ object NameOps {
     /** The expanded name of `name` relative to `basename` with given `separator`
      */
     def expandedName(prefix: Name, separator: Name = nme.EXPAND_SEPARATOR): N =
-      likeTyped(
-        if (Config.semanticNames) {
-          def qualify(name: SimpleTermName) =
-            separatorToQualified(separator.toString)(prefix.toTermName, name)
-          name rewrite {
-            case name: SimpleTermName =>
-              qualify(name)
-            case AnyQualifiedName(_, _) =>
-              // Note: an expanded name may itself be expanded. For example, look at javap of scala.App.initCode
-              qualify(name.toSimpleName)
-          }
+      likeTyped {
+        def qualify(name: SimpleTermName) =
+          separatorToQualified(separator.toString)(prefix.toTermName, name)
+        name rewrite {
+          case name: SimpleTermName =>
+            qualify(name)
+          case AnyQualifiedName(_, _) =>
+            // Note: an expanded name may itself be expanded. For example, look at javap of scala.App.initCode
+            qualify(name.toSimpleName)
         }
-        else prefix ++ separator ++ name)
+      }
 
     def expandedName(prefix: Name): N = expandedName(prefix, nme.EXPAND_SEPARATOR)
 
-    /** Revert the expanded name.
-     *  Note: This currently gives incorrect results
-     *  if the normal name contains `nme.EXPAND_SEPARATOR`, i.e. two consecutive '$'
-     *  signs. This can happen for instance if a super accessor is paired with
-     *  an encoded name, e.g. super$$plus$eq. See #765.
-     */
-    def unexpandedName: N =
-      if (Config.semanticNames)
-        likeTyped {
-          name.rewrite { case XpandedName(_, unexp) => unexp }
-        }
-      else unexpandedNameOfMangled
+    /** Revert the expanded name. */
+    def unexpandedName: N = likeTyped {
+      name.rewrite { case XpandedName(_, unexp) => unexp }
+    }
 
     def unexpandedNameOfMangled: N = likeTyped {
       var idx = name.lastIndexOfSlice(nme.EXPAND_SEPARATOR)
@@ -219,13 +175,8 @@ object NameOps {
       if (idx < 0) name else (name drop (idx + nme.EXPAND_SEPARATOR.length))
     }
 
-    def expandedPrefix: N =
-      if (Config.semanticNames)
-        likeTyped {
-          name.rewrite { case XpandedName(prefix, _) => prefix }
-        }
-      else expandedPrefixOfMangled
-
+    def expandedPrefix: N = likeTyped { name.exclude(XpandedName) }
+ 
     def expandedPrefixOfMangled: N = {
       val idx = name.lastIndexOfSlice(nme.EXPAND_SEPARATOR)
       assert(idx >= 0)
@@ -233,11 +184,11 @@ object NameOps {
     }
 
     def unmangleExpandedName: N =
-      if (Config.semanticNames && name.isSimple) {
+      if (name.isSimple) {
         val unmangled = unexpandedNameOfMangled
         if (name eq unmangled) name
         else likeTyped(
-            XpandedName(expandedPrefixOfMangled.toTermName, unmangled.asSimpleName))
+          XpandedName(expandedPrefixOfMangled.toTermName, unmangled.asSimpleName))
       }
       else name
 
@@ -253,7 +204,7 @@ object NameOps {
 
     def freshened(implicit ctx: Context): N =
       likeTyped(
-        if (name.isModuleClassName) name.stripModuleClassSuffix.freshened.moduleClassName
+        if (name.is(ModuleClassName)) name.stripModuleClassSuffix.freshened.moduleClassName
         else likeTyped(ctx.freshName(name ++ NameTransformer.NAME_JOIN_STRING)))
 /*
     /** Name with variance prefix: `+` for covariant, `-` for contravariant */
@@ -283,7 +234,7 @@ object NameOps {
 
 */
     def unmangleClassName: N =
-      if (Config.semanticNames && name.isSimple && name.isTypeName)
+      if (name.isSimple && name.isTypeName)
         if (name.endsWith(MODULE_SUFFIX) && !tpnme.falseModuleClassNames.contains(name.asTypeName))
           likeTyped(name.dropRight(MODULE_SUFFIX.length).moduleClassName)
         else name
@@ -439,18 +390,11 @@ object NameOps {
 
     def fieldName: TermName =
       if (name.isSetterName) {
-        if (name.isTraitSetterName) {
-          if (Config.semanticNames) {
-            val TraitSetterName(_, original) = name
-            original.fieldName
-          }
-          else {
-            // has form <$-separated-trait-name>$_setter_$ `name`_$eq
-            val start = name.indexOfSlice(TRAIT_SETTER_SEPARATOR) + TRAIT_SETTER_SEPARATOR.length
-            val end = name.indexOfSlice(SETTER_SUFFIX)
-            (name.slice(start, end) ++ LOCAL_SUFFIX).asTermName
-          }
-        } else getterName.fieldName
+        if (name.is(TraitSetterName)) {
+           val TraitSetterName(_, original) = name
+          original.fieldName
+        }
+        else getterName.fieldName
       }
       else name.mapLast(n => (n ++ LOCAL_SUFFIX).asSimpleName)
 
@@ -469,19 +413,13 @@ object NameOps {
      *  @note Default getter name suffixes start at 1, so `pos` has to be adjusted by +1
      */
     def defaultGetterName(pos: Int): TermName =
-      if (Config.semanticNames) DefaultGetterName(name, pos)
-      else {
-        val prefix = if (name.isConstructorName) DEFAULT_GETTER_INIT else name
-        prefix ++ DEFAULT_GETTER ++ (pos + 1).toString
-      }
+      DefaultGetterName(name, pos)
 
     /** Nominally, name from name$default$N, CONSTRUCTOR for <init> */
     def defaultGetterToMethod: TermName =
-      if (Config.semanticNames)
-        name rewrite {
-          case DefaultGetterName(methName, _) => methName
-        }
-      else defaultGetterToMethodOfMangled
+      name rewrite {
+        case DefaultGetterName(methName, _) => methName
+      }
 
     def defaultGetterToMethodOfMangled: TermName = {
         val p = name.indexOfSlice(DEFAULT_GETTER)
@@ -494,11 +432,9 @@ object NameOps {
 
     /** If this is a default getter, its index (starting from 0), else -1 */
     def defaultGetterIndex: Int =
-      if (Config.semanticNames)
-        name collect {
-          case DefaultGetterName(_, num) => num
-        } getOrElse -1
-      else defaultGetterIndexOfMangled
+      name collect {
+        case DefaultGetterName(_, num) => num
+      } getOrElse -1
 
     def defaultGetterIndexOfMangled: Int = {
       var i = name.length
@@ -590,7 +526,7 @@ object NameOps {
     def inlineAccessorName = nme.INLINE_ACCESSOR_PREFIX ++ name ++ "$"
 
     def unmangleMethodName: TermName =
-      if (Config.semanticNames && name.isSimple) {
+      if (name.isSimple) {
         val idx = name.defaultGetterIndexOfMangled
         if (idx >= 0) name.defaultGetterToMethodOfMangled.defaultGetterName(idx)
         else name
@@ -598,13 +534,8 @@ object NameOps {
       else name
 
     def unmangleSuperName: TermName =
-      if (Config.semanticNames && name.isSimple)
-        SuperAccessorName.tryUnmangle(name.lastPart) match {
-          case scala.Some(original) =>
-            SuperAccessorName(name.mapLast(_ => original.asSimpleName))
-          case None =>
-            name
-        }
+      if (name.isSimple && name.startsWith(str.SUPER_PREFIX))
+        SuperAccessorName(name.drop(str.SUPER_PREFIX.length).asTermName)
       else name
   }
 
diff --git a/compiler/src/dotty/tools/dotc/core/SymDenotations.scala b/compiler/src/dotty/tools/dotc/core/SymDenotations.scala
index fa39c9782..4e40d1e05 100644
--- a/compiler/src/dotty/tools/dotc/core/SymDenotations.scala
+++ b/compiler/src/dotty/tools/dotc/core/SymDenotations.scala
@@ -406,7 +406,7 @@ object SymDenotations {
         }
         var prefix = encl.fullNameSeparated(separator)
         val fn =
-          if (Config.semanticNames && separatorToQualified.contains(sep)) {
+          if (separatorToQualified.contains(sep)) {
             if (sep == "$")
               // duplicate scalac's behavior: don't write a double '$$' for module class members.
               prefix = prefix.exclude(ModuleClassName)
@@ -1233,7 +1233,7 @@ object SymDenotations {
     // ----- denotation fields and accessors ------------------------------
 
     if (initFlags is (Module, butNot = Package))
-      assert(name.isModuleClassName, s"module naming inconsistency: ${name.debugString}")
+      assert(name.is(ModuleClassName), s"module naming inconsistency: ${name.debugString}")
 
     /** The symbol asserted to have type ClassSymbol */
     def classSymbol: ClassSymbol = symbol.asInstanceOf[ClassSymbol]
diff --git a/compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala b/compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala
index 131c9cf9b..c5194fb93 100644
--- a/compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala
+++ b/compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala
@@ -5,6 +5,7 @@ package classfile
 
 import Contexts._, Symbols._, Types._, Names._, StdNames._, NameOps._, Scopes._, Decorators._
 import SymDenotations._, unpickleScala2.Scala2Unpickler._, Constants._, Annotations._, util.Positions._
+import NameExtractors.ModuleClassName
 import ast.tpd._
 import java.io.{ File, IOException }
 import java.lang.Integer.toHexString
@@ -950,7 +951,7 @@ class ClassfileParser(
         val start = starts(index)
         if (in.buf(start).toInt != CONSTANT_CLASS) errorBadTag(start)
         val name = getExternalName(in.getChar(start + 1))
-        if (name.isModuleClassName && (name ne nme.nothingRuntimeClass) && (name ne nme.nullRuntimeClass))
+        if (name.is(ModuleClassName) && (name ne nme.nothingRuntimeClass) && (name ne nme.nullRuntimeClass))
           // Null$ and Nothing$ ARE classes
           c = ctx.requiredModule(name.sourceModuleName)
         else c = classNameToSymbol(name)
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/NameBuffer.scala b/compiler/src/dotty/tools/dotc/core/tasty/NameBuffer.scala
index 0101ff25d..74c4265f2 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/NameBuffer.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/NameBuffer.scala
@@ -49,43 +49,36 @@ class NameBuffer extends TastyBuffer(10000) {
   def writeNameRef(ref: NameRef): Unit = writeNat(ref.index)
   def writeNameRef(name: Name): Unit = writeNameRef(nameRefs(name.toTermName))
 
-  def pickleNameContents(name: Name): Unit = name.toTermName match {
-    case name: SimpleTermName =>
-      val bytes =
-        if (name.length == 0) new Array[Byte](0)
-        else Codec.toUTF8(chrs, name.start, name.length)
-      writeByte(UTF8)
-      writeNat(bytes.length)
-      writeBytes(bytes, bytes.length)
-    case QualifiedName(qualified, selector) =>
-      writeByte(QUALIFIED)
-      withLength { writeNameRef(qualified); writeNameRef(selector) }
-    case FlattenedName(qualified, selector) =>
-      writeByte(FLATTENED)
-      withLength { writeNameRef(qualified); writeNameRef(selector) }
-    case XpandedName(prefix, original) =>
-      writeByte(EXPANDED)
-      withLength { writeNameRef(prefix); writeNameRef(original) }
-    case SignedName(original, Signature(params, result)) =>
-      writeByte(SIGNED)
-      withLength(
+  def pickleNameContents(name: Name): Unit = {
+    writeByte(name.toTermName.info.tag)
+    name.toTermName match {
+      case name: SimpleTermName =>
+        val bytes =
+          if (name.length == 0) new Array[Byte](0)
+          else Codec.toUTF8(chrs, name.start, name.length)
+        writeNat(bytes.length)
+        writeBytes(bytes, bytes.length)
+      case QualifiedName(qualified, selector) =>
+        withLength { writeNameRef(qualified); writeNameRef(selector) }
+      case FlattenedName(qualified, selector) =>
+        withLength { writeNameRef(qualified); writeNameRef(selector) }
+      case XpandedName(prefix, original) =>
+        withLength { writeNameRef(prefix); writeNameRef(original) }
+      case SignedName(original, Signature(params, result)) =>
+        withLength(
           { writeNameRef(original); writeNameRef(result); params.foreach(writeNameRef) },
           if ((params.length + 2) * maxIndexWidth <= maxNumInByte) 1 else 2)
-    case ModuleClassName(module) =>
-      writeByte(OBJECTCLASS)
-      withLength { writeNameRef(module) }
-    case SuperAccessorName(accessed) =>
-      writeByte(SUPERACCESSOR)
-      withLength { writeNameRef(accessed) }
-    case DefaultGetterName(method, paramNumber) =>
-      writeByte(DEFAULTGETTER)
-      withLength { writeNameRef(method); writeNat(paramNumber) }
-    case ShadowedName(original) =>
-      writeByte(SHADOWED)
-      withLength { writeNameRef(original) }
-    case VariantName(original, sign) =>
-      writeByte(VARIANT)
-      withLength { writeNameRef(original); writeNat(sign + 1) }
+      case ModuleClassName(module) =>
+        withLength { writeNameRef(module) }
+      case SuperAccessorName(accessed) =>
+        withLength { writeNameRef(accessed) }
+      case DefaultGetterName(method, paramNumber) =>
+        withLength { writeNameRef(method); writeNat(paramNumber) }
+      case ShadowedName(original) =>
+        withLength { writeNameRef(original) }
+      case VariantName(original, sign) =>
+        withLength { writeNameRef(original); writeNat(sign + 1) }
+    }
   }
 
   override def assemble(): Unit = {
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TastyFormat.scala b/compiler/src/dotty/tools/dotc/core/tasty/TastyFormat.scala
index d4f6782fb..de70c04f3 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TastyFormat.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/TastyFormat.scala
@@ -224,12 +224,15 @@ object TastyFormat {
   final val QUALIFIED = 2
   final val FLATTENED = 3
   final val EXPANDED = 4
-  final val SIGNED = 5
-  final val OBJECTCLASS = 6
-  final val SUPERACCESSOR = 7
-  final val DEFAULTGETTER = 8
-  final val SHADOWED = 9
-  final val VARIANT = 10
+  final val TRAITSETTER = 5
+  final val DEFAULTGETTER = 10
+  final val VARIANT = 11
+  final val SUPERACCESSOR = 20
+  final val INITIALIZER = 21
+  final val SHADOWED = 22
+  final val OBJECTCLASS = 29
+
+  final val SIGNED = 63
 
   // AST tags
 
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
index d1f2a3766..2da638291 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
@@ -56,16 +56,6 @@ class TreePickler(pickler: TastyPickler) {
   private def pickleNameAndSig(name: Name, sig: Signature) =
     pickleName(SignedName(name.toTermName, sig))
 
-  private def pickleName(sym: Symbol)(implicit ctx: Context): Unit = {
-    val nameRef =
-      if (Config.semanticNames) {
-        if (sym is Flags.ExpandedName) assert(sym.name.is(XpandedName))
-        nameIndex(sym.name)
-      }
-      else ???
-    writeNat(nameRef.index)
-  }
-
   private def pickleSymRef(sym: Symbol)(implicit ctx: Context) = symRefs.get(sym) match {
     case Some(label) =>
       if (label != NoAddr) writeRef(label) else pickleForwardSymRef(sym)
@@ -303,7 +293,7 @@ class TreePickler(pickler: TastyPickler) {
     registerDef(sym)
     writeByte(tag)
     withLength {
-      pickleName(sym)
+      pickleName(sym.name)
       pickleParams
       tpt match {
         case templ: Template => pickleTree(tpt)
diff --git a/compiler/src/dotty/tools/dotc/transform/Mixin.scala b/compiler/src/dotty/tools/dotc/transform/Mixin.scala
index fd4370d3e..e9ec4890c 100644
--- a/compiler/src/dotty/tools/dotc/transform/Mixin.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Mixin.scala
@@ -13,6 +13,7 @@ import Decorators._
 import DenotTransformers._
 import StdNames._
 import NameOps._
+import NameExtractors._
 import Phases._
 import ast.untpd
 import ast.Trees._
diff --git a/compiler/src/dotty/tools/dotc/transform/ResolveSuper.scala b/compiler/src/dotty/tools/dotc/transform/ResolveSuper.scala
index b6c28f570..9e22a6b46 100644
--- a/compiler/src/dotty/tools/dotc/transform/ResolveSuper.scala
+++ b/compiler/src/dotty/tools/dotc/transform/ResolveSuper.scala
@@ -13,6 +13,7 @@ import Decorators._
 import DenotTransformers._
 import StdNames._
 import NameOps._
+import NameExtractors._
 import ast.Trees._
 import util.Positions._
 import Names._
@@ -95,15 +96,7 @@ object ResolveSuper {
   def rebindSuper(base: Symbol, acc: Symbol)(implicit ctx: Context): Symbol = {
     var bcs = base.info.baseClasses.dropWhile(acc.owner != _).tail
     var sym: Symbol = NoSymbol
-    val unexpandedAccName =
-      if (acc.is(ExpandedName))
-        if (Config.semanticNames) acc.name.unexpandedName
-        else // Cannot use unexpandedName because of #765. t2183.scala would fail if we did.
-          acc.name
-           .drop(acc.name.indexOfSlice(nme.EXPAND_SEPARATOR ++ nme.SUPER_PREFIX))
-           .drop(nme.EXPAND_SEPARATOR.length)
-      else acc.name
-    val SuperAccessorName(memberName) = unexpandedAccName: Name // dotty deviation: ": Name" needed otherwise pattern type is neither a subtype nor a supertype of selector type
+    val SuperAccessorName(memberName) = acc.name.unexpandedName // dotty deviation: ": Name" needed otherwise pattern type is neither a subtype nor a supertype of selector type
     ctx.debuglog(i"starting rebindsuper from $base of ${acc.showLocated}: ${acc.info} in $bcs, name = $memberName")
     while (bcs.nonEmpty && sym == NoSymbol) {
       val other = bcs.head.info.nonPrivateDecl(memberName)
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index a7b8200b5..8674c8fbd 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -18,6 +18,7 @@ import SymDenotations._
 import Annotations._
 import Names._
 import NameOps._
+import NameExtractors._
 import Flags._
 import Decorators._
 import ErrorReporting._
@@ -572,7 +573,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
         def canAssign(sym: Symbol) = // allow assignments from the primary constructor to class fields
           sym.is(Mutable, butNot = Accessor) ||
           ctx.owner.isPrimaryConstructor && !sym.is(Method) && sym.owner == ctx.owner.owner ||
-          ctx.owner.name.isTraitSetterName || ctx.owner.isStaticConstructor
+          ctx.owner.name.is(TraitSetterName) || ctx.owner.isStaticConstructor
         lhsCore.tpe match {
           case ref: TermRef if canAssign(ref.symbol) =>
             assignType(cpy.Assign(tree)(lhs1, typed(tree.rhs, ref.info)))