code: static Optional<BuilderMethodClassifier> classify(
        Iterable<ExecutableElement> methods,
        ErrorReporter errorReporter,
        ProcessingEnvironment processingEnv,
        TypeElement autoValueClass,
        TypeElement builderType,
        ImmutableBiMap<ExecutableElement, String> getterToPropertyName,
        ImmutableMap<ExecutableElement, TypeMirror> getterToPropertyType,
        boolean autoValueHasToBuilder) {
      BuilderMethodClassifier classifier =
          new BuilderMethodClassifier(
              errorReporter,
              processingEnv,
              autoValueClass,
              builderType,
              getterToPropertyName,
              getterToPropertyType);
      if (classifier.classifyMethods(methods, autoValueHasToBuilder)) {
        return Optional.of(classifier);
      } else {
        return Optional.empty();
      }
    }
docs: Classifies the given methods from a builder type and its ancestors.
  
  @param methods the methods in {@code builderType} and its ancestors.
  @param errorReporter where to report errors.
  @param processingEnv the ProcessingEnvironment for annotation processing.
  @param autoValueClass the {@code AutoValue} class containing the builder.
  @param builderType the builder class or interface within {@code autoValueClass}.
  @param getterToPropertyName a map from getter methods to the properties they get.
  @param getterToPropertyType a map from getter methods to their return types. The return types
  here use type parameters from the builder class (if any) rather than from the {@code
  AutoValue} class, even though the getter methods are in the latter.
  @param autoValueHasToBuilder true if the containing {@code @AutoValue} class has a {@code
  toBuilder()} method.
  @return an {@code Optional} that contains the results of the classification if it was
  successful or nothing if it was not.