Java GrArgumentList.addAfter方法代码示例

import org.jetbrains.plugins.groovy.lang.psi.api.statements.arguments.GrArgumentList; //导入方法依赖的package包/类
private static void processChangedMethodCall(PsiElement element, GrIntroduceParameterSettings settings) {
  if (element.getParent() instanceof GrMethodCallExpression) {
    GrMethodCallExpression methodCall = (GrMethodCallExpression)element.getParent();

    final GroovyPsiElementFactory factory = GroovyPsiElementFactory.getInstance(settings.getProject());
    GrExpression expression = factory.createExpressionFromText(settings.getName(), 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);

  }
  else {
    LOG.error(element.getParent());
  }
}
 

import org.jetbrains.plugins.groovy.lang.psi.api.statements.arguments.GrArgumentList; //导入方法依赖的package包/类
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);
}
 

import org.jetbrains.plugins.groovy.lang.psi.api.statements.arguments.GrArgumentList; //导入方法依赖的package包/类
@Override
public boolean processChangeMethodUsage(IntroduceParameterData data, UsageInfo usage, UsageInfo[] usages) throws IncorrectOperationException {
  GrCall callExpression = GroovyRefactoringUtil.getCallExpressionByMethodReference(usage.getElement());
  if (callExpression == null) return true;
  GrArgumentList argList = callExpression.getArgumentList();
  GrExpression[] oldArgs = argList.getExpressionArguments();

  final GrExpression anchor;
  if (!data.getMethodToSearchFor().isVarArgs()) {
    anchor = getLast(oldArgs);
  }
  else {
    final PsiParameter[] parameters = data.getMethodToSearchFor().getParameterList().getParameters();
    if (parameters.length > oldArgs.length) {
      anchor = getLast(oldArgs);
    }
    else {
      final int lastNonVararg = parameters.length - 2;
      anchor = lastNonVararg >= 0 ? oldArgs[lastNonVararg] : null;
    }
  }

  PsiMethod method = PsiTreeUtil.getParentOfType(argList, PsiMethod.class);

  GrClosureSignature signature = GrClosureSignatureUtil.createSignature(callExpression);
  if (signature == null) signature = GrClosureSignatureUtil.createSignature(data.getMethodToSearchFor(), PsiSubstitutor.EMPTY);

  final GrClosureSignatureUtil.ArgInfo<PsiElement>[] actualArgs = GrClosureSignatureUtil
    .mapParametersToArguments(signature, callExpression.getNamedArguments(), callExpression.getExpressionArguments(),
                              callExpression.getClosureArguments(), callExpression, false, true);

  final GroovyPsiElementFactory factory = GroovyPsiElementFactory.getInstance(data.getProject());

  if (method != null && IntroduceParameterUtil.isMethodInUsages(data, method, usages)) {
    argList.addAfter(factory.createExpressionFromText(data.getParameterName()), anchor);
  }
  else {
    final PsiElement _expr = data.getParameterInitializer().getExpression();
    PsiElement initializer = ExpressionConverter.getExpression(_expr, GroovyLanguage.INSTANCE, data.getProject());
    LOG.assertTrue(initializer instanceof GrExpression);

    GrExpression newArg = GroovyIntroduceParameterUtil.addClosureToCall(initializer, argList);
    if (newArg == null) {
      final PsiElement dummy = argList.addAfter(factory.createExpressionFromText("1"), anchor);
      newArg = ((GrExpression)dummy).replaceWithExpression((GrExpression)initializer, true);
    }
    final PsiMethod methodToReplaceIn = data.getMethodToReplaceIn();
    new OldReferencesResolver(callExpression, newArg, methodToReplaceIn, data.getReplaceFieldsWithGetters(), initializer,
                              signature, actualArgs, methodToReplaceIn.getParameterList().getParameters()).resolve();
    ChangeContextUtil.clearContextInfo(initializer);

    //newArg can be replaced by OldReferenceResolver
    if (newArg.isValid()) {
      JavaCodeStyleManager.getInstance(newArg.getProject()).shortenClassReferences(newArg);
      CodeStyleManager.getInstance(data.getProject()).reformat(newArg);
    }
  }

  if (actualArgs == null) {
    removeParamsFromUnresolvedCall(callExpression, data);
  }
  else {
    removeParametersFromCall(actualArgs, data.getParametersToRemove());
  }

  if (argList.getAllArguments().length == 0 && PsiImplUtil.hasClosureArguments(callExpression)) {
    final GrArgumentList emptyArgList = ((GrMethodCallExpression)factory.createExpressionFromText("foo{}")).getArgumentList();
    LOG.assertTrue(emptyArgList != null);
    argList.replace(emptyArgList);
  }
  return false;
}