Drop Show from Any#show extension method

I added this at the last minute as a fallback, but I can't remember the
use case exactly, and it muddies the waters by mixing concerns.

Also other typo fixes and a code tweak.

Author: dwijnand

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

@@ -251,16 +251,15 @@ object Decorators {
         op: WrappedResult[U] ?=> String,
         printer: config.Printers.Printer = config.Printers.default)(using c: Conversion[T, U] = null): T = {
       // either the use of `$result` was driven by the expected type of `Shown`
-      // which lead to the summoning of `Conversion[T, Shown]` (which we'll invoke)
+      // which led to the summoning of `Conversion[T, Shown]` (which we'll invoke)
       // or no such conversion was found so we'll consume the result as it is instead
       val obj = if c == null then x.asInstanceOf[U] else c(x)
       printer.println(op(using WrappedResult(obj)))
       x
     }
 
     /** Instead of `toString` call `show` on `Showable` values, falling back to `toString` if an exception is raised. */
-    def show(using Context)(using z: Show[T] = null): String = x match
-      case _ if z != null => z.show(x).toString
+    def show(using Context): String = x match
       case x: Showable =>
         try x.show
         catch

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

@@ -16,7 +16,7 @@ object Formatting {
   object ShownDef:
     /** Represents a value that has been "shown" and can be consumed by StringFormatter.
      *  Not just a string because it may be a Seq that StringFormatter will intersperse with the trailing separator.
-     *  Also, it's not a `String | Seq[String]` because then we'd need to a Context to call `Showable#show`.  We could
+     *  Also, it's not a `String | Seq[String]` because then we'd need a Context to call `Showable#show`.  We could
      *  make Context a requirement for a Show instance but then we'd have lots of instances instead of just one ShowAny
      *  instance.  We could also try to make `Show#show` require the Context, but then that breaks the Conversion. */
     opaque type Shown = Any

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

@@ -1751,7 +1751,9 @@ import transform.SymUtils._
 
   class ClassAndCompanionNameClash(cls: Symbol, other: Symbol)(using Context)
     extends NamingMsg(ClassAndCompanionNameClashID) {
-    def msg = em"Name clash: both ${cls.owner} and its companion object defines ${cls.name.stripModuleClassSuffix.show}"
+    def msg =
+      val name = cls.name.stripModuleClassSuffix
+      em"Name clash: both ${cls.owner} and its companion object defines $name"
     def explain =
       em"""|A ${cls.kindString} and its companion object cannot both define a ${hl("class")}, ${hl("trait")} or ${hl("object")} with the same name:
            |  - ${cls.owner} defines ${cls}