private static ImmutableSet<ExecutableElement> getAllMethods(
      TypeElement type, Overrides overrides) {
    SetMultimap<String, ExecutableElement> methodMap = LinkedHashMultimap.create();
    getAllMethods(type, methodMap);
    // Find methods that are overridden. We do this using `Elements.overrides`, which means
    // that it is inherently a quadratic operation, since we have to compare every method against
    // every other method. We reduce the performance impact by (a) grouping methods by name, since
    // a method cannot override another method with a different name, and (b) making sure that
    // methods in ancestor types precede those in descendant types, which means we only have to
    // check a method against the ones that follow it in that order.
    Set<ExecutableElement> overridden = new LinkedHashSet<ExecutableElement>();
    for (Collection<ExecutableElement> methods : methodMap.asMap().values()) {
      List<ExecutableElement> methodList = ImmutableList.copyOf(methods);
      for (int i = 0; i < methodList.size(); i++) {
        ExecutableElement methodI = methodList.get(i);
        for (int j = i + 1; j < methodList.size(); j++) {
          ExecutableElement methodJ = methodList.get(j);
          if (overrides.overrides(methodJ, methodI, type)) {
            overridden.add(methodI);
            break;
          }
        }
      }
    }
    return methodMap.values().stream()
        .filter(m -> !overridden.contains(m))
        .collect(toImmutableSet());
  }
Returns the set of all methods from {@code type}, including methods that it inherits from its
ancestors. Inherited methods that are overridden are not included in the result. So if {@code
type} defines {@code public String toString()}, the returned set will contain that method, but
not the {@code toString()} method defined by {@code Object}.

<p>The returned set may contain more than one method with the same signature, if {@code type}
inherits those methods from different ancestors. For example, if it inherits from unrelated
interfaces {@code One} and {@code Two} which each define {@code void foo();}, and if it does
not itself override the {@code foo()} method, then both {@code One.foo()} and {@code Two.foo()}
will be in the returned set.

<p>The order of the returned set is deterministic: within a class or interface, methods are in
the order they appear in the source code; methods in ancestors come before methods in
descendants; methods in interfaces come before methods in classes; and in a class or interface
that has more than one superinterface, the interfaces are in the order of their appearance in
{@code implements} or {@code extends}.

@param type the type whose own and inherited methods are to be returned
@param typeUtils a {@link Types} object, typically returned by {@link
    javax.annotation.processing.AbstractProcessor#processingEnv processingEnv}.{@link
    javax.annotation.processing.ProcessingEnvironment#getTypeUtils getTypeUtils()}
@param elementUtils an {@link Elements} object, typically returned by {@link
    javax.annotation.processing.AbstractProcessor#processingEnv processingEnv}.{@link
    javax.annotation.processing.ProcessingEnvironment#getElementUtils getElementUtils()}
common/src/main/java/com/google/auto/common/MoreElements.java