Refactorings on Names: forbid .name on Name and cleanups on the way

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

@@ -49,7 +49,7 @@ object NameOps {
     }
   }
 
-  implicit class NameDecorator[N <: Name](val name: N) extends AnyVal {
+  implicit class NameDecorator[N <: Name](private val name: N) extends AnyVal {
     import nme._
 
     def testSimple(f: SimpleName => Boolean): Boolean = name match {
@@ -58,8 +58,8 @@ object NameOps {
       case _ => false
     }
 
-    def likeSpaced(n: PreName): N =
-      (if (name.isTermName) n.toTermName else n.toTypeName).asInstanceOf[N]
+    private def likeSpaced(n: PreName): N =
+      name.likeSpaced(n).asInstanceOf[N]
 
     def isConstructorName = name == CONSTRUCTOR || name == TRAIT_CONSTRUCTOR
     def isStaticConstructorName = name == STATIC_CONSTRUCTOR
@@ -233,12 +233,12 @@ object NameOps {
       case nme.clone_ => nme.clone_
     }
 
-    def specializedFor(classTargs: List[Types.Type], classTargsNames: List[Name], methodTargs: List[Types.Type], methodTarsNames: List[Name])(implicit ctx: Context): name.ThisName = {
+    def specializedFor(classTargs: List[Types.Type], classTargsNames: List[Name], methodTargs: List[Types.Type], methodTarsNames: List[Name])(implicit ctx: Context): N = {
 
       val methodTags: Seq[Name] = (methodTargs zip methodTarsNames).sortBy(_._2).map(x => defn.typeTag(x._1))
       val classTags: Seq[Name] = (classTargs zip classTargsNames).sortBy(_._2).map(x => defn.typeTag(x._1))
 
-      name.likeSpaced(name ++ nme.specializedTypeNames.prefix ++
+      likeSpaced(name ++ nme.specializedTypeNames.prefix ++
         methodTags.fold(nme.EMPTY)(_ ++ _) ++ nme.specializedTypeNames.separator ++
         classTags.fold(nme.EMPTY)(_ ++ _) ++ nme.specializedTypeNames.suffix)
     }
@@ -271,7 +271,7 @@ object NameOps {
     }
   }
 
-  implicit class TermNameDecorator(val name: TermName) extends AnyVal {
+  implicit class TermNameDecorator(private val name: TermName) extends AnyVal {
     import nme._
 
     def setterName: TermName = name.exclude(FieldName) ++ str.SETTER_SUFFIX

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

@@ -98,7 +98,7 @@ object Names {
     /** 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 likeSpaced(name: PreName): ThisName
 
     /** A derived name consisting of this name and the added info, unless it is
      *  already present in this name.
@@ -181,7 +181,7 @@ object Names {
       _typeName
     }
 
-    override def likeSpaced(name: Name): TermName = name.toTermName
+    override def likeSpaced(name: PreName): TermName = name.toTermName
 
     def info: NameInfo = SimpleNameKind.info
     def underlying: TermName = unsupported("underlying")
@@ -450,7 +450,7 @@ object Names {
     override def mapLast(f: SimpleName => SimpleName) = toTermName.mapLast(f).toTypeName
     override def mapParts(f: SimpleName => SimpleName) = toTermName.mapParts(f).toTypeName
 
-    override def likeSpaced(name: Name): TypeName = name.toTypeName
+    override def likeSpaced(name: PreName): TypeName = name.toTypeName
 
     override def derived(info: NameInfo): TypeName = toTermName.derived(info).toTypeName
     override def exclude(kind: NameKind): TypeName = toTermName.exclude(kind).toTypeName

compiler/src/dotty/tools/dotc/reporting/diagnostic/messages.scala

@@ -1260,26 +1260,26 @@ object messages {
            |""".stripMargin
   }
 
-  case class OverloadedOrRecursiveMethodNeedsResultType(tree: Names.TermName)(implicit ctx: Context)
+  case class OverloadedOrRecursiveMethodNeedsResultType(method: Names.TermName)(implicit ctx: Context)
   extends Message(OverloadedOrRecursiveMethodNeedsResultTypeID) {
     val kind = "Syntax"
-    val msg = hl"""overloaded or recursive method ${tree} needs return type"""
+    val msg = hl"""overloaded or recursive method ${method} needs return type"""
     val explanation =
-      hl"""Case 1: ${tree} is overloaded
-          |If there are multiple methods named `${tree.name}` and at least one definition of
+      hl"""Case 1: ${method} is overloaded
+          |If there are multiple methods named `${method}` and at least one definition of
           |it calls another, you need to specify the calling method's return type.
           |
-          |Case 2: ${tree} is recursive
-          |If `${tree.name}` calls itself on any path, you need to specify its return type.
+          |Case 2: ${method} is recursive
+          |If `${method}` calls itself on any path, you need to specify its return type.
           |""".stripMargin
   }
 
-  case class RecursiveValueNeedsResultType(tree: Names.TermName)(implicit ctx: Context)
+  case class RecursiveValueNeedsResultType(value: Names.TermName)(implicit ctx: Context)
   extends Message(RecursiveValueNeedsResultTypeID) {
     val kind = "Syntax"
-    val msg = hl"""recursive value ${tree.name} needs type"""
+    val msg = hl"""recursive value ${value} needs type"""
     val explanation =
-      hl"""The definition of `${tree.name}` is recursive and you need to specify its type.
+      hl"""The definition of `${value}` is recursive and you need to specify its type.
           |""".stripMargin
   }