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 handleBranchingInstruction(
ProblemsHolder holder,
StandardInstructionVisitor visitor,
Set<Instruction> trueSet,
Set<Instruction> falseSet,
HashSet<PsiElement> reportedAnchors,
BranchingInstruction instruction,
final boolean onTheFly) {
PsiElement psiAnchor = instruction.getPsiAnchor();
boolean underBinary = isAtRHSOfBooleanAnd(psiAnchor);
if (instruction instanceof InstanceofInstruction
&& visitor.isInstanceofRedundant((InstanceofInstruction) instruction)) {
if (visitor.canBeNull((BinopInstruction) instruction)) {
holder.registerProblem(
psiAnchor,
InspectionsBundle.message("dataflow.message.redundant.instanceof"),
new RedundantInstanceofFix());
} else {
final LocalQuickFix localQuickFix = createSimplifyBooleanExpressionFix(psiAnchor, true);
holder.registerProblem(
psiAnchor,
InspectionsBundle.message(
underBinary
? "dataflow.message.constant.condition.when.reached"
: "dataflow.message.constant.condition",
Boolean.toString(true)),
localQuickFix == null ? null : new LocalQuickFix[] {localQuickFix});
}
} else if (psiAnchor instanceof PsiSwitchLabelStatement) {
if (falseSet.contains(instruction)) {
holder.registerProblem(
psiAnchor, InspectionsBundle.message("dataflow.message.unreachable.switch.label"));
}
} else if (psiAnchor != null
&& !reportedAnchors.contains(psiAnchor)
&& !isFlagCheck(psiAnchor)) {
boolean evaluatesToTrue = trueSet.contains(instruction);
final PsiElement parent = psiAnchor.getParent();
if (parent instanceof PsiAssignmentExpression
&& ((PsiAssignmentExpression) parent).getLExpression() == psiAnchor) {
holder.registerProblem(
psiAnchor,
InspectionsBundle.message(
"dataflow.message.pointless.assignment.expression",
Boolean.toString(evaluatesToTrue)),
createConditionalAssignmentFixes(
evaluatesToTrue, (PsiAssignmentExpression) parent, onTheFly));
} else if (!skipReportingConstantCondition(visitor, psiAnchor, evaluatesToTrue)) {
final LocalQuickFix fix = createSimplifyBooleanExpressionFix(psiAnchor, evaluatesToTrue);
String message =
InspectionsBundle.message(
underBinary
? "dataflow.message.constant.condition.when.reached"
: "dataflow.message.constant.condition",
Boolean.toString(evaluatesToTrue));
holder.registerProblem(psiAnchor, message, fix == null ? null : new LocalQuickFix[] {fix});
}
reportedAnchors.add(psiAnchor);
}
}
private static void reportOptionalOfNullableImprovements(
ProblemsHolder holder, Set<PsiElement> reportedAnchors, Instruction[] instructions) {
for (Instruction instruction : instructions) {
if (instruction instanceof MethodCallInstruction) {
final PsiExpression[] args = ((MethodCallInstruction) instruction).getArgs();
if (args.length != 1) continue;
final PsiExpression expr = args[0];
if (((MethodCallInstruction) instruction).isOptionalAlwaysNullProblem()) {
if (!reportedAnchors.add(expr)) continue;
holder.registerProblem(
expr,
"Passing <code>null</code> argument to <code>Optional</code>",
DfaOptionalSupport.createReplaceOptionalOfNullableWithEmptyFix(expr));
} else if (((MethodCallInstruction) instruction).isOptionalAlwaysNotNullProblem()) {
if (!reportedAnchors.add(expr)) continue;
holder.registerProblem(
expr,
"Passing a non-null argument to <code>Optional</code>",
DfaOptionalSupport.createReplaceOptionalOfNullableWithOfFix());
}
}
}
}
private void reportFieldAccessMayProduceNpe(
ProblemsHolder holder, PsiElement elementToAssert, PsiExpression expression) {
if (expression instanceof PsiArrayAccessExpression) {
LocalQuickFix[] fix =
createNPEFixes((PsiExpression) elementToAssert, expression, holder.isOnTheFly());
holder.registerProblem(
expression, InspectionsBundle.message("dataflow.message.npe.array.access"), fix);
} else {
LocalQuickFix[] fix =
createNPEFixes((PsiExpression) elementToAssert, expression, holder.isOnTheFly());
assert elementToAssert != null;
holder.registerProblem(
elementToAssert, InspectionsBundle.message("dataflow.message.npe.field.access"), fix);
}
}
private void reportNullableArguments(
DataFlowInstructionVisitor visitor, ProblemsHolder holder, Set<PsiElement> reportedAnchors) {
for (PsiElement expr :
visitor.getProblems(NullabilityProblem.passingNullableToNotNullParameter)) {
if (!reportedAnchors.add(expr)) continue;
final String text =
isNullLiteralExpression(expr)
? InspectionsBundle.message("dataflow.message.passing.null.argument")
: InspectionsBundle.message("dataflow.message.passing.nullable.argument");
LocalQuickFix[] fixes =
createNPEFixes((PsiExpression) expr, (PsiExpression) expr, holder.isOnTheFly());
holder.registerProblem(expr, text, fixes);
}
}
private static void reportUnboxedNullables(
DataFlowInstructionVisitor visitor, ProblemsHolder holder, Set<PsiElement> reportedAnchors) {
for (PsiElement expr : visitor.getProblems(NullabilityProblem.unboxingNullable)) {
if (!reportedAnchors.add(expr)) continue;
holder.registerProblem(expr, InspectionsBundle.message("dataflow.message.unboxing"));
}
}
private void analyzeDfaWithNestedClosures(
PsiElement scope,
ProblemsHolder holder,
StandardDataFlowRunner dfaRunner,
Collection<DfaMemoryState> initialStates) {
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);
MultiMap<PsiElement, DfaMemoryState> nestedClosures = dfaRunner.getNestedClosures();
for (PsiElement closure : nestedClosures.keySet()) {
analyzeDfaWithNestedClosures(closure, holder, dfaRunner, nestedClosures.get(closure));
}
} 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);
}
}
}
}
private static void checkSillyAssignment(
PsiAssignmentExpression assignment, ProblemsHolder holder) {
if (assignment.getOperationTokenType() != JavaTokenType.EQ) return;
PsiExpression lExpression = assignment.getLExpression();
PsiExpression rExpression = assignment.getRExpression();
if (rExpression == null) return;
lExpression = PsiUtil.deparenthesizeExpression(lExpression);
rExpression = PsiUtil.deparenthesizeExpression(rExpression);
if (!(lExpression instanceof PsiReferenceExpression)) return;
PsiReferenceExpression rRef;
if (!(rExpression instanceof PsiReferenceExpression)) {
if (!(rExpression instanceof PsiAssignmentExpression)) return;
final PsiAssignmentExpression rAssignmentExpression = (PsiAssignmentExpression) rExpression;
final PsiExpression assignee =
PsiUtil.deparenthesizeExpression(rAssignmentExpression.getLExpression());
if (!(assignee instanceof PsiReferenceExpression)) return;
rRef = (PsiReferenceExpression) assignee;
} else {
rRef = (PsiReferenceExpression) rExpression;
}
PsiReferenceExpression lRef = (PsiReferenceExpression) lExpression;
PsiManager manager = assignment.getManager();
if (!sameInstanceReferences(lRef, rRef, manager)) return;
final PsiVariable variable = (PsiVariable) lRef.resolve();
if (variable == null) return;
holder.registerProblem(
assignment,
InspectionsBundle.message("assignment.to.itself.problem.descriptor", variable.getName()),
ProblemHighlightType.LIKE_UNUSED_SYMBOL);
}
private static void reportCastMayFail(ProblemsHolder holder, TypeCastInstruction instruction) {
PsiTypeCastExpression typeCast = instruction.getCastExpression();
PsiExpression operand = typeCast.getOperand();
PsiTypeElement castType = typeCast.getCastType();
assert castType != null;
assert operand != null;
holder.registerProblem(
castType, InspectionsBundle.message("dataflow.message.cce", operand.getText()));
}
@NotNull
@Override
public PsiElementVisitor buildVisitor(@NotNull final ProblemsHolder holder, boolean isOnTheFly) {
if (!PsiUtil.isLanguageLevel8OrHigher(holder.getFile())) {
return PsiElementVisitor.EMPTY_VISITOR;
}
return new PsiElementVisitor() {
@Override
public void visitElement(PsiElement element) {
if (element instanceof PsiMethodCallExpression) {
final PsiMethodCallExpression methodCallExpression = (PsiMethodCallExpression) element;
String qName = methodCallExpression.getMethodExpression().getQualifiedName();
if (qName == null) {
return;
}
qName = StringUtil.getShortName(qName);
final Collection<StaticPseudoFunctionalStyleMethodOptions.PipelineElement> handlerInfos =
myOptions.findElementsByMethodName(qName);
if (handlerInfos.isEmpty()) {
return;
}
final PsiMethod method = methodCallExpression.resolveMethod();
if (method == null) {
return;
}
final PsiClass aClass = method.getContainingClass();
if (aClass == null) {
return;
}
final String classQualifiedName = aClass.getQualifiedName();
if (classQualifiedName == null) {
return;
}
StaticPseudoFunctionalStyleMethodOptions.PipelineElement suitableHandler = null;
for (StaticPseudoFunctionalStyleMethodOptions.PipelineElement h : handlerInfos) {
if (h.getHandlerClass().equals(classQualifiedName)) {
suitableHandler = h;
break;
}
}
if (suitableHandler == null) {
return;
}
final PseudoLambdaReplaceTemplate.ValidationInfo validationInfo =
suitableHandler.getTemplate().validate(methodCallExpression);
if (validationInfo != null) {
holder.registerProblem(
methodCallExpression.getMethodExpression(),
"Pseudo functional style code",
new ReplacePseudoLambdaWithLambda(suitableHandler));
}
}
}
};
}
private void reportCallMayProduceNpe(
ProblemsHolder holder, PsiMethodCallExpression callExpression, boolean onTheFly) {
LocalQuickFix[] fix =
createNPEFixes(
callExpression.getMethodExpression().getQualifierExpression(),
callExpression,
onTheFly);
holder.registerProblem(
callExpression, InspectionsBundle.message("dataflow.message.npe.method.invocation"), fix);
}
private static void reportNullableAssignments(
DataFlowInstructionVisitor visitor, ProblemsHolder holder, Set<PsiElement> reportedAnchors) {
for (PsiElement expr : visitor.getProblems(NullabilityProblem.assigningToNotNull)) {
if (!reportedAnchors.add(expr)) continue;
final String text =
isNullLiteralExpression(expr)
? InspectionsBundle.message("dataflow.message.assigning.null")
: InspectionsBundle.message("dataflow.message.assigning.nullable");
holder.registerProblem(expr, text);
}
}
private static void reportNullableReturns(
StandardDataFlowRunner runner,
DataFlowInstructionVisitor visitor,
ProblemsHolder holder,
Set<PsiElement> reportedAnchors) {
for (PsiElement statement : visitor.getProblems(NullabilityProblem.nullableReturn)) {
assert statement instanceof PsiExpression;
final PsiExpression expr = (PsiExpression) statement;
if (!reportedAnchors.add(expr)) continue;
if (runner.isInNotNullMethod()) {
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);
holder.registerProblem(
expr,
text,
new AnnotateMethodFix(defaultNullable, ArrayUtil.toStringArray(manager.getNotNulls())) {
@Override
public int shouldAnnotateBaseMethod(
PsiMethod method, PsiMethod superMethod, Project project) {
return 1;
}
});
}
}
}
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);
}
}
}
}
}
}
}
private static ProblemDescriptor runLocalTool(
@NotNull PsiElement psiElement,
@NotNull InspectionManager inspectionManager,
@NotNull OfflineProblemDescriptor offlineProblemDescriptor,
@NotNull LocalInspectionToolWrapper toolWrapper) {
PsiFile containingFile = psiElement.getContainingFile();
final ProblemsHolder holder = new ProblemsHolder(inspectionManager, containingFile, false);
final LocalInspectionTool localTool = toolWrapper.getTool();
final int startOffset = psiElement.getTextRange().getStartOffset();
final int endOffset = psiElement.getTextRange().getEndOffset();
LocalInspectionToolSession session =
new LocalInspectionToolSession(containingFile, startOffset, endOffset);
final PsiElementVisitor visitor = localTool.buildVisitor(holder, false, session);
localTool.inspectionStarted(session, false);
final PsiElement[] elementsInRange =
getElementsIntersectingRange(containingFile, startOffset, endOffset);
for (PsiElement element : elementsInRange) {
element.accept(visitor);
}
localTool.inspectionFinished(session, holder);
if (holder.hasResults()) {
final List<ProblemDescriptor> list = holder.getResults();
final int idx = offlineProblemDescriptor.getProblemIndex();
int curIdx = 0;
for (ProblemDescriptor descriptor : list) {
final PsiNamedElement member = localTool.getProblemElement(descriptor.getPsiElement());
if (psiElement instanceof PsiFile || member != null && member.equals(psiElement)) {
if (curIdx == idx) {
return descriptor;
}
curIdx++;
}
}
}
return null;
}
@Override
public void visitXmlAttributeValue(XmlAttributeValue value) {
for (PsiReference reference : value.getReferences()) {
if (!(reference instanceof OnClickConverter.MyReference)) {
continue;
}
final OnClickConverter.MyReference ref = (OnClickConverter.MyReference) reference;
final String methodName = ref.getValue();
if (methodName.isEmpty()) {
continue;
}
final ResolveResult[] results = ref.multiResolve(false);
final Set<PsiClass> resolvedClasses = new HashSet<PsiClass>();
final Set<PsiClass> resolvedClassesWithMistake = new HashSet<PsiClass>();
for (ResolveResult result : results) {
if (result instanceof OnClickConverter.MyResolveResult) {
final PsiElement element = result.getElement();
if (element != null) {
final PsiClass aClass = PsiTreeUtil.getParentOfType(element, PsiClass.class);
if (aClass != null) {
resolvedClasses.add(aClass);
if (!((OnClickConverter.MyResolveResult) result).hasCorrectSignature()) {
resolvedClassesWithMistake.add(aClass);
}
}
}
}
}
PsiClass activity = null;
for (PsiClass relatedActivity : myRelatedActivities) {
if (!containsOrExtends(resolvedClasses, relatedActivity)) {
activity = relatedActivity;
break;
} else if (activity == null
&& containsOrExtends(resolvedClassesWithMistake, relatedActivity)) {
activity = relatedActivity;
}
}
if (activity != null) {
reportMissingOnClickProblem(
ref, activity, methodName, resolvedClassesWithMistake.contains(activity));
} else if (results.length == 0) {
myResult.add(
myInspectionManager.createProblemDescriptor(
value,
reference.getRangeInElement(),
ProblemsHolder.unresolvedReferenceMessage(reference),
ProblemHighlightType.GENERIC_ERROR_OR_WARNING,
myOnTheFly));
} else if (resolvedClassesWithMistake.size() > 0) {
reportMissingOnClickProblem(
ref, resolvedClassesWithMistake.iterator().next(), methodName, true);
}
}
}
@NotNull
@Override
public PsiElementVisitor buildVisitor(@NotNull final ProblemsHolder holder, boolean isOnTheFly) {
if (!PsiUtil.isLanguageLevel8OrHigher(holder.getFile())) {
return PsiElementVisitor.EMPTY_VISITOR;
}
return new JavaElementVisitor() {
private final AtomicNotNullLazyValue<Map<String, PsiClass>> myGuavaClassConversions =
new AtomicNotNullLazyValue<Map<String, PsiClass>>() {
@NotNull
@Override
protected Map<String, PsiClass> compute() {
Map<String, PsiClass> map = new HashMap<String, PsiClass>();
for (TypeConversionRule rule : TypeConversionRule.EP_NAME.getExtensions()) {
if (rule instanceof BaseGuavaTypeConversionRule) {
final String fromClass = ((BaseGuavaTypeConversionRule) rule).ruleFromClass();
final String toClass = ((BaseGuavaTypeConversionRule) rule).ruleToClass();
final Project project = holder.getProject();
final JavaPsiFacade javaPsiFacade = JavaPsiFacade.getInstance(project);
final PsiClass targetClass =
javaPsiFacade.findClass(toClass, GlobalSearchScope.allScope(project));
if (targetClass != null) {
map.put(fromClass, targetClass);
}
}
}
return map;
}
};
@Override
public void visitVariable(PsiVariable variable) {
final PsiType type = variable.getType();
if (type instanceof PsiClassType) {
final PsiClassType.ClassResolveResult resolveResult =
((PsiClassType) type).resolveGenerics();
final PsiClass psiClass = resolveResult.getElement();
if (psiClass != null) {
final String qName = psiClass.getQualifiedName();
final PsiClass targetClass = myGuavaClassConversions.getValue().get(qName);
if (targetClass != null) {
final VariableTypeFix fix =
TypeMigrationVariableTypeFixProvider.createTypeMigrationFix(
variable, addTypeParameters(type, resolveResult, targetClass));
holder.registerProblem(variable, PROBLEM_DESCRIPTION_FOR_VARIABLE, fix);
}
}
}
}
private PsiClassType addTypeParameters(
PsiType currentType,
PsiClassType.ClassResolveResult currentTypeResolveResult,
PsiClass targetClass) {
final Map<PsiTypeParameter, PsiType> substitutionMap =
currentTypeResolveResult.getSubstitutor().getSubstitutionMap();
final PsiElementFactory elementFactory =
JavaPsiFacade.getElementFactory(holder.getProject());
if (substitutionMap.size() == 1) {
return elementFactory.createType(
targetClass, ContainerUtil.getFirstItem(substitutionMap.values()));
} else {
LOG.assertTrue(substitutionMap.size() == 2);
LOG.assertTrue(
GuavaFunctionConversionRule.JAVA_UTIL_FUNCTION_FUNCTION.equals(
targetClass.getQualifiedName()));
final PsiType returnType = LambdaUtil.getFunctionalInterfaceReturnType(currentType);
final List<PsiType> types = new ArrayList<PsiType>(substitutionMap.values());
types.remove(returnType);
final PsiType parameterType = types.get(0);
return elementFactory.createType(targetClass, parameterType, returnType);
}
}
};
}
private static void reportConstantReferenceValues(
ProblemsHolder holder, StandardInstructionVisitor visitor, Set<PsiElement> reportedAnchors) {
for (Pair<PsiReferenceExpression, DfaConstValue> pair : visitor.getConstantReferenceValues()) {
PsiReferenceExpression ref = pair.first;
if (ref.getParent() instanceof PsiReferenceExpression || !reportedAnchors.add(ref)) {
continue;
}
final Object value = pair.second.getValue();
PsiVariable constant = pair.second.getConstant();
final String presentableName = constant != null ? constant.getName() : String.valueOf(value);
final String exprText = String.valueOf(value);
if (presentableName == null || exprText == null) {
continue;
}
holder.registerProblem(
ref,
"Value <code>#ref</code> #loc is always '" + presentableName + "'",
new LocalQuickFix() {
@NotNull
@Override
public String getName() {
return "Replace with '" + presentableName + "'";
}
@NotNull
@Override
public String getFamilyName() {
return "Replace with constant value";
}
@Override
public void applyFix(@NotNull Project project, @NotNull ProblemDescriptor descriptor) {
if (!FileModificationService.getInstance()
.preparePsiElementsForWrite(descriptor.getPsiElement())) {
return;
}
PsiElement problemElement = descriptor.getPsiElement();
if (problemElement == null) return;
PsiMethodCallExpression call =
problemElement.getParent() instanceof PsiExpressionList
&& problemElement.getParent().getParent()
instanceof PsiMethodCallExpression
? (PsiMethodCallExpression) problemElement.getParent().getParent()
: null;
PsiMethod targetMethod = call == null ? null : call.resolveMethod();
JavaPsiFacade facade = JavaPsiFacade.getInstance(project);
problemElement.replace(
facade.getElementFactory().createExpressionFromText(exprText, null));
if (targetMethod != null) {
ExtractMethodUtil.addCastsToEnsureResolveTarget(targetMethod, call);
}
}
});
}
}
private void createDescription(
StandardDataFlowRunner runner, ProblemsHolder holder, DataFlowInstructionVisitor visitor) {
Pair<Set<Instruction>, Set<Instruction>> constConditions =
runner.getConstConditionalExpressions();
Set<Instruction> trueSet = constConditions.getFirst();
Set<Instruction> falseSet = constConditions.getSecond();
ArrayList<Instruction> allProblems = new ArrayList<Instruction>();
allProblems.addAll(trueSet);
allProblems.addAll(falseSet);
allProblems.addAll(runner.getCCEInstructions());
allProblems.addAll(StandardDataFlowRunner.getRedundantInstanceofs(runner, visitor));
HashSet<PsiElement> reportedAnchors = new HashSet<PsiElement>();
for (PsiElement element : visitor.getProblems(NullabilityProblem.callNPE)) {
if (reportedAnchors.add(element)) {
reportCallMayProduceNpe(holder, (PsiMethodCallExpression) element, holder.isOnTheFly());
}
}
for (PsiElement element : visitor.getProblems(NullabilityProblem.fieldAccessNPE)) {
if (reportedAnchors.add(element)) {
PsiElement parent = element.getParent();
PsiElement fieldAccess =
parent instanceof PsiArrayAccessExpression || parent instanceof PsiReferenceExpression
? parent
: element;
reportFieldAccessMayProduceNpe(holder, element, (PsiExpression) fieldAccess);
}
}
for (Instruction instruction : allProblems) {
if (instruction instanceof TypeCastInstruction
&& reportedAnchors.add(
((TypeCastInstruction) instruction).getCastExpression().getCastType())) {
reportCastMayFail(holder, (TypeCastInstruction) instruction);
} else if (instruction instanceof BranchingInstruction) {
handleBranchingInstruction(
holder,
visitor,
trueSet,
falseSet,
reportedAnchors,
(BranchingInstruction) instruction);
}
}
reportNullableArguments(visitor, holder, reportedAnchors);
reportNullableAssignments(visitor, holder, reportedAnchors);
reportUnboxedNullables(visitor, holder, reportedAnchors);
if (!runner.isInNullableMethod()
&& runner.isInMethod()
&& (runner.isInNotNullMethod() || SUGGEST_NULLABLE_ANNOTATIONS)) {
reportNullableReturns(runner, visitor, holder, reportedAnchors);
}
if (SUGGEST_NULLABLE_ANNOTATIONS) {
reportNullableArgumentsPassedToNonAnnotated(visitor, holder, reportedAnchors);
}
if (REPORT_CONSTANT_REFERENCE_VALUES) {
reportConstantReferenceValues(holder, visitor, reportedAnchors);
}
}
private static void reportConstantReferenceValues(
ProblemsHolder holder, StandardInstructionVisitor visitor, Set<PsiElement> reportedAnchors) {
for (Pair<PsiReferenceExpression, DfaConstValue> pair : visitor.getConstantReferenceValues()) {
PsiReferenceExpression ref = pair.first;
if (!reportedAnchors.add(ref)) {
continue;
}
final Object value = pair.second.getValue();
PsiVariable constant = pair.second.getConstant();
final String presentableName = constant != null ? constant.getName() : String.valueOf(value);
final String exprText = getConstantValueText(value, constant);
if (presentableName == null || exprText == null) {
continue;
}
holder.registerProblem(
ref,
"Value <code>#ref</code> #loc is always '" + presentableName + "'",
new LocalQuickFix() {
@NotNull
@Override
public String getName() {
return "Replace with '" + presentableName + "'";
}
@NotNull
@Override
public String getFamilyName() {
return "Replace with constant value";
}
@Override
public void applyFix(@NotNull Project project, @NotNull ProblemDescriptor descriptor) {
if (!FileModificationService.getInstance()
.preparePsiElementsForWrite(descriptor.getPsiElement())) {
return;
}
JavaPsiFacade facade = JavaPsiFacade.getInstance(project);
PsiElement newElement =
descriptor
.getPsiElement()
.replace(facade.getElementFactory().createExpressionFromText(exprText, null));
newElement =
JavaCodeStyleManager.getInstance(project).shortenClassReferences(newElement);
if (newElement instanceof PsiJavaCodeReferenceElement) {
PsiJavaCodeReferenceElement ref = (PsiJavaCodeReferenceElement) newElement;
PsiElement target = ref.resolve();
String shortName = ref.getReferenceName();
if (target != null
&& shortName != null
&& ref.isQualified()
&& facade.getResolveHelper().resolveReferencedVariable(shortName, newElement)
== target) {
newElement.replace(
facade.getElementFactory().createExpressionFromText(shortName, null));
}
}
}
});
}
}
@NotNull
@Override
public PsiElementVisitor buildVisitor(@NotNull final ProblemsHolder holder, boolean isOnTheFly) {
if (!PsiUtil.isLanguageLevel8OrHigher(holder.getFile())) {
return PsiElementVisitor.EMPTY_VISITOR;
}
return new JavaElementVisitor() {
void handleIteratorLoop(
PsiLoopStatement statement, PsiJavaToken endToken, IteratorDeclaration declaration) {
if (endToken == null || declaration == null || !declaration.isCollection()) return;
PsiStatement body = statement.getBody();
if (!(body instanceof PsiBlockStatement)) return;
PsiStatement[] statements = ((PsiBlockStatement) body).getCodeBlock().getStatements();
if (statements.length == 2 && statements[1] instanceof PsiIfStatement) {
PsiVariable element = declaration.getNextElementVariable(statements[0]);
if (element == null) return;
PsiIfStatement ifStatement = (PsiIfStatement) statements[1];
if (checkAndExtractCondition(declaration, ifStatement) == null) return;
registerProblem(statement, endToken);
} else if (statements.length == 1 && statements[0] instanceof PsiIfStatement) {
PsiIfStatement ifStatement = (PsiIfStatement) statements[0];
PsiExpression condition = checkAndExtractCondition(declaration, ifStatement);
if (condition == null) return;
PsiElement ref = declaration.findOnlyIteratorRef(condition);
if (ref != null
&& declaration.isIteratorMethodCall(ref.getParent().getParent(), "next")
&& isAlwaysExecuted(condition, ref)) {
registerProblem(statement, endToken);
}
}
}
private boolean isAlwaysExecuted(PsiExpression condition, PsiElement ref) {
while (ref != condition) {
PsiElement parent = ref.getParent();
if (parent instanceof PsiPolyadicExpression) {
PsiPolyadicExpression polyadicExpression = (PsiPolyadicExpression) parent;
IElementType type = polyadicExpression.getOperationTokenType();
if ((type.equals(JavaTokenType.ANDAND) || type.equals(JavaTokenType.OROR))
&& polyadicExpression.getOperands()[0] != ref) {
return false;
}
}
if (parent instanceof PsiConditionalExpression
&& ((PsiConditionalExpression) parent).getCondition() != ref) {
return false;
}
ref = parent;
}
return true;
}
private void registerProblem(PsiLoopStatement statement, PsiJavaToken endToken) {
//noinspection DialogTitleCapitalization
holder.registerProblem(
statement,
new TextRange(0, endToken.getTextOffset() - statement.getTextOffset() + 1),
QuickFixBundle.message("java.8.collection.removeif.inspection.description"),
new ReplaceWithRemoveIfQuickFix());
}
@Nullable
private PsiExpression checkAndExtractCondition(
IteratorDeclaration declaration, PsiIfStatement ifStatement) {
PsiExpression condition = ifStatement.getCondition();
if (condition == null || ifStatement.getElseBranch() != null) return null;
PsiStatement thenStatement = ControlFlowUtils.stripBraces(ifStatement.getThenBranch());
if (!(thenStatement instanceof PsiExpressionStatement)) return null;
if (!declaration.isIteratorMethodCall(
((PsiExpressionStatement) thenStatement).getExpression(), "remove")) return null;
if (!LambdaGenerationUtil.canBeUncheckedLambda(condition)) return null;
return condition;
}
@Override
public void visitForStatement(PsiForStatement statement) {
super.visitForStatement(statement);
IteratorDeclaration declaration = IteratorDeclaration.fromLoop(statement);
handleIteratorLoop(statement, statement.getRParenth(), declaration);
}
@Override
public void visitWhileStatement(PsiWhileStatement statement) {
super.visitWhileStatement(statement);
IteratorDeclaration declaration = IteratorDeclaration.fromLoop(statement);
handleIteratorLoop(statement, statement.getRParenth(), declaration);
}
};
}