public void addCompletions(
@NotNull CompletionParameters parameters,
ProcessingContext context,
@NotNull CompletionResultSet resultSet) {
PsiElement element = parameters.getPosition().getParent();
Project project = element.getProject();
if (!SilexProjectComponent.isEnabled(project)) {
return;
}
if (!(element instanceof StringLiteralExpression)) {
return;
}
Container container =
Utils.findContainerForFirstParameterOfPimpleMethod((StringLiteralExpression) element);
if (container == null) {
return;
}
for (Service service : container.getServices().values()) {
resultSet.addElement(new ServiceLookupElement(service, project));
}
for (Parameter parameter : container.getParameters().values()) {
resultSet.addElement(new ParameterLookupElement(parameter));
}
resultSet.stopHere();
}
private static void suggestChainedCalls(
CompletionParameters parameters, CompletionResultSet result, PsiElement position) {
PsiElement parent = position.getParent();
if (!(parent instanceof PsiJavaCodeReferenceElement)) {
return;
}
PsiElement qualifier = ((PsiJavaCodeReferenceElement) parent).getQualifier();
if (!(qualifier instanceof PsiJavaCodeReferenceElement)
|| ((PsiJavaCodeReferenceElement) qualifier).isQualified()
|| ((PsiJavaCodeReferenceElement) qualifier).resolve() != null) {
return;
}
String fullPrefix =
position
.getContainingFile()
.getText()
.substring(parent.getTextRange().getStartOffset(), parameters.getOffset());
CompletionResultSet qualifiedCollector = result.withPrefixMatcher(fullPrefix);
ElementFilter filter = JavaCompletionContributor.getReferenceFilter(position);
for (LookupElement base :
suggestQualifierItems(parameters, (PsiJavaCodeReferenceElement) qualifier, filter)) {
PsiType type = JavaCompletionUtil.getLookupElementType(base);
if (type != null && !PsiType.VOID.equals(type)) {
PsiReferenceExpression ref =
ReferenceExpressionCompletionContributor.createMockReference(position, type, base);
for (final LookupElement item :
JavaSmartCompletionContributor.completeReference(
position, ref, filter, true, true, parameters, result.getPrefixMatcher())) {
qualifiedCollector.addElement(new JavaChainLookupElement(base, item));
}
}
}
}
private static void addPathCompletions(
@NotNull CompletionResultSet result,
@NotNull BipartiteString caretBipartiteElementText,
@NotNull VirtualFile basePath,
boolean directoryExpected) {
ParentDirWithLastComponentPrefix parentWithLastComponentPrefix =
findParentDirWithLastComponentPrefix(basePath, caretBipartiteElementText.getPrefix());
if (parentWithLastComponentPrefix != null) {
PrefixMatcher matcher =
new StrictPrefixMatcher(parentWithLastComponentPrefix.getLastComponentPrefix(), false);
result = result.withPrefixMatcher(matcher);
VirtualFile parentFile = parentWithLastComponentPrefix.getParent();
VirtualFile[] children = parentFile.getChildren();
Character dirSeparatorSuffix =
extractDirectoryTrailingFileSeparator(caretBipartiteElementText);
if (parentFile.isDirectory()) {
result.addElement(LookupItem.fromString(".."));
}
for (VirtualFile child : children) {
if (child.isDirectory() || !directoryExpected) {
String name = child.getName();
if (child.isDirectory() && dirSeparatorSuffix != null) {
name += dirSeparatorSuffix;
}
result.addElement(LookupItem.fromString(name));
}
}
}
}
public static CompletionResultSet addJavaSorting(
final CompletionParameters parameters, CompletionResultSet result) {
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> afterProximity = new ArrayList<LookupElementWeigher>();
afterProximity.add(new PreferContainingSameWords(expectedTypes));
if (smart) {
afterProximity.add(new PreferFieldsAndGetters());
}
afterProximity.add(new PreferShorter(expectedTypes));
CompletionSorter sorter = CompletionSorter.defaultSorter(parameters, result.getPrefixMatcher());
if (!smart && afterNew) {
sorter = sorter.weighBefore("liftShorter", new PreferExpected(true, expectedTypes));
} else if (PsiTreeUtil.getParentOfType(position, PsiReferenceList.class) == null) {
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));
}
Collections.addAll(
afterPrefix,
new PreferByKindWeigher(type, position),
new PreferSimilarlyEnding(expectedTypes),
new PreferNonGeneric(),
new PreferAccessible(position),
new PreferSimple(),
new PreferEnumConstants(parameters));
sorter =
sorter.weighAfter(
"prefix", afterPrefix.toArray(new LookupElementWeigher[afterPrefix.size()]));
sorter =
sorter.weighAfter(
"proximity", afterProximity.toArray(new LookupElementWeigher[afterProximity.size()]));
return result.withRelevanceSorter(sorter);
}
@Override
public void fillCompletionVariants(CompletionParameters parameters, CompletionResultSet result) {
PsiFile file = parameters.getOriginalFile();
final Consumer<Task> consumer = file.getUserData(KEY);
if (CompletionService.getCompletionService().getAdvertisementText() == null) {
final String shortcut = getActionShortcut(IdeActions.ACTION_QUICK_JAVADOC);
if (shortcut != null) {
CompletionService.getCompletionService()
.setAdvertisementText(
"Pressing " + shortcut + " would show task description and comments");
}
}
if (consumer != null) {
result.stopHere();
String text = parameters.getOriginalFile().getText();
int i = text.lastIndexOf(' ', parameters.getOffset() - 1) + 1;
final String prefix = text.substring(i, parameters.getOffset());
if (parameters.getInvocationCount() == 0
&& !file.getUserData(AUTO_POPUP_KEY)) { // is autopopup
return;
}
result = result.withPrefixMatcher(new PlainPrefixMatcher(prefix));
final TaskSearchSupport searchSupport = new TaskSearchSupport(file.getProject());
List<Task> items = searchSupport.getItems(prefix, true);
addCompletionElements(result, consumer, items, -10000);
Future<List<Task>> future =
ApplicationManager.getApplication()
.executeOnPooledThread(
new Callable<List<Task>>() {
@Override
public List<Task> call() {
return searchSupport.getItems(prefix, false);
}
});
while (true) {
try {
List<Task> tasks = future.get(100, TimeUnit.MILLISECONDS);
if (tasks != null) {
addCompletionElements(result, consumer, tasks, 0);
return;
}
} catch (ProcessCanceledException e) {
throw e;
} catch (Exception ignore) {
}
ProgressManager.checkCanceled();
}
}
}
private static void addResult(
CompletionResultSet result, Collection<Lookup> collection, PsiElement position, int offset) {
result = result.withPrefixMatcher(findPrefixStatic(position, offset));
for (Lookup lookup : collection) {
final LookupItem<Lookup> item = new LookupItem<>(lookup, lookup.toString());
item.setInsertHandler(INSERT_HANDLER);
if (lookup.isKeyword()) {
item.setBold();
}
result.addElement(item);
}
}
@Override
protected void addCompletions(
@NotNull CompletionParameters completionParameters,
ProcessingContext processingContext,
@NotNull CompletionResultSet completionResultSet) {
YAMLKeyValue yamlKeyValue =
PsiTreeUtil.getParentOfType(
completionParameters.getOriginalPosition(), YAMLKeyValue.class);
if (yamlKeyValue != null) {
PsiElement compoundValue = yamlKeyValue.getParent();
if (compoundValue instanceof YAMLCompoundValue) {
// path and pattern are valid
String pattern =
YamlHelper.getYamlKeyValueAsString((YAMLCompoundValue) compoundValue, "path", false);
if (pattern == null) {
pattern =
YamlHelper.getYamlKeyValueAsString(
(YAMLCompoundValue) compoundValue, "pattern", false);
}
if (pattern != null) {
Matcher matcher = Pattern.compile("\\{(\\w+)}").matcher(pattern);
while (matcher.find()) {
completionResultSet.addElement(LookupElementBuilder.create(matcher.group(1)));
}
}
}
}
}
@Override
protected void addCompletions(
@NotNull CompletionParameters completionParameters,
ProcessingContext processingContext,
@NotNull CompletionResultSet completionResultSet) {
PsiElement position = completionParameters.getPosition();
if (!Symfony2ProjectComponent.isEnabled(position)) {
return;
}
YAMLCompoundValue yamlCompoundValue =
PsiTreeUtil.getParentOfType(position, YAMLCompoundValue.class);
if (yamlCompoundValue == null) {
return;
}
String className =
YamlHelper.getYamlKeyValueAsString(yamlCompoundValue, "targetEntity", false);
if (className == null) {
return;
}
PhpClass phpClass = PhpElementsUtil.getClass(position.getProject(), className);
if (phpClass == null) {
return;
}
for (DoctrineModelField field : EntityHelper.getModelFields(phpClass)) {
if (field.getRelation() != null) {
completionResultSet.addElement(new DoctrineModelFieldLookupElement(field));
}
}
}
@Override
protected void addCompletions(
@NotNull CompletionParameters parameters,
ProcessingContext processingContext,
@NotNull CompletionResultSet completionResultSet) {
PsiElement position = parameters.getPosition();
if (!Symfony2ProjectComponent.isEnabled(position)) {
return;
}
PsiElement prevSiblingOfType =
PsiElementUtils.getPrevSiblingOfType(
position, YamlElementPatternHelper.getPreviousCommaSibling());
if (prevSiblingOfType == null) {
return;
}
String service = PsiElementUtils.trimQuote(prevSiblingOfType.getText());
if (StringUtils.isBlank(service)) {
return;
}
PhpClass phpClass = ServiceUtil.getServiceClass(prevSiblingOfType.getProject(), service);
if (phpClass == null) {
return;
}
for (Method method : phpClass.getMethods()) {
if (method.getAccess().isPublic() && !(method.getName().startsWith("__"))) {
completionResultSet.addElement(new PhpLookupElement(method));
}
}
}
private static void addInheritors(
CompletionParameters parameters,
final CompletionResultSet resultSet,
final PsiClass referencedClass,
final int parameterIndex) {
final List<PsiClassType> typeList =
Collections.singletonList(
(PsiClassType)
TypeConversionUtil.typeParameterErasure(
referencedClass.getTypeParameters()[parameterIndex]));
JavaInheritorsGetter.processInheritors(
parameters,
typeList,
resultSet.getPrefixMatcher(),
new Consumer<PsiType>() {
@Override
public void consume(final PsiType type) {
final PsiClass psiClass = PsiUtil.resolveClassInType(type);
if (psiClass == null) return;
resultSet.addElement(
TailTypeDecorator.withTail(
new JavaPsiClassReferenceElement(psiClass),
getTail(parameterIndex == referencedClass.getTypeParameters().length - 1)));
}
});
}
@Override
protected void addCompletions(
@NotNull CompletionParameters parameters,
ProcessingContext context,
@NotNull CompletionResultSet result) {
for (String[] completion :
RegExpLanguageHosts.getInstance().getPosixCharacterClasses(parameters.getPosition())) {
result.addElement(
LookupElementBuilder.create(completion[0])
.withTypeText((completion.length > 1) ? completion[1] : null)
.withIcon(emptyIcon)
.withInsertHandler(
new InsertHandler<LookupElement>() {
@Override
public void handleInsert(InsertionContext context, LookupElement item) {
context.setAddCompletionChar(false);
final Editor editor = context.getEditor();
final Document document = editor.getDocument();
final int tailOffset = context.getTailOffset();
if (document.getTextLength() < tailOffset + 2
|| !document
.getText(new TextRange(tailOffset, tailOffset + 2))
.equals(":]")) {
document.insertString(tailOffset, ":]");
}
editor.getCaretModel().moveCaretRelatively(2, 0, false, false, true);
}
}));
}
}
public static void addAllClasses(
CompletionParameters parameters,
final CompletionResultSet result,
final InheritorsHolder inheritors) {
if (!isClassNamePossible(parameters) || !mayStartClassName(result)) {
return;
}
if (parameters.getInvocationCount() >= 2) {
JavaClassNameCompletionContributor.addAllClasses(
parameters,
parameters.getInvocationCount() <= 2,
result.getPrefixMatcher(),
new Consumer<LookupElement>() {
@Override
public void consume(LookupElement element) {
if (!inheritors.alreadyProcessed(element)) {
result.addElement(element);
}
}
});
} else {
advertiseSecondCompletion(parameters.getPosition().getProject(), result);
}
}
public static void fillCompletionVariants(
CompletionParameters parameters, CompletionResultSet result) {
if (parameters.getCompletionType() != CompletionType.BASIC
&& parameters.getCompletionType() != CompletionType.SMART) {
return;
}
PsiElement position = parameters.getPosition();
if (psiElement(PsiIdentifier.class)
.withParents(PsiJavaCodeReferenceElement.class, PsiTypeElement.class, PsiClass.class)
.andNot(JavaCompletionData.AFTER_DOT)
.andNot(psiElement().afterLeaf(psiElement().inside(PsiModifierList.class)))
.accepts(position)) {
suggestGeneratedMethods(result, position);
} else if (psiElement(PsiIdentifier.class)
.withParents(
PsiJavaCodeReferenceElement.class,
PsiAnnotation.class,
PsiModifierList.class,
PsiClass.class)
.accepts(position)) {
PsiAnnotation annotation =
ObjectUtils.assertNotNull(PsiTreeUtil.getParentOfType(position, PsiAnnotation.class));
int annoStart = annotation.getTextRange().getStartOffset();
suggestGeneratedMethods(
result.withPrefixMatcher(
annotation.getText().substring(0, parameters.getOffset() - annoStart)),
position);
}
}
@Override
public void fillCompletionVariants(CompletionParameters parameters, CompletionResultSet result) {
PsiElement position = parameters.getPosition();
JavaClassReference reference =
findJavaClassReference(position.getContainingFile(), parameters.getOffset());
if (reference == null) {
return;
}
String[] extendClassNames = reference.getExtendClassNames();
PsiElement context = reference.getCompletionContext();
if (extendClassNames != null && context instanceof PsiJavaPackage) {
if (parameters.getCompletionType() == CompletionType.SMART) {
JavaClassReferenceSet set = reference.getJavaClassReferenceSet();
int setStart =
set.getRangeInElement().getStartOffset()
+ set.getElement().getTextRange().getStartOffset();
String fullPrefix =
parameters
.getPosition()
.getContainingFile()
.getText()
.substring(setStart, parameters.getOffset());
reference.processSubclassVariants(
(PsiJavaPackage) context, extendClassNames, result.withPrefixMatcher(fullPrefix));
return;
}
result.addLookupAdvertisement(
"Press "
+ getActionShortcut(IdeActions.ACTION_SMART_TYPE_COMPLETION)
+ " to see inheritors of "
+ StringUtil.join(extendClassNames, ", "));
}
if (parameters.getCompletionType() == CompletionType.SMART) {
return;
}
if (parameters.isExtendedCompletion()
|| parameters.getCompletionType() == CompletionType.CLASS_NAME) {
JavaClassNameCompletionContributor.addAllClasses(parameters, result);
} else {
LegacyCompletionContributor.completeReference(parameters, result);
}
result.stopHere();
}
private void addLanguageKeyword(CompletionResultSet resultSet, String text) {
// TODO:: order most common used first
String keywords =
"|abs|accept|alarm|atan2|AUTOLOAD|BEGIN|bind|binmode|bless|break|caller|chdir|CHECK|chmod|chomp|chop|chown|chr|chroot|close|closedir|connect|cos|crypt|dbmclose|dbmopen|defined|delete|DESTROY|die|dump|each|END|endgrent|endhostent|endnetent|endprotoent|endpwent|endservent|eof|eval|exec|exists|exit|fcntl|fileno|flock|fork|format|formline|getc|getgrent|getgrgid|getgrnam|gethostbyaddr|gethostbyname|gethostent|getlogin|getnetbyaddr|getnetbyname|getnetent|getpeername|getpgrp|getppid|getpriority|getprotobyname|getprotobynumber|getprotoent|getpwent|getpwnam|getpwuid|getservbyname|getservbyport|getservent|getsockname|getsockopt|glob|gmtime|goto|grep|hex|index|INIT|int|ioctl|join|keys|kill|last|lc|each|lcfirst|setnetent|length|link|listen|local|localtime|log|lstat|map|mkdir|msgctl|msgget|msgrcv|msgsnd|next|not|oct|open|opendir|ord|our|pack|pipe|pop|pos|print|printf|prototype|push|quotemeta|rand|read|readdir|readline|readlink|readpipe|recv|redo|ref|rename|require|reset|return|reverse|rewinddir|rindex|rmdir|say|scalar|seek|seekdir|select|semctl|semget|semop|send|setgrent|sethostent|each|lcfirst|setnetent|setpgrp|setpriority|setprotoent|setpwent|setservent|setsockopt|shift|shmctl|shmget|shmread|shmwrite|shutdown|sin|sleep|socket|socketpair|sort|splice|split|sprintf|sqrt|srand|stat|state|study|substr|symlink|syscall|sysopen|sysread|sysseek|system|syswrite|tell|telldir|tie|tied|time|times|truncate|ucfirst|umask|undef|UNITCHECK|unlink|unpack|unshift|untie|use|utime|values|vec|wait|waitpid|wantarray|warn|write|each|lcfirst|setnetent|cmp|continue|CORE|else|elsif|exp|for|foreach|lock|package|unless|until|while|ARGV|ARGVOUT|STDERR|STDIN|STDOUT";
Matcher matcher = Utils.applyRegex("\\|(" + text + "[^\\|]+)", keywords);
while (matcher.find()) {
resultSet.addElement(LookupElementBuilder.create(matcher.group(1)));
}
}
private static void ensureTemplatesShown(
Ref<Boolean> templatesShown, List<TemplateImpl> templates, CompletionResultSet result) {
if (!templatesShown.get()) {
templatesShown.set(true);
for (final TemplateImpl possible : templates) {
result.addElement(new LiveTemplateLookupElement(possible, false));
}
}
}
private static void addKeywords(CompletionParameters parameters, CompletionResultSet result) {
PsiElement position = parameters.getPosition();
final Set<LookupElement> lookupSet = new LinkedHashSet<LookupElement>();
final Set<CompletionVariant> keywordVariants = new HashSet<CompletionVariant>();
final JavaCompletionData completionData = getCompletionData(PsiUtil.getLanguageLevel(position));
completionData.addKeywordVariants(keywordVariants, position, parameters.getOriginalFile());
completionData.completeKeywordsBySet(
lookupSet,
keywordVariants,
position,
result.getPrefixMatcher(),
parameters.getOriginalFile());
completionData.fillCompletions(parameters, result);
for (final LookupElement item : lookupSet) {
result.addElement(item);
}
}
public static void advertiseSecondCompletion(Project project, CompletionResultSet result) {
if (FeatureUsageTracker.getInstance()
.isToBeAdvertisedInLookup(CodeCompletionFeatures.SECOND_BASIC_COMPLETION, project)) {
result.addLookupAdvertisement(
"Press "
+ getActionShortcut(IdeActions.ACTION_CODE_COMPLETION)
+ " to see non-imported classes");
}
}
@Override
public void fillCompletionVariants(
@NotNull final CompletionParameters parameters, @NotNull final CompletionResultSet result) {
final JavaCompletionSession session = new JavaCompletionSession(result);
ResultTracker tracker =
new ResultTracker(result) {
@Override
public void consume(CompletionResult plainResult) {
super.consume(plainResult);
LookupElement element = plainResult.getLookupElement();
Object o = element.getObject();
if (o instanceof PsiClass) {
session.registerClass((PsiClass) o);
}
if (element instanceof TypeArgumentCompletionProvider.TypeArgsLookupElement) {
((TypeArgumentCompletionProvider.TypeArgsLookupElement) element)
.registerSingleClass(session);
}
}
};
result.runRemainingContributors(parameters, tracker);
final boolean empty = tracker.containsOnlyPackages || suggestAllAnnotations(parameters);
if (!empty && parameters.getInvocationCount() == 0) {
result.restartCompletionWhenNothingMatches();
}
if (empty) {
delegate(parameters, JavaCompletionSorting.addJavaSorting(parameters, result), session);
} else if (Registry.is("ide.completion.show.better.matching.classes")) {
if (parameters.getCompletionType() == CompletionType.BASIC
&& parameters.getInvocationCount() <= 1
&& JavaCompletionContributor.mayStartClassName(result)
&& JavaCompletionContributor.isClassNamePossible(parameters)
&& !JavaSmartCompletionContributor.AFTER_NEW.accepts(parameters.getPosition())) {
suggestNonImportedClasses(
parameters,
JavaCompletionSorting.addJavaSorting(
parameters, result.withPrefixMatcher(tracker.betterMatcher)),
session);
}
}
}
private static void suggestCollectionUtilities(
CompletionParameters parameters, final CompletionResultSet result, PsiElement position) {
if (StringUtil.isNotEmpty(result.getPrefixMatcher().getPrefix())) {
for (ExpectedTypeInfo info : JavaSmartCompletionContributor.getExpectedTypes(parameters)) {
new CollectionsUtilityMethodsProvider(
position, info.getType(), info.getDefaultType(), result)
.addCompletions(true);
}
}
}
private static void addCachedPackage(CompletionResultSet resultSet, Package packageObj) {
if (packageObj != null && !packagesCache.containsKey(packageObj)) {
if (Utils.verbose) {
Utils.print("cache package: " + packageObj.getQualifiedName());
}
packagesCache.put(packageObj, getPackageLookupElementBuilder(packageObj));
}
if (resultSet != null) {
resultSet.addElement(packagesCache.get(packageObj));
}
}
private static void addCachedVariables(CompletionResultSet resultSet, String str) {
if (str != null && !variablesCache.containsKey(str)) {
if (Utils.verbose) {
Utils.print("cache variable: " + str);
}
variablesCache.put(str, getVariableLookupElementBuilder(str));
}
if (resultSet != null) {
resultSet.addElement(variablesCache.get(str));
}
}
private static void addTopLevelKeysCompletionIfNeeded(
@NotNull CompletionParameters parameters,
@NotNull CompletionResultSet result,
@NotNull BipartiteString caretBipartiteElementText) {
PsiElement element = parameters.getPosition();
YAMLDocument yamlDocument = ObjectUtils.tryCast(element.getParent(), YAMLDocument.class);
if (yamlDocument == null) {
yamlDocument =
JstdConfigFileUtils.getVerifiedHierarchyHead(
element.getParent(), new Class[] {YAMLKeyValue.class}, YAMLDocument.class);
}
if (yamlDocument != null) {
String prefix = caretBipartiteElementText.getPrefix();
result = result.withPrefixMatcher(prefix);
for (String key : JstdConfigFileUtils.VALID_TOP_LEVEL_KEYS) {
if (key.startsWith(prefix)) {
result.addElement(LookupItem.fromString(key + ":"));
}
}
}
}
@Override
public void consume(CompletionResult plainResult) {
myResult.passResult(plainResult);
LookupElement element = plainResult.getLookupElement();
if (containsOnlyPackages
&& !(CompletionUtil.getTargetElement(element) instanceof PsiPackage)) {
containsOnlyPackages = false;
}
betterMatcher = betterMatcher.improve(plainResult);
}
@Override
public void addCompletions(
@NotNull final CompletionParameters parameters,
final ProcessingContext context,
@NotNull final CompletionResultSet result) {
for (String[] stringArray :
RegExpLanguageHosts.getInstance().getAllKnownProperties(parameters.getPosition())) {
result.addElement(
TailTypeDecorator.withTail(
createLookupElement(stringArray[0], null, emptyIcon),
TailType.createSimpleTailType('}')));
}
}
@Override
protected void addCompletions(
@NotNull CompletionParameters parameters,
ProcessingContext context,
@NotNull CompletionResultSet result) {
UnicodeCharacterNames.iterate(
name -> {
if (result.getPrefixMatcher().prefixMatches(name)) {
final String type =
new String(new int[] {UnicodeCharacterNames.getCodePoint(name)}, 0, 1);
if (myEmbrace) {
result.addElement(createLookupElement("{" + name + "}", type, emptyIcon));
} else {
result.addElement(
TailTypeDecorator.withTail(
createLookupElement(name, type, emptyIcon),
TailType.createSimpleTailType('}')));
}
}
ProgressManager.checkCanceled();
});
}
private static void fillExpectedTypeArgs(
CompletionResultSet resultSet,
PsiElement context,
final PsiClass actualClass,
final int index,
PsiClassType.ClassResolveResult expectedType,
TailType globalTail) {
final PsiClass expectedClass = expectedType.getElement();
if (!InheritanceUtil.isInheritorOrSelf(actualClass, expectedClass, true)) return;
assert expectedClass != null;
final PsiSubstitutor currentSubstitutor =
TypeConversionUtil.getClassSubstitutor(expectedClass, actualClass, PsiSubstitutor.EMPTY);
assert currentSubstitutor != null;
PsiTypeParameter[] params = actualClass.getTypeParameters();
final List<PsiTypeLookupItem> typeItems = new ArrayList<PsiTypeLookupItem>();
for (int i = index; i < params.length; i++) {
PsiType arg = getExpectedTypeArg(context, i, expectedType, currentSubstitutor, params);
if (arg == null) {
arg = getExpectedTypeArg(context, index, expectedType, currentSubstitutor, params);
if (arg != null) {
resultSet.addElement(
TailTypeDecorator.withTail(
PsiTypeLookupItem.createLookupItem(arg, context),
getTail(index == params.length - 1)));
}
return;
}
typeItems.add(PsiTypeLookupItem.createLookupItem(arg, context));
}
resultSet.addElement(
new TypeArgsLookupElement(
typeItems,
globalTail,
ConstructorInsertHandler.hasConstructorParameters(actualClass, context)));
}
@Override
public boolean process(
@NotNull String name,
@NotNull GoNamedElement element,
@NotNull ExistingImportData importData,
@NotNull CompletionResultSet result) {
GoTypeSpec spec = ((GoTypeSpec) element);
boolean forTypes = myParent instanceof GoTypeReferenceExpression;
double priority;
if (importData.exists) {
priority = forTypes ? GoCompletionUtil.TYPE_PRIORITY : GoCompletionUtil.TYPE_CONVERSION;
} else {
priority =
forTypes
? GoCompletionUtil.NOT_IMPORTED_TYPE_PRIORITY
: GoCompletionUtil.NOT_IMPORTED_TYPE_CONVERSION;
}
String lookupString = replacePackageWithAlias(name, importData.alias);
if (forTypes) {
result.addElement(
GoCompletionUtil.createTypeLookupElement(
spec,
lookupString,
GoAutoImportInsertHandler.SIMPLE_INSERT_HANDLER,
importData.importPath,
priority));
} else {
result.addElement(
GoCompletionUtil.createTypeConversionLookupElement(
spec,
lookupString,
GoAutoImportInsertHandler.TYPE_CONVERSION_INSERT_HANDLER,
importData.importPath,
priority));
}
return true;
}
private static void suggestNonImportedClasses(
CompletionParameters parameters,
CompletionResultSet result,
@Nullable JavaCompletionSession session) {
JavaClassNameCompletionContributor.addAllClasses(
parameters,
true,
result.getPrefixMatcher(),
element -> {
if (session != null && session.alreadyProcessed(element)) {
return;
}
JavaPsiClassReferenceElement classElement =
element.as(JavaPsiClassReferenceElement.CLASS_CONDITION_KEY);
if (classElement != null) {
classElement.setAutoCompletionPolicy(AutoCompletionPolicy.NEVER_AUTOCOMPLETE);
element =
JavaClassNameCompletionContributor.highlightIfNeeded(classElement, parameters);
}
result.addElement(element);
});
}
private static void addCachedSubNoArgs(CompletionResultSet resultSet, Sub sub) {
if (!subsCacheNoArgs.containsKey(sub)) {
if (Utils.verbose) {
Utils.print(
"cache sub(no args): "
+ sub.getName()
+ " , containingPackage:"
+ sub.getPackageObj().getQualifiedName());
}
subsCacheNoArgs.put(sub, getSubLookupElementBuilder(sub, false));
}
if (resultSet != null) {
resultSet.addElement(subsCacheNoArgs.get(sub));
}
}
