move comparator into +find_best_match_name+ function

src/librustc_resolve/lib.rs

@@ -3213,17 +3213,6 @@ impl<'a> Resolver<'a> {
         // Make sure error reporting is deterministic.
         names.sort_by_key(|name| name.as_str());
 
-
-        // Ugly code, just to see if using case insensitive comparison will help
-        let exact_match = names.iter().find(|x| x.as_str().to_uppercase() == name.as_str().to_uppercase());
-        // do not use Levenstein, just return the value we found (if any)
-        if exact_match.is_some() {
-            return match exact_match {
-                Some(found) => Some(found.clone()),
-                _ => None,
-            }
-        }
-
         match find_best_match_for_name(names.iter(), &name.as_str(), None) {
             Some(found) if found != name => Some(found),
             _ => None,

src/libsyntax/util/lev_distance.rs

@@ -44,23 +44,45 @@ pub fn lev_distance(a: &str, b: &str) -> usize {
 /// To find the best match for a given string from an iterator of names
 /// As a loose rule to avoid the obviously incorrect suggestions, it takes
 /// an optional limit for the maximum allowable edit distance, which defaults
-/// to one-third of the given word
+/// to one-third of the given word.
+/// Besides Levenshtein, we use case insensitive comparison to improve accuracy on an edge case with
+/// a lower(upper)case letters mismatch.
 pub fn find_best_match_for_name<'a, T>(iter_names: T,
                                        lookup: &str,
                                        dist: Option<usize>) -> Option<Symbol>
     where T: Iterator<Item = &'a Symbol> {
     let max_dist = dist.map_or_else(|| cmp::max(lookup.len(), 3) / 3, |d| d);
-    iter_names
+
+    let (case_insensitive_match, levenstein_match) = iter_names
     .filter_map(|&name| {
         let dist = lev_distance(lookup, &name.as_str());
-        if dist <= max_dist {    // filter the unwanted cases
+        if dist <= max_dist {
             Some((name, dist))
         } else {
             None
         }
     })
-    .min_by_key(|&(_, val)| val)    // extract the tuple containing the minimum edit distance
+    // Here we are collecting the next structure:
-    .map(|(s, _)| s)                // and return only the string
+    // (case_insensitive_match, (levenstein_match, levenstein_distance))
+    .fold((None, None), |result, (candidate, dist)| {
+        (
+            if candidate.as_str().to_uppercase() == lookup.to_uppercase() {
+                Some(candidate)
+            } else {
+                result.0
+            },
+            match result.1 {
+                None => Some((candidate, dist)),
+                Some((c, d)) => Some(if dist < d { (candidate, dist) } else { (c, d) })
+            }
+        )
+    });
+
+    if let Some(candidate) = case_insensitive_match {
+        Some(candidate) // exact case insensitive match has a higher priority
+    } else {
+        if let Some((candidate, _)) = levenstein_match { Some(candidate) } else { None }
+    }
 }
 
 #[test]

src/test/ui/issue-46332.rs

@@ -0,0 +1,20 @@
+// Copyright 2016 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// Original Levenshtein distance for both of this is 1. We improved accuracy with
+// additional case insensitive comparison.
+
+struct TyUint {}
+
+struct TyInt {}
+
+fn main() {
+    TyUInt {};
+}

src/test/ui/issue-46332.stderr

@@ -0,0 +1,8 @@
+error[E0422]: cannot find struct, variant or union type `TyUInt` in this scope
+  --> $DIR/issue-46332.rs:19:5
+   |
+19 |     TyUInt {};
+   |     ^^^^^^ did you mean `TyUint`?
+
+error: aborting due to previous error
+

src/test/ui/issue46332.rs

@@ -1,14 +0,0 @@
-// Original problem is Levenstein distance.
-
-fn TyUint() {
-    println!("TyUint");
-}
-
-fn TyInt() {
-    println!("TyInt");
-}
-
-
-fn main() {
-    TyUInt();
-}