During some minimization efforts on the previous released version 28.2-jre, I noticed a spurious file in the published version on maven central:

```
tn@proteus:~/Downloads$ unzip -l guava-28.2-jre.jar  | grep swp
    16384  2019-09-18 17:29   com/google/common/collect/.ImmutableListMultimap.java.swp
```

Looks like an transient artefact from an editor that slipped into the release. It is not present in the android variant or in older releases (I checked at least 28.1-jre).

Minor things that can not be changed anymore but maybe a trigger for improvement of future releases.

Edit: I noticed that 29.0 has been released that does not contain this spurious file.
*     keyFunction} produces {@code null} for any key
   * @since 14.0
   */
  public final <K> ImmutableListMultimap<K, E> index(Function<? super E, K> keyFunction) {
    return Multimaps.index(getDelegate(), keyFunction);
  }
  /**
   * Returns a map with the contents of this {@code FluentIterable} as its {@code values}, indexed
   * by keys derived from those values. In other words, each input value produces an entry in the
   * map whose key is the result of applying {@code keyFunction} to that value. These entries appear
   * in the same order as they appeared in this fluent iterable. Example usage:
   *
   * <pre>{@code
   * Color red = new Color("red", 255, 0, 0);
   * ...
   * FluentIterable<Color> allColors = FluentIterable.from(ImmutableSet.of(red, green, blue));
   *
   * Map<String, Color> colorForName = allColors.uniqueIndex(toStringFunction());
   * assertThat(colorForName).containsEntry("red", red);
   * }</pre>
   *
   * <p>If your index may associate multiple values with each key, use {@link #index(Function)
   * index}.
   *
   * <p><b>{@code Stream} equivalent:</b> use {@code
   * stream.collect(ImmutableMap.toImmutableMap(keyFunction, v -> v))}. {@code
   * ImmutableMap.copyOf(stream.collect(Collectors.toMap(keyFunction, v -> v)))}, but be aware that
   * this may not preserve the order of entries.
   *
   * @param keyFunction the function used to produce the key for each value