1 files changed, 18 insertions, 32 deletions

diff --git a/java/java-impl/src/com/intellij/codeInsight/completion/JavaCompletionSorting.java b/java/java-impl/src/com/intellij/codeInsight/completion/JavaCompletionSorting.java
index 236e2e6768f6..853debf37051 100644
--- a/java/java-impl/src/com/intellij/codeInsight/completion/JavaCompletionSorting.java
+++ b/java/java-impl/src/com/intellij/codeInsight/completion/JavaCompletionSorting.java
@@ -51,26 +51,18 @@ public class JavaCompletionSorting {
   }
 
   public static CompletionResultSet addJavaSorting(final CompletionParameters parameters, CompletionResultSet result) {
-    String prefix = result.getPrefixMatcher().getPrefix();
     final PsiElement position = parameters.getPosition();
     final ExpectedTypeInfo[] expectedTypes = PsiJavaPatterns.psiElement().beforeLeaf(PsiJavaPatterns.psiElement().withText(".")).accepts(position) ? ExpectedTypeInfo.EMPTY_ARRAY : JavaSmartCompletionContributor.getExpectedTypes(parameters);
     final CompletionType type = parameters.getCompletionType();
     final boolean smart = type == CompletionType.SMART;
     final boolean afterNew = JavaSmartCompletionContributor.AFTER_NEW.accepts(position);
 
-    List<LookupElementWeigher> afterPriority = new ArrayList<LookupElementWeigher>();
-    if (smart) {
-      afterPriority.add(new PreferDefaultTypeWeigher(expectedTypes, parameters));
-    }
-    ContainerUtil.addIfNotNull(afterPriority, recursion(parameters, expectedTypes));
-    afterPriority.add(new PreferSimilarlyEnding(expectedTypes, prefix));
-
     List<LookupElementWeigher> afterProximity = new ArrayList<LookupElementWeigher>();
     afterProximity.add(new PreferContainingSameWords(expectedTypes));
     if (smart) {
       afterProximity.add(new PreferFieldsAndGetters());
     }
-    afterProximity.add(new PreferShorter(expectedTypes, prefix));
+    afterProximity.add(new PreferShorter(expectedTypes));
 
     CompletionSorter sorter = CompletionSorter.defaultSorter(parameters, result.getPrefixMatcher());
     if (!smart && afterNew) {
@@ -78,20 +70,22 @@ public class JavaCompletionSorting {
     } else {
       sorter = ((CompletionSorterImpl)sorter).withClassifier("liftShorterClasses", true, new LiftShorterClasses(position));
     }
+    if (smart) {
+      sorter = sorter.weighAfter("priority", new PreferDefaultTypeWeigher(expectedTypes, parameters));
+    }
 
     List<LookupElementWeigher> afterPrefix = ContainerUtil.newArrayList();
     if (!smart) {
       ContainerUtil.addIfNotNull(afterPrefix, preferStatics(position, expectedTypes));
     }
+    ContainerUtil.addIfNotNull(afterPrefix, recursion(parameters, expectedTypes));
     if (!smart && !afterNew) {
       afterPrefix.add(new PreferExpected(false, expectedTypes));
     }
-    afterPrefix.add(new PreferByKindWeigher(type, position));
-    Collections.addAll(afterPrefix, new PreferNonGeneric(), new PreferAccessible(position), new PreferSimple(),
+    Collections.addAll(afterPrefix, new PreferByKindWeigher(type, position), new PreferSimilarlyEnding(expectedTypes),
+                       new PreferNonGeneric(), new PreferAccessible(position), new PreferSimple(),
                        new PreferEnumConstants(parameters));
-    
-    
-    sorter = sorter.weighAfter("priority", afterPriority.toArray(new LookupElementWeigher[afterPriority.size()]));
+
     sorter = sorter.weighAfter("prefix", afterPrefix.toArray(new LookupElementWeigher[afterPrefix.size()]));
     sorter = sorter.weighAfter("proximity", afterProximity.toArray(new LookupElementWeigher[afterProximity.size()]));
     return result.withRelevanceSorter(sorter);
@@ -207,18 +201,14 @@ public class JavaCompletionSorting {
     return null;
   }
 
-  private static int getNameEndMatchingDegree(final String name, ExpectedTypeInfo[] expectedInfos, String prefix) {
+  private static int getNameEndMatchingDegree(final String name, ExpectedTypeInfo[] expectedInfos) {
     int res = 0;
     if (name != null && expectedInfos != null) {
-      if (prefix.equals(name)) {
-        res = Integer.MAX_VALUE;
-      } else {
-        final List<String> words = NameUtil.nameToWordsLowerCase(name);
-        final List<String> wordsNoDigits = NameUtil.nameToWordsLowerCase(truncDigits(name));
-        int max1 = calcMatch(words, 0, expectedInfos);
-        max1 = calcMatch(wordsNoDigits, max1, expectedInfos);
-        res = max1;
-      }
+      final List<String> words = NameUtil.nameToWordsLowerCase(name);
+      final List<String> wordsNoDigits = NameUtil.nameToWordsLowerCase(truncDigits(name));
+      int max1 = calcMatch(words, 0, expectedInfos);
+      max1 = calcMatch(wordsNoDigits, max1, expectedInfos);
+      res = max1;
     }
 
     return res;
@@ -457,19 +447,17 @@ public class JavaCompletionSorting {
 
   private static class PreferSimilarlyEnding extends LookupElementWeigher {
     private final ExpectedTypeInfo[] myExpectedTypes;
-    private final String myPrefix;
 
-    public PreferSimilarlyEnding(ExpectedTypeInfo[] expectedTypes, String prefix) {
+    public PreferSimilarlyEnding(ExpectedTypeInfo[] expectedTypes) {
       super("nameEnd");
       myExpectedTypes = expectedTypes;
-      myPrefix = prefix;
     }
 
     @NotNull
     @Override
     public Comparable weigh(@NotNull LookupElement element) {
       final String name = getLookupObjectName(element.getObject());
-      return -getNameEndMatchingDegree(name, myExpectedTypes, myPrefix);
+      return -getNameEndMatchingDegree(name, myExpectedTypes);
     }
   }
 
@@ -521,12 +509,10 @@ public class JavaCompletionSorting {
 
   private static class PreferShorter extends LookupElementWeigher {
     private final ExpectedTypeInfo[] myExpectedTypes;
-    private final String myPrefix;
 
-    public PreferShorter(ExpectedTypeInfo[] expectedTypes, String prefix) {
+    public PreferShorter(ExpectedTypeInfo[] expectedTypes) {
       super("shorter");
       myExpectedTypes = expectedTypes;
-      myPrefix = prefix;
     }
 
     @NotNull
@@ -535,7 +521,7 @@ public class JavaCompletionSorting {
       final Object object = element.getObject();
       final String name = getLookupObjectName(object);
 
-      if (name != null && getNameEndMatchingDegree(name, myExpectedTypes, myPrefix) != 0) {
+      if (name != null && getNameEndMatchingDegree(name, myExpectedTypes) != 0) {
         return NameUtil.nameToWords(name).length - 1000;
       }
       return 0;