Refactor "did you mean" hinting

 - Handle all members instead of just decls.
 - Simplify the logic and implementation.

To tell the truth, the previous implementation was too convoluted for me
to be able to say what it does exactly. But the new one seems to fit the
intuitive spec.

Author: odersky

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

@@ -314,13 +314,19 @@ object messages {
 
     val msg: String = {
       import core.Flags._
-      val maxDist = 3
-      val decls = site.decls.toList
-        .filter(_.isType == name.isTypeName)
-        .flatMap { sym =>
-          if (sym.flagsUNSAFE.isOneOf(Synthetic | PrivateLocal) || sym.isConstructor) Nil
-          else List((sym.name.show, sym))
-        }
+      val maxDist = 3  // maximal number of differences to be considered for a hint
+      val missing = name.show
+
+      // The names of all non-synthetic, non-private members of `site`
+      // that are of the same type/term kind as the missing member.
+      def candidates: Set[String] =
+        for
+          bc <- site.baseClasses.toSet
+          sym <- bc.info.decls.filter(sym =>
+            sym.isType == name.isTypeName
+            && !sym.isConstructor
+            && !sym.flagsUNSAFE.isOneOf(Synthetic | Private))
+        yield sym.name.show
 
       // Calculate Levenshtein distance
       def distance(n1: Iterable[?], n2: Iterable[?]) =
@@ -333,37 +339,18 @@ object messages {
           }
         }.last
 
-      // Count number of wrong characters
-      def incorrectChars(x: (String, Int, Symbol)): (String, Symbol, Int) = {
-        val (currName, _, sym) = x
-        val matching = name.show.zip(currName).foldLeft(0) {
-          case (acc, (x,y)) => if (x != y) acc + 1 else acc
-        }
-        (currName, sym, matching)
-      }
-
-      // Get closest match in `site`
-      def closest: List[String] =
-        decls
-        .map { (n, sym) => (n, distance(n, name.show), sym) }
-        .collect {
-          case (n, dist, sym)
-          if dist <= maxDist && dist < (name.toString.length min n.length) =>
-            (n, dist, sym)
-        }
-        .groupBy(_._2).toList
-        .sortBy(_._1)
-        .headOption.map(_._2).getOrElse(Nil)
-        .map(incorrectChars).toList
-        .sortBy(_._3)
-        .map(_._1)
-          // [Martin] Note: I have no idea what this does. This shows the
-          // pitfalls of not naming things, functional or not.
+      // A list of possible candidate strings with their Levenstein distances
+      // to the name of the missing member
+      def closest: List[(Int, String)] = candidates
+        .toList
+        .map(n => (distance(n.show, missing), n))
+        .filter((d, n) => d <= maxDist && d < missing.length & d < n.length)
+        .sorted  // sort by distance first, alphabetically second
 
       val finalAddendum =
         if addendum.nonEmpty then addendum
         else closest match {
-          case n :: _ =>
+          case (d, n) :: _ =>
             val siteName = site match
               case site: NamedType => site.name.show
               case site => i"$site"