Merge likeTyped and likeKinded into likeSpaced

Author: odersky

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

@@ -58,7 +58,7 @@ object NameOps {
       case _ => false
     }
 
-    def likeTyped(n: PreName): N =
+    def likeSpaced(n: PreName): N =
       (if (name.isTermName) n.toTermName else n.toTypeName).asInstanceOf[N]
 
     def isConstructorName = name == CONSTRUCTOR || name == TRAIT_CONSTRUCTOR
@@ -99,34 +99,34 @@ object NameOps {
      *  method needs to work on mangled as well as unmangled names because
      *  it is also called from the backend.
      */
-    def stripModuleClassSuffix: N = likeTyped {
+    def stripModuleClassSuffix: N = likeSpaced {
       val name1 =
         if (name.isSimple && name.endsWith("$")) name.unmangleClassName else name
       name.exclude(ModuleClassName)
     }
 
     /** If flags is a ModuleClass but not a Package, add module class suffix */
-    def adjustIfModuleClass(flags: Flags.FlagSet): N = likeTyped {
+    def adjustIfModuleClass(flags: Flags.FlagSet): N = likeSpaced {
       if (flags is (ModuleClass, butNot = Package)) name.asTypeName.moduleClassName
       else name.toTermName.exclude(AvoidClashName)
     }
 
     def expandedName(base: Symbol, kind: QualifiedNameKind = ExpandedName)(implicit ctx: Context): N = {
       val prefix =
         if (base.name.is(ExpandedName)) base.name else base.fullNameSeparated(ExpandPrefixName)
-      likeTyped { kind(prefix.toTermName, name.toTermName) }
+      likeSpaced { kind(prefix.toTermName, name.toTermName) }
     }
 
     /** Revert the expanded name. */
-    def unexpandedName: N = likeTyped {
+    def unexpandedName: N = likeSpaced {
       name.rewrite { case ExpandedName(_, unexp) => unexp }
     }
 
-    def implClassName: N = likeTyped(name ++ tpnme.IMPL_CLASS_SUFFIX)
+    def implClassName: N = likeSpaced(name ++ tpnme.IMPL_CLASS_SUFFIX)
 
-    def errorName: N = likeTyped(name ++ nme.ERROR)
+    def errorName: N = likeSpaced(name ++ nme.ERROR)
 
-    def freshened(implicit ctx: Context): N = likeTyped {
+    def freshened(implicit ctx: Context): N = likeSpaced {
       name.toTermName match {
         case ModuleClassName(original) => ModuleClassName(original.freshened)
         case name => UniqueName.fresh(name)
@@ -208,7 +208,7 @@ object NameOps {
       val methodTags: Seq[Name] = (methodTargs zip methodTarsNames).sortBy(_._2).map(x => typeToTag(x._1))
       val classTags: Seq[Name] = (classTargs zip classTargsNames).sortBy(_._2).map(x => typeToTag(x._1))
 
-      name.likeKinded(name ++ nme.specializedTypeNames.prefix ++
+      name.likeSpaced(name ++ nme.specializedTypeNames.prefix ++
         methodTags.fold(nme.EMPTY)(_ ++ _) ++ nme.specializedTypeNames.separator ++
         classTags.fold(nme.EMPTY)(_ ++ _) ++ nme.specializedTypeNames.suffix)
     }
@@ -219,11 +219,11 @@ object NameOps {
     def unmangleClassName: N = name.toTermName match {
       case name: SimpleTermName
       if name.endsWith(str.MODULE_SUFFIX) && !nme.falseModuleClassNames.contains(name) =>
-        likeTyped(name.dropRight(str.MODULE_SUFFIX.length).moduleClassName)
+        likeSpaced(name.dropRight(str.MODULE_SUFFIX.length).moduleClassName)
       case _ => name
     }
 
-    def unmangle(kind: NameKind): N = likeTyped {
+    def unmangle(kind: NameKind): N = likeSpaced {
       name rewrite {
         case unmangled: SimpleTermName =>
           kind.unmangle(unmangled)

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

@@ -71,8 +71,10 @@ object Names {
     def mapLast(f: SimpleTermName => SimpleTermName): ThisName
     def mapParts(f: SimpleTermName => SimpleTermName): ThisName
 
-    /** A name of the same kind as this name and with same characters as given `name` */
-    def likeKinded(name: Name): ThisName
+    /** A name in the same (term or type) namespace as this name and
+     *  with same characters as given `name`.
+     */
+    def likeSpaced(name: Name): ThisName
 
     def derived(info: NameInfo): ThisName
     def derived(kind: ClassifiedNameKind): ThisName = derived(kind.info)
@@ -129,7 +131,7 @@ object Names {
       _typeName
     }
 
-    def likeKinded(name: Name): TermName = name.toTermName
+    def likeSpaced(name: Name): TermName = name.toTermName
 
     def info: NameInfo = SimpleTermNameKind.info
     def underlying: TermName = unsupported("underlying")
@@ -264,7 +266,7 @@ object Names {
     def asSimpleName = this
     def toSimpleName = this
     def rewrite(f: PartialFunction[Name, Name]): ThisName =
-      if (f.isDefinedAt(this)) likeKinded(f(this)) else this
+      if (f.isDefinedAt(this)) likeSpaced(f(this)) else this
     def collect[T](f: PartialFunction[Name, T]): Option[T] = f.lift(this)
     def mapLast(f: SimpleTermName => SimpleTermName) = f(this)
     def mapParts(f: SimpleTermName => SimpleTermName) = f(this)
@@ -311,7 +313,7 @@ object Names {
     def mapLast(f: SimpleTermName => SimpleTermName) = toTermName.mapLast(f).toTypeName
     def mapParts(f: SimpleTermName => SimpleTermName) = toTermName.mapParts(f).toTypeName
 
-    def likeKinded(name: Name): TypeName = name.toTypeName
+    def likeSpaced(name: Name): TypeName = name.toTypeName
 
     def derived(info: NameInfo): TypeName = toTermName.derived(info).toTypeName
     def exclude(kind: NameKind): TypeName = toTermName.exclude(kind).toTypeName
@@ -342,7 +344,7 @@ object Names {
     def toSimpleName = termName(toString)
 
     def rewrite(f: PartialFunction[Name, Name]): ThisName =
-      if (f.isDefinedAt(this)) likeKinded(f(this))
+      if (f.isDefinedAt(this)) likeSpaced(f(this))
       else info match {
         case qual: QualifiedInfo => this
         case _ => underlying.rewrite(f).derived(info)