private static boolean isGetterInvocation(@NotNull GrMethodCall call) { GrExpression expr = call.getInvokedExpression(); if (!(expr instanceof GrReferenceExpression)) return false; PsiMethod method = call.resolveMethod(); if (!GroovyPropertyUtils.isSimplePropertyGetter(method)) return false; LOG.assertTrue(method != null); if (!GroovyNamesUtil.isValidReference( GroovyPropertyUtils.getPropertyNameByGetterName(method.getName(), true), ((GrReferenceExpression) expr).getQualifier() != null, call.getProject())) { return false; } GrArgumentList args = call.getArgumentList(); if (args == null || args.getAllArguments().length != 0) { return false; } GrExpression ref = genRefForGetter(call, ((GrReferenceExpression) expr).getReferenceName()); if (ref instanceof GrReferenceExpression) { PsiElement resolved = ((GrReferenceExpression) ref).resolve(); PsiManager manager = call.getManager(); if (manager.areElementsEquivalent(resolved, method) || areEquivalentAccessors(method, resolved, manager)) { return true; } } return false; }
private static boolean isQualifiedStaticMethodWithUnnecessaryQualifier( GrReferenceExpression ref) { if (ref.getQualifier() == null) return false; final PsiElement resolved = ref.resolve(); if (!(resolved instanceof PsiMember)) return false; if (!((PsiMember) resolved).hasModifierProperty(PsiModifier.STATIC)) return false; PsiElement copyResolved; final PsiElement parent = ref.getParent(); if (parent instanceof GrMethodCall) { final GrMethodCall copy = (GrMethodCall) parent.copy(); GrReferenceExpression invoked = (GrReferenceExpression) copy.getInvokedExpression(); assert invoked != null; invoked.setQualifier(null); copyResolved = ((GrReferenceExpression) copy.getInvokedExpression()).resolve(); } else { final GrReferenceExpression copy = (GrReferenceExpression) ref.copy(); copy.setQualifier(null); copyResolved = copy.resolve(); } return ref.getManager().areElementsEquivalent(copyResolved, resolved); }
private static GrExpression genRefForGetter(GrMethodCall call, String accessorName) { String name = GroovyPropertyUtils.getPropertyNameByGetterName(accessorName, true); GrReferenceExpression refExpr = (GrReferenceExpression) call.getInvokedExpression(); String oldNameStr = refExpr.getReferenceNameElement().getText(); String newRefExpr = StringUtil.trimEnd(refExpr.getText(), oldNameStr) + name; final GroovyPsiElementFactory factory = GroovyPsiElementFactory.getInstance(call.getProject()); return factory.createExpressionFromText(newRefExpr, call); }
public static void fixJavaStyleProperty(GrMethodCall call) { GrExpression invoked = call.getInvokedExpression(); String accessorName = ((GrReferenceExpression) invoked).getReferenceName(); if (isGetterInvocation(call) && invoked instanceof GrReferenceExpression) { final GrExpression newCall = genRefForGetter(call, accessorName); call.replaceWithExpression(newCall, true); } else if (isSetterInvocation(call) && invoked instanceof GrReferenceExpression) { final GrStatement newCall = genRefForSetter(call, accessorName); if (newCall != null) { call.replaceWithStatement(newCall); } } }
@Nullable private static GrAssignmentExpression genRefForSetter(GrMethodCall call, String accessorName) { String name = GroovyPropertyUtils.getPropertyNameBySetterName(accessorName); if (name == null) return null; GrExpression value = call.getExpressionArguments()[0]; GrReferenceExpression refExpr = (GrReferenceExpression) call.getInvokedExpression(); final GroovyPsiElementFactory factory = GroovyPsiElementFactory.getInstance(call.getProject()); final GrAssignmentExpression assignment = (GrAssignmentExpression) factory.createStatementFromText("yyy = xxx", call); GrReferenceExpression lvalueRef = (GrReferenceExpression) assignment.getLValue(); lvalueRef.setQualifier(refExpr.getQualifier()); lvalueRef.handleElementRenameSimple(name); assignment.getRValue().replaceWithExpression(value, true); return assignment; }
private static boolean isSetterInvocation(GrMethodCall call) { GrExpression expr = call.getInvokedExpression(); if (!(expr instanceof GrReferenceExpression)) return false; GrReferenceExpression refExpr = (GrReferenceExpression) expr; PsiMethod method; if (call instanceof GrApplicationStatement) { PsiElement element = refExpr.resolve(); if (!(element instanceof PsiMethod) || !GroovyPropertyUtils.isSimplePropertySetter(((PsiMethod) element))) return false; method = (PsiMethod) element; } else { method = call.resolveMethod(); if (!GroovyPropertyUtils.isSimplePropertySetter(method)) return false; LOG.assertTrue(method != null); } if (!GroovyNamesUtil.isValidReference( GroovyPropertyUtils.getPropertyNameBySetterName(method.getName()), ((GrReferenceExpression) expr).getQualifier() != null, call.getProject())) { return false; } GrArgumentList args = call.getArgumentList(); if (args == null || args.getExpressionArguments().length != 1 || PsiImplUtil.hasNamedArguments(args)) { return false; } GrAssignmentExpression assignment = genRefForSetter(call, refExpr.getReferenceName()); if (assignment != null) { GrExpression value = assignment.getLValue(); if (value instanceof GrReferenceExpression && call.getManager() .areElementsEquivalent(((GrReferenceExpression) value).resolve(), method)) { return true; } } return false; }
private static boolean methodCallExpressionsAreEquivalent( @NotNull GrMethodCall methodExp1, @NotNull GrMethodCall methodExp2) { final GrExpression methodExpression1 = methodExp1.getInvokedExpression(); final GrExpression methodExpression2 = methodExp2.getInvokedExpression(); if (!expressionsAreEquivalent(methodExpression1, methodExpression2)) { return false; } final GrArgumentList argumentList1 = methodExp1.getArgumentList(); if (argumentList1 == null) { return false; } final GrArgumentList argumentList2 = methodExp2.getArgumentList(); if (argumentList2 == null) { return false; } final GrExpression[] args1 = argumentList1.getExpressionArguments(); final GrExpression[] args2 = argumentList2.getExpressionArguments(); if (!expressionListsAreEquivalent(args1, args2)) { return false; } final GrNamedArgument[] namedArgs1 = argumentList1.getNamedArguments(); final GrNamedArgument[] namedArgs2 = argumentList2.getNamedArguments(); if (!namedArgumentListsAreEquivalent(namedArgs1, namedArgs2)) { return false; } final GrClosableBlock[] closures1 = methodExp1.getClosureArguments(); final GrClosableBlock[] closures2 = methodExp2.getClosureArguments(); return expressionListsAreEquivalent(closures1, closures2); }
@NotNull private Collection<? extends MavenRemoteRepository> findMavenRemoteRepositories( @Nullable GrClosableBlock repositoriesBlock) { Set<MavenRemoteRepository> myRemoteRepositories = ContainerUtil.newHashSet(); for (GrMethodCall repo : PsiTreeUtil.getChildrenOfTypeAsList(repositoriesBlock, GrMethodCall.class)) { final String expressionText = repo.getInvokedExpression().getText(); if ("mavenCentral".equals(expressionText)) { myRemoteRepositories.add(mavenCentralRemoteRepository); } else if ("mavenRepo".equals(expressionText)) { for (GrNamedArgument namedArgument : repo.getNamedArguments()) { if ("url".equals(namedArgument.getLabelName())) { URI urlArgumentValue = resolveUriFromSimpleExpression(namedArgument.getExpression()); if (urlArgumentValue != null) { String textUri = urlArgumentValue.toString(); myRemoteRepositories.add( new MavenRemoteRepository(textUri, null, textUri, null, null, null)); } break; } } } else if ("maven".equals(expressionText) && repo.getClosureArguments().length > 0) { List<GrApplicationStatement> applicationStatementList = PsiTreeUtil.getChildrenOfTypeAsList( repo.getClosureArguments()[0], GrApplicationStatement.class); if (!applicationStatementList.isEmpty()) { GrApplicationStatement statement = applicationStatementList.get(0); if (statement == null) continue; GrExpression expression = statement.getInvokedExpression(); if ("url".equals(expression.getText())) { URI urlArgumentValue = resolveUriFromSimpleExpression(statement.getExpressionArguments()[0]); if (urlArgumentValue != null) { String textUri = urlArgumentValue.toString(); myRemoteRepositories.add( new MavenRemoteRepository(textUri, null, textUri, null, null, null)); } } } List<GrAssignmentExpression> assignmentExpressionList = PsiTreeUtil.getChildrenOfTypeAsList( repo.getClosureArguments()[0], GrAssignmentExpression.class); if (!assignmentExpressionList.isEmpty()) { GrAssignmentExpression statement = assignmentExpressionList.get(0); if (statement == null) continue; GrExpression expression = statement.getLValue(); if ("url".equals(expression.getText())) { URI urlArgumentValue = resolveUriFromSimpleExpression(statement.getRValue()); if (urlArgumentValue != null) { String textUri = urlArgumentValue.toString(); myRemoteRepositories.add( new MavenRemoteRepository(textUri, null, textUri, null, null, null)); } } } } } return myRemoteRepositories; }
@Nullable public static GrExpression replaceExpression( GrExpression oldExpr, GrExpression newExpr, boolean removeUnnecessaryParentheses) { PsiElement oldParent = oldExpr.getParent(); if (oldParent == null) throw new PsiInvalidElementAccessException(oldExpr); if (!(oldExpr instanceof GrApplicationStatement)) { newExpr = ApplicationStatementUtil.convertToMethodCallExpression(newExpr); } // Remove unnecessary parentheses if (removeUnnecessaryParentheses && oldParent instanceof GrParenthesizedExpression && !(oldParent.getParent() instanceof GrArgumentLabel)) { return ((GrExpression) oldParent) .replaceWithExpression(newExpr, removeUnnecessaryParentheses); } // regexes cannot be after identifier , try to replace it with simple string if (getRegexAtTheBeginning(newExpr) != null && isAfterIdentifier(oldExpr)) { final PsiElement copy = newExpr.copy(); final GrLiteral regex = getRegexAtTheBeginning(copy); LOG.assertTrue(regex != null); final GrLiteral stringLiteral = GrStringUtil.createStringFromRegex(regex); if (regex == copy) { return oldExpr.replaceWithExpression(stringLiteral, removeUnnecessaryParentheses); } else { regex.replace(stringLiteral); return oldExpr.replaceWithExpression((GrExpression) copy, removeUnnecessaryParentheses); } } GroovyPsiElementFactory factory = GroovyPsiElementFactory.getInstance(oldExpr.getProject()); if (oldParent instanceof GrStringInjection) { if (newExpr instanceof GrString || newExpr instanceof GrLiteral && ((GrLiteral) newExpr).getValue() instanceof String) { return GrStringUtil.replaceStringInjectionByLiteral( (GrStringInjection) oldParent, (GrLiteral) newExpr); } else { newExpr = factory.createExpressionFromText("{" + newExpr.getText() + "}"); oldParent.getNode().replaceChild(oldExpr.getNode(), newExpr.getNode()); return newExpr; } } if (PsiTreeUtil.getParentOfType(oldExpr, GrStringInjection.class, false, GrCodeBlock.class) != null) { final PsiElement replaced = oldExpr.replace(newExpr); final GrStringInjection stringInjection = PsiTreeUtil.getParentOfType(replaced, GrStringInjection.class); GrStringUtil.wrapInjection(stringInjection); assert stringInjection != null; return stringInjection.getClosableBlock(); } // check priorities if (oldParent instanceof GrExpression && !(oldParent instanceof GrParenthesizedExpression)) { GrExpression addedParenth = addParenthesesIfNeeded(newExpr, oldExpr, (GrExpression) oldParent); if (newExpr != addedParenth) { return oldExpr.replaceWithExpression(addedParenth, removeUnnecessaryParentheses); } } // if replace closure argument with expression // we should add the expression in arg list if (oldExpr instanceof GrClosableBlock && !(newExpr instanceof GrClosableBlock) && oldParent instanceof GrMethodCallExpression && ArrayUtil.contains( oldExpr, ((GrMethodCallExpression) oldParent).getClosureArguments())) { return ((GrMethodCallExpression) oldParent) .replaceClosureArgument((GrClosableBlock) oldExpr, newExpr); } newExpr = (GrExpression) oldExpr.replace(newExpr); // if newExpr is the first grand child of command argument list we should replace command arg // list with parenthesised arg list. // In other case the code will be broken. So we try to find wrapping command arg list counting // levels. After arg list replace we go inside it // to find target parenthesised expression. if (newExpr instanceof GrParenthesizedExpression && isFirstChild(newExpr)) { int parentCount = 0; PsiElement element = oldParent; while (element != null && !(element instanceof GrCommandArgumentList)) { if (element instanceof GrCodeBlock || element instanceof GrParenthesizedExpression) break; if (element instanceof PsiFile) break; final PsiElement parent = element.getParent(); if (parent == null) break; if (!isFirstChild(element)) break; element = parent; parentCount++; } if (element instanceof GrCommandArgumentList) { final GrCommandArgumentList commandArgList = (GrCommandArgumentList) element; final PsiElement parent = commandArgList.getParent(); LOG.assertTrue(parent instanceof GrApplicationStatement); final GrMethodCall methodCall = factory.createMethodCallByAppCall((GrApplicationStatement) parent); final GrMethodCall newCall = (GrMethodCall) parent.replace(methodCall); PsiElement result = newCall.getArgumentList().getAllArguments()[0]; for (int i = 0; i < parentCount; i++) { result = PsiUtil.skipWhitespacesAndComments(result.getFirstChild(), true); } LOG.assertTrue(result instanceof GrParenthesizedExpression); return (GrExpression) result; } } return newExpr; }
private static boolean isInvokedOnMap(GrMethodCall call) { GrExpression expr = call.getInvokedExpression(); return expr instanceof GrReferenceExpression && ResolveUtil.isKeyOfMap((GrReferenceExpression) expr); }