@Override public void visitMethodCallExpression(GrMethodCallExpression grMethodCallExpression) { super.visitMethodCallExpression(grMethodCallExpression); final GrArgumentList args = grMethodCallExpression.getArgumentList(); if (args.getExpressionArguments().length != 1) { return; } if (PsiImplUtil.hasNamedArguments(args)) { return; } final GrExpression methodExpression = grMethodCallExpression.getInvokedExpression(); if (!(methodExpression instanceof GrReferenceExpression)) { return; } final GrReferenceExpression referenceExpression = (GrReferenceExpression) methodExpression; final String name = referenceExpression.getReferenceName(); if (!"get".equals(name)) { return; } final GrExpression qualifier = referenceExpression.getQualifierExpression(); if (qualifier == null || PsiUtil.isThisOrSuperRef(qualifier)) { return; } if (referenceExpression.getDotTokenType() == GroovyTokenTypes.mOPTIONAL_DOT) return; final PsiType type = qualifier.getType(); if (!InheritanceUtil.isInheritor(type, CommonClassNames.JAVA_UTIL_MAP)) { return; } registerMethodCallError(grMethodCallExpression); }
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; }
@Override public void doFix(Project project, ProblemDescriptor descriptor) throws IncorrectOperationException { final PsiElement referenceName = descriptor.getPsiElement(); final GrReferenceExpression invokedExpression = (GrReferenceExpression) referenceName.getParent(); final GrMethodCallExpression callExpression = (GrMethodCallExpression) invokedExpression.getParent(); final GrArgumentList args = callExpression.getArgumentList(); final GrExpression arg = args.getExpressionArguments()[0]; replaceExpression( callExpression, invokedExpression.getQualifierExpression().getText() + '[' + arg.getText() + ']'); }
public static boolean hasExpressionArguments(@Nullable GrArgumentList list) { if (list == null) return false; for (PsiElement child = list.getFirstChild(); child != null; child = child.getNextSibling()) { if (child instanceof GrExpression) return true; } return false; }
public void visitArgumentList(GrArgumentList list) { List<TypeConstraint> constraints = new ArrayList<TypeConstraint>(); for (GroovyResolveResult variant : ResolveUtil.getCallVariants(list)) { final Map<GrExpression, Pair<PsiParameter, PsiType>> map = GrClosureSignatureUtil.mapArgumentsToParameters( variant, list, true, true, list.getNamedArguments(), list.getExpressionArguments(), GrClosableBlock.EMPTY_ARRAY); addConstraintsFromMap(constraints, map); } if (!constraints.isEmpty()) { myResult = constraints.toArray(new TypeConstraint[constraints.size()]); } }
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 newExpressionsAreEquivalent( @NotNull GrNewExpression newExp1, @NotNull GrNewExpression newExp2) { final PsiMethod constructor1 = newExp1.resolveMethod(); final PsiMethod constructor2 = newExp2.resolveMethod(); if (constructor1 == null || constructor2 == null || constructor1.equals(constructor2)) { return false; } final GrArgumentList argumentList1 = newExp1.getArgumentList(); if (argumentList1 == null) { return false; } final GrExpression[] args1 = argumentList1.getExpressionArguments(); final GrArgumentList argumentList2 = newExp2.getArgumentList(); if (argumentList2 == null) { return false; } final GrExpression[] args2 = argumentList2.getExpressionArguments(); return expressionListsAreEquivalent(args1, args2); }
@Override public void getNamedArguments( @NotNull GrCall call, @Nullable PsiElement resolve, @Nullable String argumentName, boolean forCompletion, Map<String, ArgumentDescriptor> result) { if (!(call instanceof GrNewExpression)) return; if (resolve != null) { if (!(resolve instanceof PsiMethod)) return; PsiMethod method = (PsiMethod) resolve; if (!method.isConstructor()) return; } GrNewExpression newCall = (GrNewExpression) call; GrArgumentList argumentList = newCall.getArgumentList(); if (argumentList == null) return; GrExpression[] expressionArguments = argumentList.getExpressionArguments(); if (expressionArguments.length > 1 || (expressionArguments.length == 1 && !(expressionArguments[0] instanceof GrReferenceExpression))) { return; } for (GroovyResolveResult resolveResult : newCall.multiResolveClass()) { PsiElement element = resolveResult.getElement(); if (!(element instanceof PsiClass)) continue; PsiClass aClass = (PsiClass) element; if (!isClassHasConstructorWithMap(aClass)) continue; PsiClassType classType = JavaPsiFacade.getElementFactory(aClass.getProject()).createType(aClass); processClass(call, classType, argumentName, result); } }
@NotNull @Override public PsiReference[] getReferencesByElement( @NotNull PsiElement element, @NotNull ProcessingContext context) { GrExpression argument = (GrExpression) element; PsiElement parent = element.getParent(); if (parent instanceof GrConditionalExpression) { // support case: foo(a > b ? "aaa" : "bbb") if (((GrConditionalExpression) parent).getCondition() == parent) return PsiReference.EMPTY_ARRAY; argument = (GrConditionalExpression) parent; parent = parent.getParent(); } if (parent instanceof GrListOrMap) { // support case: foo(["aaa", "bbb"]) if (!((GrListOrMap) parent).isMap()) { argument = (GrListOrMap) parent; parent = parent.getParent(); } } if (parent instanceof GrNamedArgument) { return createReferencesForNamedArgument(element, (GrNamedArgument) parent, context); } if (parent instanceof GrArgumentList) { GrArgumentList argumentList = (GrArgumentList) parent; int index = argumentList.getExpressionArgumentIndex(argument); PsiElement call = argumentList.getParent(); if (!(call instanceof GrMethodCall)) return PsiReference.EMPTY_ARRAY; return PsiReference.EMPTY_ARRAY; } return PsiReference.EMPTY_ARRAY; }
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); }
private static boolean applicationStatementsAreEquivalent( GrApplicationStatement statement1, GrApplicationStatement statement2) { final GrExpression funExpression1 = statement1.getInvokedExpression(); final GrExpression funExpression2 = statement2.getInvokedExpression(); if (!expressionsAreEquivalent(funExpression1, funExpression2)) { return false; } final GrArgumentList argumentList1 = statement1.getArgumentList(); if (argumentList1 == null) { return false; } final GrArgumentList argumentList2 = statement2.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; } return true; }
public void visitMethodCallExpression(GrMethodCallExpression methodCall) { final GrExpression invokedExpression = methodCall.getInvokedExpression(); if (myExpression.equals(invokedExpression)) { myResult = new TypeConstraint[] { SubtypeConstraint.create(GroovyCommonClassNames.GROOVY_LANG_CLOSURE, methodCall) }; return; } final GrClosableBlock[] closureArgs = methodCall.getClosureArguments(); //noinspection SuspiciousMethodCalls final int closureIndex = Arrays.asList(closureArgs).indexOf(myExpression); if (closureIndex >= 0) { List<TypeConstraint> constraints = new ArrayList<TypeConstraint>(); for (GroovyResolveResult variant : ResolveUtil.getCallVariants(myExpression)) { final GrArgumentList argumentList = methodCall.getArgumentList(); final GrNamedArgument[] namedArgs = argumentList == null ? GrNamedArgument.EMPTY_ARRAY : argumentList.getNamedArguments(); final GrExpression[] expressionArgs = argumentList == null ? GrExpression.EMPTY_ARRAY : argumentList.getExpressionArguments(); try { final Map<GrExpression, Pair<PsiParameter, PsiType>> map = GrClosureSignatureUtil.mapArgumentsToParameters( variant, methodCall, true, true, namedArgs, expressionArgs, closureArgs); addConstraintsFromMap(constraints, map); } catch (RuntimeException e) { LOG.error( "call: " + methodCall.getText() + "\nsymbol: " + variant.getElement().getText(), e); } } if (!constraints.isEmpty()) { myResult = constraints.toArray(new TypeConstraint[constraints.size()]); } } }
public static void processChangedMethodCall( PsiElement element, GrIntroduceParameterSettings settings, Project project) { if (!(element.getParent() instanceof GrMethodCallExpression)) { LOG.error(element.getParent()); return; } GrMethodCallExpression methodCall = (GrMethodCallExpression) element.getParent(); GroovyPsiElementFactory factory = GroovyPsiElementFactory.getInstance(project); final String name = settings.getName(); LOG.assertTrue(name != null); GrExpression expression = factory.createExpressionFromText(name, null); final GrArgumentList argList = methodCall.getArgumentList(); final PsiElement[] exprs = argList.getAllArguments(); if (exprs.length > 0) { argList.addAfter(expression, exprs[exprs.length - 1]); } else { argList.add(expression); } removeParametersFromCall(methodCall, settings); }
@Nullable public static GrExpression addClosureToCall(PsiElement initializer, GrArgumentList list) { if (!(initializer instanceof GrClosableBlock)) return null; final PsiElement parent = list.getParent(); if (!(parent instanceof GrMethodCallExpression)) return null; PsiElement anchor; final GrClosableBlock[] cls = ((GrMethodCallExpression) parent).getClosureArguments(); if (cls.length > 0) { anchor = cls[cls.length - 1]; } else { anchor = list; } return (GrExpression) parent.addAfter(initializer, anchor); }
private GroovyResolveResult[] resolveImpl( boolean incompleteCode, @Nullable GrExpression upToArgument) { GrExpression invoked = getInvokedExpression(); PsiType thisType = invoked.getType(); if (thisType == null) return GroovyResolveResult.EMPTY_ARRAY; GrArgumentList argList = getArgumentList(); PsiType[] argTypes = PsiUtil.getArgumentTypes( argList.getNamedArguments(), argList.getExpressionArguments(), GrClosableBlock.EMPTY_ARRAY, true, upToArgument, false); if (argTypes == null) return GroovyResolveResult.EMPTY_ARRAY; final PsiManager manager = getManager(); final GlobalSearchScope resolveScope = getResolveScope(); if (argTypes.length == 0) { PsiType arrType = null; if (invoked instanceof GrBuiltinTypeClassExpression) { arrType = ((GrBuiltinTypeClassExpression) invoked).getPrimitiveType(); } if (invoked instanceof GrReferenceExpression) { final PsiElement resolved = ((GrReferenceExpression) invoked).resolve(); if (resolved instanceof PsiClass) { String qname = ((PsiClass) resolved).getQualifiedName(); if (qname != null) { arrType = TypesUtil.createTypeByFQClassName(qname, this); } } } if (arrType != null) { return GroovyResolveResult.EMPTY_ARRAY; } } GroovyResolveResult[] candidates; final String name; if (PsiUtil.isLValue(this)) { name = "putAt"; if (!incompleteCode) { argTypes = ArrayUtil.append(argTypes, TypeInferenceHelper.getInitializerFor(this), PsiType.class); } } else { name = "getAt"; } if (PsiImplUtil.isSimpleArrayAccess( thisType, argTypes, manager, resolveScope, PsiUtil.isLValue(this))) { return GroovyResolveResult.EMPTY_ARRAY; } candidates = ResolveUtil.getMethodCandidates( thisType, name, this, true, incompleteCode, false, argTypes); // hack for remove DefaultGroovyMethods.getAt(Object, ...) if (candidates.length == 2) { for (int i = 0; i < candidates.length; i++) { GroovyResolveResult candidate = candidates[i]; final PsiElement element = candidate.getElement(); if (element instanceof GrGdkMethod) { final PsiMethod staticMethod = ((GrGdkMethod) element).getStaticMethod(); final PsiParameter param = staticMethod.getParameterList().getParameters()[0]; if (param.getType().equalsToText(CommonClassNames.JAVA_LANG_OBJECT)) { return new GroovyResolveResult[] {candidates[1 - i]}; } } } } if (candidates.length != 1) { final GrTupleType tupleType = new GrTupleType(argTypes, JavaPsiFacade.getInstance(getProject()), resolveScope); candidates = ResolveUtil.getMethodCandidates(thisType, name, this, tupleType); } return candidates; }
@Nullable private static GrExpression createDefaultValue( GroovyPsiElementFactory factory, JavaChangeInfo changeInfo, JavaParameterInfo info, final GrArgumentList list) { if (info.isUseAnySingleVariable()) { final PsiResolveHelper resolveHelper = JavaPsiFacade.getInstance(list.getProject()).getResolveHelper(); final PsiType type = info.getTypeWrapper().getType(changeInfo.getMethod(), list.getManager()); final VariablesProcessor processor = new VariablesProcessor(false) { @Override protected boolean check(PsiVariable var, ResolveState state) { if (var instanceof PsiField && !resolveHelper.isAccessible((PsiField) var, list, null)) return false; if (var instanceof GrVariable && PsiUtil.isLocalVariable(var) && list.getTextRange().getStartOffset() <= var.getTextRange().getStartOffset()) { return false; } if (PsiTreeUtil.isAncestor(var, list, false)) return false; final PsiType _type = var instanceof GrVariable ? ((GrVariable) var).getTypeGroovy() : var.getType(); final PsiType varType = state.get(PsiSubstitutor.KEY).substitute(_type); return type.isAssignableFrom(varType); } @Override public boolean execute(@NotNull PsiElement pe, @NotNull ResolveState state) { super.execute(pe, state); return size() < 2; } }; ResolveUtil.treeWalkUp(list, processor, false); if (processor.size() == 1) { final PsiVariable result = processor.getResult(0); return factory.createExpressionFromText(result.getName(), list); } if (processor.size() == 0) { final PsiClass parentClass = PsiTreeUtil.getParentOfType(list, PsiClass.class); if (parentClass != null) { PsiClass containingClass = parentClass; final Set<PsiClass> containingClasses = new HashSet<PsiClass>(); final PsiElementFactory jfactory = JavaPsiFacade.getElementFactory(list.getProject()); while (containingClass != null) { if (type.isAssignableFrom(jfactory.createType(containingClass, PsiSubstitutor.EMPTY))) { containingClasses.add(containingClass); } containingClass = PsiTreeUtil.getParentOfType(containingClass, PsiClass.class); } if (containingClasses.size() == 1) { return factory.createThisExpression( containingClasses.contains(parentClass) ? null : containingClasses.iterator().next()); } } } } final String value = info.getDefaultValue(); return !StringUtil.isEmpty(value) ? factory.createExpressionFromText(value, list) : null; }
@Override public GrNamedArgument addNamedArgument(GrNamedArgument namedArgument) throws IncorrectOperationException { GrArgumentList list = getArgumentList(); return list.addNamedArgument(namedArgument); }
@NotNull @Override public GrExpression[] getExpressionArguments() { GrArgumentList list = getArgumentList(); return list.getExpressionArguments(); }
@Override public PsiType fun(GrIndexPropertyImpl index) { GrExpression selected = index.getInvokedExpression(); PsiType thisType = selected.getType(); if (thisType == null) return null; GrArgumentList argList = index.getArgumentList(); PsiType[] argTypes = PsiUtil.getArgumentTypes(argList); if (argTypes == null) return null; final PsiManager manager = index.getManager(); final GlobalSearchScope resolveScope = index.getResolveScope(); if (argTypes.length == 0) { PsiType arrType = null; if (selected instanceof GrBuiltinTypeClassExpression) { arrType = ((GrBuiltinTypeClassExpression) selected).getPrimitiveType(); } if (selected instanceof GrReferenceExpression) { final PsiElement resolved = ((GrReferenceExpression) selected).resolve(); if (resolved instanceof PsiClass) { String qname = ((PsiClass) resolved).getQualifiedName(); if (qname != null) { arrType = TypesUtil.createTypeByFQClassName(qname, index); } } } if (arrType != null) { final PsiArrayType param = arrType.createArrayType(); return TypesUtil.createJavaLangClassType(param, index.getProject(), resolveScope); } } if (PsiImplUtil.isSimpleArrayAccess( thisType, argTypes, manager, resolveScope, PsiUtil.isLValue(index))) { return TypesUtil.boxPrimitiveType( ((PsiArrayType) thisType).getComponentType(), manager, resolveScope); } final GroovyResolveResult[] candidates = index.multiResolve(false); PsiType[] args = PsiUtil.getArgumentTypes( argList.getNamedArguments(), argList.getExpressionArguments(), GrClosableBlock.EMPTY_ARRAY, true, null, false); final GroovyResolveResult candidate = PsiImplUtil.extractUniqueResult(candidates); final PsiElement element = candidate.getElement(); if (element instanceof PsiNamedElement) { final String name = ((PsiNamedElement) element).getName(); if ("putAt".equals(name) && args != null) { args = ArrayUtil.append( args, TypeInferenceHelper.getInitializerFor(index), PsiType.class); } } PsiType overloadedOperatorType = ResolveUtil.extractReturnTypeFromCandidate(candidate, index, args); PsiType componentType = extractMapValueType(thisType, args, manager, resolveScope); if (overloadedOperatorType != null && (componentType == null || !TypesUtil.isAssignable( overloadedOperatorType, componentType, manager, resolveScope))) { return TypesUtil.boxPrimitiveType(overloadedOperatorType, manager, resolveScope); } return componentType; }
@NotNull @Override public GrNamedArgument[] getNamedArguments() { GrArgumentList list = getArgumentList(); return list.getNamedArguments(); }
private static void processMethodUsage( PsiElement element, JavaChangeInfo changeInfo, boolean toChangeArguments, boolean toCatchExceptions, GrClosureSignatureUtil.ArgInfo<PsiElement>[] map, PsiSubstitutor substitutor) { if (map == null) return; if (changeInfo.isNameChanged()) { if (element instanceof GrReferenceElement) { element = ((GrReferenceElement) element).handleElementRename(changeInfo.getNewName()); } } if (toChangeArguments) { JavaParameterInfo[] parameters = changeInfo.getNewParameters(); GrArgumentList argumentList = PsiUtil.getArgumentsList(element); GroovyPsiElementFactory factory = GroovyPsiElementFactory.getInstance(element.getProject()); if (argumentList == null) { if (element instanceof GrEnumConstant) { argumentList = factory.createArgumentList(); argumentList = (GrArgumentList) element.add(argumentList); } else { return; } } Set<PsiElement> argsToDelete = new HashSet<PsiElement>(map.length * 2); for (GrClosureSignatureUtil.ArgInfo<PsiElement> argInfo : map) { argsToDelete.addAll(argInfo.args); } for (JavaParameterInfo parameter : parameters) { int index = parameter.getOldIndex(); if (index >= 0) { argsToDelete.removeAll(map[index].args); } } for (PsiElement arg : argsToDelete) { arg.delete(); } boolean skipOptionals = false; PsiElement anchor = null; // PsiTreeUtil.getChildOfAnyType(argumentList, GrExpression.class, // GrNamedArgument.class); for (int i = 0; i < parameters.length; i++) { JavaParameterInfo parameter = parameters[i]; int index = parameter.getOldIndex(); if (index >= 0) { GrClosureSignatureUtil.ArgInfo<PsiElement> argInfo = map[index]; List<PsiElement> arguments = argInfo.args; if (argInfo.isMultiArg) { // arguments for Map and varArg if ((i != 0 || !(!arguments.isEmpty() && arguments.iterator().next() instanceof GrNamedArgument)) && (i != parameters.length - 1 || !parameter.isVarargType())) { final PsiType type = parameter.createType( changeInfo.getMethod().getParameterList(), argumentList.getManager()); final GrExpression arg = GroovyRefactoringUtil.generateArgFromMultiArg( substitutor, arguments, type, element.getProject()); for (PsiElement argument : arguments) { argument.delete(); } anchor = argumentList.addAfter(arg, anchor); JavaCodeStyleManager.getInstance(anchor.getProject()).shortenClassReferences(anchor); } } else { // arguments for simple parameters if (arguments.size() == 1) { // arg exists PsiElement arg = arguments.iterator().next(); if (i == parameters.length - 1 && parameter.isVarargType()) { if (arg instanceof GrSafeCastExpression) { PsiElement expr = ((GrSafeCastExpression) arg).getOperand(); if (expr instanceof GrListOrMap && !((GrListOrMap) expr).isMap()) { final PsiElement copy = expr.copy(); PsiElement[] newVarargs = ((GrListOrMap) copy).getInitializers(); for (PsiElement vararg : newVarargs) { anchor = argumentList.addAfter(vararg, anchor); } arg.delete(); continue; } } } PsiElement curArg = getNextOfType(argumentList, anchor, GrExpression.class); if (curArg == arg) { anchor = arg; } else { final PsiElement copy = arg.copy(); anchor = argumentList.addAfter(copy, anchor); arg.delete(); } } else { // arg is skipped. Parameter is optional skipOptionals = true; } } } else { if (skipOptionals && isParameterOptional(parameter)) continue; if (forceOptional(parameter)) { skipOptionals = true; continue; } try { GrExpression value = createDefaultValue(factory, changeInfo, parameter, argumentList); if (i > 0 && (value == null || anchor == null)) { PsiElement comma = Factory.createSingleLeafElement( GroovyTokenTypes.mCOMMA, ",", 0, 1, SharedImplUtil.findCharTableByTree(argumentList.getNode()), argumentList.getManager()) .getPsi(); if (anchor == null) anchor = argumentList.getLeftParen(); anchor = argumentList.addAfter(comma, anchor); } if (value != null) { anchor = argumentList.addAfter(value, anchor); } } catch (IncorrectOperationException e) { LOG.error(e.getMessage()); } } } GrCall call = GroovyRefactoringUtil.getCallExpressionByMethodReference(element); if (argumentList.getText().trim().isEmpty() && (call == null || !PsiImplUtil.hasClosureArguments(call))) { argumentList = argumentList.replaceWithArgumentList(factory.createArgumentList()); } CodeStyleManager.getInstance(argumentList.getProject()).reformat(argumentList); } if (toCatchExceptions) { final ThrownExceptionInfo[] exceptionInfos = changeInfo.getNewExceptions(); PsiClassType[] exceptions = getExceptions(exceptionInfos, element, element.getManager()); fixExceptions(element, exceptions); } }