CompletionLocation myLocation = new CompletionLocation(indicator.getParameters());
final StatisticsInfo main = StatisticsManager.serialize(CompletionService.STATISTICS_KEY, item, myLocation);
final List<LookupElement> items = lookupImpl.getItems();
- final int count = Math.min(lookupImpl.getPreferredItemsCount(), lookupImpl.getList().getSelectedIndex());
+ final int count = Math.min(3, lookupImpl.getList().getSelectedIndex());
final List<StatisticsInfo> ignored = new ArrayList<StatisticsInfo>();
for (int i = 0; i < count; i++) {
}
private Color getItemBackground(JList list, int index, boolean isSelected) {
- final int preferredCount = myLookup.getPreferredItemsCount();
- final boolean isPreferred = index <= preferredCount - 1 && preferredCount < list.getModel().getSize() - 1 && LookupImpl.limitRelevance();
-
- if (isPreferred) {
- return isSelected ? SELECTED_BACKGROUND_COLOR : PREFERRED_BACKGROUND_COLOR;
- }
return isSelected ? SELECTED_BACKGROUND_COLOR : BACKGROUND_COLOR;
}
import com.intellij.openapi.util.Disposer;
import com.intellij.openapi.util.IconLoader;
import com.intellij.openapi.util.Trinity;
-import com.intellij.openapi.util.registry.Registry;
import com.intellij.openapi.util.text.StringUtil;
import com.intellij.psi.PsiDocumentManager;
import com.intellij.psi.PsiElement;
private final Project myProject;
private final Editor myEditor;
- private int myPreferredItemsCount;
private String myInitialPrefix;
private boolean myStableStart;
}
}
- public int getPreferredItemsCount() {
- return myPreferredItemsCount;
- }
-
public void markSelectionTouched() {
if (!ApplicationManager.getApplication().isUnitTestMode()) {
ApplicationManager.getApplication().assertIsDispatchThread();
}
}
- myPreferredItemsCount = model.size();
myFrozenItems.clear();
if (myShown) {
myFrozenItems.addAll(model);
}
});
model.addAll(elements);
- } else if (limitRelevance()) {
- model.addAll(addRemainingItemsLexicographically(model, items));
} else {
for (List<LookupElement> group : snapshot.second) {
for (LookupElement element : group) {
return p;
}
- private static List<LookupElement> addRemainingItemsLexicographically(Set<LookupElement> firstItems, Collection<LookupElement> allItems) {
- List<LookupElement> model = new ArrayList<LookupElement>();
- for (LookupElement item : allItems) {
- if (!firstItems.contains(item)) {
- model.add(item);
- }
- }
- return model;
- }
-
private void addMostRelevantItems(final Set<LookupElement> model, final Iterable<List<LookupElement>> sortedItems) {
if (model.size() > MAX_PREFERRED_COUNT) return;
}
}
- public static boolean limitRelevance() {
- return Registry.is("limited.relevance.sorting.in.completion");
- }
-
public boolean isFrozen(@NotNull LookupElement element) {
return myFrozenItems.contains(element);
}
import com.intellij.openapi.diagnostic.Logger;
import com.intellij.openapi.editor.Editor;
import com.intellij.openapi.project.DumbAware;
+import com.intellij.openapi.util.text.StringUtil;
+import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
}
public static void dumpLookupElementWeights(final LookupImpl lookup) {
- final LinkedHashMap<LookupElement,StringBuilder> strings = lookup.getRelevanceStrings();
-
- final List<LookupElement> items = lookup.getItems();
- final int count = lookup.getPreferredItemsCount();
+ String sb = StringUtil.join(getLookupElementWeights(lookup), "\n");
+ System.out.println(sb);
+ LOG.info(sb);
+ }
- for (int i = 0; i < items.size(); i++) {
- LookupElement item = items.get(i);
+ public static List<String> getLookupElementWeights(LookupImpl lookup) {
+ final LinkedHashMap<LookupElement,StringBuilder> strings = lookup.getRelevanceStrings();
+ List<String> sb = new ArrayList<String>();
+ for (LookupElement item : lookup.getItems()) {
String weight = strings.get(item).toString();
final String s = item.getLookupString() + (lookup.isFrozen(item) ? "\t_first_\t" : "\t") + weight;
- System.out.println(s);
- LOG.info(s);
- if (i == count - 1) {
- final String separator = "------------";
- System.out.println(separator);
- LOG.info(separator);
- }
+ sb.add(s);
}
+ return sb;
}
-
}
\ No newline at end of file
ide.mac.useNativeClipboard=false
show.all.classes.on.first.completion=false
-limited.relevance.sorting.in.completion=false
-limited.relevance.sorting.in.completion.description=Whether only 5 most relevant items are shown at the top of the completion list, or it's sorted by relevance completely
ide.enable.toolwindow.stack=false
change.signature.awesome.mode=true
import com.intellij.ide.startup.impl.StartupManagerImpl;
import com.intellij.ide.structureView.StructureViewBuilder;
import com.intellij.ide.structureView.newStructureView.StructureViewComponent;
+import com.intellij.internal.DumpLookupElementWeights;
import com.intellij.lang.LanguageStructureViewBuilder;
import com.intellij.openapi.Disposable;
import com.intellij.openapi.actionSystem.*;
final LookupImpl lookup = getLookup();
assertNotNull(lookup);
- final LinkedHashMap<LookupElement,StringBuilder> relevanceStrings = lookup.getRelevanceStrings();
-
final JList list = lookup.getList();
- final List<LookupElement> model = lookup.getItems();
- final List<String> actual = new ArrayList<String>();
- final int count = lookup.getPreferredItemsCount();
- for (int i = 0; i < count; i++) {
- actual.add(model.get(i).getLookupString());
- }
+ List<String> strings = getLookupElementStrings();
+ assert strings != null;
+ final List<String> actual = strings.subList(0, Math.min(expected.length, strings.size()));
if (!actual.equals(Arrays.asList(expected))) {
- final List<String> strings = new ArrayList<String>();
- for (int i = 0; i < model.size(); i++) {
- final LookupElement item = model.get(i);
- strings.add(item.getLookupString() + " " + relevanceStrings.get(item));
- if (i == count - 1) {
- strings.add("---");
- }
- }
- assertOrderedEquals(strings, expected);
+ assertOrderedEquals(DumpLookupElementWeights.getLookupElementWeights(lookup), expected);
}
assertEquals(selected, list.getSelectedIndex());
}