@NotNull public List<String> createConversions(@NotNull PsiCallExpression expression) { PsiExpressionList argumentList = expression.getArgumentList(); PsiExpression[] arguments = argumentList != null ? argumentList.getExpressions() : new PsiExpression[] {}; List<String> conversions = new LinkedList<String>(); //noinspection UnusedDeclaration for (PsiExpression a : arguments) { conversions.add(""); } PsiMethod resolve = expression.resolveMethod(); if (resolve != null) { List<PsiType> expectedTypes = new LinkedList<PsiType>(); List<PsiType> actualTypes = new LinkedList<PsiType>(); for (PsiParameter p : resolve.getParameterList().getParameters()) expectedTypes.add(p.getType()); for (PsiExpression e : arguments) actualTypes.add(e.getType()); if (conversions.size() == actualTypes.size() && actualTypes.size() == expectedTypes.size()) { for (int i = 0; i < actualTypes.size(); i++) conversions.set(i, createConversionForExpression(arguments[i], expectedTypes.get(i))); } } return conversions; }
@Override protected Nullness create(MethodCallInstruction key) { final PsiCallExpression callExpression = key.getCallExpression(); if (callExpression instanceof PsiNewExpression) { return Nullness.NOT_NULL; } return callExpression != null ? DfaPsiUtil.getElementNullability( key.getResultType(), callExpression.resolveMethod()) : null; }
private static void checkCall( @NotNull PsiCallExpression methodCall, @NotNull ProblemsHolder holder) { PsiMethod method = methodCall.resolveMethod(); if (method == null) return; PsiParameter[] parameters = method.getParameterList().getParameters(); PsiExpression[] arguments = methodCall.getArgumentList().getExpressions(); for (int i = 0; i < parameters.length; i++) { PsiParameter parameter = parameters[i]; AllowedValues values = getAllowedValues(parameter, parameter.getType(), null); if (values == null) continue; if (i >= arguments.length) break; PsiExpression argument = arguments[i]; argument = PsiUtil.deparenthesizeExpression(argument); if (argument == null) continue; checkMagicParameterArgument(parameter, argument, values, holder); } }
private static boolean isTrivial(PsiStatement body, PsiParameter parameter) { final PsiIfStatement ifStatement = extractIfStatement(body); // filter if (ifStatement != null) { return false; } // method reference final PsiCallExpression callExpression = LambdaCanBeMethodReferenceInspection.canBeMethodReferenceProblem( body instanceof PsiBlockStatement ? ((PsiBlockStatement) body).getCodeBlock() : body, new PsiParameter[] {parameter}, createDefaultConsumerType(parameter.getProject(), parameter)); if (callExpression == null) { return true; } final PsiMethod method = callExpression.resolveMethod(); return method != null && isThrowsCompatible(method); }
private boolean isTestOnlyMethodCalled(PsiCallExpression e) { return isAnnotatedAsTestOnly(e.resolveMethod()); }
public static void processNonArrayExpression( ClassInstanceReferenceVisitor visitor, PsiExpression expression, PsiElement referencedElement) { expression = RefactoringUtil.outermostParenthesizedExpression(expression); PsiElement parent = expression.getParent(); if (parent instanceof PsiReferenceExpression && expression == ((PsiReferenceExpression) parent).getQualifierExpression()) { visitor.visitQualifier((PsiReferenceExpression) parent, expression, referencedElement); } else if (parent instanceof PsiTypeCastExpression) { visitor.visitTypeCast((PsiTypeCastExpression) parent, expression, referencedElement); } else if (parent instanceof PsiReturnStatement) { final PsiReturnStatement returnStatement = (PsiReturnStatement) parent; PsiElement enclosingMethod = PsiTreeUtil.getParentOfType(returnStatement, PsiMethod.class, PsiLambdaExpression.class); final PsiType returnType; if (enclosingMethod instanceof PsiMethod) { returnType = ((PsiMethod) enclosingMethod).getReturnType(); } else { returnType = null; } visitor.visitReadUsage(expression, returnType, referencedElement); } else if (parent instanceof PsiStatement) { visitor.visitReadUsage(expression, null, referencedElement); } else if (parent instanceof PsiExpressionList) { PsiExpressionList expressionList = (PsiExpressionList) parent; PsiElement pparent = expressionList.getParent(); if (pparent instanceof PsiStatement) { visitor.visitReadUsage(expression, null, referencedElement); } else if (pparent instanceof PsiCallExpression) { PsiCallExpression callExpression = (PsiCallExpression) pparent; PsiExpression[] arguments = callExpression.getArgumentList().getExpressions(); PsiMethod method = callExpression.resolveMethod(); if (method != null) { int index = -1; for (int i = 0; i < arguments.length; i++) { PsiExpression argument = arguments[i]; if (argument.equals(expression)) { index = i; break; } } if (index >= 0) { PsiParameter[] parameters = method.getParameterList().getParameters(); if (parameters.length > index) { visitor.visitReadUsage(expression, parameters[index].getType(), referencedElement); } } } } } else if (parent instanceof PsiAssignmentExpression) { PsiAssignmentExpression assignmentExpression = (PsiAssignmentExpression) parent; if (expression.equals(assignmentExpression.getRExpression())) { visitor.visitReadUsage( expression, assignmentExpression.getLExpression().getType(), referencedElement); } else { // LExpression visitor.visitWriteUsage( expression, assignmentExpression.getRExpression().getType(), referencedElement); } } else if (RefactoringUtil.isAssignmentLHS(expression)) { visitor.visitWriteUsage(expression, null, referencedElement); } else if (parent instanceof PsiVariable) { visitor.visitReadUsage(expression, ((PsiVariable) parent).getType(), referencedElement); } else if (parent instanceof PsiExpression) { // for usages in expressions other than above, we do not care about the type visitor.visitReadUsage(expression, null, referencedElement); } else { LOG.error("Unknown variation of class instance usage"); } }
public PsiElement findTargetMember(PsiElement element) { if (PsiTreeUtil.getParentOfType(element, PsiParameterList.class) != null) { return PsiTreeUtil.getParentOfType(element, PsiMethod.class); } final PsiTypeParameterList typeParameterList = PsiTreeUtil.getParentOfType(element, PsiTypeParameterList.class); if (typeParameterList != null) { return PsiTreeUtil.getParentOfType(typeParameterList, PsiMember.class); } final PsiElement elementParent = element.getParent(); if (elementParent instanceof PsiMethod && ((PsiMethod) elementParent).getNameIdentifier() == element) { return elementParent; } if (elementParent instanceof PsiClass && ((PsiClass) elementParent).getNameIdentifier() == element) { return elementParent; } final PsiCallExpression expression = PsiTreeUtil.getParentOfType(element, PsiCallExpression.class); if (expression != null) { final PsiExpression qualifierExpression; if (expression instanceof PsiMethodCallExpression) { qualifierExpression = ((PsiMethodCallExpression) expression).getMethodExpression().getQualifierExpression(); } else if (expression instanceof PsiNewExpression) { qualifierExpression = ((PsiNewExpression) expression).getQualifier(); } else { qualifierExpression = null; } if (PsiTreeUtil.isAncestor(qualifierExpression, element, false)) { final PsiExpressionList expressionList = PsiTreeUtil.getParentOfType(qualifierExpression, PsiExpressionList.class); if (expressionList != null) { final PsiElement parent = expressionList.getParent(); if (parent instanceof PsiCallExpression) { return ((PsiCallExpression) parent).resolveMethod(); } } } else { return expression.resolveMethod(); } } final PsiReferenceParameterList referenceParameterList = PsiTreeUtil.getParentOfType(element, PsiReferenceParameterList.class); if (referenceParameterList != null) { final PsiJavaCodeReferenceElement referenceElement = PsiTreeUtil.getParentOfType(referenceParameterList, PsiJavaCodeReferenceElement.class); if (referenceElement != null) { final PsiElement resolved = referenceElement.resolve(); if (resolved instanceof PsiClass) { return resolved; } else if (resolved instanceof PsiMethod) { return resolved; } } } return null; }