From 6506f9c2532d05606d97629c20b08e856e880177 Mon Sep 17 00:00:00 2001 From: Julian Kulesh Date: Wed, 29 Nov 2017 00:02:09 +0300 Subject: [PATCH 1/3] Add case insensitive comparison, besides Levenstein --- src/librustc_resolve/lib.rs | 12 ++++++++++++ src/test/ui/issue46332.rs | 14 ++++++++++++++ 2 files changed, 26 insertions(+) create mode 100644 src/test/ui/issue46332.rs diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs index 42c31a6e47eaa..ea74dffd9fd64 100644 --- a/src/librustc_resolve/lib.rs +++ b/src/librustc_resolve/lib.rs @@ -3212,6 +3212,18 @@ impl<'a> Resolver<'a> { let name = path[path.len() - 1].node.name; // 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, diff --git a/src/test/ui/issue46332.rs b/src/test/ui/issue46332.rs new file mode 100644 index 0000000000000..79de1600ae2d2 --- /dev/null +++ b/src/test/ui/issue46332.rs @@ -0,0 +1,14 @@ +// Original problem is Levenstein distance. + +fn TyUint() { + println!("TyUint"); +} + +fn TyInt() { + println!("TyInt"); +} + + +fn main() { + TyUInt(); +} From 537f2a6e1e9823e22ead30a85fdd3a8438648bc4 Mon Sep 17 00:00:00 2001 From: Julian Kulesh Date: Fri, 1 Dec 2017 00:39:47 +0300 Subject: [PATCH 2/3] move comparator into +find_best_match_name+ function --- src/librustc_resolve/lib.rs | 11 ---------- src/libsyntax/util/lev_distance.rs | 32 +++++++++++++++++++++++++----- src/test/ui/issue-46332.rs | 20 +++++++++++++++++++ src/test/ui/issue-46332.stderr | 8 ++++++++ src/test/ui/issue46332.rs | 14 ------------- 5 files changed, 55 insertions(+), 30 deletions(-) create mode 100644 src/test/ui/issue-46332.rs create mode 100644 src/test/ui/issue-46332.stderr delete mode 100644 src/test/ui/issue46332.rs diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs index ea74dffd9fd64..fdee469a3fbe3 100644 --- a/src/librustc_resolve/lib.rs +++ b/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, diff --git a/src/libsyntax/util/lev_distance.rs b/src/libsyntax/util/lev_distance.rs index 9307f3c58d4b0..e429791f2bdd4 100644 --- a/src/libsyntax/util/lev_distance.rs +++ b/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) -> Option where T: Iterator { 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 - .map(|(s, _)| s) // and return only the string + // Here we are collecting the next structure: + // (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] diff --git a/src/test/ui/issue-46332.rs b/src/test/ui/issue-46332.rs new file mode 100644 index 0000000000000..32cd5d39dc30c --- /dev/null +++ b/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 or the MIT license +// , 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 {}; +} diff --git a/src/test/ui/issue-46332.stderr b/src/test/ui/issue-46332.stderr new file mode 100644 index 0000000000000..6aef84568353c --- /dev/null +++ b/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 + diff --git a/src/test/ui/issue46332.rs b/src/test/ui/issue46332.rs deleted file mode 100644 index 79de1600ae2d2..0000000000000 --- a/src/test/ui/issue46332.rs +++ /dev/null @@ -1,14 +0,0 @@ -// Original problem is Levenstein distance. - -fn TyUint() { - println!("TyUint"); -} - -fn TyInt() { - println!("TyInt"); -} - - -fn main() { - TyUInt(); -} From f18446e78de1e925b9849bd618e20ed471ad0e61 Mon Sep 17 00:00:00 2001 From: Julian Kulesh Date: Fri, 1 Dec 2017 11:38:30 +0300 Subject: [PATCH 3/3] add magic comment for ui test, remove newline --- src/librustc_resolve/lib.rs | 1 - src/test/ui/issue-46332.rs | 1 + 2 files changed, 1 insertion(+), 1 deletion(-) diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs index fdee469a3fbe3..42c31a6e47eaa 100644 --- a/src/librustc_resolve/lib.rs +++ b/src/librustc_resolve/lib.rs @@ -3212,7 +3212,6 @@ impl<'a> Resolver<'a> { let name = path[path.len() - 1].node.name; // Make sure error reporting is deterministic. names.sort_by_key(|name| name.as_str()); - match find_best_match_for_name(names.iter(), &name.as_str(), None) { Some(found) if found != name => Some(found), _ => None, diff --git a/src/test/ui/issue-46332.rs b/src/test/ui/issue-46332.rs index 32cd5d39dc30c..d094497e246d0 100644 --- a/src/test/ui/issue-46332.rs +++ b/src/test/ui/issue-46332.rs @@ -17,4 +17,5 @@ struct TyInt {} fn main() { TyUInt {}; + //~^ ERROR cannot find struct, variant or union type `TyUInt` in this scope }