On identifier not found, detect swapped words

[estebank]

On identifiers that have more than one word, it is relatively common to write them in the wrong order (foo_bar_baz → foo_baz_bar). These are normally not found by Levenshtein distance checks, but we could do a basic "split on _, sort and join before comparison" so that we could suggest the right identifier.

This issue has been assigned to @cjkenn via this comment.

[LeSeulArtichaut]

I'd like to try to work on this.

As foo_bar_baz is short enough to be caught by the Levenstein distance, I wrote this example for testing:

fn main() {
    let long_variable_name = true;
    println!("{}", long_name_variable);
}

@rustbot claim

[LeSeulArtichaut]

@estebank I'm thinking about the priority of the different possible matches. I tend to think that a match found by levenstein distance should have a greater priority, but what do you think?

[estebank]

@LeSeulArtichaut it's tricky. I feel that your instinct might be right but we'd only know when looking at real world usage. The nice thing is that the lev distance check by its very nature it is limited, so doing the swapped words check as a fallback should work out ok in practice.

[LeSeulArtichaut]

Releasing my assignment, as I am not sure to be able to commit.
In case someone want to take on this, here is the function that should be modified.

rust/src/libsyntax/util/lev_distance.rs

Lines 46 to 82 in ae1b871

	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);
	let (case_insensitive_match, levenstein_match) = iter_names
	.filter_map(|&name| {
	let dist = lev_distance(lookup, &name.as_str());
	if dist <= max_dist {
	Some((name, dist))
	} else {
	None
	}
	})
	// 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 {
	levenstein_match.map(|(candidate, _)| candidate)
	}
	}

@rustbot release-assignment

[LeSeulArtichaut]

(I think this is appropriate, please tell me if it isn't)
@rustbot modify labels to +E-Easy

[cjkenn]

I can take a stab at this, seems reasonable with previous comments.

@rustbot claim