public void updateReturnValueTemplate(PsiExpression expression) {
if (myReturnValueTemplate == null) return;
if (!getSuperMethods().isEmpty()) {
for (final RefMethod refMethod : getSuperMethods()) {
RefMethodImpl refSuper = (RefMethodImpl) refMethod;
refSuper.updateReturnValueTemplate(expression);
}
} else {
String newTemplate = null;
final RefJavaUtil refUtil = RefJavaUtil.getInstance();
if (expression instanceof PsiLiteralExpression) {
PsiLiteralExpression psiLiteralExpression = (PsiLiteralExpression) expression;
newTemplate = psiLiteralExpression.getText();
} else if (expression instanceof PsiReferenceExpression) {
PsiReferenceExpression referenceExpression = (PsiReferenceExpression) expression;
PsiElement resolved = referenceExpression.resolve();
if (resolved instanceof PsiField) {
PsiField psiField = (PsiField) resolved;
if (psiField.hasModifierProperty(PsiModifier.STATIC)
&& psiField.hasModifierProperty(PsiModifier.FINAL)
&& refUtil.compareAccess(refUtil.getAccessModifier(psiField), getAccessModifier())
>= 0) {
newTemplate =
PsiFormatUtil.formatVariable(
psiField,
PsiFormatUtilBase.SHOW_NAME
| PsiFormatUtilBase.SHOW_CONTAINING_CLASS
| PsiFormatUtilBase.SHOW_FQ_NAME,
PsiSubstitutor.EMPTY);
}
}
} else if (refUtil.isCallToSuperMethod(expression, (PsiMethod) getElement())) return;
//noinspection StringEquality
if (myReturnValueTemplate == RETURN_VALUE_UNDEFINED) {
myReturnValueTemplate = newTemplate;
} else if (!Comparing.equal(myReturnValueTemplate, newTemplate)) {
myReturnValueTemplate = null;
}
}
}
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;
}
@Nullable
public static String getSuspiciousMethodCallMessage(
@NotNull PsiMethodCallExpression methodCall,
PsiType argType,
boolean reportConvertibleMethodCalls,
@NotNull List<PsiMethod> patternMethods,
@NotNull IntArrayList indices) {
final PsiReferenceExpression methodExpression = methodCall.getMethodExpression();
final PsiExpression qualifier = methodExpression.getQualifierExpression();
if (qualifier == null
|| qualifier instanceof PsiThisExpression
|| qualifier instanceof PsiSuperExpression) return null;
if (argType instanceof PsiPrimitiveType) {
argType = ((PsiPrimitiveType) argType).getBoxedType(methodCall);
}
if (!(argType instanceof PsiClassType)) return null;
final JavaResolveResult resolveResult = methodExpression.advancedResolve(false);
PsiMethod calleeMethod = (PsiMethod) resolveResult.getElement();
if (calleeMethod == null) return null;
PsiMethod contextMethod = PsiTreeUtil.getParentOfType(methodCall, PsiMethod.class);
//noinspection SynchronizationOnLocalVariableOrMethodParameter
synchronized (patternMethods) {
if (patternMethods.isEmpty()) {
setupPatternMethods(
methodCall.getManager(), methodCall.getResolveScope(), patternMethods, indices);
}
}
for (int i = 0; i < patternMethods.size(); i++) {
PsiMethod patternMethod = patternMethods.get(i);
if (!patternMethod.getName().equals(methodExpression.getReferenceName())) continue;
int index = indices.get(i);
// we are in collections method implementation
if (contextMethod != null && isInheritorOrSelf(contextMethod, patternMethod)) return null;
final PsiClass calleeClass = calleeMethod.getContainingClass();
PsiSubstitutor substitutor = resolveResult.getSubstitutor();
final PsiClass patternClass = patternMethod.getContainingClass();
assert patternClass != null;
assert calleeClass != null;
substitutor = TypeConversionUtil.getClassSubstitutor(patternClass, calleeClass, substitutor);
if (substitutor == null) continue;
if (!patternMethod
.getSignature(substitutor)
.equals(calleeMethod.getSignature(PsiSubstitutor.EMPTY))) continue;
PsiTypeParameter[] typeParameters = patternClass.getTypeParameters();
if (typeParameters.length <= index) return null;
final PsiTypeParameter typeParameter = typeParameters[index];
PsiType typeParamMapping = substitutor.substitute(typeParameter);
if (typeParamMapping == null) return null;
PsiParameter[] parameters = patternMethod.getParameterList().getParameters();
if (parameters.length == 1 && "removeAll".equals(patternMethod.getName())) {
PsiType paramType = parameters[0].getType();
if (InheritanceUtil.isInheritor(paramType, CommonClassNames.JAVA_UTIL_COLLECTION)) {
PsiType qualifierType = qualifier.getType();
if (qualifierType != null) {
final PsiType itemType =
JavaGenericsUtil.getCollectionItemType(argType, calleeMethod.getResolveScope());
final PsiType qualifierItemType =
JavaGenericsUtil.getCollectionItemType(
qualifierType, calleeMethod.getResolveScope());
if (qualifierItemType != null
&& itemType != null
&& !qualifierItemType.isAssignableFrom(itemType)) {
return InspectionsBundle.message(
"inspection.suspicious.collections.method.calls.problem.descriptor",
PsiFormatUtil.formatType(qualifierType, 0, PsiSubstitutor.EMPTY),
PsiFormatUtil.formatType(itemType, 0, PsiSubstitutor.EMPTY));
}
}
return null;
}
}
String message = null;
if (typeParamMapping instanceof PsiCapturedWildcardType) {
typeParamMapping = ((PsiCapturedWildcardType) typeParamMapping).getWildcard();
}
if (!typeParamMapping.isAssignableFrom(argType)) {
if (typeParamMapping.isConvertibleFrom(argType)) {
if (reportConvertibleMethodCalls) {
message =
InspectionsBundle.message(
"inspection.suspicious.collections.method.calls.problem.descriptor1",
PsiFormatUtil.formatMethod(
calleeMethod,
substitutor,
PsiFormatUtilBase.SHOW_NAME | PsiFormatUtilBase.SHOW_CONTAINING_CLASS,
PsiFormatUtilBase.SHOW_TYPE));
}
} else {
PsiType qualifierType = qualifier.getType();
if (qualifierType != null) {
message =
InspectionsBundle.message(
"inspection.suspicious.collections.method.calls.problem.descriptor",
PsiFormatUtil.formatType(qualifierType, 0, PsiSubstitutor.EMPTY),
PsiFormatUtil.formatType(argType, 0, PsiSubstitutor.EMPTY));
}
}
}
return message;
}
return null;
}
private void checkExistingMethods(MultiMap<PsiElement, String> conflicts, boolean isGetter) {
if (isGetter) {
if (!myDescriptor.isToEncapsulateGet()) return;
} else {
if (!myDescriptor.isToEncapsulateSet()) return;
}
for (FieldDescriptor descriptor : myFieldDescriptors) {
PsiMethod prototype =
isGetter ? descriptor.getGetterPrototype() : descriptor.getSetterPrototype();
final PsiType prototypeReturnType = prototype.getReturnType();
PsiMethod existing = myClass.findMethodBySignature(prototype, true);
if (existing != null) {
final PsiType returnType = existing.getReturnType();
if (!RefactoringUtil.equivalentTypes(
prototypeReturnType, returnType, myClass.getManager())) {
final String descr =
PsiFormatUtil.formatMethod(
existing,
PsiSubstitutor.EMPTY,
PsiFormatUtilBase.SHOW_NAME
| PsiFormatUtilBase.SHOW_PARAMETERS
| PsiFormatUtilBase.SHOW_TYPE,
PsiFormatUtilBase.SHOW_TYPE);
String message =
isGetter
? RefactoringBundle.message(
"encapsulate.fields.getter.exists",
CommonRefactoringUtil.htmlEmphasize(descr),
CommonRefactoringUtil.htmlEmphasize(prototype.getName()))
: RefactoringBundle.message(
"encapsulate.fields.setter.exists",
CommonRefactoringUtil.htmlEmphasize(descr),
CommonRefactoringUtil.htmlEmphasize(prototype.getName()));
conflicts.putValue(existing, message);
}
} else {
PsiClass containingClass = myClass.getContainingClass();
while (containingClass != null && existing == null) {
existing = containingClass.findMethodBySignature(prototype, true);
if (existing != null) {
for (PsiReference reference : ReferencesSearch.search(existing)) {
final PsiElement place = reference.getElement();
LOG.assertTrue(place instanceof PsiReferenceExpression);
final PsiExpression qualifierExpression =
((PsiReferenceExpression) place).getQualifierExpression();
final PsiClass inheritor;
if (qualifierExpression == null) {
inheritor = PsiTreeUtil.getParentOfType(place, PsiClass.class, false);
} else {
inheritor = PsiUtil.resolveClassInType(qualifierExpression.getType());
}
if (InheritanceUtil.isInheritorOrSelf(inheritor, myClass, true)) {
conflicts.putValue(
existing,
"There is already a "
+ RefactoringUIUtil.getDescription(existing, true)
+ " which would be hidden by generated "
+ (isGetter ? "getter" : "setter"));
break;
}
}
}
containingClass = containingClass.getContainingClass();
}
}
}
}
public static LookupItem setShowFQN(final LookupItem ret) {
ret.setAttribute(
JavaPsiClassReferenceElement.PACKAGE_NAME,
PsiFormatUtil.getPackageDisplayName((PsiClass) ret.getObject()));
return ret;
}
public static String checkMethodReferenceContext(
PsiMethodReferenceExpression methodRef, PsiElement resolve, PsiType functionalInterfaceType) {
final PsiClass containingClass =
resolve instanceof PsiMethod
? ((PsiMethod) resolve).getContainingClass()
: (PsiClass) resolve;
final boolean isStaticSelector = isStaticallyReferenced(methodRef);
final PsiElement qualifier = methodRef.getQualifier();
boolean isMethodStatic = false;
boolean receiverReferenced = false;
boolean isConstructor = true;
if (resolve instanceof PsiMethod) {
final PsiMethod method = (PsiMethod) resolve;
isMethodStatic = method.hasModifierProperty(PsiModifier.STATIC);
isConstructor = method.isConstructor();
receiverReferenced = hasReceiver(methodRef, method, functionalInterfaceType);
if (method.hasModifierProperty(PsiModifier.ABSTRACT)
&& qualifier instanceof PsiSuperExpression) {
return "Abstract method '" + method.getName() + "' cannot be accessed directly";
}
}
if (!receiverReferenced && isStaticSelector && !isMethodStatic && !isConstructor) {
return "Non-static method cannot be referenced from a static context";
}
if (!receiverReferenced && !isStaticSelector && isMethodStatic) {
return "Static method referenced through non-static qualifier";
}
if (receiverReferenced && isStaticSelector && isMethodStatic && !isConstructor) {
return "Static method referenced through receiver";
}
if (isMethodStatic && isStaticSelector && qualifier instanceof PsiTypeElement) {
final PsiJavaCodeReferenceElement referenceElement =
PsiTreeUtil.getChildOfType(qualifier, PsiJavaCodeReferenceElement.class);
if (referenceElement != null) {
final PsiReferenceParameterList parameterList = referenceElement.getParameterList();
if (parameterList != null && parameterList.getTypeArguments().length > 0) {
return "Parameterized qualifier on static method reference";
}
}
}
if (isConstructor) {
if (containingClass != null
&& PsiUtil.isInnerClass(containingClass)
&& containingClass.isPhysical()) {
PsiClass outerClass = containingClass.getContainingClass();
if (outerClass != null
&& !InheritanceUtil.hasEnclosingInstanceInScope(outerClass, methodRef, true, false)) {
return "An enclosing instance of type "
+ PsiFormatUtil.formatClass(outerClass, PsiFormatUtilBase.SHOW_NAME)
+ " is not in scope";
}
}
}
return null;
}
