Add 'did you mean' help for mistaken type names (#1162)

Add a system to help the users when the compiler cannot find a name of a
type:

#### Heuristic 1: Some types are named differently in Effekt than in
other languages

<img width="469" height="100" alt="Screenshot 2025-10-27 at 15 06 41"
src="https://github.com/user-attachments/assets/8b2a4a64-1860-4e5c-b1ec-05b9c3ecc609"
/>

This specific one (`Boolean` instead of `Bool`) is done often by
students and LLMs alike.

#### Heuristic 2: Try case-insensitive comparison

<img width="390" height="137" alt="Screenshot 2025-10-27 at 15 06 26"
src="https://github.com/user-attachments/assets/893777c5-247c-486f-8a94-704c740fe69d"
/>

#### Heuristic 3: Try full on edit distance!

<img width="359" height="135" alt="Screenshot 2025-10-27 at 22 31 43"
src="https://github.com/user-attachments/assets/9570b6ef-2222-4132-9575-e8773edf8f3b"
/>

Author: jiribenes

effekt/shared/src/main/scala/effekt/symbols/Scope.scala

@@ -208,8 +208,61 @@ object scopes {
         else syms.head
       }}
 
+    // TODO: Use this for more than just types?
+    //
+    // NOTE: We might also want to generalize to return more possible candidates than one
+    //       (1 works fine for types, but maybe not for fields/methods/functions/...)
+    private def didYouMean(nameNotFound: String, candidates: => Set[String], specificHeuristic: String => Option[String] = _ => None)(using E: ErrorReporter): Unit =
+      // Priority 1: A specific heuristic
+      specificHeuristic(nameNotFound) orElse {
+        // Priority 2: Exact case-insensitive match
+        candidates
+          .find { name => name.toUpperCase == nameNotFound.toUpperCase }
+          .map { exactMatch => pp"Did you mean $exactMatch?" }
+          .orElse {
+            // Priority 3: Edit distance
+            val threshold = ((nameNotFound.length + 2) max 3) / 3
+
+            candidates
+              .toSeq
+              .flatMap { candidate =>
+                effekt.util.editDistance(nameNotFound, candidate, threshold).map((_, candidate))
+              }
+              .sorted
+              .headOption
+              .map { case (_, name) => pp"Did you mean $name?" }
+          }
+      } foreach { msg => E.info(msg) }
+
+    // NOTE: Most of these should be covered by the edit distance anyway...
+    private def didYouMeanTypeHeuristic(name: String): Option[String] = name match {
+      case "Boolean" | "boolean" => Some(pp"Did you mean Bool?")
+      case "Str" | "str" => Some(pp"Did you mean String?")
+      case "Integer" | "Int32" | "Int64" | "I32" | "I64" | "i32" | "i64" =>
+        Some(pp"Did you mean Int?")
+      case "UInt32" | "UInt64" | "UInt" | "U32" | "U64" | "u32" | "u64" =>
+        Some(pp"Effekt only supports signed integers, did you mean Int?")
+      case "Int8" | "UInt8" | "I8" | "U8" | "i8" | "u8" =>
+        Some(pp"Did you mean Byte (8 bits) or Char (32 bits)?")
+      case "Float" | "float" | "F64" | "F32" | "f64" | "f32" =>
+        Some(pp"Effekt only supports 64bit floating numbers, did you mean Double?")
+      case "Maybe" | "maybe" => Some(pp"Did you mean Option?")
+      case "Void" | "void" => Some(pp"Did you mean Unit?")
+      case _ => None
+    }
+
     def lookupType(id: IdRef)(using E: ErrorReporter): TypeSymbol =
-      lookupTypeOption(id.path, id.name) getOrElse { E.abort(pp"Could not resolve type ${id}") }
+      lookupTypeOption(id.path, id.name) getOrElse {
+        // If we got here, we could not find an exact match.
+        // But let's try and find a close one!
+        def availableTypes = all(id.path, scope) {
+          _.types.keys.toList
+        }.flatten.toSet
+
+        didYouMean(id.name, availableTypes, didYouMeanTypeHeuristic)
+
+        E.abort(pp"Could not resolve type $id")
+      }
 
     def lookupTypeOption(path: List[String], name: String)(using E: ErrorReporter): Option[TypeSymbol] =
       first(path, scope) { _.types.get(name) }

effekt/shared/src/main/scala/effekt/util/EditDistance.scala

