void migrateMethodCallExpressions(PsiType migrationType, PsiParameter param, PsiClass psiClass) {
    boolean checkNumberOfArguments = false;
    PsiType sourceType = param.getType();
    if (sourceType instanceof PsiEllipsisType && !(migrationType instanceof PsiEllipsisType)) {
      checkNumberOfArguments = true;
    }
    final PsiType strippedType =
                  migrationType instanceof PsiEllipsisType ? ((PsiEllipsisType)migrationType).getComponentType() : migrationType;
    final PsiMethod method = (PsiMethod)param.getDeclarationScope();
    final PsiParameterList parameterList = method.getParameterList();
    final int parametersCount = parameterList.getParametersCount();
    final int index = parameterList.getParameterIndex(param);
    SearchScope scope = method.getUseScope().intersectWith(myRules.getSearchScope());
    final List<PsiReference> refs = filterReferences(psiClass, ReferencesSearch.search(method, scope, false));
    for (PsiReference ref1 : refs) {
      final PsiElement ref = ref1.getElement();
      final PsiElement parent = ref instanceof PsiEnumConstant ? ref : ref.getParent();
      if (parent instanceof PsiCall call) {
        final PsiExpressionList argumentList = call.getArgumentList();
        if (argumentList != null) {
          final PsiExpression[] expressions = argumentList.getExpressions();
          if (checkNumberOfArguments) {
            if (migrationType instanceof PsiArrayType && MethodCallUtils.isVarArgCall(call)) {
              convertExpression(expressions[index], migrationType, sourceType, false, method);
              continue;
            }
            else if (parametersCount != expressions.length) {
              markFailedConversion(migrationType, argumentList);
            }
          }
          if (index > -1 && index < expressions.length) {
            for (int idx = index; idx < (param.isVarArgs() ? expressions.length : index + 1); idx++) {
              final PsiExpression actual = expressions[idx];
              final PsiType type = getTypeEvaluator().evaluateType(actual);
              if (type != null) {
                if (type instanceof PsiArrayType && migrationType instanceof PsiEllipsisType) {
                  migrateExpressionType(actual, migrationType, parent, false, true);
                }
                else {
                  migrateExpressionType(actual, strippedType, parent, TypeConversionUtil.isAssignable(strippedType, type), true);
                }
              }
            }
          }
        }
      } else if (ref instanceof PsiDocTagValue) {
        myConversions.put(ref, method);
      }
    }
  }
void migrateMethodCallExpressions(PsiType migrationType, PsiParameter param, PsiClass psiClass)