docs: private static List<List<Parameter>> findArgumentsForOtherInstances(
        MethodSymbol calledMethod, Tree currentNode, VisitorState state) {
  
      Tree enclosingNode = ASTHelpers.findEnclosingNode(state.getPath(), MethodTree.class);
      if (enclosingNode == null) {
        enclosingNode = ASTHelpers.findEnclosingNode(state.getPath(), ClassTree.class);
      }
      if (enclosingNode == null) {
        return ImmutableList.of();
      }
  
      ImmutableList.Builder<List<Parameter>> resultBuilder = ImmutableList.builder();
      new TreeScanner<Void, Void>() {
        @Override
        public Void visitMethodInvocation(MethodInvocationTree methodInvocationTree, Void aVoid) {
          addToResult(ASTHelpers.getSymbol(methodInvocationTree), methodInvocationTree);
          return super.visitMethodInvocation(methodInvocationTree, aVoid);
        }
  
        @Override
        public Void visitNewClass(NewClassTree newClassTree, Void aVoid) {
          addToResult(ASTHelpers.getSymbol(newClassTree), newClassTree);
          return super.visitNewClass(newClassTree, aVoid);
        }
  
        @Override
        public Void visitMethod(MethodTree methodTree, Void aVoid) {
          MethodSymbol methodSymbol = ASTHelpers.getSymbol(methodTree);
          if (methodSymbol != null) {
            // if the method declared here is the one we are calling then add it
            addToResult(methodSymbol, methodTree);
  
            // if any supermethod of the one declared here is the one we are calling then add it
            for (MethodSymbol superSymbol :
                ASTHelpers.findSuperMethods(methodSymbol, state.getTypes())) {
              addToResult(superSymbol, methodTree);
            }
          }
          return super.visitMethod(methodTree, aVoid);
        }
  
        private void addToResult(MethodSymbol foundSymbol, Tree tree) {
          if (foundSymbol != null
              && Objects.equals(calledMethod, foundSymbol)
              && !currentNode.equals(tree)) {
            resultBuilder.add(createParameterList(tree));
          }
        }
  
        private ImmutableList<Parameter> createParameterList(Tree tree) {
          if (tree instanceof MethodInvocationTree) {
            return Parameter.createListFromExpressionTrees(
                ((MethodInvocationTree) tree).getArguments());
          }
          if (tree instanceof NewClassTree) {
            return Parameter.createListFromExpressionTrees(((NewClassTree) tree).getArguments());
          }
          if (tree instanceof MethodTree) {
            return Parameter.createListFromVariableTrees(((MethodTree) tree).getParameters());
          }
          return ImmutableList.of();
        }
      }.scan(enclosingNode, null);
  
      return resultBuilder.build();
    }