@@ -0,0 +1,58 @@
+package effekt.util
+
+def editDistance(a: String, b: String, limit: Int): Option[Int] = {
+  val n = a.length
+  val m = b.length
+  if (n == 0) return Some(m)
+  if (m == 0) return Some(n)
+
+  // Early exit if minimum distance exceeds limit
+  val minDist = Math.abs(n - m)
+  if (minDist > limit) return None
+
+  // Strip common prefix
+  val prefixLen = a.view.zip(b.view).takeWhile { case (a, b) => a == b }.size
+
+  // Strip common suffix (but don't overlap with prefix)
+  val suffixLen = a.view.drop(prefixLen).reverse
+    .zip(b.view.drop(prefixLen).reverse)
+    .takeWhile { case (a, b) => a == b }
+    .size
+
+  val s1 = a.substring(prefixLen, n - suffixLen)
+  val s2 = b.substring(prefixLen, m - suffixLen)
+
+  // After stripping, if one is empty, distance is just the other's length
+  if (s1.isEmpty) return Some(s2.length)
+  if (s2.isEmpty) return Some(s1.length)
+
+  val distance = levenshtein(s1, s2)
+  if (distance <= limit) Some(distance) else None
+}
+
+inline def levenshtein(s1: String, s2: String): Int = {
+  val n = s1.length
+  val m = s2.length
+
+  val d = Array.ofDim[Int](n + 1, m + 1)
+  for (i <- 0 to n) { d(i)(0) = i }
+  for (j <- 0 to m) { d(0)(j) = j }
+
+  for {
+    i <- 1 to n; s1_i = s1(i - 1)
+    j <- 1 to m; s2_j = s2(j - 1)
+  } do {
+    val costDelete     = d(i - 1)(j) + 1
+    val costInsert     = d(i)(j - 1) + 1
+    val costSubstitute = d(i - 1)(j - 1) + (if (s1_i == s2_j) 0 else 1)
+
+    d(i)(j) = costDelete min costInsert min costSubstitute
+
+    // Transposition: swap adjacent characters (Bolo ~> Bool)
+    if (i > 1 && j > 1 && s1(i - 1) == s2(j - 2) && s1(i - 2) == s2(j - 1)) {
+      d(i)(j) = d(i)(j) min (d(i - 2)(j - 2) + 1)
+    }
+  }
+
+  d(n)(m)
+}

examples/neg/boolean_wrong_name.check

@@ -0,0 +1,6 @@
+[info] examples/neg/boolean_wrong_name.effekt:3:19: Did you mean Bool?
+def alwaysTrue(): Boolean = true
+                  ^^^^^^^
+[error] examples/neg/boolean_wrong_name.effekt:3:19: Could not resolve type Boolean
+def alwaysTrue(): Boolean = true
+                  ^^^^^^^

examples/neg/boolean_wrong_name.effekt

@@ -0,0 +1,3 @@
+module boolean_wrong_name
+
+def alwaysTrue(): Boolean = true

examples/neg/case_insensitive_type_hint.check

@@ -0,0 +1,6 @@
+[info] examples/neg/case_insensitive_type_hint.effekt:5:12: Did you mean MyType?
+def fun(): Mytype = MyType()
+           ^^^^^^
+[error] examples/neg/case_insensitive_type_hint.effekt:5:12: Could not resolve type Mytype
+def fun(): Mytype = MyType()
+           ^^^^^^

examples/neg/case_insensitive_type_hint.effekt

@@ -0,0 +1,5 @@
+module case_insensitive_type_hint
+
+record MyType()
+
+def fun(): Mytype = MyType()

examples/neg/case_insensitive_type_hint2.check

@@ -0,0 +1,6 @@
+[info] examples/neg/case_insensitive_type_hint2.effekt:5:12: Did you mean Mytype?
+def fun(): MyType = Mytype()
+           ^^^^^^
+[error] examples/neg/case_insensitive_type_hint2.effekt:5:12: Could not resolve type MyType
+def fun(): MyType = Mytype()
+           ^^^^^^

examples/neg/case_insensitive_type_hint2.effekt

@@ -0,0 +1,5 @@
+module case_insensitive_type_hint2
+
+record Mytype()
+
+def fun(): MyType = Mytype()

examples/pos/boolean_custom_type_no_error.check

@@ -0,0 +1,11 @@
+module boolean_custom_type_no_error
+
+// see neg/boolean_wrong_name
+// Here we define our own 'Boolean' type,
+// so that the error "please try 'Bool' instead" never pops up
+
+record Boolean(b: Bool)
+
+def alwaysTrue(): Boolean = Boolean(true)
+
+def main() = ()