@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
private static String getTypeName(PsiType type, boolean withIndices) {
type = type.getDeepComponentType();
if (type instanceof PsiClassType) {
final PsiClassType classType = (PsiClassType) type;
final String className = classType.getClassName();
if (className != null || !withIndices) return className;
final PsiClass aClass = classType.resolve();
return aClass instanceof PsiAnonymousClass
? ((PsiAnonymousClass) aClass).getBaseClassType().getClassName()
: null;
} else if (type instanceof PsiPrimitiveType) {
return type.getPresentableText();
} else if (type instanceof PsiWildcardType) {
return getTypeName(((PsiWildcardType) type).getExtendsBound(), withIndices);
} else if (type instanceof PsiIntersectionType) {
return getTypeName(((PsiIntersectionType) type).getRepresentative(), withIndices);
} else if (type instanceof PsiCapturedWildcardType) {
return getTypeName(((PsiCapturedWildcardType) type).getWildcard(), withIndices);
} else if (type instanceof PsiDisjunctionType) {
return getTypeName(((PsiDisjunctionType) type).getLeastUpperBound(), withIndices);
} else {
return null;
}
}
@Nullable
private static String getLongTypeName(PsiType type) {
if (type instanceof PsiClassType) {
PsiClass aClass = ((PsiClassType) type).resolve();
if (aClass == null) {
return null;
} else if (aClass instanceof PsiAnonymousClass) {
PsiClass baseClass = ((PsiAnonymousClass) aClass).getBaseClassType().resolve();
return baseClass != null ? baseClass.getQualifiedName() : null;
} else {
return aClass.getQualifiedName();
}
} else if (type instanceof PsiArrayType) {
return getLongTypeName(((PsiArrayType) type).getComponentType()) + "[]";
} else if (type instanceof PsiPrimitiveType) {
return type.getPresentableText();
} else if (type instanceof PsiWildcardType) {
final PsiType bound = ((PsiWildcardType) type).getBound();
return bound != null ? getLongTypeName(bound) : CommonClassNames.JAVA_LANG_OBJECT;
} else if (type instanceof PsiCapturedWildcardType) {
final PsiType bound = ((PsiCapturedWildcardType) type).getWildcard().getBound();
return bound != null ? getLongTypeName(bound) : CommonClassNames.JAVA_LANG_OBJECT;
} else if (type instanceof PsiIntersectionType) {
return getLongTypeName(((PsiIntersectionType) type).getRepresentative());
} else if (type instanceof PsiDisjunctionType) {
return getLongTypeName(((PsiDisjunctionType) type).getLeastUpperBound());
} else {
return null;
}
}
private static Map<String, PsiType> getCompatibleTypeNames(
@NotNull PsiType type, @Nullable PsiType min, PsiManager manager, GlobalSearchScope scope) {
if (type instanceof PsiDisjunctionType) type = ((PsiDisjunctionType) type).getLeastUpperBound();
// if initial type is not assignable to min type we don't take into consideration min type.
if (min != null && !TypesUtil.isAssignable(min, type, manager, scope)) {
min = null;
}
Map<String, PsiType> map = new LinkedHashMap<String, PsiType>();
final PsiPrimitiveType unboxed = PsiPrimitiveType.getUnboxedType(type);
if (unboxed != null) type = unboxed;
final Set<PsiType> set = new LinkedHashSet<PsiType>();
set.add(type);
while (!set.isEmpty()) {
PsiType cur = set.iterator().next();
set.remove(cur);
if (!map.containsValue(cur)
&& (min == null || TypesUtil.isAssignable(min, cur, manager, scope))) {
if (isPartiallySubstituted(cur)) {
LOG.assertTrue(cur instanceof PsiClassType);
PsiClassType rawType = ((PsiClassType) cur).rawType();
map.put(rawType.getPresentableText(), rawType);
} else {
map.put(cur.getPresentableText(), cur);
}
for (PsiType superType : cur.getSuperTypes()) {
if (!map.containsValue(superType)) {
set.add(superType);
}
}
}
}
return map;
}
@NotNull
public static LookupElementBuilder createPropertyLookupElement(
@NotNull String name, @Nullable PsiType type) {
LookupElementBuilder res =
LookupElementBuilder.create(name).withIcon(JetgroovyIcons.Groovy.Property);
if (type != null) {
res = res.withTypeText(type.getPresentableText());
}
return res;
}
public static boolean isInjectable(@Nullable final PsiType type, final Project project) {
if (type == null) return false;
if (type instanceof PsiPrimitiveType) return false;
if (project.isDefault()) {
@NonNls final String text = type.getPresentableText();
if (text == null) return false;
return text.equals("java.lang.String")
|| text.equals("java.lang.String...")
|| text.equals("java.lang.String[]");
} else {
return type.equalsToText("java.lang.String")
|| type.equalsToText("java.lang.String...")
|| type.equalsToText("java.lang.String[]");
}
}
@Nullable
private static String formatTypesList(ParameterInfoImpl[] infos, PsiElement context) {
if (infos == null) return null;
StringBuilder result = new StringBuilder();
try {
for (ParameterInfoImpl info : infos) {
PsiType type = info.createType(context);
if (type == null) return null;
if (result.length() != 0) result.append(", ");
result.append(type.getPresentableText());
}
return result.toString();
} catch (IncorrectOperationException e) {
return null;
}
}
@Nullable
public static LookupElementBuilder createPropertyLookupElement(
@NotNull PsiMethod accessor,
@Nullable GroovyResolveResult resolveResult,
@Nullable PrefixMatcher matcher) {
String propName;
PsiType propType;
final boolean getter = GroovyPropertyUtils.isSimplePropertyGetter(accessor, null);
if (getter) {
propName = GroovyPropertyUtils.getPropertyNameByGetter(accessor);
} else if (GroovyPropertyUtils.isSimplePropertySetter(accessor, null)) {
propName = GroovyPropertyUtils.getPropertyNameBySetter(accessor);
} else {
return null;
}
assert propName != null;
if (!PsiUtil.isValidReferenceName(propName)) {
propName = "'" + propName + "'";
}
if (matcher != null && !matcher.prefixMatches(propName)) {
return null;
}
if (getter) {
propType = PsiUtil.getSmartReturnType(accessor);
} else {
propType = accessor.getParameterList().getParameters()[0].getType();
}
final PsiType substituted =
resolveResult != null ? resolveResult.getSubstitutor().substitute(propType) : propType;
LookupElementBuilder builder =
LookupElementBuilder.create(
generatePropertyResolveResult(propName, accessor, propType, resolveResult),
propName)
.withIcon(JetgroovyIcons.Groovy.Property);
if (substituted != null) {
builder = builder.withTypeText(substituted.getPresentableText());
}
return builder;
}
private static LookupElementBuilder createGenerateMethodElement(
PsiMethod prototype,
PsiSubstitutor substitutor,
Icon icon,
String typeText,
InsertHandler<LookupElement> insertHandler) {
String methodName = prototype.getName();
String visibility = VisibilityUtil.getVisibilityModifier(prototype.getModifierList());
String modifiers = (visibility == PsiModifier.PACKAGE_LOCAL ? "" : visibility + " ");
PsiType type = substitutor.substitute(prototype.getReturnType());
String signature =
modifiers + (type == null ? "" : type.getPresentableText() + " ") + methodName;
String parameters =
PsiFormatUtil.formatMethod(
prototype, substitutor, PsiFormatUtilBase.SHOW_PARAMETERS, PsiFormatUtilBase.SHOW_NAME);
String overrideSignature =
" @Override "
+ signature; // leading space to make it a middle match, under all annotation
// suggestions
LookupElementBuilder element =
LookupElementBuilder.create(prototype, signature)
.withLookupString(methodName)
.withLookupString(signature)
.withLookupString(overrideSignature)
.withInsertHandler(insertHandler)
.appendTailText(parameters, false)
.appendTailText(" {...}", true)
.withTypeText(typeText)
.withIcon(icon);
element.putUserData(GENERATE_ELEMENT, true);
return element;
}
@Override
public String advertise(@NotNull final CompletionParameters parameters) {
if (!(parameters.getOriginalFile() instanceof PsiJavaFile)) return null;
if (parameters.getCompletionType() == CompletionType.BASIC
&& parameters.getInvocationCount() > 0) {
PsiElement position = parameters.getPosition();
if (psiElement()
.withParent(
psiReferenceExpression()
.withFirstChild(psiReferenceExpression().referencing(psiClass())))
.accepts(position)) {
if (CompletionUtil.shouldShowFeature(
parameters, JavaCompletionFeatures.GLOBAL_MEMBER_NAME)) {
final String shortcut = getActionShortcut(IdeActions.ACTION_CODE_COMPLETION);
if (shortcut != null) {
return "Pressing "
+ shortcut
+ " twice without a class qualifier would show all accessible static methods";
}
}
}
}
if (parameters.getCompletionType() != CompletionType.SMART
&& shouldSuggestSmartCompletion(parameters.getPosition())) {
if (CompletionUtil.shouldShowFeature(
parameters, CodeCompletionFeatures.EDITING_COMPLETION_SMARTTYPE_GENERAL)) {
final String shortcut = getActionShortcut(IdeActions.ACTION_SMART_TYPE_COMPLETION);
if (shortcut != null) {
return CompletionBundle.message("completion.smart.hint", shortcut);
}
}
}
if (parameters.getCompletionType() == CompletionType.SMART
&& parameters.getInvocationCount() == 1) {
final PsiType[] psiTypes =
ExpectedTypesGetter.getExpectedTypes(parameters.getPosition(), true);
if (psiTypes.length > 0) {
if (CompletionUtil.shouldShowFeature(
parameters, JavaCompletionFeatures.SECOND_SMART_COMPLETION_TOAR)) {
final String shortcut = getActionShortcut(IdeActions.ACTION_SMART_TYPE_COMPLETION);
if (shortcut != null) {
for (final PsiType psiType : psiTypes) {
final PsiType type = PsiUtil.extractIterableTypeParameter(psiType, false);
if (type != null) {
return CompletionBundle.message(
"completion.smart.aslist.hint", shortcut, type.getPresentableText());
}
}
}
}
if (CompletionUtil.shouldShowFeature(
parameters, JavaCompletionFeatures.SECOND_SMART_COMPLETION_ASLIST)) {
final String shortcut = getActionShortcut(IdeActions.ACTION_SMART_TYPE_COMPLETION);
if (shortcut != null) {
for (final PsiType psiType : psiTypes) {
if (psiType instanceof PsiArrayType) {
final PsiType componentType = ((PsiArrayType) psiType).getComponentType();
if (!(componentType instanceof PsiPrimitiveType)) {
return CompletionBundle.message(
"completion.smart.toar.hint", shortcut, componentType.getPresentableText());
}
}
}
}
}
if (CompletionUtil.shouldShowFeature(
parameters, JavaCompletionFeatures.SECOND_SMART_COMPLETION_CHAIN)) {
final String shortcut = getActionShortcut(IdeActions.ACTION_SMART_TYPE_COMPLETION);
if (shortcut != null) {
return CompletionBundle.message("completion.smart.chain.hint", shortcut);
}
}
}
}
return null;
}
@Override
public String toString() {
return myType == null ? "def" : myType.getPresentableText();
}
protected static String escapePresentableType(PsiType exprType) {
return StringUtil.escapeXml(exprType.getPresentableText());
}
private ParameterInfoImpl[] getNewParametersInfo(
PsiExpression[] expressions,
PsiMethod targetMethod,
PsiSubstitutor substitutor,
final StringBuilder buf,
final HashSet<ParameterInfoImpl> newParams,
final HashSet<ParameterInfoImpl> removedParams,
final HashSet<ParameterInfoImpl> changedParams) {
PsiParameter[] parameters = targetMethod.getParameterList().getParameters();
List<ParameterInfoImpl> result = new ArrayList<ParameterInfoImpl>();
if (expressions.length < parameters.length) {
// find which parameters to remove
int ei = 0;
int pi = 0;
while (ei < expressions.length && pi < parameters.length) {
PsiExpression expression = expressions[ei];
PsiParameter parameter = parameters[pi];
PsiType paramType = substitutor.substitute(parameter.getType());
if (buf.length() > 0) buf.append(", ");
final PsiType parameterType = PsiUtil.convertAnonymousToBaseType(paramType);
final String presentableText = escapePresentableType(parameterType);
final ParameterInfoImpl parameterInfo =
new ParameterInfoImpl(pi, parameter.getName(), parameter.getType());
if (TypeConversionUtil.areTypesAssignmentCompatible(paramType, expression)) {
buf.append(presentableText);
result.add(parameterInfo);
pi++;
ei++;
} else {
buf.append("<s>").append(presentableText).append("</s>");
removedParams.add(parameterInfo);
pi++;
}
}
if (result.size() != expressions.length) return null;
for (int i = pi; i < parameters.length; i++) {
if (buf.length() > 0) buf.append(", ");
buf.append("<s>").append(escapePresentableType(parameters[i].getType())).append("</s>");
final ParameterInfoImpl parameterInfo =
new ParameterInfoImpl(pi, parameters[i].getName(), parameters[i].getType());
removedParams.add(parameterInfo);
}
} else if (expressions.length > parameters.length) {
if (!findNewParamsPlace(
expressions, targetMethod, substitutor, buf, newParams, parameters, result)) return null;
} else {
// parameter type changed
for (int i = 0; i < parameters.length; i++) {
if (buf.length() > 0) buf.append(", ");
PsiParameter parameter = parameters[i];
PsiExpression expression = expressions[i];
PsiType paramType = substitutor.substitute(parameter.getType());
final String presentableText = escapePresentableType(paramType);
if (TypeConversionUtil.areTypesAssignmentCompatible(paramType, expression)) {
result.add(new ParameterInfoImpl(i, parameter.getName(), paramType));
buf.append(presentableText);
} else {
if (PsiPolyExpressionUtil.isPolyExpression(expression)) return null;
PsiType exprType = RefactoringUtil.getTypeByExpression(expression);
if (exprType == null) return null;
if (exprType instanceof PsiDisjunctionType) {
exprType = ((PsiDisjunctionType) exprType).getLeastUpperBound();
}
final ParameterInfoImpl changedParameterInfo =
new ParameterInfoImpl(i, parameter.getName(), exprType);
result.add(changedParameterInfo);
changedParams.add(changedParameterInfo);
buf.append("<s>")
.append(presentableText)
.append("</s> <b>")
.append(escapePresentableType(exprType))
.append("</b>");
}
}
// do not perform silly refactorings
boolean isSilly = true;
for (int i = 0; i < result.size(); i++) {
PsiParameter parameter = parameters[i];
PsiType paramType = substitutor.substitute(parameter.getType());
ParameterInfoImpl parameterInfo = result.get(i);
String typeText = parameterInfo.getTypeText();
if (!paramType.equalsToText(typeText) && !paramType.getPresentableText().equals(typeText)) {
isSilly = false;
break;
}
}
if (isSilly) return null;
}
return result.toArray(new ParameterInfoImpl[result.size()]);
}