@Override
  public boolean processUsage(
      ChangeInfo changeInfo, UsageInfo usageInfo, boolean beforeMethodChange, UsageInfo[] usages) {
    if (!(changeInfo instanceof JavaChangeInfo)) return false;

    PsiElement element = usageInfo.getElement();
    if (element == null) return false;
    if (!GroovyLanguage.INSTANCE.equals(element.getLanguage())) return false;

    if (beforeMethodChange) {
      if (usageInfo instanceof OverriderUsageInfo) {
        processPrimaryMethodInner(
            ((JavaChangeInfo) changeInfo),
            (GrMethod) ((OverriderUsageInfo) usageInfo).getElement(),
            ((OverriderUsageInfo) usageInfo).getBaseMethod());
      }
    } else {
      if (usageInfo instanceof GrMethodCallUsageInfo) {
        processMethodUsage(
            element,
            ((JavaChangeInfo) changeInfo),
            ((GrMethodCallUsageInfo) usageInfo).isToChangeArguments(),
            ((GrMethodCallUsageInfo) usageInfo).isToCatchExceptions(),
            ((GrMethodCallUsageInfo) usageInfo).getMapToArguments(),
            ((GrMethodCallUsageInfo) usageInfo).getSubstitutor());
        return true;
      } else if (usageInfo instanceof DefaultConstructorImplicitUsageInfo) {
        processConstructor(
            (GrMethod) ((DefaultConstructorImplicitUsageInfo) usageInfo).getConstructor(),
            (JavaChangeInfo) changeInfo);
        return true;
      } else if (usageInfo instanceof NoConstructorClassUsageInfo) {
        processClassUsage(
            (GrTypeDefinition) ((NoConstructorClassUsageInfo) usageInfo).getPsiClass(),
            ((JavaChangeInfo) changeInfo));
        return true;
      } else if (usageInfo instanceof ChangeSignatureParameterUsageInfo) {
        String newName = ((ChangeSignatureParameterUsageInfo) usageInfo).newParameterName;
        ((PsiReference) element).handleElementRename(newName);
        return true;
      } else {
        PsiReference ref = element.getReference();
        if (ref != null && changeInfo.getMethod() != null) {
          ref.bindToElement(changeInfo.getMethod());
          return true;
        }
      }
    }
    return false;
  }
  private PsiMethod[] findSimpleUsagesWithoutParameters(
      final PsiMethod method,
      final ArrayList<UsageInfo> result,
      boolean isToModifyArgs,
      boolean isToThrowExceptions,
      boolean isOriginal) {

    GlobalSearchScope projectScope = GlobalSearchScope.projectScope(method.getProject());
    PsiMethod[] overridingMethods =
        OverridingMethodsSearch.search(method, true).toArray(PsiMethod.EMPTY_ARRAY);

    for (PsiMethod overridingMethod : overridingMethods) {
      result.add(
          new OverriderUsageInfo(
              overridingMethod, method, isOriginal, isToModifyArgs, isToThrowExceptions));
    }

    boolean needToChangeCalls =
        !myChangeInfo.isGenerateDelegate()
            && (myChangeInfo.isNameChanged()
                || myChangeInfo.isParameterSetOrOrderChanged()
                || myChangeInfo.isExceptionSetOrOrderChanged()
                || myChangeInfo.isVisibilityChanged() /*for checking inaccessible*/);
    if (needToChangeCalls) {
      int parameterCount = method.getParameterList().getParametersCount();

      PsiReference[] refs =
          MethodReferencesSearch.search(method, projectScope, true)
              .toArray(PsiReference.EMPTY_ARRAY);
      for (PsiReference ref : refs) {
        PsiElement element = ref.getElement();

        boolean isToCatchExceptions =
            isToThrowExceptions
                && needToCatchExceptions(RefactoringUtil.getEnclosingMethod(element));
        if (!isToCatchExceptions) {
          if (RefactoringUtil.isMethodUsage(element)) {
            PsiExpressionList list = RefactoringUtil.getArgumentListByMethodReference(element);
            if (list == null
                || !method.isVarArgs() && list.getExpressions().length != parameterCount) continue;
          }
        }
        if (RefactoringUtil.isMethodUsage(element)) {
          result.add(new MethodCallUsageInfo(element, isToModifyArgs, isToCatchExceptions));
        } else if (element instanceof PsiDocTagValue) {
          result.add(new UsageInfo(element));
        } else if (element instanceof PsiMethod && ((PsiMethod) element).isConstructor()) {
          if (JavaLanguage.INSTANCE.equals(element.getLanguage())) {
            DefaultConstructorImplicitUsageInfo implicitUsageInfo =
                new DefaultConstructorImplicitUsageInfo(
                    (PsiMethod) element, ((PsiMethod) element).getContainingClass(), method);
            result.add(implicitUsageInfo);
          }
        } else if (element instanceof PsiClass) {
          LOG.assertTrue(method.isConstructor());
          final PsiClass psiClass = (PsiClass) element;
          if (JavaLanguage.INSTANCE.equals(psiClass.getLanguage())) {
            if (myChangeInfo instanceof JavaChangeInfo) {
              if (shouldPropagateToNonPhysicalMethod(
                  method,
                  result,
                  psiClass,
                  ((JavaChangeInfo) myChangeInfo).getMethodsToPropagateParameters())) {
                continue;
              }
            }
            result.add(new NoConstructorClassUsageInfo(psiClass));
          }
        } else if (ref instanceof PsiCallReference) {
          result.add(new CallReferenceUsageInfo((PsiCallReference) ref));
        } else {
          result.add(new MoveRenameUsageInfo(element, ref, method));
        }
      }

      // if (method.isConstructor() && parameterCount == 0) {
      //    RefactoringUtil.visitImplicitConstructorUsages(method.getContainingClass(),
      //                                                   new
      // DefaultConstructorUsageCollector(result));
      // }
    } else if (myChangeInfo.isParameterTypesChanged()) {
      PsiReference[] refs =
          MethodReferencesSearch.search(method, projectScope, true)
              .toArray(PsiReference.EMPTY_ARRAY);
      for (PsiReference reference : refs) {
        final PsiElement element = reference.getElement();
        if (element instanceof PsiDocTagValue) {
          result.add(new UsageInfo(reference));
        } else if (element instanceof XmlElement) {
          result.add(new MoveRenameUsageInfo(reference, method));
        } else if (element instanceof PsiMethodReferenceExpression) {
          result.add(new UsageInfo(reference));
        }
      }
    }

    // Conflicts
    detectLocalsCollisionsInMethod(method, result, isOriginal);
    for (final PsiMethod overridingMethod : overridingMethods) {
      detectLocalsCollisionsInMethod(overridingMethod, result, isOriginal);
    }

    return overridingMethods;
  }