protected String doCalculateSignature(PsiMethod method) {
final StringBuilder buffer = new StringBuilder();
final PsiModifierList modifierList = method.getModifierList();
String modifiers = modifierList.getText();
final String oldModifier = VisibilityUtil.getVisibilityModifier(modifierList);
final String newModifier = getVisibility();
String newModifierStr = VisibilityUtil.getVisibilityString(newModifier);
if (!newModifier.equals(oldModifier)) {
int index = modifiers.indexOf(oldModifier);
if (index >= 0) {
final StringBuilder buf = new StringBuilder(modifiers);
buf.replace(
index,
index + oldModifier.length() + ("".equals(newModifierStr) ? 1 : 0),
newModifierStr);
modifiers = buf.toString();
} else {
if (!StringUtil.isEmpty(newModifierStr)) {
newModifierStr += " ";
}
modifiers = newModifierStr + modifiers;
}
}
buffer.append(modifiers);
if (modifiers.length() > 0
&& !StringUtil.endsWithChar(modifiers, '\n')
&& !StringUtil.endsWithChar(modifiers, '\r')
&& !StringUtil.endsWithChar(modifiers, ' ')) {
buffer.append(" ");
}
if (!method.isConstructor()) {
final CanonicalTypes.Type type = getReturnType();
if (type != null) {
buffer.append(type.getTypeText());
}
buffer.append(" ");
}
buffer.append(getMethodName());
buffer.append("(");
final int lineBreakIdx = buffer.lastIndexOf("\n");
String indent =
StringUtil.repeatSymbol(
' ', lineBreakIdx >= 0 ? buffer.length() - lineBreakIdx - 1 : buffer.length());
List<ParameterTableModelItemBase<ParameterInfoImpl>> items = myParametersTableModel.getItems();
int curIndent = indent.length();
for (int i = 0; i < items.size(); i++) {
final ParameterTableModelItemBase<ParameterInfoImpl> item = items.get(i);
if (i > 0) {
buffer.append(",");
buffer.append("\n");
buffer.append(indent);
}
final String text = item.typeCodeFragment.getText();
buffer.append(text).append(" ");
final String name = item.parameter.getName();
buffer.append(name);
curIndent = indent.length() + text.length() + 1 + name.length();
}
// if (!items.isEmpty()) {
// buffer.append("\n");
// }
buffer.append(")");
PsiTypeCodeFragment[] thrownExceptionsFragments = myExceptionsModel.getTypeCodeFragments();
if (thrownExceptionsFragments.length > 0) {
// buffer.append("\n");
buffer.append(" throws ");
curIndent += 9; // ") throws ".length()
indent = StringUtil.repeatSymbol(' ', curIndent);
for (int i = 0; i < thrownExceptionsFragments.length; i++) {
String text = thrownExceptionsFragments[i].getText();
if (i != 0) buffer.append(indent);
buffer.append(text);
if (i < thrownExceptionsFragments.length - 1) {
buffer.append(",");
}
buffer.append("\n");
}
}
return buffer.toString();
}
private void reportNullableReturns(
DataFlowInstructionVisitor visitor,
ProblemsHolder holder,
Set<PsiElement> reportedAnchors,
@NotNull PsiElement block) {
final PsiMethod method = getScopeMethod(block);
if (method == null || NullableStuffInspectionBase.isNullableNotInferred(method, true)) return;
boolean notNullRequired = NullableNotNullManager.isNotNull(method);
if (!notNullRequired && !SUGGEST_NULLABLE_ANNOTATIONS) return;
PsiType returnType = method.getReturnType();
// no warnings in void lambdas, where the expression is not returned anyway
if (block instanceof PsiExpression
&& block.getParent() instanceof PsiLambdaExpression
&& returnType == PsiType.VOID) return;
// no warnings for Void methods, where only null can be possibly returned
if (returnType == null || returnType.equalsToText(CommonClassNames.JAVA_LANG_VOID)) return;
for (PsiElement statement : visitor.getProblems(NullabilityProblem.nullableReturn)) {
assert statement instanceof PsiExpression;
final PsiExpression expr = (PsiExpression) statement;
if (!reportedAnchors.add(expr)) continue;
if (notNullRequired) {
final String text =
isNullLiteralExpression(expr)
? InspectionsBundle.message("dataflow.message.return.null.from.notnull")
: InspectionsBundle.message("dataflow.message.return.nullable.from.notnull");
holder.registerProblem(expr, text);
} else if (AnnotationUtil.isAnnotatingApplicable(statement)) {
final NullableNotNullManager manager =
NullableNotNullManager.getInstance(expr.getProject());
final String defaultNullable = manager.getDefaultNullable();
final String presentableNullable = StringUtil.getShortName(defaultNullable);
final String text =
isNullLiteralExpression(expr)
? InspectionsBundle.message(
"dataflow.message.return.null.from.notnullable", presentableNullable)
: InspectionsBundle.message(
"dataflow.message.return.nullable.from.notnullable", presentableNullable);
final LocalQuickFix[] fixes =
PsiTreeUtil.getParentOfType(expr, PsiMethod.class, PsiLambdaExpression.class)
instanceof PsiLambdaExpression
? LocalQuickFix.EMPTY_ARRAY
: new LocalQuickFix[] {
new AnnotateMethodFix(
defaultNullable, ArrayUtil.toStringArray(manager.getNotNulls())) {
@Override
public int shouldAnnotateBaseMethod(
PsiMethod method, PsiMethod superMethod, Project project) {
return 1;
}
}
};
holder.registerProblem(expr, text, fixes);
}
}
}
private void analyzeDfaWithNestedClosures(
PsiElement scope,
ProblemsHolder holder,
StandardDataFlowRunner dfaRunner,
Collection<DfaMemoryState> initialStates,
final boolean onTheFly) {
final DataFlowInstructionVisitor visitor = new DataFlowInstructionVisitor(dfaRunner);
final RunnerResult rc =
dfaRunner.analyzeMethod(scope, visitor, IGNORE_ASSERT_STATEMENTS, initialStates);
if (rc == RunnerResult.OK) {
createDescription(dfaRunner, holder, visitor, onTheFly, scope);
MultiMap<PsiElement, DfaMemoryState> nestedClosures = dfaRunner.getNestedClosures();
for (PsiElement closure : nestedClosures.keySet()) {
analyzeDfaWithNestedClosures(
closure, holder, dfaRunner, nestedClosures.get(closure), onTheFly);
}
} else if (rc == RunnerResult.TOO_COMPLEX) {
if (scope.getParent() instanceof PsiMethod) {
PsiMethod method = (PsiMethod) scope.getParent();
final PsiIdentifier name = method.getNameIdentifier();
if (name != null) { // Might be null for synthetic methods like JSP page.
holder.registerProblem(
name,
InspectionsBundle.message("dataflow.too.complex"),
ProblemHighlightType.WEAK_WARNING);
}
}
}
}
public static boolean hasAccessibleConstructor(PsiType type) {
if (type instanceof PsiArrayType) return true;
final PsiClass psiClass = PsiUtil.resolveClassInType(type);
if (psiClass == null || psiClass.isEnum() || psiClass.isAnnotationType()) return false;
if (!(psiClass instanceof PsiCompiledElement)) return true;
final PsiMethod[] methods = psiClass.getConstructors();
if (methods.length == 0) return true;
for (final PsiMethod method : methods) {
if (!method.hasModifierProperty(PsiModifier.PRIVATE)) return true;
}
return false;
}
private static boolean canCallMethodsInConstructors(PsiClass aClass, boolean virtual) {
for (PsiMethod constructor : aClass.getConstructors()) {
if (!constructor.getLanguage().isKindOf(JavaLanguage.INSTANCE)) return true;
PsiCodeBlock body = constructor.getBody();
if (body == null) continue;
for (PsiMethodCallExpression call :
SyntaxTraverser.psiTraverser().withRoot(body).filter(PsiMethodCallExpression.class)) {
PsiReferenceExpression methodExpression = call.getMethodExpression();
if (methodExpression instanceof PsiThisExpression
|| methodExpression instanceof PsiSuperExpression) continue;
if (!virtual) return true;
PsiMethod target = call.resolveMethod();
if (target != null && PsiUtil.canBeOverriden(target)) return true;
}
}
return false;
}
private void reportNullableArgumentsPassedToNonAnnotated(
DataFlowInstructionVisitor visitor, ProblemsHolder holder, Set<PsiElement> reportedAnchors) {
for (PsiElement expr :
visitor.getProblems(NullabilityProblem.passingNullableArgumentToNonAnnotatedParameter)) {
if (reportedAnchors.contains(expr)) continue;
final String text =
isNullLiteralExpression(expr)
? "Passing <code>null</code> argument to non annotated parameter"
: "Argument <code>#ref</code> #loc might be null but passed to non annotated parameter";
LocalQuickFix[] fixes =
createNPEFixes((PsiExpression) expr, (PsiExpression) expr, holder.isOnTheFly());
final PsiElement parent = expr.getParent();
if (parent instanceof PsiExpressionList) {
final int idx = ArrayUtilRt.find(((PsiExpressionList) parent).getExpressions(), expr);
if (idx > -1) {
final PsiElement gParent = parent.getParent();
if (gParent instanceof PsiCallExpression) {
final PsiMethod psiMethod = ((PsiCallExpression) gParent).resolveMethod();
if (psiMethod != null
&& psiMethod.getManager().isInProject(psiMethod)
&& AnnotationUtil.isAnnotatingApplicable(psiMethod)) {
final PsiParameter[] parameters = psiMethod.getParameterList().getParameters();
if (idx < parameters.length) {
final AddNullableAnnotationFix addNullableAnnotationFix =
new AddNullableAnnotationFix(parameters[idx]);
fixes =
fixes == null
? new LocalQuickFix[] {addNullableAnnotationFix}
: ArrayUtil.append(fixes, addNullableAnnotationFix);
holder.registerProblem(expr, text, fixes);
reportedAnchors.add(expr);
}
}
}
}
}
}
}
@NotNull
private static LookupElement castQualifier(
@NotNull LookupElement item,
@Nullable final PsiTypeLookupItem castTypeItem,
@Nullable PsiType plainQualifier,
JavaCompletionProcessor processor) {
if (castTypeItem == null) {
return item;
}
if (plainQualifier != null) {
Object o = item.getObject();
if (o instanceof PsiMethod) {
PsiType castType = castTypeItem.getType();
if (plainQualifier instanceof PsiClassType && castType instanceof PsiClassType) {
PsiMethod method = (PsiMethod) o;
PsiClassType.ClassResolveResult plainResult =
((PsiClassType) plainQualifier).resolveGenerics();
PsiClass plainClass = plainResult.getElement();
if (plainClass != null && plainClass.findMethodBySignature(method, true) != null) {
PsiClass castClass = ((PsiClassType) castType).resolveGenerics().getElement();
if (castClass == null || !castClass.isInheritor(plainClass, true)) {
return item;
}
PsiSubstitutor plainSub = plainResult.getSubstitutor();
PsiSubstitutor castSub =
TypeConversionUtil.getSuperClassSubstitutor(plainClass, (PsiClassType) castType);
PsiType returnType = method.getReturnType();
if (method.getSignature(plainSub).equals(method.getSignature(castSub))) {
PsiType typeAfterCast = toRaw(castSub.substitute(returnType));
PsiType typeDeclared = toRaw(plainSub.substitute(returnType));
if (typeAfterCast != null
&& typeDeclared != null
&& typeAfterCast.isAssignableFrom(typeDeclared)
&& processor.isAccessible(plainClass.findMethodBySignature(method, true))) {
return item;
}
}
}
}
} else if (containsMember(plainQualifier, o)) {
return item;
}
}
return LookupElementDecorator.withInsertHandler(
item,
new InsertHandlerDecorator<LookupElement>() {
@Override
public void handleInsert(
InsertionContext context, LookupElementDecorator<LookupElement> item) {
final Document document = context.getEditor().getDocument();
context.commitDocument();
final PsiFile file = context.getFile();
final PsiJavaCodeReferenceElement ref =
PsiTreeUtil.findElementOfClassAtOffset(
file, context.getStartOffset(), PsiJavaCodeReferenceElement.class, false);
if (ref != null) {
final PsiElement qualifier = ref.getQualifier();
if (qualifier != null) {
final CommonCodeStyleSettings settings = context.getCodeStyleSettings();
final String parenSpace = settings.SPACE_WITHIN_PARENTHESES ? " " : "";
document.insertString(qualifier.getTextRange().getEndOffset(), parenSpace + ")");
final String spaceWithin = settings.SPACE_WITHIN_CAST_PARENTHESES ? " " : "";
final String prefix = "(" + parenSpace + "(" + spaceWithin;
final String spaceAfter = settings.SPACE_AFTER_TYPE_CAST ? " " : "";
final int exprStart = qualifier.getTextRange().getStartOffset();
document.insertString(exprStart, prefix + spaceWithin + ")" + spaceAfter);
CompletionUtil.emulateInsertion(context, exprStart + prefix.length(), castTypeItem);
PsiDocumentManager.getInstance(file.getProject())
.doPostponedOperationsAndUnblockDocument(document);
context.getEditor().getCaretModel().moveToOffset(context.getTailOffset());
}
}
item.getDelegate().handleInsert(context);
}
});
}
