From d231d788c89a6a6cf8236947f8551554a26c5687 Mon Sep 17 00:00:00 2001 From: peter Date: Wed, 30 Mar 2011 20:27:31 +0200 Subject: [PATCH] honor completion-case-sensitive=ALL option in the new matcher --- .../normalSorting/UppercaseMatters2.java | 9 ++++ .../NormalCompletionOrderingTest.java | 12 ++++++ .../completion/impl/CamelHumpMatcher.java | 2 +- .../src/com/intellij/ui/SpeedSearchBase.java | 2 +- .../com/intellij/psi/codeStyle/NameUtil.java | 41 ++++++++++++------- 5 files changed, 49 insertions(+), 17 deletions(-) create mode 100644 java/java-tests/testData/codeInsight/completion/normalSorting/UppercaseMatters2.java diff --git a/java/java-tests/testData/codeInsight/completion/normalSorting/UppercaseMatters2.java b/java/java-tests/testData/codeInsight/completion/normalSorting/UppercaseMatters2.java new file mode 100644 index 000000000000..b09f76b56e2c --- /dev/null +++ b/java/java-tests/testData/codeInsight/completion/normalSorting/UppercaseMatters2.java @@ -0,0 +1,9 @@ +class Foo { + { + Object classLOSomething; + Object classLoader; + Object classLoader2; + cLo + } + +} \ No newline at end of file diff --git a/java/java-tests/testSrc/com/intellij/codeInsight/completion/NormalCompletionOrderingTest.java b/java/java-tests/testSrc/com/intellij/codeInsight/completion/NormalCompletionOrderingTest.java index 9c45f1491166..08265d07ef4e 100644 --- a/java/java-tests/testSrc/com/intellij/codeInsight/completion/NormalCompletionOrderingTest.java +++ b/java/java-tests/testSrc/com/intellij/codeInsight/completion/NormalCompletionOrderingTest.java @@ -5,6 +5,7 @@ package com.intellij.codeInsight.completion; import com.intellij.JavaTestUtil; +import com.intellij.codeInsight.CodeInsightSettings; import com.intellij.codeInsight.lookup.LookupElement; import com.intellij.codeInsight.lookup.impl.LookupImpl; import com.intellij.psi.PsiClass; @@ -59,6 +60,17 @@ public class NormalCompletionOrderingTest extends CompletionSortingTestCase { assertPreferredItems(0, "p", "pre", "param"); } + public void testUppercaseMatters2() throws Throwable { + final int old = CodeInsightSettings.getInstance().COMPLETION_CASE_SENSITIVE; + try { + CodeInsightSettings.getInstance().COMPLETION_CASE_SENSITIVE = CodeInsightSettings.ALL; + checkPreferredItems(0, "classLoader", "classLoader2"); + } + finally { + CodeInsightSettings.getInstance().COMPLETION_CASE_SENSITIVE = old; + } + } + public void testShorterShouldBePreselected() throws Throwable { checkPreferredItems(0, "foo", "fooLongButOfDefaultType"); } diff --git a/platform/lang-impl/src/com/intellij/codeInsight/completion/impl/CamelHumpMatcher.java b/platform/lang-impl/src/com/intellij/codeInsight/completion/impl/CamelHumpMatcher.java index c3670d93f9bf..ef303cf7e8f6 100644 --- a/platform/lang-impl/src/com/intellij/codeInsight/completion/impl/CamelHumpMatcher.java +++ b/platform/lang-impl/src/com/intellij/codeInsight/completion/impl/CamelHumpMatcher.java @@ -116,7 +116,7 @@ public class CamelHumpMatcher extends PrefixMatcher { int exactPrefixLen = myPrefix.startsWith("*") ? 0 : 1; return NameUtil.buildCompletionMatcher(myPrefix, exactPrefixLen, true, true); case CodeInsightSettings.ALL: - return NameUtil.buildCompletionMatcher(myPrefix, 0, false, false); + return NameUtil.buildCompletionMatcher(myPrefix, 1, false, false); default: return NameUtil.buildCompletionMatcher(myPrefix, 0, true, false); } diff --git a/platform/platform-impl/src/com/intellij/ui/SpeedSearchBase.java b/platform/platform-impl/src/com/intellij/ui/SpeedSearchBase.java index 0ab0031f82db..4cbe9cdea526 100644 --- a/platform/platform-impl/src/com/intellij/ui/SpeedSearchBase.java +++ b/platform/platform-impl/src/com/intellij/ui/SpeedSearchBase.java @@ -203,7 +203,7 @@ public abstract class SpeedSearchBase extends SpeedSear myRecentSearchMatcher = recentSearchPattern.matcher(text); if (NameUtil.isUseMinusculeHumpMatcher()) { - myMinusculeMatcher = new NameUtil.MinusculeMatcher(myShouldMatchFromTheBeginning ? pattern : "*" + pattern, false); + myMinusculeMatcher = new NameUtil.MinusculeMatcher(myShouldMatchFromTheBeginning ? pattern : "*" + pattern, false, false); return myMinusculeMatcher.matches(text); } return myRecentSearchMatcher.find(); diff --git a/platform/util/src/com/intellij/psi/codeStyle/NameUtil.java b/platform/util/src/com/intellij/psi/codeStyle/NameUtil.java index 21b842ddef2a..c6b1218acdaf 100644 --- a/platform/util/src/com/intellij/psi/codeStyle/NameUtil.java +++ b/platform/util/src/com/intellij/psi/codeStyle/NameUtil.java @@ -15,6 +15,7 @@ */ package com.intellij.psi.codeStyle; +import com.intellij.openapi.diagnostic.Logger; import com.intellij.openapi.util.registry.Registry; import com.intellij.openapi.util.text.StringUtil; import com.intellij.util.ArrayUtil; @@ -34,6 +35,7 @@ import java.util.ArrayList; import java.util.List; public class NameUtil { + private static final Logger LOG = Logger.getInstance("#com.intellij.psi.codeStyle.NameUtil"); private static final Function LOWERCASE_MAPPING = new Function() { public String fun(final String s) { return s.toLowerCase(); @@ -383,23 +385,23 @@ public class NameUtil { } public static Matcher buildCompletionMatcher(String pattern, int exactPrefixLen, boolean allowToUpper, boolean allowToLower) { - return buildMatcher(pattern, buildRegexp(pattern, exactPrefixLen, allowToUpper, allowToLower, false, true), exactPrefixLen > 0); + return buildMatcher(pattern, buildRegexp(pattern, exactPrefixLen, allowToUpper, allowToLower, false, true), exactPrefixLen > 0, !allowToLower && !allowToUpper); } public static Matcher buildMatcher(String pattern, int exactPrefixLen, boolean allowToUpper, boolean allowToLower) { - return buildMatcher(pattern, buildRegexp(pattern, exactPrefixLen, allowToUpper, allowToLower), exactPrefixLen > 0); + return buildMatcher(pattern, buildRegexp(pattern, exactPrefixLen, allowToUpper, allowToLower), exactPrefixLen > 0, !allowToLower && !allowToUpper); } public static Matcher buildMatcher(String pattern, int exactPrefixLen, boolean allowToUpper, boolean allowToLower, boolean lowerCaseWords) { - return buildMatcher(pattern, buildRegexp(pattern, exactPrefixLen, allowToUpper, allowToLower, lowerCaseWords, false), exactPrefixLen > 0); + return buildMatcher(pattern, buildRegexp(pattern, exactPrefixLen, allowToUpper, allowToLower, lowerCaseWords, false), exactPrefixLen > 0, !allowToLower && !allowToUpper); } public static boolean isUseMinusculeHumpMatcher() { return Registry.is("minuscule.humps.matching"); } - private static Matcher buildMatcher(final String pattern, String regexp, boolean firstLetterMatters) { - return isUseMinusculeHumpMatcher() ? new MinusculeMatcher(pattern, firstLetterMatters) : new OptimizedMatcher(pattern, regexp); + private static Matcher buildMatcher(final String pattern, String regexp, boolean firstLetterMatters, boolean caseMatters) { + return isUseMinusculeHumpMatcher() ? new MinusculeMatcher(pattern, firstLetterMatters, caseMatters) : new OptimizedMatcher(pattern, regexp); } private static class OptimizedMatcher implements Matcher { @@ -482,9 +484,14 @@ public class NameUtil { public static class MinusculeMatcher implements Matcher { private final char[] myPattern; private final boolean myFirstLetterCaseMatters; + private final boolean myCaseMatters; - public MinusculeMatcher(String pattern, boolean firstLetterCaseMatters) { + public MinusculeMatcher(String pattern, boolean firstLetterCaseMatters, boolean caseMatters) { myFirstLetterCaseMatters = firstLetterCaseMatters; + myCaseMatters = caseMatters; + if (caseMatters) { + LOG.assertTrue(firstLetterCaseMatters); + } myPattern = StringUtil.trimEnd(pattern, "* ").replaceAll(":", "\\*:").replaceAll("\\.", "\\*\\.").toCharArray(); } @@ -496,14 +503,14 @@ public class NameUtil { return false; } - String w = words.get(wordIndex); + String word = words.get(wordIndex); if ('*' == myPattern[patternIndex]) { return handleAsterisk(patternIndex, words, wordIndex); } - if (isWordSeparator(w.charAt(0))) { - assert w.length() == 1 : "'" + w + "'"; + if (isWordSeparator(word.charAt(0))) { + assert word.length() == 1 : "'" + word + "'"; if (isWordSeparator(myPattern[patternIndex])) { return matches(patternIndex + 1, words, wordIndex + 1); } @@ -514,11 +521,11 @@ public class NameUtil { return matches(patternIndex, words, wordIndex + 1); } - if (patternIndex == 0 && myFirstLetterCaseMatters && w.charAt(0) != myPattern[0]) { + if (patternIndex == 0 && myFirstLetterCaseMatters && word.charAt(0) != myPattern[0]) { return false; } - if (StringUtil.toLowerCase(w.charAt(0)) != StringUtil.toLowerCase(myPattern[patternIndex])) { + if (StringUtil.toLowerCase(word.charAt(0)) != StringUtil.toLowerCase(myPattern[patternIndex])) { return false; } @@ -529,17 +536,21 @@ public class NameUtil { if (patternIndex + i == myPattern.length) { return true; } - if (i == w.length()) { + if (i == word.length()) { break; } char p = myPattern[patternIndex + i]; - if (uppers && isWordStart(p)) { + if (uppers && isWordStart(p) && !myCaseMatters) { p = StringUtil.toLowerCase(p); } else { uppers = false; } - if (StringUtil.toLowerCase(w.charAt(i)) != p) { + char w = word.charAt(i); + if (!myCaseMatters) { + w = StringUtil.toLowerCase(w); + } + if (w != p) { break; } i++; @@ -547,7 +558,7 @@ public class NameUtil { // there's more in the pattern, but no more words if (wordIndex == words.size() - 1) { if (patternIndex + i == myPattern.length - 1 && ' ' == myPattern[patternIndex + i]) { - return i == w.length(); + return i == word.length(); } return false;