Stop accidental support for .name on Name

This is easy for `NameDecorator`, but use of path-dependent types in
`NameDecorator` makes this tricky (see code), and you can still call `name_` on
Names. Hopefully that jumps more to the eye or we can pick an ever worse name.

Author: Blaisorblade

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

@@ -49,7 +49,8 @@ object NameOps {
     }
   }
 
-  implicit class NameDecorator[N <: Name](val name: N) extends AnyVal {
+  implicit class NameDecorator[N <: Name](val name_ : N) extends AnyVal {
+    private def name = name_
     import nme._
 
     def testSimple(f: SimpleName => Boolean): Boolean = name match {
@@ -233,12 +234,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): name_.ThisName = {
 
       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 ++
+      name_.likeSpaced(name ++ nme.specializedTypeNames.prefix ++
         methodTags.fold(nme.EMPTY)(_ ++ _) ++ nme.specializedTypeNames.separator ++
         classTags.fold(nme.EMPTY)(_ ++ _) ++ nme.specializedTypeNames.suffix)
     }
@@ -271,7 +272,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/reporting/diagnostic/messages.scala

@@ -1266,20 +1266,20 @@ object messages {
     val msg = hl"""overloaded or recursive method ${tree} 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
+          |If there are multiple methods named `${tree}` 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.
+          |If `${tree}` calls itself on any path, you need to specify its return type.
           |""".stripMargin
   }
 
   case class RecursiveValueNeedsResultType(tree: 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 ${tree} needs type"""
     val explanation =
-      hl"""The definition of `${tree.name}` is recursive and you need to specify its type.
+      hl"""The definition of `${tree}` is recursive and you need to specify its type.
           |""".stripMargin
   }