name: Feature Enhancement Request
description: I want to make an existing feature better
labels: ["type=enhancement"]
body:
  - type: markdown
    attributes:
      value: >
        Filing feature requests is one of the most popular ways to contribute to Guava.


        Be aware, though: most feature requests are not accepted, even if they're suggested by
        a full-time Guava team member. [Feedback](https://stackoverflow.com/a/4543114) from our

    Java Language specification, sections 8.1.1, 8.3.1 and 8.4.3. It is not that
    the standard is perfect, but having a consistent order makes the code more
    readable and no other order is compellingly better than the standard.
    The correct order is:
            public
            protected
            private
            abstract
            static
            final
            transient
            volatile
            synchronized

**Example:**

Source:
Let's see how that works and how to change it if you need to do that.

Avoid translating literally as:
Vamos ver como isso funciona e como alterar isso se você precisar fazer isso.

Better translation:
Vamos ver como isso funciona e como alterar se você precisar.

---

For the next terms, use the following translations:

* /// check: /// check | Verifique
* /// danger: /// danger | Cuidado

     * have the same nullness as E." Since we can't, we declare it to return nullable elements, and
     * we can override it in our non-null-guaranteeing subtypes to present a better signature to
     * their users.
     *
     * However, the checker *we* use has this special knowledge about `Collection.toArray()` anyway,

        logger.debug(indent + artifact + " (not setting artifactScope to: " + ignoredScope + "; local artifactScope "
                + artifact.getScope() + " wins)");

        // TODO better way than static? this might hide messages in a reactor
        if (!ignoredArtifacts.contains(artifact)) {
            logger.warn("\n\tArtifact " + artifact + " retains local artifactScope '" + artifact.getScope()

  @Override
  public String getName() {
    return super.getName() + '[' + suiteName + ']';
  }

  /**
   * Asserts that the given object is non-null, with a better failure message than {@link
   * TestCase#assertNull(String, Object)}.
   *
   * <p>The {@link TestCase} version (which is from JUnit 3) produces a failure message that does
   * not include the value of the object.
   *

  @Override
  public String getName() {
    return super.getName() + '[' + suiteName + ']';
  }

  /**
   * Asserts that the given object is non-null, with a better failure message than {@link
   * TestCase#assertNull(String, Object)}.
   *
   * <p>The {@link TestCase} version (which is from JUnit 3) produces a failure message that does
   * not include the value of the object.
   *

 *
 * <p>The {@link #count} and {@link #size} implementations all iterate across the set returned by
 * {@link Multiset#entrySet()}, as do many methods acting on the set returned by {@link
 * #elementSet()}. Override those methods for better performance.
 *
 * @author Kevin Bourrillion
 * @author Louis Wasserman
 */
@GwtCompatible
abstract class AbstractMultiset<E extends @Nullable Object> extends AbstractCollection<E>
    implements Multiset<E> {

        return readDirect(b, off, len);
    }

    /**
     * Reads up to len bytes of data from this input stream into an array of bytes.
     * Optimized for better performance with larger read sizes and reduced round trips.
     *
     * @param b the buffer to read into
     * @param off the offset in the buffer to start writing
     * @param len the maximum number of bytes to read

     * have the same nullness as E." Since we can't, we declare it to return nullable elements, and
     * we can override it in our non-null-guaranteeing subtypes to present a better signature to
     * their users.
     *
     * However, the checker *we* use has this special knowledge about `Collection.toArray()` anyway,