use of org.jetbrains.plugins.groovy.lang.psi.api.statements.arguments.GrNamedArgument in project intellij-community by JetBrains.
the class ExpressionGenerator method visitIndexProperty.
@Override
public void visitIndexProperty(@NotNull GrIndexProperty expression) {
final GrExpression selectedExpression = expression.getInvokedExpression();
final PsiType thisType = selectedExpression.getType();
final GrArgumentList argList = expression.getArgumentList();
if (argList.getAllArguments().length == 0) {
// int[] or String[]
if (selectedExpression instanceof GrBuiltinTypeClassExpression) {
selectedExpression.accept(this);
return;
} else if (selectedExpression instanceof GrReferenceExpression) {
PsiElement resolved = ((GrReferenceExpression) selectedExpression).resolve();
if (resolved instanceof PsiClass) {
builder.append(((PsiClass) resolved).getQualifiedName());
builder.append("[].class");
return;
}
}
}
final PsiType[] argTypes = PsiUtil.getArgumentTypes(argList);
final GrExpression[] exprArgs = argList.getExpressionArguments();
final GrNamedArgument[] namedArgs = argList.getNamedArguments();
if (!PsiImplUtil.isSimpleArrayAccess(thisType, argTypes, expression, PsiUtil.isLValue(expression))) {
final GroovyResolveResult candidate = PsiImplUtil.extractUniqueResult(expression.multiResolve(false));
PsiElement element = candidate.getElement();
if (element != null || !PsiUtil.isLValue(expression)) {
//see the case of l-value in assignment expression
if (element instanceof GrGdkMethod && ((GrGdkMethod) element).getStaticMethod().getParameterList().getParameters()[0].getType().equalsToText("java.util.Map<K,V>")) {
PsiClass map = JavaPsiFacade.getInstance(context.project).findClass(CommonClassNames.JAVA_UTIL_MAP, expression.getResolveScope());
if (map != null) {
PsiMethod[] gets = map.findMethodsByName("get", false);
invokeMethodOn(gets[0], selectedExpression, exprArgs, namedArgs, GrClosableBlock.EMPTY_ARRAY, PsiSubstitutor.EMPTY, expression);
return;
}
} else if (element instanceof GrGdkMethod && ((GrGdkMethod) element).getStaticMethod().getParameterList().getParameters()[0].getType().equalsToText("java.util.List<T>")) {
PsiClass list = JavaPsiFacade.getInstance(context.project).findClass(CommonClassNames.JAVA_UTIL_LIST, expression.getResolveScope());
if (list != null) {
PsiMethod[] gets = list.findMethodsByName("get", false);
invokeMethodOn(gets[0], selectedExpression, exprArgs, namedArgs, GrClosableBlock.EMPTY_ARRAY, PsiSubstitutor.EMPTY, expression);
return;
}
}
GenerationUtil.invokeMethodByResolveResult(selectedExpression, candidate, "getAt", exprArgs, namedArgs, GrClosableBlock.EMPTY_ARRAY, this, expression);
return;
}
}
selectedExpression.accept(this);
builder.append('[');
final GrExpression arg = exprArgs[0];
arg.accept(this);
builder.append(']');
}
use of org.jetbrains.plugins.groovy.lang.psi.api.statements.arguments.GrNamedArgument in project intellij-community by JetBrains.
the class ExpressionGenerator method generateArgsForInvokeMethod.
private GrExpression[] generateArgsForInvokeMethod(String name, GrExpression[] exprs, GrNamedArgument[] namedArgs, GrClosableBlock[] clArgs, GroovyPsiElement psiContext) {
GrExpression[] result = new GrExpression[2];
result[0] = factory.createExpressionFromText("\"" + name + "\"");
StringBuilder builder = new StringBuilder();
builder.append('[');
if (namedArgs.length > 0) {
builder.append('[');
for (GrNamedArgument namedArg : namedArgs) {
builder.append(namedArg.getText()).append(',');
}
builder.delete(builder.length() - 1, builder.length());
//builder.removeFromTheEnd(1);
builder.append("],");
}
for (GrExpression expr : exprs) {
builder.append(expr.getText()).append(',');
}
for (GrClosableBlock clArg : clArgs) {
builder.append(clArg.getText()).append(',');
}
if (namedArgs.length + exprs.length + clArgs.length > 0)
builder.delete(builder.length() - 1, builder.length());
//if (namedArgs.length + exprs.length + clArgs.length > 0) builder.removeFromTheEnd(1);
builder.append("] as Object[]");
result[1] = factory.createExpressionFromText(builder.toString(), psiContext);
return result;
}
use of org.jetbrains.plugins.groovy.lang.psi.api.statements.arguments.GrNamedArgument in project intellij-community by JetBrains.
the class GroovyTypeCheckVisitor method checkNamedArgumentsType.
private void checkNamedArgumentsType(@NotNull CallInfo<?> info) {
GroovyPsiElement rawCall = info.getCall();
if (!(rawCall instanceof GrCall))
return;
GrCall call = (GrCall) rawCall;
GrNamedArgument[] namedArguments = PsiUtil.getFirstMapNamedArguments(call);
if (namedArguments.length == 0)
return;
Map<String, NamedArgumentDescriptor> map = GroovyNamedArgumentProvider.getNamedArgumentsFromAllProviders(call, null, false);
if (map == null)
return;
checkNamedArguments(call, namedArguments, map);
}
use of org.jetbrains.plugins.groovy.lang.psi.api.statements.arguments.GrNamedArgument in project intellij-community by JetBrains.
the class GrChangeSignatureUsageProcessor method processMethodUsage.
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<>(map.length * 2);
for (GrClosureSignatureUtil.ArgInfo<PsiElement> argInfo : map) {
argsToDelete.addAll(argInfo.args);
}
GrExpression[] values = new GrExpression[parameters.length];
for (int i = 0; i < parameters.length; i++) {
JavaParameterInfo parameter = parameters[i];
int index = parameter.getOldIndex();
if (index >= 0) {
argsToDelete.removeAll(map[index].args);
} else {
values[i] = createDefaultValue(factory, changeInfo, parameter, argumentList, substitutor);
}
}
for (PsiElement arg : argsToDelete) {
arg.delete();
}
boolean skipOptionals = false;
//PsiTreeUtil.getChildOfAnyType(argumentList, GrExpression.class, GrNamedArgument.class);
PsiElement anchor = null;
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 {
final GrExpression value = values[i];
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());
}
}
}
for (PsiElement arg : argsToDelete) {
arg.delete();
}
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);
}
}
use of org.jetbrains.plugins.groovy.lang.psi.api.statements.arguments.GrNamedArgument in project intellij-community by JetBrains.
the class RecursionUtils method callExpressionDefinitelyRecurses.
private static boolean callExpressionDefinitelyRecurses(GrCallExpression exp, GrMethod method) {
final GrArgumentList argumentList = exp.getArgumentList();
if (argumentList != null) {
final GrExpression[] args = argumentList.getExpressionArguments();
for (final GrExpression arg : args) {
if (expressionDefinitelyRecurses(arg, method)) {
return true;
}
}
final GrNamedArgument[] namedArgs = argumentList.getNamedArguments();
for (final GrNamedArgument arg : namedArgs) {
if (expressionDefinitelyRecurses(arg.getExpression(), method)) {
return true;
}
}
}
return false;
}
Aggregations