Extend is_case_difference to handle digit-letter confusables

Signed-off-by: xizheyin <[email protected]>

Author: xizheyin

compiler/rustc_errors/src/emitter.rs

@@ -3519,23 +3519,68 @@ pub fn is_different(sm: &SourceMap, suggested: &str, sp: Span) -> bool {
 
 /// Whether the original and suggested code are visually similar enough to warrant extra wording.
 pub fn is_case_difference(sm: &SourceMap, suggested: &str, sp: Span) -> bool {
-    // FIXME: this should probably be extended to also account for `FO0` → `FOO` and unicode.
     let found = match sm.span_to_snippet(sp) {
         Ok(snippet) => snippet,
         Err(e) => {
             warn!(error = ?e, "Invalid span {:?}", sp);
             return false;
         }
     };
-    let ascii_confusables = &['c', 'f', 'i', 'k', 'o', 's', 'u', 'v', 'w', 'x', 'y', 'z'];
-    // All the chars that differ in capitalization are confusable (above):
-    let confusable = iter::zip(found.chars(), suggested.chars())
-        .filter(|(f, s)| f != s)
-        .all(|(f, s)| ascii_confusables.contains(&f) || ascii_confusables.contains(&s));
-    confusable && found.to_lowercase() == suggested.to_lowercase()
-            // FIXME: We sometimes suggest the same thing we already have, which is a
-            //        bug, but be defensive against that here.
-            && found != suggested
+
+    // Check if the strings are identical after case normalization
+    if found.to_lowercase() == suggested.to_lowercase() {
+        // Check if they differ only in case
+        let ascii_confusables = &['c', 'f', 'i', 'k', 'o', 's', 'u', 'v', 'w', 'x', 'y', 'z'];
+        let confusable = iter::zip(found.chars(), suggested.chars())
+            .filter(|(f, s)| f != s)
+            .all(|(f, s)| ascii_confusables.contains(&f) || ascii_confusables.contains(&s));
+
+        if confusable
+        // FIXME: We sometimes suggest the same thing we already have, which is a
+        // bug, but be defensive against that here.
+        && found != suggested
+        {
+            return true;
+        }
+    }
+
+    // Check for digit-letter confusables (like 0 vs O, 1 vs l, etc.)
+    if found.len() == suggested.len() {
+        let digit_letter_confusables = [
+            ('0', 'O'),
+            ('O', '0'),
+            ('1', 'l'),
+            ('l', '1'),
+            ('5', 'S'),
+            ('S', '5'),
+            ('8', 'B'),
+            ('B', '8'),
+            ('9', 'g'),
+            ('g', '9'),
+        ];
+
+        let mut has_confusable = false;
+        // To ensure all the differences are confusables,
+        // we need to check that all the differences
+        let mut all_confusable = true;
+
+        for (f, s) in iter::zip(found.chars(), suggested.chars()) {
+            if f != s {
+                if digit_letter_confusables.contains(&(f, s)) {
+                    has_confusable = true;
+                } else {
+                    all_confusable = false;
+                    break;
+                }
+            }
+        }
+
+        if has_confusable && all_confusable && found != suggested {
+            return true;
+        }
+    }
+
+    false
 }
 
 pub(crate) fn should_show_source_code(

tests/ui/suggestions/case-difference-suggestions.rs

@@ -0,0 +1,29 @@
+fn main() {
+    // Test case difference suggestions
+    {
+        let FOO = 42;
+        // Test 1: Case difference (should show "notice the capitalization")
+        println!("{}", Foo); //~ ERROR cannot find value `Foo` in this scope
+
+    }
+
+    // Test 2: Digit-letter confusion (0 vs O)
+    let FO0 = 100;
+    println!("{}", FOO); //~ ERROR cannot find value `FOO` in this scope
+
+    // Test 3: Digit-letter confusion (1 vs l)
+    let l1st = vec![1, 2, 3];
+    println!("{}", list); //~ ERROR cannot find value `list` in this scope
+
+    // Test 4: Digit-letter confusion (5 vs S)
+    let S5 = "test";
+    println!("{}", SS); //~ ERROR cannot find value `SS` in this scope
+
+    // Test 5: Digit-letter confusion (8 vs B)
+    let B8 = 8;
+    println!("{}", BB); //~ ERROR cannot find value `BB` in this scope
+
+    // Test 6: Digit-letter confusion (9 vs g)
+    let g9 = 9;
+    println!("{}", gg); //~ ERROR cannot find value `gg` in this scope
+}

tests/ui/suggestions/case-difference-suggestions.stderr

@@ -0,0 +1,39 @@
+error[E0425]: cannot find value `Foo` in this scope
+  --> $DIR/case-difference-suggestions.rs:6:24
+   |
+LL |         println!("{}", Foo);
+   |                        ^^^ help: a local variable with a similar name exists (notice the capitalization): `FOO`
+
+error[E0425]: cannot find value `FOO` in this scope
+  --> $DIR/case-difference-suggestions.rs:12:20
+   |
+LL |     println!("{}", FOO);
+   |                    ^^^ help: a local variable with a similar name exists (notice the capitalization): `FO0`
+
+error[E0425]: cannot find value `list` in this scope
+  --> $DIR/case-difference-suggestions.rs:16:20
+   |
+LL |     println!("{}", list);
+   |                    ^^^^ help: a local variable with a similar name exists: `l1st`
+
+error[E0425]: cannot find value `SS` in this scope
+  --> $DIR/case-difference-suggestions.rs:20:20
+   |
+LL |     println!("{}", SS);
+   |                    ^^ help: a local variable with a similar name exists (notice the capitalization): `S5`
+
+error[E0425]: cannot find value `BB` in this scope
+  --> $DIR/case-difference-suggestions.rs:24:20
+   |
+LL |     println!("{}", BB);
+   |                    ^^ help: a local variable with a similar name exists (notice the capitalization): `B8`
+
+error[E0425]: cannot find value `gg` in this scope
+  --> $DIR/case-difference-suggestions.rs:28:20
+   |
+LL |     println!("{}", gg);
+   |                    ^^ help: a local variable with a similar name exists (notice the capitalization): `g9`
+
+error: aborting due to 6 previous errors
+
+For more information about this error, try `rustc --explain E0425`.