private int CompareMatches(PatternMatch match1, PatternMatch match2, CompletionItem item1, CompletionItem item2)
{
// First see how the two items compare in a case insensitive fashion. Matches that
// are strictly better (ignoring case) should prioritize the item. i.e. if we have
// a prefix match, that should always be better than a substring match.
//
// The reason we ignore case is that it's very common for people to type expecting
// completion to fix up their casing. i.e. 'false' will be written with the
// expectation that it will get fixed by the completion list to 'False'.
var diff = match1.CompareTo(match2, ignoreCase: true);
if (diff != 0)
{
return(diff);
}
// If they both seemed just as good, but they differ on preselection, then
// item1 is better if it is preselected, otherwise it is worse.
if (item1.Rules.MatchPriority == MatchPriority.Preselect &&
item2.Rules.MatchPriority != MatchPriority.Preselect)
{
return(-1);
}
else if (item1.Rules.MatchPriority != MatchPriority.Preselect &&
item2.Rules.MatchPriority == MatchPriority.Preselect)
{
return(1);
}
// At this point we have two items which we're matching in a rather similar fasion.
// If one is a prefix of the other, prefer the prefix. i.e. if we have
// "Table" and "table:=" and the user types 't' and we are in a case insensitive
// language, then we prefer the former.
if (item1.DisplayText.Length != item2.DisplayText.Length)
{
var comparison = _isCaseSensitive ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase;
if (item2.DisplayText.StartsWith(item1.DisplayText, comparison))
{
return(-1);
}
else if (item1.DisplayText.StartsWith(item2.DisplayText, comparison))
{
return(1);
}
}
// Now compare the matches again in a case sensitive manner. If everything was
// equal up to this point, we prefer the item that better matches based on case.
diff = match1.CompareTo(match2, ignoreCase: false);
if (diff != 0)
{
return(diff);
}
return(0);
}
private int CompareMatches(PatternMatch match1, PatternMatch match2, CompletionItem item1, CompletionItem item2)
{
// First see how the two items compare in a case insensitive fashion. Matches that
// are strictly better (ignoring case) should prioritize the item. i.e. if we have
// a prefix match, that should always be better than a substring match.
//
// The reason we ignore case is that it's very common for people to type expecting
// completion to fix up their casing. i.e. 'false' will be written with the
// expectation that it will get fixed by the completion list to 'False'.
var diff = match1.CompareTo(match2, ignoreCase: true);
if (diff != 0)
{
return(diff);
}
// Now, after comparing matches, check if an item wants to be preselected. If so,
// we prefer that. i.e. say the user has typed 'f' and we have the items 'foo'
// and 'False' (with the latter being 'Preselected'). Both will be a prefix match.
// And because we are ignoring case, neither will be seen as better. Now, because
// 'False' is preselected we pick it even though 'foo' matches 'f' case sensitively.
diff = item2.Rules.MatchPriority - item1.Rules.MatchPriority;
if (diff != 0)
{
return(diff);
}
// At this point we have two items which we're matching in a rather similar fasion.
// If one is a prefix of the other, prefer the prefix. i.e. if we have
// "Table" and "table:=" and the user types 't' and we are in a case insensitive
// language, then we prefer the former.
if (item1.DisplayText.Length != item2.DisplayText.Length)
{
var comparison = _isCaseSensitive ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase;
if (item2.DisplayText.StartsWith(item1.DisplayText, comparison))
{
return(-1);
}
else if (item1.DisplayText.StartsWith(item2.DisplayText, comparison))
{
return(1);
}
}
// Now compare the matches again in a case sensitive manner. If everything was
// equal up to this point, we prefer the item that better matches based on case.
diff = match1.CompareTo(match2, ignoreCase: false);
if (diff != 0)
{
return(diff);
}
return(0);
}
protected virtual int CompareMatches(PatternMatch match1, PatternMatch match2, CompletionItem item1, CompletionItem item2)
{
return(match1.CompareTo(match2));
}
protected virtual int CompareMatches(PatternMatch match1, PatternMatch match2, CompletionItem item1, CompletionItem item2)
{
return match1.CompareTo(match2);
}
private int CompareMatches(PatternMatch match1, PatternMatch match2, CompletionItem item1, CompletionItem item2)
{
// First see how the two items compare in a case insensitive fashion. Matches that
// are strictly better (ignoring case) should prioritize the item. i.e. if we have
// a prefix match, that should always be better than a substring match.
//
// The reason we ignore case is that it's very common for people to type expecting
// completion to fix up their casing. i.e. 'false' will be written with the
// expectation that it will get fixed by the completion list to 'False'.
var diff = match1.CompareTo(match2, ignoreCase: true);
if (diff != 0)
{
return diff;
}
// If they both seemed just as good, but they differ on preselection, then
// item1 is better if it is preselected, otherwise it is worse.
if (item1.Rules.MatchPriority == MatchPriority.Preselect &&
item2.Rules.MatchPriority != MatchPriority.Preselect)
{
return -1;
}
else if (item1.Rules.MatchPriority != MatchPriority.Preselect &&
item2.Rules.MatchPriority == MatchPriority.Preselect)
{
return 1;
}
// At this point we have two items which we're matching in a rather similar fasion.
// If one is a prefix of the other, prefer the prefix. i.e. if we have
// "Table" and "table:=" and the user types 't' and we are in a case insensitive
// language, then we prefer the former.
if (item1.DisplayText.Length != item2.DisplayText.Length)
{
var comparison = _isCaseSensitive ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase;
if (item2.DisplayText.StartsWith(item1.DisplayText, comparison))
{
return -1;
}
else if (item1.DisplayText.StartsWith(item2.DisplayText, comparison))
{
return 1;
}
}
// Now compare the matches again in a case sensitive manner. If everything was
// equal up to this point, we prefer the item that better matches based on case.
diff = match1.CompareTo(match2, ignoreCase: false);
if (diff != 0)
{
return diff;
}
return 0;
}
private int CompareMatches(PatternMatch match1, PatternMatch match2, CompletionItem item1, CompletionItem item2)
{
// First see how the two items compare in a case insensitive fashion. Matches that
// are strictly better (ignoring case) should prioritize the item. i.e. if we have
// a prefix match, that should always be better than a substring match.
//
// The reason we ignore case is that it's very common for people to type expecting
// completion to fix up their casing. i.e. 'false' will be written with the
// expectation that it will get fixed by the completion list to 'False'.
var diff = match1.CompareTo(match2, ignoreCase: true);
if (diff != 0)
{
return diff;
}
// Now, after comparing matches, check if an item wants to be preselected. If so,
// we prefer that. i.e. say the user has typed 'f' and we have the items 'foo'
// and 'False' (with the latter being 'Preselected'). Both will be a prefix match.
// And because we are ignoring case, neither will be seen as better. Now, because
// 'False' is preselected we pick it even though 'foo' matches 'f' case sensitively.
diff = item2.Rules.MatchPriority - item1.Rules.MatchPriority;
if (diff != 0)
{
return diff;
}
// At this point we have two items which we're matching in a rather similar fasion.
// If one is a prefix of the other, prefer the prefix. i.e. if we have
// "Table" and "table:=" and the user types 't' and we are in a case insensitive
// language, then we prefer the former.
if (item1.DisplayText.Length != item2.DisplayText.Length)
{
var comparison = _isCaseSensitive ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase;
if (item2.DisplayText.StartsWith(item1.DisplayText, comparison))
{
return -1;
}
else if (item1.DisplayText.StartsWith(item2.DisplayText, comparison))
{
return 1;
}
}
// Now compare the matches again in a case sensitive manner. If everything was
// equal up to this point, we prefer the item that better matches based on case.
diff = match1.CompareTo(match2, ignoreCase: false);
if (diff != 0)
{
return diff;
}
return 0;
}
