protected void addLookupItem(
Set<LookupElement> set,
TailType tailType,
@NotNull Object completion,
final PsiFile file,
final CompletionVariant variant) {
LookupElement ret = objectToLookupItem(completion);
if (ret == null) return;
if (!(ret instanceof LookupItem)) {
set.add(ret);
return;
}
LookupItem item = (LookupItem) ret;
final InsertHandler insertHandler = variant.getInsertHandler();
if (insertHandler != null && item.getInsertHandler() == null) {
item.setInsertHandler(insertHandler);
item.setTailType(TailType.UNKNOWN);
} else if (tailType != TailType.NONE) {
item.setTailType(tailType);
}
final Map<Object, Object> itemProperties = variant.getItemProperties();
for (final Object key : itemProperties.keySet()) {
item.setAttribute(key, itemProperties.get(key));
}
set.add(ret);
}
@Override
public String handleEmptyLookup(
@NotNull final CompletionParameters parameters, final Editor editor) {
if (!(parameters.getOriginalFile() instanceof PsiJavaFile)) return null;
final String ad = advertise(parameters);
final String suffix = ad == null ? "" : "; " + StringUtil.decapitalize(ad);
if (parameters.getCompletionType() == CompletionType.SMART) {
if (!ApplicationManager.getApplication().isUnitTestMode()) {
final Project project = parameters.getPosition().getProject();
final PsiFile file = parameters.getOriginalFile();
PsiExpression expression =
PsiTreeUtil.getContextOfType(parameters.getPosition(), PsiExpression.class, true);
if (expression != null && expression.getParent() instanceof PsiExpressionList) {
int lbraceOffset = expression.getParent().getTextRange().getStartOffset();
ShowParameterInfoHandler.invoke(project, editor, file, lbraceOffset, null);
}
if (expression instanceof PsiLiteralExpression) {
return LangBundle.message("completion.no.suggestions") + suffix;
}
if (expression instanceof PsiInstanceOfExpression) {
final PsiInstanceOfExpression instanceOfExpression = (PsiInstanceOfExpression) expression;
if (PsiTreeUtil.isAncestor(
instanceOfExpression.getCheckType(), parameters.getPosition(), false)) {
return LangBundle.message("completion.no.suggestions") + suffix;
}
}
}
final Set<PsiType> expectedTypes = JavaCompletionUtil.getExpectedTypes(parameters);
if (expectedTypes != null) {
PsiType type = expectedTypes.size() == 1 ? expectedTypes.iterator().next() : null;
if (type != null) {
final PsiType deepComponentType = type.getDeepComponentType();
if (deepComponentType instanceof PsiClassType) {
if (((PsiClassType) deepComponentType).resolve() != null) {
return CompletionBundle.message(
"completion.no.suggestions.of.type", type.getPresentableText())
+ suffix;
}
return CompletionBundle.message("completion.unknown.type", type.getPresentableText())
+ suffix;
}
if (!PsiType.NULL.equals(type)) {
return CompletionBundle.message(
"completion.no.suggestions.of.type", type.getPresentableText())
+ suffix;
}
}
}
}
return LangBundle.message("completion.no.suggestions") + suffix;
}
@Nullable
public static Set<PsiType> getExpectedTypes(final CompletionParameters parameters) {
final PsiExpression expr =
PsiTreeUtil.getContextOfType(parameters.getPosition(), PsiExpression.class, true);
if (expr != null) {
final Set<PsiType> set = new THashSet<PsiType>();
for (final ExpectedTypeInfo expectedInfo :
JavaSmartCompletionContributor.getExpectedTypes(parameters)) {
set.add(expectedInfo.getType());
}
return set;
}
return null;
}
protected boolean isScopeFinal(Class scopeClass) {
if (myFinalScopes.contains(scopeClass)) return true;
for (final Class myFinalScope : myFinalScopes) {
if (ReflectionCache.isAssignable(myFinalScope, scopeClass)) {
return true;
}
}
return false;
}
public static Set<String> getAllLookupStrings(@NotNull PsiMember member) {
Set<String> allLookupStrings = ContainerUtil.newLinkedHashSet();
String name = member.getName();
allLookupStrings.add(name);
PsiClass containingClass = member.getContainingClass();
while (containingClass != null) {
final String className = containingClass.getName();
if (className == null) {
break;
}
name = className + "." + name;
allLookupStrings.add(name);
final PsiElement parent = containingClass.getParent();
if (!(parent instanceof PsiClass)) {
break;
}
containingClass = (PsiClass) parent;
}
return allLookupStrings;
}
protected final void declareFinalScope(Class scopeClass) {
myFinalScopes.add(scopeClass);
}
public void addKeywordVariants(
Set<CompletionVariant> set, PsiElement position, final PsiFile file) {
set.addAll(Arrays.asList(findVariants(position, file)));
}
public static Set<LookupElement> processJavaReference(
PsiElement element,
PsiJavaReference javaReference,
ElementFilter elementFilter,
JavaCompletionProcessor.Options options,
final PrefixMatcher matcher,
CompletionParameters parameters) {
final Set<LookupElement> set = new LinkedHashSet<LookupElement>();
final Condition<String> nameCondition =
new Condition<String>() {
@Override
public boolean value(String s) {
return matcher.prefixMatches(s);
}
};
PsiMethodCallExpression call =
PsiTreeUtil.getParentOfType(element, PsiMethodCallExpression.class);
boolean checkInitialized =
parameters.getInvocationCount() <= 1
&& call != null
&& PsiKeyword.SUPER.equals(call.getMethodExpression().getText());
final JavaCompletionProcessor processor =
new JavaCompletionProcessor(
element, elementFilter, options.withInitialized(checkInitialized), nameCondition);
final PsiType plainQualifier = processor.getQualifierType();
PsiType qualifierType = plainQualifier;
PsiType runtimeQualifier = getQualifierCastType(javaReference, parameters);
if (runtimeQualifier != null) {
PsiType composite =
qualifierType == null
? runtimeQualifier
: PsiIntersectionType.createIntersection(qualifierType, runtimeQualifier);
PsiElement ctx = createContextWithXxxVariable(element, composite);
javaReference =
(PsiReferenceExpression)
JavaPsiFacade.getElementFactory(element.getProject())
.createExpressionFromText("xxx.xxx", ctx);
qualifierType = runtimeQualifier;
processor.setQualifierType(qualifierType);
}
javaReference.processVariants(processor);
final PsiTypeLookupItem castItem =
runtimeQualifier == null
? null
: PsiTypeLookupItem.createLookupItem(
runtimeQualifier, (PsiReferenceExpression) javaReference);
final boolean pkgContext = inSomePackage(element);
final Set<PsiMember> mentioned = new THashSet<PsiMember>();
for (CompletionElement completionElement : processor.getResults()) {
for (LookupElement item : createLookupElements(completionElement, javaReference)) {
item.putUserData(QUALIFIER_TYPE_ATTR, qualifierType);
final Object o = item.getObject();
if (o instanceof PsiClass && !isSourceLevelAccessible(element, (PsiClass) o, pkgContext)) {
continue;
}
if (o instanceof PsiMember) {
if (isInExcludedPackage((PsiMember) o, true)) {
continue;
}
mentioned.add(CompletionUtil.getOriginalOrSelf((PsiMember) o));
}
set.add(
highlightIfNeeded(
qualifierType,
castQualifier(item, castItem, plainQualifier, processor),
o,
element));
}
}
if (javaReference instanceof PsiJavaCodeReferenceElement
&& !((PsiJavaCodeReferenceElement) javaReference).isQualified()) {
final StaticMemberProcessor memberProcessor = new JavaStaticMemberProcessor(parameters);
memberProcessor.processMembersOfRegisteredClasses(
matcher,
new PairConsumer<PsiMember, PsiClass>() {
@Override
public void consume(PsiMember member, PsiClass psiClass) {
if (!mentioned.contains(member)
&& processor.satisfies(member, ResolveState.initial())) {
set.add(memberProcessor.createLookupElement(member, psiClass, true));
}
}
});
}
return set;
}