private void classifyMethodOneArg(ExecutableElement method) {
    if (classifyPropertyBuilderOneArg(method)) {
      return;
    }
    String methodName = method.getSimpleName().toString();
    ImmutableMap<String, E> propertyElements = propertyElements();
    String propertyName = null;
    E propertyElement = propertyElements.get(methodName);
    Multimap<String, PropertySetter> propertyNameToSetters = null;
    if (propertyElement != null) {
      propertyNameToSetters = propertyNameToUnprefixedSetters;
      propertyName = methodName;
    } else if (methodName.startsWith("set") && methodName.length() > 3) {
      propertyNameToSetters = propertyNameToPrefixedSetters;
      propertyName = PropertyNames.decapitalizeLikeJavaBeans(methodName.substring(3));
      propertyElement = propertyElements.get(propertyName);
      if (propertyElement == null) {
        // If our property is defined by a getter called getOAuth() then it is called "OAuth"
        // because of JavaBeans rules. Therefore we want JavaBeans rules to be used for the setter
        // too, so that you can write setOAuth(x). Meanwhile if the property is defined by a getter
        // called oAuth() then it is called "oAuth", but you would still expect to be able to set it
        // using setOAuth(x). Hence the second try using a decapitalize method without the quirky
        // two-leading-capitals rule.
        propertyName = PropertyNames.decapitalizeNormally(methodName.substring(3));
        propertyElement = propertyElements.get(propertyName);
      }
    } else {
      // We might also have an unprefixed setter, so the getter is called OAuth() or getOAuth() and
      // the setter is called oAuth(x), where again JavaBeans rules imply that it should be called
      // OAuth(x). Iterating over the properties here is a bit clunky but this case should be
      // unusual.
      propertyNameToSetters = propertyNameToUnprefixedSetters;
      for (Map.Entry<String, E> entry : propertyElements.entrySet()) {
        if (methodName.equals(PropertyNames.decapitalizeNormally(entry.getKey()))) {
          propertyName = entry.getKey();
          propertyElement = entry.getValue();
          break;
        }
      }
    }
    if (propertyElement == null || propertyNameToSetters == null) {
      // The second disjunct isn't needed but convinces control-flow checkers that
      // propertyNameToSetters can't be null when we call put on it below.
      errorReporter.reportError(
          method,
          "[%sBuilderWhatProp] Method %s does not correspond to %s",
          autoWhat(),
          methodName,
          getterMustMatch());
      checkForFailedJavaBean(method);
      return;
    }
    Optional<Copier> function = getSetterFunction(propertyElement, method);
    if (function.isPresent()) {
      MethodSignature methodSignature = MethodSignature.asMemberOf(typeUtils, builderType, method);
      TypeMirror returnType = methodSignature.returnType().getType();
      if (typeUtils.isSubtype(builderType.asType(), returnType)
          && !MoreTypes.isTypeOf(Object.class, returnType)) {
        if (nullableAnnotationFor(method, returnType).isPresent()) {
          errorReporter.
              reportWarning(
              method,
              "[%sBuilderSetterNullable] Setter methods always return the Builder so @Nullable"
                  + " is not appropriate",
              autoWhat());
        }
        // We allow the return type to be a supertype (other than Object), to support step builders.
        AnnotatedTypeMirror parameterType =
            Iterables.getOnlyElement(methodSignature.parameterTypes());
        propertyNameToSetters.put(
            propertyName, new PropertySetter(method, parameterType, function.get()));
      } else {
        errorReporter.reportError(
            method,
            "[%sBuilderRet] Setter methods must return %s or a supertype",
            autoWhat(),
            builderType.asType());
      }
    }
  }
Classifies a method given that it has one argument. A method with one argument can be:

<ul>
  <li>a setter, meaning that it looks like {@code foo(T)} or {@code setFoo(T)}, where the
      {@code AutoValue} class has a property called {@code foo} of type {@code T};
  <li>a property builder with one argument, meaning it looks like {@code
      ImmutableSortedSet.Builder<V> foosBuilder(Comparator<V>)}, where the {@code AutoValue}
      class has a property called {@code foos} with a type whose builder can be made with an
      argument of the given type.
</ul>
value/src/main/java/com/google/auto/value/processor/BuilderMethodClassifier.java