docs: public boolean visit(MethodInvocation node)
      {
          if (!StringUtils.contains(node.toString(), "."))
          {
              // it must be a local method. ignore.
              return true;
          }
          List<String> qualifiedInstances = new ArrayList<>();
          List<String> argumentsQualified = new ArrayList<>();
          // get qualified arguments of the method
          IMethodBinding resolveTypeBinding = node.resolveMethodBinding();
          final ResolutionStatus resolutionStatus;
          int columnNumber = compilationUnit.getColumnNumber(node.getName().getStartPosition());
          int length = node.getName().getLength();
          if (resolveTypeBinding != null)
          {
              resolutionStatus = ResolutionStatus.RESOLVED;
              ITypeBinding[] argumentTypeBindings = resolveTypeBinding.getParameterTypes();
              List<Expression> arguments = node.arguments();
              int index = 0;
              for (ITypeBinding type : argumentTypeBindings)
              {
                  argumentsQualified.add(type.getQualifiedName());
  
                  if (type.isEnum())
                  {
                      // there is different number of passed arguments and possible arguments from declaration
                      if (arguments.size() > index)
                      {
                          Expression expression = arguments.get(index);
                          processTypeAsEnum(type, expression, resolutionStatus,
                                  compilationUnit.getLineNumber(node.getName().getStartPosition()),
                                  columnNumber,
                                  length, extractDefinitionLine(node.toString()));
                      }
                      index++;
                  }
              }
  
              // find the interface declaring the method
              if (resolveTypeBinding != null && resolveTypeBinding.getDeclaringClass() != null)
              {
                  ITypeBinding declaringClass = resolveTypeBinding.getDeclaringClass();
                  qualifiedInstances.add(declaringClass.getQualifiedName());
                  ITypeBinding[] interfaces = declaringClass.getInterfaces();
                  // Now find all the implemented interfaces having the method called.
                  for (ITypeBinding possibleInterface : interfaces)
                  {
                      IMethodBinding[] declaredMethods = possibleInterface.getDeclaredMethods();
                      if (declaredMethods.length != 0)
                      {
                          for (IMethodBinding interfaceMethod : declaredMethods)
                          {
                              if (interfaceMethod.getName().equals(node.getName().toString()))
                              {
                                  List<String> interfaceMethodArguments = new ArrayList<>();
                                  for (ITypeBinding type : interfaceMethod.getParameterTypes())
                                  {
                                      interfaceMethodArguments.add(type.getQualifiedName());
                                  }
                                  if (interfaceMethodArguments.equals(argumentsQualified))
                                  {
                                      qualifiedInstances.add(possibleInterface.getQualifiedName());
                                  }
                              }
                          }
                      }
                  }
              }
  
          }
          else
          {
              resolutionStatus = ResolutionStatus.RECOVERED;
              String nodeName = StringUtils.removeStart(node.toString(), "this.");
              String objRef = StringUtils.substringBefore(nodeName, "." + node.getName().toString());
              if (state.getNameInstance().containsKey(objRef))
              {
                  objRef = state.getNameInstance().get(objRef);
              }
              objRef = resolveClassname(objRef).result;
  
              @SuppressWarnings("unchecked")
              List<Expression> arguments = node.arguments();
              for (Expression expression : arguments)
              {
                  ITypeBinding argumentBinding = expression.resolveTypeBinding();
                  if (argumentBinding != null)
                  {
                      argumentsQualified.add(argumentBinding.getQualifiedName());
  
                      if (argumentBinding.isEnum())
                      {
                          // FIXME -- Test
                          String constantEnum = expression.toString();
                          if (constantEnum != null)
                          {
                              processTypeAsEnum(argumentBinding, expression, ResolutionStatus.RESOLVED, compilationUnit.getLineNumber(node.getName().getStartPosition()),
                                      columnNumber, length, extractDefinitionLine(node.toString()));
                          }
                      }
                  }
                  else
                  {
                      PackageAndClassName argumentQualifiedGuess = PackageAndClassName.parseFromQualifiedName(expression.toString());
                      argumentsQualified.add(argumentQualifiedGuess.toString());
                  }
              }
              qualifiedInstances.add(objRef);
          }
  
          for (String qualifiedInstance : qualifiedInstances)
          {
              PackageAndClassName packageAndClassName = PackageAndClassName.parseFromQualifiedName(qualifiedInstance);
              MethodType methodCall = new MethodType(qualifiedInstance, packageAndClassName.packageName, packageAndClassName.className,
                          node.getName().toString(), argumentsQualified);
              processMethod(methodCall, resolutionStatus, TypeReferenceLocation.METHOD_CALL,
                          compilationUnit.getLineNumber(node.getName().getStartPosition()),
                          columnNumber, length, node.toString());
          }
  
          return super.visit(node);
      }