Reformat all the Auto projects using google-java-format. For now, javadoc reformatting is excluded.

RELNOTES=n/a
PiperOrigin-RevId: 377145832

128 files changed, 1844 insertions, 1437 deletions

diff --git a/common/src/main/java/com/google/auto/common/AnnotationMirrors.java b/common/src/main/java/com/google/auto/common/AnnotationMirrors.java
index 737857b0..80d2335d 100644
--- a/common/src/main/java/com/google/auto/common/AnnotationMirrors.java
+++ b/common/src/main/java/com/google/auto/common/AnnotationMirrors.java
@@ -45,25 +45,32 @@ public final class AnnotationMirrors {
       new Equivalence<AnnotationMirror>() {
         @Override
         protected boolean doEquivalent(AnnotationMirror left, AnnotationMirror right) {
-          return MoreTypes.equivalence().equivalent(left.getAnnotationType(),
-              right.getAnnotationType()) && AnnotationValues.equivalence().pairwise().equivalent(
-              getAnnotationValuesWithDefaults(left).values(),
-              getAnnotationValuesWithDefaults(right).values());
+          return MoreTypes.equivalence()
+                  .equivalent(left.getAnnotationType(), right.getAnnotationType())
+              && AnnotationValues.equivalence()
+                  .pairwise()
+                  .equivalent(
+                      getAnnotationValuesWithDefaults(left).values(),
+                      getAnnotationValuesWithDefaults(right).values());
         }
+
         @Override
         protected int doHash(AnnotationMirror annotation) {
           DeclaredType type = annotation.getAnnotationType();
           Iterable<AnnotationValue> annotationValues =
               getAnnotationValuesWithDefaults(annotation).values();
-          return Arrays.hashCode(new int[] {MoreTypes.equivalence().hash(type),
-              AnnotationValues.equivalence().pairwise().hash(annotationValues)});
+          return Arrays.hashCode(
+              new int[] {
+                MoreTypes.equivalence().hash(type),
+                AnnotationValues.equivalence().pairwise().hash(annotationValues)
+              });
         }
 
         @Override
         public String toString() {
-         return "AnnotationMirrors.equivalence()";
+          return "AnnotationMirrors.equivalence()";
         }
-    };
+      };
 
   /**
    * Returns an {@link Equivalence} for {@link AnnotationMirror} as some implementations
@@ -100,8 +107,10 @@ public final class AnnotationMirrors {
       } else {
         throw new IllegalStateException(
             "Unset annotation value without default should never happen: "
-            + MoreElements.asType(method.getEnclosingElement()).getQualifiedName()
-            + '.' + method.getSimpleName() + "()");
+                + MoreElements.asType(method.getEnclosingElement()).getQualifiedName()
+                + '.'
+                + method.getSimpleName()
+                + "()");
       }
     }
     return values.build();
@@ -136,24 +145,29 @@ public final class AnnotationMirrors {
         return entry;
       }
     }
-    throw new IllegalArgumentException(String.format("@%s does not define an element %s()",
-        MoreElements.asType(annotationMirror.getAnnotationType().asElement()).getQualifiedName(),
-        elementName));
+    throw new IllegalArgumentException(
+        String.format(
+            "@%s does not define an element %s()",
+            MoreElements.asType(annotationMirror.getAnnotationType().asElement())
+                .getQualifiedName(),
+            elementName));
   }
 
   /**
    * Returns all {@linkplain AnnotationMirror annotations} that are present on the given
    * {@link Element} which are themselves annotated with {@code annotationType}.
    */
-  public static ImmutableSet<? extends AnnotationMirror> getAnnotatedAnnotations(Element element,
-      final Class<? extends Annotation> annotationType) {
+  public static ImmutableSet<? extends AnnotationMirror> getAnnotatedAnnotations(
+      Element element, final Class<? extends Annotation> annotationType) {
     List<? extends AnnotationMirror> annotations = element.getAnnotationMirrors();
     return FluentIterable.from(annotations)
-        .filter(new Predicate<AnnotationMirror>() {
-          @Override public boolean apply(AnnotationMirror input) {
-            return isAnnotationPresent(input.getAnnotationType().asElement(), annotationType);
-          }
-        })
+        .filter(
+            new Predicate<AnnotationMirror>() {
+              @Override
+              public boolean apply(AnnotationMirror input) {
+                return isAnnotationPresent(input.getAnnotationType().asElement(), annotationType);
+              }
+            })
         .toSet();
   }
 
diff --git a/common/src/main/java/com/google/auto/common/AnnotationValues.java b/common/src/main/java/com/google/auto/common/AnnotationValues.java
index 296bacd1..0712e56a 100644
--- a/common/src/main/java/com/google/auto/common/AnnotationValues.java
+++ b/common/src/main/java/com/google/auto/common/AnnotationValues.java
@@ -37,91 +37,120 @@ import javax.lang.model.util.SimpleAnnotationValueVisitor8;
 public final class AnnotationValues {
   private static final Equivalence<AnnotationValue> ANNOTATION_VALUE_EQUIVALENCE =
       new Equivalence<AnnotationValue>() {
-        @Override protected boolean doEquivalent(AnnotationValue left, AnnotationValue right) {
-          return left.accept(new SimpleAnnotationValueVisitor8<Boolean, AnnotationValue>() {
-            // LHS is not an annotation or array of annotation values, so just test equality.
-            @Override protected Boolean defaultAction(Object left, AnnotationValue right) {
-              return left.equals(right.accept(
-                  new SimpleAnnotationValueVisitor8<Object, Void>() {
-                    @Override protected Object defaultAction(Object object, Void unused) {
-                      return object;
-                    }
-                  }, null));
-            }
-
-            // LHS is an annotation mirror so test equivalence for RHS annotation mirrors
-            // and false for other types.
-            @Override public Boolean visitAnnotation(AnnotationMirror left, AnnotationValue right) {
-              return right.accept(
-                  new SimpleAnnotationValueVisitor8<Boolean, AnnotationMirror>() {
-                    @Override protected Boolean defaultAction(Object right, AnnotationMirror left) {
-                      return false; // Not an annotation mirror, so can't be equal to such.
-                    }
-                    @Override
-                    public Boolean visitAnnotation(AnnotationMirror right, AnnotationMirror left) {
-                      return AnnotationMirrors.equivalence().equivalent(left, right);
-                    }
-                  }, left);
-            }
-
-            // LHS is a list of annotation values have to collect-test equivalences, or false
-            // for any other types.
-            @Override
-            public Boolean visitArray(List<? extends AnnotationValue> left, AnnotationValue right) {
-              return right.accept(
-                  new SimpleAnnotationValueVisitor8<Boolean, List<? extends AnnotationValue>>() {
-                    @Override protected Boolean defaultAction(
-                        Object ignored, List<? extends AnnotationValue> alsoIgnored) {
-                      return false; // Not an array, so can't be equal to such.
-                    }
-
-                    @SuppressWarnings("unchecked") // safe covariant cast
-                    @Override public Boolean visitArray(
-                        List<? extends AnnotationValue> right ,
-                        List<? extends AnnotationValue> left) {
-                      return AnnotationValues.equivalence().pairwise().equivalent(
-                          (List<AnnotationValue>) left, (List<AnnotationValue>) right);
-                    }
-                  }, left);
-            }
-
-            @Override
-            public Boolean visitType(TypeMirror left, AnnotationValue right) {
-              return right.accept(
-                  new SimpleAnnotationValueVisitor8<Boolean, TypeMirror>() {
-                    @Override protected Boolean defaultAction(
-                        Object ignored, TypeMirror alsoIgnored) {
-                      return false; // Not an annotation mirror, so can't be equal to such.
-                    }
-
-                    @Override public Boolean visitType(TypeMirror right, TypeMirror left) {
-                      return MoreTypes.equivalence().equivalent(left, right);
-                    }
-                  }, left);
-            }
-          }, right);
+        @Override
+        protected boolean doEquivalent(AnnotationValue left, AnnotationValue right) {
+          return left.accept(
+              new SimpleAnnotationValueVisitor8<Boolean, AnnotationValue>() {
+                // LHS is not an annotation or array of annotation values, so just test equality.
+                @Override
+                protected Boolean defaultAction(Object left, AnnotationValue right) {
+                  return left.equals(
+                      right.accept(
+                          new SimpleAnnotationValueVisitor8<Object, Void>() {
+                            @Override
+                            protected Object defaultAction(Object object, Void unused) {
+                              return object;
+                            }
+                          },
+                          null));
+                }
+
+                // LHS is an annotation mirror so test equivalence for RHS annotation mirrors
+                // and false for other types.
+                @Override
+                public Boolean visitAnnotation(AnnotationMirror left, AnnotationValue right) {
+                  return right.accept(
+                      new SimpleAnnotationValueVisitor8<Boolean, AnnotationMirror>() {
+                        @Override
+                        protected Boolean defaultAction(Object right, AnnotationMirror left) {
+                          return false; // Not an annotation mirror, so can't be equal to such.
+                        }
+
+                        @Override
+                        public Boolean visitAnnotation(
+                            AnnotationMirror right, AnnotationMirror left) {
+                          return AnnotationMirrors.equivalence().equivalent(left, right);
+                        }
+                      },
+                      left);
+                }
+
+                // LHS is a list of annotation values have to collect-test equivalences, or false
+                // for any other types.
+                @Override
+                public Boolean visitArray(
+                    List<? extends AnnotationValue> left, AnnotationValue right) {
+                  return right.accept(
+                      new SimpleAnnotationValueVisitor8<
+                          Boolean, List<? extends AnnotationValue>>() {
+                        @Override
+                        protected Boolean defaultAction(
+                            Object ignored, List<? extends AnnotationValue> alsoIgnored) {
+                          return false; // Not an array, so can't be equal to such.
+                        }
+
+                        @SuppressWarnings("unchecked") // safe covariant cast
+                        @Override
+                        public Boolean visitArray(
+                            List<? extends AnnotationValue> right,
+                            List<? extends AnnotationValue> left) {
+                          return AnnotationValues.equivalence()
+                              .pairwise()
+                              .equivalent(
+                                  (List<AnnotationValue>) left, (List<AnnotationValue>) right);
+                        }
+                      },
+                      left);
+                }
+
+                @Override
+                public Boolean visitType(TypeMirror left, AnnotationValue right) {
+                  return right.accept(
+                      new SimpleAnnotationValueVisitor8<Boolean, TypeMirror>() {
+                        @Override
+                        protected Boolean defaultAction(Object ignored, TypeMirror alsoIgnored) {
+                          return false; // Not an annotation mirror, so can't be equal to such.
+                        }
+
+                        @Override
+                        public Boolean visitType(TypeMirror right, TypeMirror left) {
+                          return MoreTypes.equivalence().equivalent(left, right);
+                        }
+                      },
+                      left);
+                }
+              },
+              right);
         }
 
-        @Override protected int doHash(AnnotationValue value) {
-          return value.accept(new SimpleAnnotationValueVisitor8<Integer, Void>() {
-            @Override public Integer visitAnnotation(AnnotationMirror value, Void ignore) {
-              return AnnotationMirrors.equivalence().hash(value);
-            }
-
-            @SuppressWarnings("unchecked") // safe covariant cast
-            @Override public Integer visitArray(
-                List<? extends AnnotationValue> values, Void ignore) {
-              return AnnotationValues.equivalence().pairwise().hash((List<AnnotationValue>) values);
-            }
-
-            @Override public Integer visitType(TypeMirror value, Void ignore) {
-              return MoreTypes.equivalence().hash(value);
-            }
-
-            @Override protected Integer defaultAction(Object value, Void ignored) {
-              return value.hashCode();
-            }
-          }, null);
+        @Override
+        protected int doHash(AnnotationValue value) {
+          return value.accept(
+              new SimpleAnnotationValueVisitor8<Integer, Void>() {
+                @Override
+                public Integer visitAnnotation(AnnotationMirror value, Void ignore) {
+                  return AnnotationMirrors.equivalence().hash(value);
+                }
+
+                @SuppressWarnings("unchecked") // safe covariant cast
+                @Override
+                public Integer visitArray(List<? extends AnnotationValue> values, Void ignore) {
+                  return AnnotationValues.equivalence()
+                      .pairwise()
+                      .hash((List<AnnotationValue>) values);
+                }
+
+                @Override
+                public Integer visitType(TypeMirror value, Void ignore) {
+                  return MoreTypes.equivalence().hash(value);
+                }
+
+                @Override
+                protected Integer defaultAction(Object value, Void ignored) {
+                  return value.hashCode();
+                }
+              },
+              null);
         }
       };
 
@@ -485,4 +514,3 @@ public final class AnnotationValues {
 
   private AnnotationValues() {}
 }
-
diff --git a/common/src/main/java/com/google/auto/common/MoreElements.java b/common/src/main/java/com/google/auto/common/MoreElements.java
index 5e8e3541..bee157f6 100644
--- a/common/src/main/java/com/google/auto/common/MoreElements.java
+++ b/common/src/main/java/com/google/auto/common/MoreElements.java
@@ -218,8 +218,8 @@ public final class MoreElements {
    * {@link Element#getAnnotation} and checking for {@code null} as it avoids any interaction with
    * annotation proxies.
    */
-  public static boolean isAnnotationPresent(Element element,
-      Class<? extends Annotation> annotationClass) {
+  public static boolean isAnnotationPresent(
+      Element element, Class<? extends Annotation> annotationClass) {
     return getAnnotationMirror(element, annotationClass).isPresent();
   }
 
@@ -229,8 +229,8 @@ public final class MoreElements {
    * safer alternative to calling {@link Element#getAnnotation} as it avoids any interaction with
    * annotation proxies.
    */
-  public static Optional<AnnotationMirror> getAnnotationMirror(Element element,
-      Class<? extends Annotation> annotationClass) {
+  public static Optional<AnnotationMirror> getAnnotationMirror(
+      Element element, Class<? extends Annotation> annotationClass) {
     String annotationClassName = annotationClass.getCanonicalName();
     for (AnnotationMirror annotationMirror : element.getAnnotationMirrors()) {
       TypeElement annotationTypeElement = asType(annotationMirror.getAnnotationType().asElement());
diff --git a/common/src/main/java/com/google/auto/common/MoreTypes.java b/common/src/main/java/com/google/auto/common/MoreTypes.java
index af433aa0..cf273c2d 100644
--- a/common/src/main/java/com/google/auto/common/MoreTypes.java
+++ b/common/src/main/java/com/google/auto/common/MoreTypes.java
@@ -144,9 +144,7 @@ public final class MoreTypes {
       if (o instanceof ComparedElements) {
         ComparedElements that = (ComparedElements) o;
         int nArguments = aArguments.size();
-        if (!this.a.equals(that.a)
-            || !this.b.equals(that.b)
-            || nArguments != bArguments.size()) {
+        if (!this.a.equals(that.a) || !this.b.equals(that.b) || nArguments != bArguments.size()) {
           // The arguments must be the same size, but we check anyway.
           return false;
         }
@@ -436,7 +434,7 @@ public final class MoreTypes {
     public Integer visitUnknown(TypeMirror t, Set<Element> visiting) {
       throw new UnsupportedOperationException();
     }
-  };
+  }
 
   private static int hashList(List<? extends TypeMirror> mirrors, Set<Element> visiting) {
     int result = HASH_SEED;
@@ -537,7 +535,8 @@ public final class MoreTypes {
     public Element visitTypeVariable(TypeVariable t, Void p) {
       return t.asElement();
     }
-  };
+  }
+  ;
 
   // TODO(gak): consider removing these two methods as they're pretty trivial now
   public static TypeElement asTypeElement(TypeMirror mirror) {
@@ -882,10 +881,10 @@ public final class MoreTypes {
    * is {@link Object}.
    */
   // TODO(bcorso): Remove unused parameter Elements?
-  public static Optional<DeclaredType> nonObjectSuperclass(Types types, Elements elements,
-      DeclaredType type) {
+  public static Optional<DeclaredType> nonObjectSuperclass(
+      Types types, Elements elements, DeclaredType type) {
     checkNotNull(types);
-    checkNotNull(elements);  // This is no longer used, but here to avoid changing the API.
+    checkNotNull(elements); // This is no longer used, but here to avoid changing the API.
     checkNotNull(type);
 
     TypeMirror superclassType = asTypeElement(type).getSuperclass();
@@ -893,7 +892,7 @@ public final class MoreTypes {
       return Optional.absent();
     }
 
-    DeclaredType superclass =  asDeclared(superclassType);
+    DeclaredType superclass = asDeclared(superclassType);
     if (isObjectType(superclass)) {
       return Optional.absent();
     }
@@ -920,8 +919,8 @@ public final class MoreTypes {
    * {@code container} of type {@code Set<String>}, and a variable corresponding to the {@code E e}
    * parameter in the {@code Set.add(E e)} method, this will return a TypeMirror for {@code String}.
    */
-  public static TypeMirror asMemberOf(Types types, DeclaredType container,
-      VariableElement variable) {
+  public static TypeMirror asMemberOf(
+      Types types, DeclaredType container, VariableElement variable) {
     if (variable.getKind().equals(ElementKind.PARAMETER)) {
       ExecutableElement methodOrConstructor =
           MoreElements.asExecutable(variable.getEnclosingElement());
@@ -1013,7 +1012,7 @@ public final class MoreTypes {
       }
       return true;
     }
-    
+
     private static boolean isJavaLangObject(TypeMirror type) {
       if (type.getKind() != TypeKind.DECLARED) {
         return false;
diff --git a/common/src/main/java/com/google/auto/common/SimpleAnnotationMirror.java b/common/src/main/java/com/google/auto/common/SimpleAnnotationMirror.java
index bbaf8fc9..e6d1e677 100644
--- a/common/src/main/java/com/google/auto/common/SimpleAnnotationMirror.java
+++ b/common/src/main/java/com/google/auto/common/SimpleAnnotationMirror.java
@@ -65,7 +65,7 @@ public final class SimpleAnnotationMirror implements AnnotationMirror {
         missingMembers.add(memberName);
       }
     }
-    
+
     checkArgument(
         unusedValues.isEmpty(),
         "namedValues has entries for members that are not in %s: %s",
@@ -77,8 +77,7 @@ public final class SimpleAnnotationMirror implements AnnotationMirror {
     this.annotationType = annotationType;
     this.namedValues = ImmutableMap.copyOf(namedValues);
     this.elementValues =
-        methodsIn(annotationType.getEnclosedElements())
-            .stream()
+        methodsIn(annotationType.getEnclosedElements()).stream()
             .collect(toImmutableMap(e -> e, e -> values.get(e.getSimpleName().toString())));
   }
 
diff --git a/common/src/main/java/com/google/auto/common/SuperficialValidation.java b/common/src/main/java/com/google/auto/common/SuperficialValidation.java
index 5ef4dbf2..614e2626 100644
--- a/common/src/main/java/com/google/auto/common/SuperficialValidation.java
+++ b/common/src/main/java/com/google/auto/common/SuperficialValidation.java
@@ -57,23 +57,27 @@ public final class SuperficialValidation {
 
   private static final ElementVisitor<Boolean, Void> ELEMENT_VALIDATING_VISITOR =
       new AbstractElementVisitor8<Boolean, Void>() {
-        @Override public Boolean visitPackage(PackageElement e, Void p) {
+        @Override
+        public Boolean visitPackage(PackageElement e, Void p) {
           // don't validate enclosed elements because it will return types in the package
           return validateAnnotations(e.getAnnotationMirrors());
         }
 
-        @Override public Boolean visitType(TypeElement e, Void p) {
+        @Override
+        public Boolean visitType(TypeElement e, Void p) {
           return isValidBaseElement(e)
               && validateElements(e.getTypeParameters())
               && validateTypes(e.getInterfaces())
               && validateType(e.getSuperclass());
         }
 
-        @Override public Boolean visitVariable(VariableElement e, Void p) {
+        @Override
+        public Boolean visitVariable(VariableElement e, Void p) {
           return isValidBaseElement(e);
         }
 
-        @Override public Boolean visitExecutable(ExecutableElement e, Void p) {
+        @Override
+        public Boolean visitExecutable(ExecutableElement e, Void p) {
           AnnotationValue defaultValue = e.getDefaultValue();
           return isValidBaseElement(e)
               && (defaultValue == null || validateAnnotationValue(defaultValue, e.getReturnType()))
@@ -83,12 +87,13 @@ public final class SuperficialValidation {
               && validateElements(e.getParameters());
         }
 
-        @Override public Boolean visitTypeParameter(TypeParameterElement e, Void p) {
-          return isValidBaseElement(e)
-              && validateTypes(e.getBounds());
+        @Override
+        public Boolean visitTypeParameter(TypeParameterElement e, Void p) {
+          return isValidBaseElement(e) && validateTypes(e.getBounds());
         }
 
-        @Override public Boolean visitUnknown(Element e, Void p) {
+        @Override
+        public Boolean visitUnknown(Element e, Void p) {
           // just assume that unknown elements are OK
           return true;
         }
@@ -206,16 +211,19 @@ public final class SuperficialValidation {
 
   private static final AnnotationValueVisitor<Boolean, TypeMirror> VALUE_VALIDATING_VISITOR =
       new SimpleAnnotationValueVisitor8<Boolean, TypeMirror>() {
-        @Override protected Boolean defaultAction(Object o, TypeMirror expectedType) {
+        @Override
+        protected Boolean defaultAction(Object o, TypeMirror expectedType) {
           return MoreTypes.isTypeOf(o.getClass(), expectedType);
         }
 
-        @Override public Boolean visitUnknown(AnnotationValue av, TypeMirror expectedType) {
+        @Override
+        public Boolean visitUnknown(AnnotationValue av, TypeMirror expectedType) {
           // just take the default action for the unknown
           return defaultAction(av, expectedType);
         }
 
-        @Override public Boolean visitAnnotation(AnnotationMirror a, TypeMirror expectedType) {
+        @Override
+        public Boolean visitAnnotation(AnnotationMirror a, TypeMirror expectedType) {
           return MoreTypes.equivalence().equivalent(a.getAnnotationType(), expectedType)
               && validateAnnotation(a);
         }
@@ -235,7 +243,8 @@ public final class SuperficialValidation {
               && validateElement(enumConstant);
         }
 
-        @Override public Boolean visitType(TypeMirror type, TypeMirror ignored) {
+        @Override
+        public Boolean visitType(TypeMirror type, TypeMirror ignored) {
           // We could check assignability here, but would require a Types instance. Since this
           // isn't really the sort of thing that shows up in a bad AST from upstream compilation
           // we ignore the expected type and just validate the type.  It might be wrong, but
@@ -243,35 +252,43 @@ public final class SuperficialValidation {
           return validateType(type);
         }
 
-        @Override public Boolean visitBoolean(boolean b, TypeMirror expectedType) {
+        @Override
+        public Boolean visitBoolean(boolean b, TypeMirror expectedType) {
           return MoreTypes.isTypeOf(Boolean.TYPE, expectedType);
         }
 
-        @Override public Boolean visitByte(byte b, TypeMirror expectedType) {
+        @Override
+        public Boolean visitByte(byte b, TypeMirror expectedType) {
           return MoreTypes.isTypeOf(Byte.TYPE, expectedType);
         }
 
-        @Override public Boolean visitChar(char c, TypeMirror expectedType) {
+        @Override
+        public Boolean visitChar(char c, TypeMirror expectedType) {
           return MoreTypes.isTypeOf(Character.TYPE, expectedType);
         }
 
-        @Override public Boolean visitDouble(double d, TypeMirror expectedType) {
+        @Override
+        public Boolean visitDouble(double d, TypeMirror expectedType) {
           return MoreTypes.isTypeOf(Double.TYPE, expectedType);
         }
 
-        @Override public Boolean visitFloat(float f, TypeMirror expectedType) {
+        @Override
+        public Boolean visitFloat(float f, TypeMirror expectedType) {
           return MoreTypes.isTypeOf(Float.TYPE, expectedType);
         }
 
-        @Override public Boolean visitInt(int i, TypeMirror expectedType) {
+        @Override
+        public Boolean visitInt(int i, TypeMirror expectedType) {
           return MoreTypes.isTypeOf(Integer.TYPE, expectedType);
         }
 
-        @Override public Boolean visitLong(long l, TypeMirror expectedType) {
+        @Override
+        public Boolean visitLong(long l, TypeMirror expectedType) {
           return MoreTypes.isTypeOf(Long.TYPE, expectedType);
         }
 
-        @Override public Boolean visitShort(short s, TypeMirror expectedType) {
+        @Override
+        public Boolean visitShort(short s, TypeMirror expectedType) {
           return MoreTypes.isTypeOf(Short.TYPE, expectedType);
         }
       };
diff --git a/common/src/main/java/com/google/auto/common/Visibility.java b/common/src/main/java/com/google/auto/common/Visibility.java
index f82fdd59..c90f8829 100644
--- a/common/src/main/java/com/google/auto/common/Visibility.java
+++ b/common/src/main/java/com/google/auto/common/Visibility.java
@@ -76,8 +76,7 @@ public enum Visibility {
     Visibility effectiveVisibility = PUBLIC;
     Element currentElement = element;
     while (currentElement != null) {
-      effectiveVisibility =
-          Ordering.natural().min(effectiveVisibility, ofElement(currentElement));
+      effectiveVisibility = Ordering.natural().min(effectiveVisibility, ofElement(currentElement));
       currentElement = currentElement.getEnclosingElement();
     }
     return effectiveVisibility;
diff --git a/common/src/test/java/com/google/auto/common/AnnotationMirrorsTest.java b/common/src/test/java/com/google/auto/common/AnnotationMirrorsTest.java
index f63ee031..b1a0a152 100644
--- a/common/src/test/java/com/google/auto/common/AnnotationMirrorsTest.java
+++ b/common/src/test/java/com/google/auto/common/AnnotationMirrorsTest.java
@@ -46,110 +46,134 @@ public class AnnotationMirrorsTest {
 
   private Elements elements;
 
-  @Before public void setUp() {
+  @Before
+  public void setUp() {
     this.elements = compilationRule.getElements();
   }
 
   @interface SimpleAnnotation {}
 
-  @SimpleAnnotation class SimplyAnnotated {}
-  @SimpleAnnotation class AlsoSimplyAnnotated {}
+  @SimpleAnnotation
+  class SimplyAnnotated {}
+
+  @SimpleAnnotation
+  class AlsoSimplyAnnotated {}
 
   enum SimpleEnum {
-    BLAH, FOO
+    BLAH,
+    FOO
   }
 
   @interface Outer {
     SimpleEnum value();
   }
 
-  @Outer(BLAH) static class TestClassBlah {}
-  @Outer(BLAH) static class TestClassBlah2 {}
-  @Outer(FOO) static class TestClassFoo {}
+  @Outer(BLAH)
+  static class TestClassBlah {}
+
+  @Outer(BLAH)
+  static class TestClassBlah2 {}
+
+  @Outer(FOO)
+  static class TestClassFoo {}
 
   @interface DefaultingOuter {
     SimpleEnum value() default SimpleEnum.BLAH;
   }
 
-  @DefaultingOuter class TestWithDefaultingOuterDefault {}
-  @DefaultingOuter(BLAH) class TestWithDefaultingOuterBlah {}
-  @DefaultingOuter(FOO) class TestWithDefaultingOuterFoo {}
+  @DefaultingOuter
+  class TestWithDefaultingOuterDefault {}
+
+  @DefaultingOuter(BLAH)
+  class TestWithDefaultingOuterBlah {}
+
+  @DefaultingOuter(FOO)
+  class TestWithDefaultingOuterFoo {}
 
   @interface AnnotatedOuter {
     DefaultingOuter value();
   }
 
-  @AnnotatedOuter(@DefaultingOuter) class TestDefaultNestedAnnotated {}
-  @AnnotatedOuter(@DefaultingOuter(BLAH)) class TestBlahNestedAnnotated {}
-  @AnnotatedOuter(@DefaultingOuter(FOO)) class TestFooNestedAnnotated {}
+  @AnnotatedOuter(@DefaultingOuter)
+  class TestDefaultNestedAnnotated {}
+
+  @AnnotatedOuter(@DefaultingOuter(BLAH))
+  class TestBlahNestedAnnotated {}
+
+  @AnnotatedOuter(@DefaultingOuter(FOO))
+  class TestFooNestedAnnotated {}
 
   @interface OuterWithValueArray {
     DefaultingOuter[] value() default {};
   }
 
-  @OuterWithValueArray class TestValueArrayWithDefault {}
-  @OuterWithValueArray({}) class TestValueArrayWithEmpty {}
+  @OuterWithValueArray
+  class TestValueArrayWithDefault {}
+
+  @OuterWithValueArray({})
+  class TestValueArrayWithEmpty {}
+
+  @OuterWithValueArray({@DefaultingOuter})
+  class TestValueArrayWithOneDefault {}
+
+  @OuterWithValueArray(@DefaultingOuter(BLAH))
+  class TestValueArrayWithOneBlah {}
 
-  @OuterWithValueArray({@DefaultingOuter}) class TestValueArrayWithOneDefault {}
-  @OuterWithValueArray(@DefaultingOuter(BLAH)) class TestValueArrayWithOneBlah {}
-  @OuterWithValueArray(@DefaultingOuter(FOO)) class TestValueArrayWithOneFoo {}
+  @OuterWithValueArray(@DefaultingOuter(FOO))
+  class TestValueArrayWithOneFoo {}
 
   @OuterWithValueArray({@DefaultingOuter(FOO), @DefaultingOuter})
   class TestValueArrayWithFooAndDefaultBlah {}
+
   @OuterWithValueArray({@DefaultingOuter(FOO), @DefaultingOuter(BLAH)})
   class TestValueArrayWithFooBlah {}
+
   @OuterWithValueArray({@DefaultingOuter(FOO), @DefaultingOuter(BLAH)})
   class TestValueArrayWithFooBlah2 {} // Different instances than on TestValueArrayWithFooBlah.
+
   @OuterWithValueArray({@DefaultingOuter(BLAH), @DefaultingOuter(FOO)})
   class TestValueArrayWithBlahFoo {}
 
-  @Test public void testEquivalences() {
+  @Test
+  public void testEquivalences() {
     EquivalenceTester<AnnotationMirror> tester =
         EquivalenceTester.of(AnnotationMirrors.equivalence());
 
     tester.addEquivalenceGroup(
-        annotationOn(SimplyAnnotated.class),
-        annotationOn(AlsoSimplyAnnotated.class));
+        annotationOn(SimplyAnnotated.class), annotationOn(AlsoSimplyAnnotated.class));
 
     tester.addEquivalenceGroup(
-        annotationOn(TestClassBlah.class),
-        annotationOn(TestClassBlah2.class));
+        annotationOn(TestClassBlah.class), annotationOn(TestClassBlah2.class));
 
-    tester.addEquivalenceGroup(
-        annotationOn(TestClassFoo.class));
+    tester.addEquivalenceGroup(annotationOn(TestClassFoo.class));
 
     tester.addEquivalenceGroup(
         annotationOn(TestWithDefaultingOuterDefault.class),
         annotationOn(TestWithDefaultingOuterBlah.class));
 
-    tester.addEquivalenceGroup(
-        annotationOn(TestWithDefaultingOuterFoo.class));
+    tester.addEquivalenceGroup(annotationOn(TestWithDefaultingOuterFoo.class));
 
     tester.addEquivalenceGroup(
         annotationOn(TestDefaultNestedAnnotated.class),
         annotationOn(TestBlahNestedAnnotated.class));
 
-    tester.addEquivalenceGroup(
-        annotationOn(TestFooNestedAnnotated.class));
+    tester.addEquivalenceGroup(annotationOn(TestFooNestedAnnotated.class));
 
     tester.addEquivalenceGroup(
-        annotationOn(TestValueArrayWithDefault.class),
-        annotationOn(TestValueArrayWithEmpty.class));
+        annotationOn(TestValueArrayWithDefault.class), annotationOn(TestValueArrayWithEmpty.class));
 
     tester.addEquivalenceGroup(
         annotationOn(TestValueArrayWithOneDefault.class),
         annotationOn(TestValueArrayWithOneBlah.class));
 
-    tester.addEquivalenceGroup(
-        annotationOn(TestValueArrayWithOneFoo.class));
+    tester.addEquivalenceGroup(annotationOn(TestValueArrayWithOneFoo.class));
 
     tester.addEquivalenceGroup(
         annotationOn(TestValueArrayWithFooAndDefaultBlah.class),
         annotationOn(TestValueArrayWithFooBlah.class),
         annotationOn(TestValueArrayWithFooBlah2.class));
 
-    tester.addEquivalenceGroup(
-        annotationOn(TestValueArrayWithBlahFoo.class));
+    tester.addEquivalenceGroup(annotationOn(TestValueArrayWithBlahFoo.class));
 
     tester.test();
   }
@@ -158,44 +182,61 @@ public class AnnotationMirrorsTest {
     String value() default "default";
   }
 
-  @Stringy class StringyUnset {}
-  @Stringy("foo") class StringySet {}
+  @Stringy
+  class StringyUnset {}
+
+  @Stringy("foo")
+  class StringySet {}
 
-  @Test public void testGetDefaultValuesUnset() {
+  @Test
+  public void testGetDefaultValuesUnset() {
     assertThat(annotationOn(StringyUnset.class).getElementValues()).isEmpty();
-    Iterable<AnnotationValue> values = AnnotationMirrors.getAnnotationValuesWithDefaults(
-        annotationOn(StringyUnset.class)).values();
-    String value = getOnlyElement(values).accept(new SimpleAnnotationValueVisitor6<String, Void>() {
-          @Override public String visitString(String value, Void ignored) {
-            return value;
-          }
-        }, null);
+    Iterable<AnnotationValue> values =
+        AnnotationMirrors.getAnnotationValuesWithDefaults(annotationOn(StringyUnset.class))
+            .values();
+    String value =
+        getOnlyElement(values)
+            .accept(
+                new SimpleAnnotationValueVisitor6<String, Void>() {
+                  @Override
+                  public String visitString(String value, Void ignored) {
+                    return value;
+                  }
+                },
+                null);
     assertThat(value).isEqualTo("default");
   }
 
-  @Test public void testGetDefaultValuesSet() {
-    Iterable<AnnotationValue> values = AnnotationMirrors.getAnnotationValuesWithDefaults(
-        annotationOn(StringySet.class)).values();
-    String value = getOnlyElement(values).accept(new SimpleAnnotationValueVisitor6<String, Void>() {
-          @Override public String visitString(String value, Void ignored) {
-            return value;
-          }
-        }, null);
+  @Test
+  public void testGetDefaultValuesSet() {
+    Iterable<AnnotationValue> values =
+        AnnotationMirrors.getAnnotationValuesWithDefaults(annotationOn(StringySet.class)).values();
+    String value =
+        getOnlyElement(values)
+            .accept(
+                new SimpleAnnotationValueVisitor6<String, Void>() {
+                  @Override
+                  public String visitString(String value, Void ignored) {
+                    return value;
+                  }
+                },
+                null);
     assertThat(value).isEqualTo("foo");
   }
 
-  @Test public void testGetValueEntry() {
+  @Test
+  public void testGetValueEntry() {
     Map.Entry<ExecutableElement, AnnotationValue> elementValue =
-        AnnotationMirrors.getAnnotationElementAndValue(
-            annotationOn(TestClassBlah.class), "value");
+        AnnotationMirrors.getAnnotationElementAndValue(annotationOn(TestClassBlah.class), "value");
     assertThat(elementValue.getKey().getSimpleName().toString()).isEqualTo("value");
     assertThat(elementValue.getValue().getValue()).isInstanceOf(VariableElement.class);
-    AnnotationValue value = AnnotationMirrors.getAnnotationValue(
-        annotationOn(TestClassBlah.class), "value");
+    AnnotationValue value =
+        AnnotationMirrors.getAnnotationValue(annotationOn(TestClassBlah.class), "value");
     assertThat(value.getValue()).isInstanceOf(VariableElement.class);
   }
 
-  @Test public void testGetValueEntryFailure() {
+  @Test
+  public void testGetValueEntryFailure() {
     try {
       AnnotationMirrors.getAnnotationValue(annotationOn(TestClassBlah.class), "a");
     } catch (IllegalArgumentException e) {
diff --git a/common/src/test/java/com/google/auto/common/GeneratedAnnotationsTest.java b/common/src/test/java/com/google/auto/common/GeneratedAnnotationsTest.java
index 1c816c10..11b98706 100644
--- a/common/src/test/java/com/google/auto/common/GeneratedAnnotationsTest.java
+++ b/common/src/test/java/com/google/auto/common/GeneratedAnnotationsTest.java
@@ -187,8 +187,7 @@ public class GeneratedAnnotationsTest {
     // An alternative would be to delete this test method. JDK8 always has
     // javax.annotation.Generated so it isn't really meaningful to test it without.
     ImmutableList<String> options = ImmutableList.of("-source", "8", "-target", "8");
-    String generated =
-        runProcessor(options, "javax.annotation");
+    String generated = runProcessor(options, "javax.annotation");
     assertThat(generated).doesNotContain(JAVAX_ANNOTATION_GENERATED);
     assertThat(generated).doesNotContain(JAVAX_ANNOTATION_PROCESSING_GENERATED);
   }
diff --git a/common/src/test/java/com/google/auto/common/MoreElementsTest.java b/common/src/test/java/com/google/auto/common/MoreElementsTest.java
index 95043cf3..de33c567 100644
--- a/common/src/test/java/com/google/auto/common/MoreElementsTest.java
+++ b/common/src/test/java/com/google/auto/common/MoreElementsTest.java
@@ -80,8 +80,7 @@ public class MoreElementsTest {
 
   @Test
   public void asPackage() {
-    assertThat(MoreElements.asPackage(javaLangPackageElement))
-        .isEqualTo(javaLangPackageElement);
+    assertThat(MoreElements.asPackage(javaLangPackageElement)).isEqualTo(javaLangPackageElement);
   }
 
   @Test
@@ -89,17 +88,19 @@ public class MoreElementsTest {
     try {
       MoreElements.asPackage(stringElement);
       fail();
-    } catch (IllegalArgumentException expected) {}
+    } catch (IllegalArgumentException expected) {
+    }
   }
 
-  @Test public void asTypeElement() {
-    Element typeElement =
-        compilation.getElements().getTypeElement(String.class.getCanonicalName());
+  @Test
+  public void asTypeElement() {
+    Element typeElement = compilation.getElements().getTypeElement(String.class.getCanonicalName());
     assertTrue(MoreElements.isType(typeElement));
     assertThat(MoreElements.asType(typeElement)).isEqualTo(typeElement);
   }
 
-  @Test public void asTypeElement_notATypeElement() {
+  @Test
+  public void asTypeElement_notATypeElement() {
     TypeElement typeElement =
         compilation.getElements().getTypeElement(String.class.getCanonicalName());
     for (ExecutableElement e : ElementFilter.methodsIn(typeElement.getEnclosedElements())) {
@@ -143,7 +144,8 @@ public class MoreElementsTest {
     try {
       MoreElements.asType(javaLangPackageElement);
       fail();
-    } catch (IllegalArgumentException expected) {}
+    } catch (IllegalArgumentException expected) {
+    }
   }
 
   @Test
@@ -158,7 +160,8 @@ public class MoreElementsTest {
     try {
       MoreElements.asVariable(javaLangPackageElement);
       fail();
-    } catch (IllegalArgumentException expected) {}
+    } catch (IllegalArgumentException expected) {
+    }
   }
 
   @Test
@@ -166,8 +169,8 @@ public class MoreElementsTest {
     for (Element methodElement : ElementFilter.methodsIn(stringElement.getEnclosedElements())) {
       assertThat(MoreElements.asExecutable(methodElement)).isEqualTo(methodElement);
     }
-    for (Element methodElement
-        : ElementFilter.constructorsIn(stringElement.getEnclosedElements())) {
+    for (Element methodElement :
+        ElementFilter.constructorsIn(stringElement.getEnclosedElements())) {
       assertThat(MoreElements.asExecutable(methodElement)).isEqualTo(methodElement);
     }
   }
@@ -177,7 +180,8 @@ public class MoreElementsTest {
     try {
       MoreElements.asExecutable(javaLangPackageElement);
       fail();
-    } catch (IllegalArgumentException expected) {}
+    } catch (IllegalArgumentException expected) {
+    }
   }
 
   @Retention(RetentionPolicy.RUNTIME)
@@ -217,12 +221,14 @@ public class MoreElementsTest {
 
     Element annotationElement = documented.get().getAnnotationType().asElement();
     expect.that(MoreElements.isType(annotationElement)).isTrue();
-    expect.that(MoreElements.asType(annotationElement).getQualifiedName().toString())
+    expect
+        .that(MoreElements.asType(annotationElement).getQualifiedName().toString())
         .isEqualTo(Documented.class.getCanonicalName());
 
     annotationElement = innerAnnotation.get().getAnnotationType().asElement();
     expect.that(MoreElements.isType(annotationElement)).isTrue();
-    expect.that(MoreElements.asType(annotationElement).getQualifiedName().toString())
+    expect
+        .that(MoreElements.asType(annotationElement).getQualifiedName().toString())
         .isEqualTo(InnerAnnotation.class.getCanonicalName());
   }
 
@@ -270,14 +276,16 @@ public class MoreElementsTest {
     Set<ExecutableElement> objectMethods = visibleMethodsFromObject();
     assertThat(childTypeMethods).containsAtLeastElementsIn(objectMethods);
     Set<ExecutableElement> nonObjectMethods = Sets.difference(childTypeMethods, objectMethods);
-    assertThat(nonObjectMethods).containsExactly(
+    assertThat(nonObjectMethods)
+        .containsExactly(
             getMethod(ParentInterface.class, "bar", longMirror),
             getMethod(ParentClass.class, "foo"),
             getMethod(Child.class, "bar"),
             getMethod(Child.class, "baz"),
             getMethod(Child.class, "buh", intMirror),
             getMethod(Child.class, "buh", intMirror, intMirror))
-        .inOrder();;
+        .inOrder();
+    ;
   }
 
   @Test
@@ -293,7 +301,8 @@ public class MoreElementsTest {
     Set<ExecutableElement> objectMethods = visibleMethodsFromObject();
     assertThat(childTypeMethods).containsAtLeastElementsIn(objectMethods);
     Set<ExecutableElement> nonObjectMethods = Sets.difference(childTypeMethods, objectMethods);
-    assertThat(nonObjectMethods).containsExactly(
+    assertThat(nonObjectMethods)
+        .containsExactly(
             getMethod(ParentInterface.class, "bar", longMirror),
             getMethod(ParentClass.class, "foo"),
             getMethod(Child.class, "bar"),
@@ -316,7 +325,8 @@ public class MoreElementsTest {
     Set<ExecutableElement> objectMethods = allMethodsFromObject();
     assertThat(childTypeMethods).containsAtLeastElementsIn(objectMethods);
     Set<ExecutableElement> nonObjectMethods = Sets.difference(childTypeMethods, objectMethods);
-    assertThat(nonObjectMethods).containsExactly(
+    assertThat(nonObjectMethods)
+        .containsExactly(
             getMethod(ParentInterface.class, "staticMethod"),
             getMethod(ParentInterface.class, "bar", longMirror),
             getMethod(ParentClass.class, "staticMethod"),
@@ -357,8 +367,8 @@ public class MoreElementsTest {
   public void getLocalAndInheritedMethods_DaggerBug() {
     Elements elementUtils = compilation.getElements();
     TypeElement main = elementUtils.getTypeElement(Main.ParentComponent.class.getCanonicalName());
-    Set<ExecutableElement> methods = MoreElements.getLocalAndInheritedMethods(
-        main, compilation.getTypes(), elementUtils);
+    Set<ExecutableElement> methods =
+        MoreElements.getLocalAndInheritedMethods(main, compilation.getTypes(), elementUtils);
     assertThat(methods).hasSize(1);
     ExecutableElement method = methods.iterator().next();
     assertThat(method.getSimpleName().toString()).isEqualTo("injectable");
diff --git a/common/src/test/java/com/google/auto/common/MoreTypesIsTypeOfTest.java b/common/src/test/java/com/google/auto/common/MoreTypesIsTypeOfTest.java
index 05a0a119..a829e18d 100644
--- a/common/src/test/java/com/google/auto/common/MoreTypesIsTypeOfTest.java
+++ b/common/src/test/java/com/google/auto/common/MoreTypesIsTypeOfTest.java
@@ -43,13 +43,15 @@ public class MoreTypesIsTypeOfTest {
 
   private Elements elements;
 
-  @Before public void setUp() {
+  @Before
+  public void setUp() {
     this.elements = compilationRule.getElements();
   }
 
   private interface TestType {}
 
-  @Test public void isTypeOf_DeclaredType() {
+  @Test
+  public void isTypeOf_DeclaredType() {
     assertTrue(MoreTypes.isType(typeElementFor(TestType.class).asType()));
     assertWithMessage("mirror represents the TestType")
         .that(MoreTypes.isTypeOf(TestType.class, typeElementFor(TestType.class).asType()))
@@ -63,7 +65,8 @@ public class MoreTypesIsTypeOfTest {
     String[] array();
   }
 
-  @Test public void isTypeOf_ArrayType() {
+  @Test
+  public void isTypeOf_ArrayType() {
     assertTrue(MoreTypes.isType(typeElementFor(ArrayType.class).asType()));
     TypeMirror type = extractReturnTypeFromHolder(typeElementFor(ArrayType.class));
     assertWithMessage("array mirror represents an array Class object")
@@ -75,7 +78,8 @@ public class MoreTypesIsTypeOfTest {
     boolean method();
   }
 
-  @Test public void isTypeOf_PrimitiveBoolean() {
+  @Test
+  public void isTypeOf_PrimitiveBoolean() {
     assertTrue(MoreTypes.isType(typeElementFor(PrimitiveBoolean.class).asType()));
     TypeMirror type = extractReturnTypeFromHolder(typeElementFor(PrimitiveBoolean.class));
     assertWithMessage("mirror of a boolean").that(MoreTypes.isTypeOf(Boolean.TYPE, type)).isTrue();
@@ -85,7 +89,8 @@ public class MoreTypesIsTypeOfTest {
     byte method();
   }
 
-  @Test public void isTypeOf_PrimitiveByte() {
+  @Test
+  public void isTypeOf_PrimitiveByte() {
     assertTrue(MoreTypes.isType(typeElementFor(PrimitiveByte.class).asType()));
     TypeMirror type = extractReturnTypeFromHolder(typeElementFor(PrimitiveByte.class));
     assertWithMessage("mirror of a byte").that(MoreTypes.isTypeOf(Byte.TYPE, type)).isTrue();
@@ -95,7 +100,8 @@ public class MoreTypesIsTypeOfTest {
     char method();
   }
 
-  @Test public void isTypeOf_PrimitiveChar() {
+  @Test
+  public void isTypeOf_PrimitiveChar() {
     assertTrue(MoreTypes.isType(typeElementFor(PrimitiveChar.class).asType()));
     TypeMirror type = extractReturnTypeFromHolder(typeElementFor(PrimitiveChar.class));
     assertWithMessage("mirror of a char").that(MoreTypes.isTypeOf(Character.TYPE, type)).isTrue();
@@ -105,7 +111,8 @@ public class MoreTypesIsTypeOfTest {
     double method();
   }
 
-  @Test public void isTypeOf_PrimitiveDouble() {
+  @Test
+  public void isTypeOf_PrimitiveDouble() {
     assertTrue(MoreTypes.isType(typeElementFor(PrimitiveDouble.class).asType()));
     TypeMirror type = extractReturnTypeFromHolder(typeElementFor(PrimitiveDouble.class));
     assertWithMessage("mirror of a double").that(MoreTypes.isTypeOf(Double.TYPE, type)).isTrue();
@@ -115,7 +122,8 @@ public class MoreTypesIsTypeOfTest {
     float method();
   }
 
-  @Test public void isTypeOf_PrimitiveFloat() {
+  @Test
+  public void isTypeOf_PrimitiveFloat() {
     assertTrue(MoreTypes.isType(typeElementFor(PrimitiveFloat.class).asType()));
     TypeMirror type = extractReturnTypeFromHolder(typeElementFor(PrimitiveFloat.class));
     assertWithMessage("mirror of a float").that(MoreTypes.isTypeOf(Float.TYPE, type)).isTrue();
@@ -125,7 +133,8 @@ public class MoreTypesIsTypeOfTest {
     int method();
   }
 
-  @Test public void isTypeOf_PrimitiveInt() {
+  @Test
+  public void isTypeOf_PrimitiveInt() {
     assertTrue(MoreTypes.isType(typeElementFor(PrimitiveInt.class).asType()));
     TypeMirror type = extractReturnTypeFromHolder(typeElementFor(PrimitiveInt.class));
     assertWithMessage("mirror of a int").that(MoreTypes.isTypeOf(Integer.TYPE, type)).isTrue();
@@ -135,7 +144,8 @@ public class MoreTypesIsTypeOfTest {
     long method();
   }
 
-  @Test public void isTypeOf_PrimitiveLong() {
+  @Test
+  public void isTypeOf_PrimitiveLong() {
     assertTrue(MoreTypes.isType(typeElementFor(PrimitiveLong.class).asType()));
     TypeMirror type = extractReturnTypeFromHolder(typeElementFor(PrimitiveLong.class));
     assertWithMessage("mirror of a long").that(MoreTypes.isTypeOf(Long.TYPE, type)).isTrue();
@@ -145,7 +155,8 @@ public class MoreTypesIsTypeOfTest {
     short method();
   }
 
-  @Test public void isTypeOf_PrimitiveShort() {
+  @Test
+  public void isTypeOf_PrimitiveShort() {
     assertTrue(MoreTypes.isType(typeElementFor(PrimitiveShort.class).asType()));
     TypeMirror type = extractReturnTypeFromHolder(typeElementFor(PrimitiveShort.class));
     assertWithMessage("mirror of a short").that(MoreTypes.isTypeOf(Short.TYPE, type)).isTrue();
@@ -155,7 +166,8 @@ public class MoreTypesIsTypeOfTest {
     void method();
   }
 
-  @Test public void isTypeOf_void() {
+  @Test
+  public void isTypeOf_void() {
     assertTrue(MoreTypes.isType(typeElementFor(PrimitiveVoid.class).asType()));
     TypeMirror primitive = extractReturnTypeFromHolder(typeElementFor(PrimitiveVoid.class));
     assertWithMessage("mirror of a void").that(MoreTypes.isTypeOf(Void.TYPE, primitive)).isTrue();
@@ -165,21 +177,25 @@ public class MoreTypesIsTypeOfTest {
     Void method();
   }
 
-  @Test public void isTypeOf_Void() {
+  @Test
+  public void isTypeOf_Void() {
     assertTrue(MoreTypes.isType(typeElementFor(DeclaredVoid.class).asType()));
     TypeMirror declared = extractReturnTypeFromHolder(typeElementFor(DeclaredVoid.class));
     assertWithMessage("mirror of a void").that(MoreTypes.isTypeOf(Void.class, declared)).isTrue();
   }
 
-  @Test public void isTypeOf_fail() {
-    assertFalse(MoreTypes.isType(
-        getOnlyElement(typeElementFor(DeclaredVoid.class).getEnclosedElements()).asType()));
+  @Test
+  public void isTypeOf_fail() {
+    assertFalse(
+        MoreTypes.isType(
+            getOnlyElement(typeElementFor(DeclaredVoid.class).getEnclosedElements()).asType()));
     TypeMirror method =
         getOnlyElement(typeElementFor(DeclaredVoid.class).getEnclosedElements()).asType();
     try {
       MoreTypes.isTypeOf(String.class, method);
       fail();
-    } catch (IllegalArgumentException expected) {}
+    } catch (IllegalArgumentException expected) {
+    }
   }
 
   // Utility methods for this test.
diff --git a/common/src/test/java/com/google/auto/common/MoreTypesTest.java b/common/src/test/java/com/google/auto/common/MoreTypesTest.java
index ff33ffc1..bc55d63f 100644
--- a/common/src/test/java/com/google/auto/common/MoreTypesTest.java
+++ b/common/src/test/java/com/google/auto/common/MoreTypesTest.java
@@ -91,48 +91,51 @@ public class MoreTypesTest {
     DeclaredType containerOfString = types.getDeclaredType(container, stringType);
     TypeMirror containedInObject = types.asMemberOf(containerOfObject, contained);
     TypeMirror containedInString = types.asMemberOf(containerOfString, contained);
-    EquivalenceTester<TypeMirror> tester = EquivalenceTester.<TypeMirror>of(MoreTypes.equivalence())
-        .addEquivalenceGroup(types.getNullType())
-        .addEquivalenceGroup(types.getNoType(NONE))
-        .addEquivalenceGroup(types.getNoType(VOID))
-        .addEquivalenceGroup(objectType)
-        .addEquivalenceGroup(stringType)
-        .addEquivalenceGroup(containedInObject)
-        .addEquivalenceGroup(containedInString)
-        .addEquivalenceGroup(funkyBounds.asType())
-        .addEquivalenceGroup(funkyBounds2.asType())
-        .addEquivalenceGroup(funkierBounds.asType())
-        .addEquivalenceGroup(funkyBoundsVar, funkyBounds2Var)
-        .addEquivalenceGroup(funkierBoundsVar)
-        // Enum<E extends Enum<E>>
-        .addEquivalenceGroup(enumElement.asType())
-        // Map<K, V>
-        .addEquivalenceGroup(mapType)
-        .addEquivalenceGroup(mapOfObjectToObjectType)
-        // Map<?, ?>
-        .addEquivalenceGroup(types.getDeclaredType(mapElement, wildcard, wildcard))
-        // Map
-        .addEquivalenceGroup(types.erasure(mapType), types.erasure(mapOfObjectToObjectType))
-        .addEquivalenceGroup(types.getDeclaredType(mapElement, objectType, stringType))
-        .addEquivalenceGroup(types.getDeclaredType(mapElement, stringType, objectType))
-        .addEquivalenceGroup(types.getDeclaredType(mapElement, stringType, stringType))
-        .addEquivalenceGroup(setOfSetOfObject)
-        .addEquivalenceGroup(setOfSetOfString)
-        .addEquivalenceGroup(setOfSetOfSetOfObject)
-        .addEquivalenceGroup(setOfSetOfSetOfString)
-        .addEquivalenceGroup(wildcard)
-        // ? extends Object
-        .addEquivalenceGroup(types.getWildcardType(objectType, null))
-        // ? extends String
-        .addEquivalenceGroup(types.getWildcardType(stringType, null))
-        // ? super String
-        .addEquivalenceGroup(types.getWildcardType(null, stringType))
-        // Map<String, Map<String, Set<Object>>>
-        .addEquivalenceGroup(types.getDeclaredType(mapElement, stringType,
-            types.getDeclaredType(mapElement, stringType,
-                types.getDeclaredType(setElement, objectType))))
-        .addEquivalenceGroup(FAKE_ERROR_TYPE)
-        ;
+    EquivalenceTester<TypeMirror> tester =
+        EquivalenceTester.<TypeMirror>of(MoreTypes.equivalence())
+            .addEquivalenceGroup(types.getNullType())
+            .addEquivalenceGroup(types.getNoType(NONE))
+            .addEquivalenceGroup(types.getNoType(VOID))
+            .addEquivalenceGroup(objectType)
+            .addEquivalenceGroup(stringType)
+            .addEquivalenceGroup(containedInObject)
+            .addEquivalenceGroup(containedInString)
+            .addEquivalenceGroup(funkyBounds.asType())
+            .addEquivalenceGroup(funkyBounds2.asType())
+            .addEquivalenceGroup(funkierBounds.asType())
+            .addEquivalenceGroup(funkyBoundsVar, funkyBounds2Var)
+            .addEquivalenceGroup(funkierBoundsVar)
+            // Enum<E extends Enum<E>>
+            .addEquivalenceGroup(enumElement.asType())
+            // Map<K, V>
+            .addEquivalenceGroup(mapType)
+            .addEquivalenceGroup(mapOfObjectToObjectType)
+            // Map<?, ?>
+            .addEquivalenceGroup(types.getDeclaredType(mapElement, wildcard, wildcard))
+            // Map
+            .addEquivalenceGroup(types.erasure(mapType), types.erasure(mapOfObjectToObjectType))
+            .addEquivalenceGroup(types.getDeclaredType(mapElement, objectType, stringType))
+            .addEquivalenceGroup(types.getDeclaredType(mapElement, stringType, objectType))
+            .addEquivalenceGroup(types.getDeclaredType(mapElement, stringType, stringType))
+            .addEquivalenceGroup(setOfSetOfObject)
+            .addEquivalenceGroup(setOfSetOfString)
+            .addEquivalenceGroup(setOfSetOfSetOfObject)
+            .addEquivalenceGroup(setOfSetOfSetOfString)
+            .addEquivalenceGroup(wildcard)
+            // ? extends Object
+            .addEquivalenceGroup(types.getWildcardType(objectType, null))
+            // ? extends String
+            .addEquivalenceGroup(types.getWildcardType(stringType, null))
+            // ? super String
+            .addEquivalenceGroup(types.getWildcardType(null, stringType))
+            // Map<String, Map<String, Set<Object>>>
+            .addEquivalenceGroup(
+                types.getDeclaredType(
+                    mapElement,
+                    stringType,
+                    types.getDeclaredType(
+                        mapElement, stringType, types.getDeclaredType(setElement, objectType))))
+            .addEquivalenceGroup(FAKE_ERROR_TYPE);
 
     for (TypeKind kind : TypeKind.values()) {
       if (kind.isPrimitive()) {
@@ -145,20 +148,24 @@ public class MoreTypesTest {
       }
     }
 
-    ImmutableSet<Class<?>> testClasses = ImmutableSet.of(
-        ExecutableElementsGroupA.class,
-        ExecutableElementsGroupB.class,
-        ExecutableElementsGroupC.class,
-        ExecutableElementsGroupD.class,
-        ExecutableElementsGroupE.class);
+    ImmutableSet<Class<?>> testClasses =
+        ImmutableSet.of(
+            ExecutableElementsGroupA.class,
+            ExecutableElementsGroupB.class,
+            ExecutableElementsGroupC.class,
+            ExecutableElementsGroupD.class,
+            ExecutableElementsGroupE.class);
     for (Class<?> testClass : testClasses) {
-      ImmutableList<TypeMirror> equivalenceGroup = FluentIterable.from(
-          elements.getTypeElement(testClass.getCanonicalName()).getEnclosedElements())
-              .transform(new Function<Element, TypeMirror>() {
-                @Override public TypeMirror apply(Element input) {
-                  return input.asType();
-                }
-              })
+      ImmutableList<TypeMirror> equivalenceGroup =
+          FluentIterable.from(
+                  elements.getTypeElement(testClass.getCanonicalName()).getEnclosedElements())
+              .transform(
+                  new Function<Element, TypeMirror>() {
+                    @Override
+                    public TypeMirror apply(Element input) {
+                      return input.asType();
+                    }
+                  })
               .toList();
       tester.addEquivalenceGroup(equivalenceGroup);
     }
@@ -169,35 +176,45 @@ public class MoreTypesTest {
   @SuppressWarnings("unused")
   private static final class ExecutableElementsGroupA {
     ExecutableElementsGroupA() {}
+
     void a() {}
+
     public static void b() {}
   }
 
   @SuppressWarnings("unused")
   private static final class ExecutableElementsGroupB {
     ExecutableElementsGroupB(String s) {}
+
     void a(String s) {}
+
     public static void b(String s) {}
   }
 
   @SuppressWarnings("unused")
   private static final class ExecutableElementsGroupC {
     ExecutableElementsGroupC() throws Exception {}
+
     void a() throws Exception {}
+
     public static void b() throws Exception {}
   }
 
   @SuppressWarnings("unused")
   private static final class ExecutableElementsGroupD {
     ExecutableElementsGroupD() throws RuntimeException {}
+
     void a() throws RuntimeException {}
+
     public static void b() throws RuntimeException {}
   }
 
   @SuppressWarnings("unused")
   private static final class ExecutableElementsGroupE {
     <T> ExecutableElementsGroupE() {}
+
     <T> void a() {}
+
     public static <T> void b() {}
   }
 
@@ -215,28 +232,26 @@ public class MoreTypesTest {
   @SuppressWarnings("unused")
   private static final class FunkierBounds<T extends Number & Comparable<T> & Cloneable> {}
 
-  @Test public void testReferencedTypes() {
+  @Test
+  public void testReferencedTypes() {
     Elements elements = compilationRule.getElements();
-    TypeElement testDataElement = elements
-        .getTypeElement(ReferencedTypesTestData.class.getCanonicalName());
+    TypeElement testDataElement =
+        elements.getTypeElement(ReferencedTypesTestData.class.getCanonicalName());
     ImmutableMap<String, VariableElement> fieldIndex =
         FluentIterable.from(ElementFilter.fieldsIn(testDataElement.getEnclosedElements()))
-            .uniqueIndex(new Function<VariableElement, String>() {
-              @Override public String apply(VariableElement input) {
-                return input.getSimpleName().toString();
-              }
-            });
-
-    TypeElement objectElement =
-        elements.getTypeElement(Object.class.getCanonicalName());
-    TypeElement stringElement =
-        elements.getTypeElement(String.class.getCanonicalName());
-    TypeElement integerElement =
-        elements.getTypeElement(Integer.class.getCanonicalName());
-    TypeElement setElement =
-        elements.getTypeElement(Set.class.getCanonicalName());
-    TypeElement mapElement =
-        elements.getTypeElement(Map.class.getCanonicalName());
+            .uniqueIndex(
+                new Function<VariableElement, String>() {
+                  @Override
+                  public String apply(VariableElement input) {
+                    return input.getSimpleName().toString();
+                  }
+                });
+
+    TypeElement objectElement = elements.getTypeElement(Object.class.getCanonicalName());
+    TypeElement stringElement = elements.getTypeElement(String.class.getCanonicalName());
+    TypeElement integerElement = elements.getTypeElement(Integer.class.getCanonicalName());
+    TypeElement setElement = elements.getTypeElement(Set.class.getCanonicalName());
+    TypeElement mapElement = elements.getTypeElement(Map.class.getCanonicalName());
     TypeElement charSequenceElement =
         elements.getTypeElement(CharSequence.class.getCanonicalName());
 
@@ -281,20 +296,23 @@ public class MoreTypesTest {
   }
 
   private static class Parent<T> {}
+
   private static class ChildA extends Parent<Number> {}
+
   private static class ChildB extends Parent<String> {}
+
   private static class GenericChild<T> extends Parent<T> {}
+
   private interface InterfaceType {}
 
   @Test
   public void asElement_throws() {
-    TypeMirror javaDotLang =
-        compilationRule.getElements().getPackageElement("java.lang").asType();
+    TypeMirror javaDotLang = compilationRule.getElements().getPackageElement("java.lang").asType();
     try {
       MoreTypes.asElement(javaDotLang);
       fail();
-    } catch (IllegalArgumentException expected) {}
-
+    } catch (IllegalArgumentException expected) {
+    }
   }
 
   @Test
@@ -302,8 +320,9 @@ public class MoreTypesTest {
     Elements elements = compilationRule.getElements();
     TypeElement stringElement = elements.getTypeElement("java.lang.String");
     assertThat(MoreTypes.asElement(stringElement.asType())).isEqualTo(stringElement);
-    TypeParameterElement setParameterElement = Iterables.getOnlyElement(
-        compilationRule.getElements().getTypeElement("java.util.Set").getTypeParameters());
+    TypeParameterElement setParameterElement =
+        Iterables.getOnlyElement(
+            compilationRule.getElements().getTypeElement("java.util.Set").getTypeParameters());
     assertThat(MoreTypes.asElement(setParameterElement.asType())).isEqualTo(setParameterElement);
     // we don't test error types because those are very hard to get predictably
   }
@@ -321,8 +340,7 @@ public class MoreTypesTest {
     TypeElement genericChild = elements.getTypeElement(GenericChild.class.getCanonicalName());
     TypeMirror genericChildOfNumber = types.getDeclaredType(genericChild, numberType);
     TypeMirror genericChildOfInteger = types.getDeclaredType(genericChild, integerType);
-    TypeMirror objectType =
-        elements.getTypeElement(Object.class.getCanonicalName()).asType();
+    TypeMirror objectType = elements.getTypeElement(Object.class.getCanonicalName()).asType();
     TypeMirror interfaceType =
         elements.getTypeElement(InterfaceType.class.getCanonicalName()).asType();
 
@@ -344,18 +362,20 @@ public class MoreTypesTest {
     Optional<DeclaredType> parentOfGenericChildOfInteger =
         MoreTypes.nonObjectSuperclass(types, elements, (DeclaredType) genericChildOfInteger);
 
-    EquivalenceTester<TypeMirror> tester = EquivalenceTester.<TypeMirror>of(MoreTypes.equivalence())
-          .addEquivalenceGroup(parentOfChildA.get(),
-              types.getDeclaredType(parent, numberType),
-              parentOfGenericChildOfNumber.get())
-          .addEquivalenceGroup(parentOfChildB.get(), types.getDeclaredType(parent, stringType))
-          .addEquivalenceGroup(parentOfGenericChild.get(), parent.asType())
-          .addEquivalenceGroup(parentOfGenericChildOfInteger.get(),
-              types.getDeclaredType(parent, integerType));
+    EquivalenceTester<TypeMirror> tester =
+        EquivalenceTester.<TypeMirror>of(MoreTypes.equivalence())
+            .addEquivalenceGroup(
+                parentOfChildA.get(),
+                types.getDeclaredType(parent, numberType),
+                parentOfGenericChildOfNumber.get())
+            .addEquivalenceGroup(parentOfChildB.get(), types.getDeclaredType(parent, stringType))
+            .addEquivalenceGroup(parentOfGenericChild.get(), parent.asType())
+            .addEquivalenceGroup(
+                parentOfGenericChildOfInteger.get(), types.getDeclaredType(parent, integerType));
 
     tester.test();
   }
-  
+
   @Test
   public void testAsMemberOf_variableElement() {
     Types types = compilationRule.getTypes();
@@ -365,11 +385,13 @@ public class MoreTypesTest {
     TypeMirror integerType = elements.getTypeElement(Integer.class.getCanonicalName()).asType();
 
     TypeElement paramsElement = elements.getTypeElement(Params.class.getCanonicalName());
-    VariableElement tParam = Iterables.getOnlyElement(Iterables.getOnlyElement(
-        ElementFilter.methodsIn(paramsElement.getEnclosedElements())).getParameters());
+    VariableElement tParam =
+        Iterables.getOnlyElement(
+            Iterables.getOnlyElement(ElementFilter.methodsIn(paramsElement.getEnclosedElements()))
+                .getParameters());
     VariableElement tField =
-        Iterables.getOnlyElement(ElementFilter.fieldsIn(paramsElement.getEnclosedElements())); 
-    
+        Iterables.getOnlyElement(ElementFilter.fieldsIn(paramsElement.getEnclosedElements()));
+
     DeclaredType numberParams =
         (DeclaredType) elements.getTypeElement(NumberParams.class.getCanonicalName()).asType();
     DeclaredType stringParams =
@@ -377,7 +399,7 @@ public class MoreTypesTest {
     TypeElement genericParams = elements.getTypeElement(GenericParams.class.getCanonicalName());
     DeclaredType genericParamsOfNumber = types.getDeclaredType(genericParams, numberType);
     DeclaredType genericParamsOfInteger = types.getDeclaredType(genericParams, integerType);
-    
+
     TypeMirror fieldOfNumberParams = MoreTypes.asMemberOf(types, numberParams, tField);
     TypeMirror paramOfNumberParams = MoreTypes.asMemberOf(types, numberParams, tParam);
     TypeMirror fieldOfStringParams = MoreTypes.asMemberOf(types, stringParams, tField);
@@ -389,62 +411,74 @@ public class MoreTypesTest {
     TypeMirror paramOfGenericOfInteger =
         MoreTypes.asMemberOf(types, genericParamsOfInteger, tParam);
 
-    EquivalenceTester<TypeMirror> tester = EquivalenceTester.<TypeMirror>of(MoreTypes.equivalence())
-        .addEquivalenceGroup(fieldOfNumberParams, paramOfNumberParams, fieldOfGenericOfNumber,
-            paramOfGenericOfNumber, numberType)
-        .addEquivalenceGroup(fieldOfStringParams, paramOfStringParams, stringType)
-        .addEquivalenceGroup(fieldOfGenericOfInteger, paramOfGenericOfInteger, integerType);
+    EquivalenceTester<TypeMirror> tester =
+        EquivalenceTester.<TypeMirror>of(MoreTypes.equivalence())
+            .addEquivalenceGroup(
+                fieldOfNumberParams,
+                paramOfNumberParams,
+                fieldOfGenericOfNumber,
+                paramOfGenericOfNumber,
+                numberType)
+            .addEquivalenceGroup(fieldOfStringParams, paramOfStringParams, stringType)
+            .addEquivalenceGroup(fieldOfGenericOfInteger, paramOfGenericOfInteger, integerType);
     tester.test();
   }
-  
-  private static class Params<T> {
-    @SuppressWarnings("unused") T t;
-    @SuppressWarnings("unused") void add(T t) {}
-  }
-  private static class NumberParams extends Params<Number> {}
-  private static class StringParams extends Params<String> {}
-  private static class GenericParams<T> extends Params<T> {}
-
-  private static final ErrorType FAKE_ERROR_TYPE = new ErrorType() {
-    @Override
-    public TypeKind getKind() {
-      return TypeKind.ERROR;
-    }
-
-    @Override
-    public <R, P> R accept(TypeVisitor<R, P> v, P p) {
-      return v.visitError(this, p);
-    }
-
-    @Override
-    public List<? extends TypeMirror> getTypeArguments() {
-      return ImmutableList.of();
-    }
 
-    @Override
-    public TypeMirror getEnclosingType() {
-      return null;
-    }
+  private static class Params<T> {
+    @SuppressWarnings("unused")
+    T t;
 
-    @Override
-    public Element asElement() {
-      return null;
-    }
+    @SuppressWarnings("unused")
+    void add(T t) {}
+  }
 
-    // JDK8 Compatibility:
+  private static class NumberParams extends Params<Number> {}
 
-    public <A extends Annotation> A[] getAnnotationsByType(Class<A> annotationType) {
-      return null;
-    }
+  private static class StringParams extends Params<String> {}
 
-    public <A extends Annotation> A getAnnotation(Class<A> annotationType) {
-      return null;
-    }
+  private static class GenericParams<T> extends Params<T> {}
 
-    public List<? extends AnnotationMirror> getAnnotationMirrors() {
-      return null;
-    }
-  };
+  private static final ErrorType FAKE_ERROR_TYPE =
+      new ErrorType() {
+        @Override
+        public TypeKind getKind() {
+          return TypeKind.ERROR;
+        }
+
+        @Override
+        public <R, P> R accept(TypeVisitor<R, P> v, P p) {
+          return v.visitError(this, p);
+        }
+
+        @Override
+        public List<? extends TypeMirror> getTypeArguments() {
+          return ImmutableList.of();
+        }
+
+        @Override
+        public TypeMirror getEnclosingType() {
+          return null;
+        }
+
+        @Override
+        public Element asElement() {
+          return null;
+        }
+
+        // JDK8 Compatibility:
+
+        public <A extends Annotation> A[] getAnnotationsByType(Class<A> annotationType) {
+          return null;
+        }
+
+        public <A extends Annotation> A getAnnotation(Class<A> annotationType) {
+          return null;
+        }
+
+        public List<? extends AnnotationMirror> getAnnotationMirrors() {
+          return null;
+        }
+      };
 
   @Test
   public void testIsConversionFromObjectUnchecked_yes() {
diff --git a/common/src/test/java/com/google/auto/common/OverridesTest.java b/common/src/test/java/com/google/auto/common/OverridesTest.java
index f630382d..85ccdcd7 100644
--- a/common/src/test/java/com/google/auto/common/OverridesTest.java
+++ b/common/src/test/java/com/google/auto/common/OverridesTest.java
@@ -103,6 +103,7 @@ public class OverridesTest {
 
     abstract void initUtils(OverridesTest test);
   }
+
   private final CompilerType compilerType;
 
   private Types typeUtils;
@@ -126,12 +127,15 @@ public class OverridesTest {
   static class TypesForInheritance {
     interface One {
       void m();
+
       void m(String x);
+
       void n();
     }
 
     interface Two {
       void m();
+
       void m(int x);
     }
 
@@ -142,28 +146,50 @@ public class OverridesTest {
     static class ChildOfParent extends Parent {}
 
     static class ChildOfOne implements One {
-      @Override public void m() {}
-      @Override public void m(String x) {}
-      @Override public void n() {}
+      @Override
+      public void m() {}
+
+      @Override
+      public void m(String x) {}
+
+      @Override
+      public void n() {}
     }
 
     static class ChildOfOneAndTwo implements One, Two {
-      @Override public void m() {}
-      @Override public void m(String x) {}
-      @Override public void m(int x) {}
-      @Override public void n() {}
+      @Override
+      public void m() {}
+
+      @Override
+      public void m(String x) {}
+
+      @Override
+      public void m(int x) {}
+
+      @Override
+      public void n() {}
     }
 
     static class ChildOfParentAndOne extends Parent implements One {
-      @Override public void m() {}
-      @Override public void m(String x) {}
-      @Override public void n() {}
+      @Override
+      public void m() {}
+
+      @Override
+      public void m(String x) {}
+
+      @Override
+      public void n() {}
     }
 
     static class ChildOfParentAndOneAndTwo extends Parent implements One, Two {
-      @Override public void m(String x) {}
-      @Override public void m(int x) {}
-      @Override public void n() {}
+      @Override
+      public void m(String x) {}
+
+      @Override
+      public void m(int x) {}
+
+      @Override
+      public void n() {}
     }
 
     abstract static class AbstractChildOfOne implements One {}
@@ -194,14 +220,20 @@ public class OverridesTest {
 
     abstract static class BindingDeclaration implements HasKey {
       abstract Optional<Element> bindingElement();
+
       abstract Optional<TypeElement> contributingModule();
     }
 
-    abstract static class MultibindingDeclaration
-        extends BindingDeclaration implements HasBindingType, HasContributionType {
-      @Override public abstract Key key();
-      @Override public abstract ContributionType contributionType();
-      @Override public abstract BindingType bindingType();
+    abstract static class MultibindingDeclaration extends BindingDeclaration
+        implements HasBindingType, HasContributionType {
+      @Override
+      public abstract Key key();
+
+      @Override
+      public abstract ContributionType contributionType();
+
+      @Override
+      public abstract BindingType bindingType();
     }
   }
 
@@ -226,18 +258,21 @@ public class OverridesTest {
     }
 
     interface GList<E> extends GCollection<E> {
-      @Override boolean add(E x);
+      @Override
+      boolean add(E x);
     }
 
     static class StringList implements GList<String> {
-      @Override public boolean add(String x) {
+      @Override
+      public boolean add(String x) {
         return false;
       }
     }
 
     @SuppressWarnings("rawtypes")
     static class RawList implements GList {
-      @Override public boolean add(Object x) {
+      @Override
+      public boolean add(Object x) {
         return false;
       }
     }
@@ -250,7 +285,8 @@ public class OverridesTest {
     }
 
     static class RawChildOfRaw extends RawParent {
-      @Override void frob(List x) {}
+      @Override
+      void frob(List x) {}
     }
 
     static class NonRawParent {
@@ -258,7 +294,8 @@ public class OverridesTest {
     }
 
     static class RawChildOfNonRaw extends NonRawParent {
-      @Override void frob(List x) {}
+      @Override
+      void frob(List x) {}
     }
   }
 
@@ -298,8 +335,9 @@ public class OverridesTest {
   // since the two Es are not the same.
   @Test
   public void overridesDiamond() {
-    checkOverridesInSet(ImmutableSet.<Class<?>>of(
-        Collection.class, List.class, AbstractCollection.class, AbstractList.class));
+    checkOverridesInSet(
+        ImmutableSet.<Class<?>>of(
+            Collection.class, List.class, AbstractCollection.class, AbstractList.class));
   }
 
   private void checkOverridesInContainedClasses(Class<?> container) {
@@ -331,10 +369,13 @@ public class OverridesTest {
             expect
                 .withMessage(
                     "%s.%s overrides %s.%s in %s: javac says %s, we say %s",
-                    overrider.getEnclosingElement(), overrider,
-                    overridden.getEnclosingElement(), overridden,
+                    overrider.getEnclosingElement(),
+                    overrider,
+                    overridden.getEnclosingElement(),
+                    overridden,
                     in,
-                    javacSays, weSay)
+                    javacSays,
+                    weSay)
                 .fail();
           }
         }
@@ -382,8 +423,8 @@ public class OverridesTest {
     }
   }
 
-  private abstract static class XAbstractList<E>
-      extends XAbstractCollection<E> implements XList<E> {
+  private abstract static class XAbstractList<E> extends XAbstractCollection<E>
+      implements XList<E> {
     @Override
     public boolean add(E e) {
       return true;
@@ -477,8 +518,7 @@ public class OverridesTest {
         explicitOverrides.methodFromSuperclasses(xAbstractStringList, add);
     assertThat(addInAbstractStringList).isNull();
 
-    ExecutableElement addInStringList =
-        explicitOverrides.methodFromSuperclasses(xStringList, add);
+    ExecutableElement addInStringList = explicitOverrides.methodFromSuperclasses(xStringList, add);
     assertThat(addInStringList.getEnclosingElement()).isEqualTo(xAbstractList);
   }
 
@@ -500,8 +540,7 @@ public class OverridesTest {
         explicitOverrides.methodFromSuperinterfaces(xNumberList, add);
     assertThat(addInNumberList.getEnclosingElement()).isEqualTo(xAbstractList);
 
-    ExecutableElement addInList =
-        explicitOverrides.methodFromSuperinterfaces(xList, add);
+    ExecutableElement addInList = explicitOverrides.methodFromSuperinterfaces(xList, add);
     assertThat(addInList.getEnclosingElement()).isEqualTo(xCollection);
   }
 
@@ -559,10 +598,11 @@ public class OverridesTest {
       // it hard for ecj to find the boot class path. Elsewhere it is unnecessary but harmless.
       File rtJar = new File(StandardSystemProperty.JAVA_HOME.value() + "/lib/rt.jar");
       if (rtJar.exists()) {
-        List<File> bootClassPath = ImmutableList.<File>builder()
-            .add(rtJar)
-            .addAll(fileManager.getLocation(StandardLocation.PLATFORM_CLASS_PATH))
-            .build();
+        List<File> bootClassPath =
+            ImmutableList.<File>builder()
+                .add(rtJar)
+                .addAll(fileManager.getLocation(StandardLocation.PLATFORM_CLASS_PATH))
+                .build();
         fileManager.setLocation(StandardLocation.PLATFORM_CLASS_PATH, bootClassPath);
       }
       Iterable<? extends JavaFileObject> sources = fileManager.getJavaFileObjects(dummySourceFile);
@@ -590,8 +630,7 @@ public class OverridesTest {
     }
 
     @Override
-    public boolean process(
-        Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
+    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
       if (roundEnv.processingOver()) {
         ecjCompilation.elements = processingEnv.getElementUtils();
         ecjCompilation.types = processingEnv.getTypeUtils();
@@ -650,24 +689,24 @@ public class OverridesTest {
 
   private static final TypeVisitor<String, Void> ERASED_STRING_TYPE_VISITOR =
       new SimpleTypeVisitor6<String, Void>() {
-    @Override
-    protected String defaultAction(TypeMirror e, Void p) {
-      return e.toString();
-    }
+        @Override
+        protected String defaultAction(TypeMirror e, Void p) {
+          return e.toString();
+        }
 
-    @Override
-    public String visitArray(ArrayType t, Void p) {
-      return visit(t.getComponentType()) + "[]";
-    }
+        @Override
+        public String visitArray(ArrayType t, Void p) {
+          return visit(t.getComponentType()) + "[]";
+        }
 
-    @Override
-    public String visitDeclared(DeclaredType t, Void p) {
-      return MoreElements.asType(t.asElement()).getQualifiedName().toString();
-    }
+        @Override
+        public String visitDeclared(DeclaredType t, Void p) {
+          return MoreElements.asType(t.asElement()).getQualifiedName().toString();
+        }
 
-    @Override
-    public String visitTypeVariable(TypeVariable t, Void p) {
-      return visit(t.getUpperBound());
-    }
-  };
+        @Override
+        public String visitTypeVariable(TypeVariable t, Void p) {
+          return visit(t.getUpperBound());
+        }
+      };
 }
diff --git a/common/src/test/java/com/google/auto/common/SimpleAnnotationMirrorTest.java b/common/src/test/java/com/google/auto/common/SimpleAnnotationMirrorTest.java
index d73e1b6c..0bad83db 100644
--- a/common/src/test/java/com/google/auto/common/SimpleAnnotationMirrorTest.java
+++ b/common/src/test/java/com/google/auto/common/SimpleAnnotationMirrorTest.java
@@ -46,6 +46,7 @@ public class SimpleAnnotationMirrorTest {
 
   @interface MultipleValues {
     int value1();
+
     int value2();
   }
 
diff --git a/common/src/test/java/com/google/auto/common/SimpleTypeAnnotationValueTest.java b/common/src/test/java/com/google/auto/common/SimpleTypeAnnotationValueTest.java
index 4fc61b51..b1679cdb 100644
--- a/common/src/test/java/com/google/auto/common/SimpleTypeAnnotationValueTest.java
+++ b/common/src/test/java/com/google/auto/common/SimpleTypeAnnotationValueTest.java
@@ -70,18 +70,21 @@ public class SimpleTypeAnnotationValueTest {
 
   @Test
   public void visitorMethod() {
-    SimpleTypeAnnotationValue.of(objectType).accept(new SimpleAnnotationValueVisitor8<Void, Void>(){
-      @Override
-      public Void visitType(TypeMirror typeMirror, Void aVoid) {
-        // do nothing, expected case
-        return null;
-      }
+    SimpleTypeAnnotationValue.of(objectType)
+        .accept(
+            new SimpleAnnotationValueVisitor8<Void, Void>() {
+              @Override
+              public Void visitType(TypeMirror typeMirror, Void aVoid) {
+                // do nothing, expected case
+                return null;
+              }
 
-      @Override
-      protected Void defaultAction(Object o, Void aVoid) {
-        throw new AssertionError();
-      }
-    }, null);
+              @Override
+              protected Void defaultAction(Object o, Void aVoid) {
+                throw new AssertionError();
+              }
+            },
+            null);
   }
 
   @Test
diff --git a/common/src/test/java/com/google/auto/common/SuperficialValidationTest.java b/common/src/test/java/com/google/auto/common/SuperficialValidationTest.java
index 15e54fff..c9bcf778 100644
--- a/common/src/test/java/com/google/auto/common/SuperficialValidationTest.java
+++ b/common/src/test/java/com/google/auto/common/SuperficialValidationTest.java
@@ -35,231 +35,263 @@ import org.junit.runners.JUnit4;
 public class SuperficialValidationTest {
   @Test
   public void missingReturnType() {
-    JavaFileObject javaFileObject = JavaFileObjects.forSourceLines(
-        "test.TestClass",
-        "package test;",
-        "",
-        "abstract class TestClass {",
-        "  abstract MissingType blah();",
-        "}");
+    JavaFileObject javaFileObject =
+        JavaFileObjects.forSourceLines(
+            "test.TestClass",
+            "package test;",
+            "",
+            "abstract class TestClass {",
+            "  abstract MissingType blah();",
+            "}");
     assertAbout(javaSource())
         .that(javaFileObject)
-        .processedWith(new AssertingProcessor() {
-          @Override void runAssertions() {
-            TypeElement testClassElement =
-                processingEnv.getElementUtils().getTypeElement("test.TestClass");
-            assertThat(SuperficialValidation.validateElement(testClassElement)).isFalse();
-          }
-        })
+        .processedWith(
+            new AssertingProcessor() {
+              @Override
+              void runAssertions() {
+                TypeElement testClassElement =
+                    processingEnv.getElementUtils().getTypeElement("test.TestClass");
+                assertThat(SuperficialValidation.validateElement(testClassElement)).isFalse();
+              }
+            })
         .failsToCompile();
   }
 
   @Test
   public void missingGenericReturnType() {
-    JavaFileObject javaFileObject = JavaFileObjects.forSourceLines(
-        "test.TestClass",
-        "package test;",
-        "",
-        "abstract class TestClass {",
-        "  abstract MissingType<?> blah();",
-        "}");
+    JavaFileObject javaFileObject =
+        JavaFileObjects.forSourceLines(
+            "test.TestClass",
+            "package test;",
+            "",
+            "abstract class TestClass {",
+            "  abstract MissingType<?> blah();",
+            "}");
     assertAbout(javaSource())
         .that(javaFileObject)
-        .processedWith(new AssertingProcessor() {
-          @Override void runAssertions() {
-            TypeElement testClassElement =
-                processingEnv.getElementUtils().getTypeElement("test.TestClass");
-            assertThat(SuperficialValidation.validateElement(testClassElement)).isFalse();
-          }
-        })
+        .processedWith(
+            new AssertingProcessor() {
+              @Override
+              void runAssertions() {
+                TypeElement testClassElement =
+                    processingEnv.getElementUtils().getTypeElement("test.TestClass");
+                assertThat(SuperficialValidation.validateElement(testClassElement)).isFalse();
+              }
+            })
         .failsToCompile();
   }
 
   @Test
   public void missingReturnTypeTypeParameter() {
-    JavaFileObject javaFileObject = JavaFileObjects.forSourceLines(
-        "test.TestClass",
-        "package test;",
-        "",
-        "import java.util.Map;",
-        "import java.util.Set;",
-        "",
-        "abstract class TestClass {",
-        "  abstract Map<Set<?>, MissingType<?>> blah();",
-        "}");
+    JavaFileObject javaFileObject =
+        JavaFileObjects.forSourceLines(
+            "test.TestClass",
+            "package test;",
+            "",
+            "import java.util.Map;",
+            "import java.util.Set;",
+            "",
+            "abstract class TestClass {",
+            "  abstract Map<Set<?>, MissingType<?>> blah();",
+            "}");
     assertAbout(javaSource())
         .that(javaFileObject)
-        .processedWith(new AssertingProcessor() {
-          @Override void runAssertions() {
-            TypeElement testClassElement =
-                processingEnv.getElementUtils().getTypeElement("test.TestClass");
-            assertThat(SuperficialValidation.validateElement(testClassElement)).isFalse();
-          }
-        })
+        .processedWith(
+            new AssertingProcessor() {
+              @Override
+              void runAssertions() {
+                TypeElement testClassElement =
+                    processingEnv.getElementUtils().getTypeElement("test.TestClass");
+                assertThat(SuperficialValidation.validateElement(testClassElement)).isFalse();
+              }
+            })
         .failsToCompile();
   }
 
   @Test
   public void missingTypeParameter() {
-    JavaFileObject javaFileObject = JavaFileObjects.forSourceLines(
-        "test.TestClass",
-        "package test;",
-        "",
-        "class TestClass<T extends MissingType> {}");
+    JavaFileObject javaFileObject =
+        JavaFileObjects.forSourceLines(
+            "test.TestClass", //
+            "package test;",
+            "",
+            "class TestClass<T extends MissingType> {}");
     assertAbout(javaSource())
         .that(javaFileObject)
-        .processedWith(new AssertingProcessor() {
-          @Override void runAssertions() {
-            TypeElement testClassElement =
-                processingEnv.getElementUtils().getTypeElement("test.TestClass");
-            assertThat(SuperficialValidation.validateElement(testClassElement)).isFalse();
-          }
-        })
+        .processedWith(
+            new AssertingProcessor() {
+              @Override
+              void runAssertions() {
+                TypeElement testClassElement =
+                    processingEnv.getElementUtils().getTypeElement("test.TestClass");
+                assertThat(SuperficialValidation.validateElement(testClassElement)).isFalse();
+              }
+            })
         .failsToCompile();
   }
 
   @Test
   public void missingParameterType() {
-    JavaFileObject javaFileObject = JavaFileObjects.forSourceLines(
-        "test.TestClass",
-        "package test;",
-        "",
-        "abstract class TestClass {",
-        "  abstract void foo(MissingType x);",
-        "}");
+    JavaFileObject javaFileObject =
+        JavaFileObjects.forSourceLines(
+            "test.TestClass",
+            "package test;",
+            "",
+            "abstract class TestClass {",
+            "  abstract void foo(MissingType x);",
+            "}");
     assertAbout(javaSource())
         .that(javaFileObject)
-        .processedWith(new AssertingProcessor() {
-          @Override void runAssertions() {
-            TypeElement testClassElement =
-                processingEnv.getElementUtils().getTypeElement("test.TestClass");
-            assertThat(SuperficialValidation.validateElement(testClassElement)).isFalse();
-          }
-        })
+        .processedWith(
+            new AssertingProcessor() {
+              @Override
+              void runAssertions() {
+                TypeElement testClassElement =
+                    processingEnv.getElementUtils().getTypeElement("test.TestClass");
+                assertThat(SuperficialValidation.validateElement(testClassElement)).isFalse();
+              }
+            })
         .failsToCompile();
   }
 
   @Test
   public void missingAnnotation() {
-    JavaFileObject javaFileObject = JavaFileObjects.forSourceLines(
-        "test.TestClass",
-        "package test;",
-        "",
-        "@MissingAnnotation",
-        "class TestClass {}");
+    JavaFileObject javaFileObject =
+        JavaFileObjects.forSourceLines(
+            "test.TestClass", //
+            "package test;",
+            "",
+            "@MissingAnnotation",
+            "class TestClass {}");
     assertAbout(javaSource())
         .that(javaFileObject)
-        .processedWith(new AssertingProcessor() {
-          @Override void runAssertions() {
-            TypeElement testClassElement =
-                processingEnv.getElementUtils().getTypeElement("test.TestClass");
-            assertThat(SuperficialValidation.validateElement(testClassElement)).isFalse();
-          }
-        })
+        .processedWith(
+            new AssertingProcessor() {
+              @Override
+              void runAssertions() {
+                TypeElement testClassElement =
+                    processingEnv.getElementUtils().getTypeElement("test.TestClass");
+                assertThat(SuperficialValidation.validateElement(testClassElement)).isFalse();
+              }
+            })
         .failsToCompile();
   }
 
   @Test
   public void handlesRecursiveTypeParams() {
-    JavaFileObject javaFileObject = JavaFileObjects.forSourceLines(
-        "test.TestClass",
-        "package test;",
-        "",
-        "class TestClass<T extends Comparable<T>> {}");
+    JavaFileObject javaFileObject =
+        JavaFileObjects.forSourceLines(
+            "test.TestClass", //
+            "package test;",
+            "",
+            "class TestClass<T extends Comparable<T>> {}");
     assertAbout(javaSource())
         .that(javaFileObject)
-        .processedWith(new AssertingProcessor() {
-          @Override void runAssertions() {
-            TypeElement testClassElement =
-                processingEnv.getElementUtils().getTypeElement("test.TestClass");
-            assertThat(SuperficialValidation.validateElement(testClassElement)).isTrue();
-          }
-        })
+        .processedWith(
+            new AssertingProcessor() {
+              @Override
+              void runAssertions() {
+                TypeElement testClassElement =
+                    processingEnv.getElementUtils().getTypeElement("test.TestClass");
+                assertThat(SuperficialValidation.validateElement(testClassElement)).isTrue();
+              }
+            })
         .compilesWithoutError();
   }
 
   @Test
   public void handlesRecursiveType() {
-    JavaFileObject javaFileObject = JavaFileObjects.forSourceLines(
-        "test.TestClass",
-        "package test;",
-        "",
-        "abstract class TestClass {",
-        "  abstract TestClass foo(TestClass x);",
-        "}");
+    JavaFileObject javaFileObject =
+        JavaFileObjects.forSourceLines(
+            "test.TestClass",
+            "package test;",
+            "",
+            "abstract class TestClass {",
+            "  abstract TestClass foo(TestClass x);",
+            "}");
     assertAbout(javaSource())
         .that(javaFileObject)
-        .processedWith(new AssertingProcessor() {
-          @Override void runAssertions() {
-            TypeElement testClassElement =
-                processingEnv.getElementUtils().getTypeElement("test.TestClass");
-            assertThat(SuperficialValidation.validateElement(testClassElement)).isTrue();
-          }
-        })
+        .processedWith(
+            new AssertingProcessor() {
+              @Override
+              void runAssertions() {
+                TypeElement testClassElement =
+                    processingEnv.getElementUtils().getTypeElement("test.TestClass");
+                assertThat(SuperficialValidation.validateElement(testClassElement)).isTrue();
+              }
+            })
         .compilesWithoutError();
   }
 
   @Test
   public void missingWildcardBound() {
-    JavaFileObject javaFileObject = JavaFileObjects.forSourceLines(
-        "test.TestClass",
-        "package test;",
-        "",
-        "import java.util.Set;",
-        "",
-        "class TestClass {",
-        "  Set<? extends MissingType> extendsTest() {",
-        "    return null;",
-        "  }",
-        "",
-        "  Set<? super MissingType> superTest() {",
-        "    return null;",
-        "  }",
-        "}");
+    JavaFileObject javaFileObject =
+        JavaFileObjects.forSourceLines(
+            "test.TestClass",
+            "package test;",
+            "",
+            "import java.util.Set;",
+            "",
+            "class TestClass {",
+            "  Set<? extends MissingType> extendsTest() {",
+            "    return null;",
+            "  }",
+            "",
+            "  Set<? super MissingType> superTest() {",
+            "    return null;",
+            "  }",
+            "}");
     assertAbout(javaSource())
         .that(javaFileObject)
-        .processedWith(new AssertingProcessor() {
-          @Override void runAssertions() {
-            TypeElement testClassElement =
-                processingEnv.getElementUtils().getTypeElement("test.TestClass");
-            assertThat(SuperficialValidation.validateElement(testClassElement)).isFalse();
-          }
-        })
+        .processedWith(
+            new AssertingProcessor() {
+              @Override
+              void runAssertions() {
+                TypeElement testClassElement =
+                    processingEnv.getElementUtils().getTypeElement("test.TestClass");
+                assertThat(SuperficialValidation.validateElement(testClassElement)).isFalse();
+              }
+            })
         .failsToCompile();
   }
 
   @Test
   public void missingIntersection() {
-    JavaFileObject javaFileObject = JavaFileObjects.forSourceLines(
-        "test.TestClass",
-        "package test;",
-        "",
-        "class TestClass<T extends Number & Missing> {}");
+    JavaFileObject javaFileObject =
+        JavaFileObjects.forSourceLines(
+            "test.TestClass",
+            "package test;",
+            "",
+            "class TestClass<T extends Number & Missing> {}");
     assertAbout(javaSource())
         .that(javaFileObject)
-        .processedWith(new AssertingProcessor() {
-          @Override void runAssertions() {
-            TypeElement testClassElement =
-                processingEnv.getElementUtils().getTypeElement("test.TestClass");
-            assertThat(SuperficialValidation.validateElement(testClassElement)).isFalse();
-          }
-        })
+        .processedWith(
+            new AssertingProcessor() {
+              @Override
+              void runAssertions() {
+                TypeElement testClassElement =
+                    processingEnv.getElementUtils().getTypeElement("test.TestClass");
+                assertThat(SuperficialValidation.validateElement(testClassElement)).isFalse();
+              }
+            })
         .failsToCompile();
   }
 
   @Test
   public void invalidAnnotationValue() {
-    JavaFileObject javaFileObject = JavaFileObjects.forSourceLines("test.Outer",
-        "package test;",
-        "",
-        "final class Outer {",
-        "  @interface TestAnnotation {",
-        "    Class[] classes();",
-        "  }",
-        "",
-        "  @TestAnnotation(classes = Foo)",
-        "  static class TestClass {}",
-        "}");
+    JavaFileObject javaFileObject =
+        JavaFileObjects.forSourceLines(
+            "test.Outer",
+            "package test;",
+            "",
+            "final class Outer {",
+            "  @interface TestAnnotation {",
+            "    Class[] classes();",
+            "  }",
+            "",
+            "  @TestAnnotation(classes = Foo)",
+            "  static class TestClass {}",
+            "}");
     assertAbout(javaSource())
         .that(javaFileObject)
         .processedWith(
diff --git a/common/src/test/java/com/google/auto/common/VisibilityTest.java b/common/src/test/java/com/google/auto/common/VisibilityTest.java
index 6a80b7af..fc5e630b 100644
--- a/common/src/test/java/com/google/auto/common/VisibilityTest.java
+++ b/common/src/test/java/com/google/auto/common/VisibilityTest.java
@@ -39,9 +39,10 @@ public class VisibilityTest {
   public void packageVisibility() {
     assertThat(Visibility.ofElement(compilation.getElements().getPackageElement("java.lang")))
         .isEqualTo(PUBLIC);
-    assertThat(Visibility.ofElement(
-        compilation.getElements().getPackageElement("com.google.auto.common")))
-            .isEqualTo(PUBLIC);
+    assertThat(
+            Visibility.ofElement(
+                compilation.getElements().getPackageElement("com.google.auto.common")))
+        .isEqualTo(PUBLIC);
   }
 
   @Test
@@ -61,32 +62,44 @@ public class VisibilityTest {
   @SuppressWarnings("unused")
   public static class PublicClass {
     public static class NestedPublicClass {}
+
     protected static class NestedProtectedClass {}
+
     static class NestedDefaultClass {}
+
     private static class NestedPrivateClass {}
   }
 
   @SuppressWarnings("unused")
   protected static class ProtectedClass {
     public static class NestedPublicClass {}
+
     protected static class NestedProtectedClass {}
+
     static class NestedDefaultClass {}
+
     private static class NestedPrivateClass {}
   }
 
   @SuppressWarnings("unused")
   static class DefaultClass {
     public static class NestedPublicClass {}
+
     protected static class NestedProtectedClass {}
+
     static class NestedDefaultClass {}
+
     private static class NestedPrivateClass {}
   }
 
   @SuppressWarnings("unused")
   private static class PrivateClass {
     public static class NestedPublicClass {}
+
     protected static class NestedProtectedClass {}
+
     static class NestedDefaultClass {}
+
     private static class NestedPrivateClass {}
   }
 
@@ -94,21 +107,25 @@ public class VisibilityTest {
   public void classVisibility() {
     assertThat(Visibility.ofElement(compilation.getElements().getTypeElement("java.util.Map")))
         .isEqualTo(PUBLIC);
-    assertThat(Visibility.ofElement(
-        compilation.getElements().getTypeElement("java.util.Map.Entry")))
-            .isEqualTo(PUBLIC);
-    assertThat(Visibility.ofElement(
-        compilation.getElements().getTypeElement(PublicClass.class.getCanonicalName())))
-            .isEqualTo(PUBLIC);
-    assertThat(Visibility.ofElement(
-        compilation.getElements().getTypeElement(ProtectedClass.class.getCanonicalName())))
-            .isEqualTo(PROTECTED);
-    assertThat(Visibility.ofElement(
-        compilation.getElements().getTypeElement(DefaultClass.class.getCanonicalName())))
-            .isEqualTo(DEFAULT);
-    assertThat(Visibility.ofElement(
-        compilation.getElements().getTypeElement(PrivateClass.class.getCanonicalName())))
-            .isEqualTo(PRIVATE);
+    assertThat(
+            Visibility.ofElement(compilation.getElements().getTypeElement("java.util.Map.Entry")))
+        .isEqualTo(PUBLIC);
+    assertThat(
+            Visibility.ofElement(
+                compilation.getElements().getTypeElement(PublicClass.class.getCanonicalName())))
+        .isEqualTo(PUBLIC);
+    assertThat(
+            Visibility.ofElement(
+                compilation.getElements().getTypeElement(ProtectedClass.class.getCanonicalName())))
+        .isEqualTo(PROTECTED);
+    assertThat(
+            Visibility.ofElement(
+                compilation.getElements().getTypeElement(DefaultClass.class.getCanonicalName())))
+        .isEqualTo(DEFAULT);
+    assertThat(
+            Visibility.ofElement(
+                compilation.getElements().getTypeElement(PrivateClass.class.getCanonicalName())))
+        .isEqualTo(PRIVATE);
   }
 
   @Test
@@ -118,14 +135,11 @@ public class VisibilityTest {
     assertThat(effectiveVisiblityOfClass(DefaultClass.class)).isEqualTo(DEFAULT);
     assertThat(effectiveVisiblityOfClass(PrivateClass.class)).isEqualTo(PRIVATE);
 
-    assertThat(effectiveVisiblityOfClass(PublicClass.NestedPublicClass.class))
-        .isEqualTo(PUBLIC);
+    assertThat(effectiveVisiblityOfClass(PublicClass.NestedPublicClass.class)).isEqualTo(PUBLIC);
     assertThat(effectiveVisiblityOfClass(PublicClass.NestedProtectedClass.class))
         .isEqualTo(PROTECTED);
-    assertThat(effectiveVisiblityOfClass(PublicClass.NestedDefaultClass.class))
-        .isEqualTo(DEFAULT);
-    assertThat(effectiveVisiblityOfClass(PublicClass.NestedPrivateClass.class))
-        .isEqualTo(PRIVATE);
+    assertThat(effectiveVisiblityOfClass(PublicClass.NestedDefaultClass.class)).isEqualTo(DEFAULT);
+    assertThat(effectiveVisiblityOfClass(PublicClass.NestedPrivateClass.class)).isEqualTo(PRIVATE);
 
     assertThat(effectiveVisiblityOfClass(ProtectedClass.NestedPublicClass.class))
         .isEqualTo(PROTECTED);
@@ -136,23 +150,17 @@ public class VisibilityTest {
     assertThat(effectiveVisiblityOfClass(ProtectedClass.NestedPrivateClass.class))
         .isEqualTo(PRIVATE);
 
-    assertThat(effectiveVisiblityOfClass(DefaultClass.NestedPublicClass.class))
-        .isEqualTo(DEFAULT);
+    assertThat(effectiveVisiblityOfClass(DefaultClass.NestedPublicClass.class)).isEqualTo(DEFAULT);
     assertThat(effectiveVisiblityOfClass(DefaultClass.NestedProtectedClass.class))
         .isEqualTo(DEFAULT);
-    assertThat(effectiveVisiblityOfClass(DefaultClass.NestedDefaultClass.class))
-        .isEqualTo(DEFAULT);
-    assertThat(effectiveVisiblityOfClass(DefaultClass.NestedPrivateClass.class))
-        .isEqualTo(PRIVATE);
+    assertThat(effectiveVisiblityOfClass(DefaultClass.NestedDefaultClass.class)).isEqualTo(DEFAULT);
+    assertThat(effectiveVisiblityOfClass(DefaultClass.NestedPrivateClass.class)).isEqualTo(PRIVATE);
 
-    assertThat(effectiveVisiblityOfClass(PrivateClass.NestedPublicClass.class))
-        .isEqualTo(PRIVATE);
+    assertThat(effectiveVisiblityOfClass(PrivateClass.NestedPublicClass.class)).isEqualTo(PRIVATE);
     assertThat(effectiveVisiblityOfClass(PrivateClass.NestedProtectedClass.class))
         .isEqualTo(PRIVATE);
-    assertThat(effectiveVisiblityOfClass(PrivateClass.NestedDefaultClass.class))
-        .isEqualTo(PRIVATE);
-    assertThat(effectiveVisiblityOfClass(PrivateClass.NestedPrivateClass.class))
-        .isEqualTo(PRIVATE);
+    assertThat(effectiveVisiblityOfClass(PrivateClass.NestedDefaultClass.class)).isEqualTo(PRIVATE);
+    assertThat(effectiveVisiblityOfClass(PrivateClass.NestedPrivateClass.class)).isEqualTo(PRIVATE);
   }
 
   private Visibility effectiveVisiblityOfClass(Class<?> clazz) {
diff --git a/factory/src/it/functional/src/main/java/com/google/auto/factory/DaggerModule.java b/factory/src/it/functional/src/main/java/com/google/auto/factory/DaggerModule.java
index 4c4a38af..e31f92b6 100644
--- a/factory/src/it/functional/src/main/java/com/google/auto/factory/DaggerModule.java
+++ b/factory/src/it/functional/src/main/java/com/google/auto/factory/DaggerModule.java
@@ -21,7 +21,8 @@ import dagger.Provides;
 
 @Module
 final class DaggerModule {
-  @Provides Dependency provideDependency(DependencyImpl impl) {
+  @Provides
+  Dependency provideDependency(DependencyImpl impl) {
     return impl;
   }
 
diff --git a/factory/src/it/functional/src/main/java/com/google/auto/factory/DependencyImpl.java b/factory/src/it/functional/src/main/java/com/google/auto/factory/DependencyImpl.java
index 4c019ea6..d94a3cf6 100644
--- a/factory/src/it/functional/src/main/java/com/google/auto/factory/DependencyImpl.java
+++ b/factory/src/it/functional/src/main/java/com/google/auto/factory/DependencyImpl.java
@@ -18,5 +18,6 @@ package com.google.auto.factory;
 import javax.inject.Inject;
 
 public class DependencyImpl implements Dependency {
-  @Inject DependencyImpl() {}
+  @Inject
+  DependencyImpl() {}
 }
diff --git a/factory/src/it/functional/src/main/java/com/google/auto/factory/GenericFoo.java b/factory/src/it/functional/src/main/java/com/google/auto/factory/GenericFoo.java
index f7c13b41..31954a19 100644
--- a/factory/src/it/functional/src/main/java/com/google/auto/factory/GenericFoo.java
+++ b/factory/src/it/functional/src/main/java/com/google/auto/factory/GenericFoo.java
@@ -28,10 +28,7 @@ public class GenericFoo<A, B extends List<? extends A>, C, E extends Enum<E>> {
   private final E depE;
 
   <D extends IntAccessor & StringAccessor> GenericFoo(
-      @Provided Provider<A> depA,
-      B depB,
-      D depD,
-      E depE) {
+      @Provided Provider<A> depA, B depB, D depD, E depE) {
     this.depA = depA.get();
     this.depB = depB;
     this.depDIntAccessor = depD;
diff --git a/factory/src/it/functional/src/main/java/com/google/auto/factory/GuiceModule.java b/factory/src/it/functional/src/main/java/com/google/auto/factory/GuiceModule.java
index 45d4d26e..77346655 100644
--- a/factory/src/it/functional/src/main/java/com/google/auto/factory/GuiceModule.java
+++ b/factory/src/it/functional/src/main/java/com/google/auto/factory/GuiceModule.java
@@ -18,7 +18,8 @@ package com.google.auto.factory;
 import com.google.inject.AbstractModule;
 
 public class GuiceModule extends AbstractModule {
-  @Override protected void configure() {
+  @Override
+  protected void configure() {
     bind(Dependency.class).to(DependencyImpl.class);
     bind(Dependency.class).annotatedWith(Qualifier.class).to(QualifiedDependencyImpl.class);
     bind(Integer.class).toInstance(1);
diff --git a/factory/src/it/functional/src/main/java/com/google/auto/factory/ReferencePackage.java b/factory/src/it/functional/src/main/java/com/google/auto/factory/ReferencePackage.java
index 22aff651..338d4501 100755
--- a/factory/src/it/functional/src/main/java/com/google/auto/factory/ReferencePackage.java
+++ b/factory/src/it/functional/src/main/java/com/google/auto/factory/ReferencePackage.java
@@ -25,9 +25,7 @@ public class ReferencePackage {
   private final int random;
 
   @Inject
-  public ReferencePackage(
-      @Provided OtherPackageFactory otherPackageFactory,
-      int random) {
+  public ReferencePackage(@Provided OtherPackageFactory otherPackageFactory, int random) {
     this.otherPackageFactory = otherPackageFactory;
     this.random = random;
   }
diff --git a/factory/src/it/functional/src/test/java/com/google/auto/factory/DependencyInjectionIntegrationTest.java b/factory/src/it/functional/src/test/java/com/google/auto/factory/DependencyInjectionIntegrationTest.java
index e1412117..3caa5a54 100644
--- a/factory/src/it/functional/src/test/java/com/google/auto/factory/DependencyInjectionIntegrationTest.java
+++ b/factory/src/it/functional/src/test/java/com/google/auto/factory/DependencyInjectionIntegrationTest.java
@@ -19,7 +19,8 @@ public class DependencyInjectionIntegrationTest {
 
   private static final IntAndStringAccessor INT_AND_STRING_ACCESSOR = new IntAndStringAccessor() {};
 
-  @Test public void daggerInjectedFactory() {
+  @Test
+  public void daggerInjectedFactory() {
     FooFactory fooFactory = DaggerFactoryComponent.create().factory();
     Foo one = fooFactory.create("A");
     Foo two = fooFactory.create("B");
@@ -46,8 +47,9 @@ public class DependencyInjectionIntegrationTest {
         genericFooFactory.create(ImmutableList.of(3L), INT_AND_STRING_ACCESSOR, DepE.VALUE_1);
     ArrayList<Double> intAndStringAccessorArrayList = new ArrayList<>();
     intAndStringAccessorArrayList.add(4.0);
-    GenericFoo<Number, ArrayList<Double>, Long, DepE> four = genericFooFactory.create(
-        intAndStringAccessorArrayList, INT_AND_STRING_ACCESSOR, DepE.VALUE_2);
+    GenericFoo<Number, ArrayList<Double>, Long, DepE> four =
+        genericFooFactory.create(
+            intAndStringAccessorArrayList, INT_AND_STRING_ACCESSOR, DepE.VALUE_2);
     assertThat(three.getDepA()).isEqualTo(3);
     ImmutableList<Long> unusedLongList = three.getDepB();
     assertThat(three.getDepB()).containsExactly(3L);
@@ -75,7 +77,8 @@ public class DependencyInjectionIntegrationTest {
     assertThat(otherPackage.random()).isEqualTo(5);
   }
 
-  @Test public void guiceInjectedFactory() {
+  @Test
+  public void guiceInjectedFactory() {
     FooFactory fooFactory = Guice.createInjector(new GuiceModule()).getInstance(FooFactory.class);
     Foo one = fooFactory.create("A");
     Foo two = fooFactory.create("B");
@@ -103,8 +106,9 @@ public class DependencyInjectionIntegrationTest {
         genericFooFactory.create(ImmutableList.of(3L), INT_AND_STRING_ACCESSOR, DepE.VALUE_1);
     ArrayList<Double> intAndStringAccessorArrayList = new ArrayList<>();
     intAndStringAccessorArrayList.add(4.0);
-    GenericFoo<Number, ArrayList<Double>, Long, DepE> four = genericFooFactory.create(
-        intAndStringAccessorArrayList, INT_AND_STRING_ACCESSOR, DepE.VALUE_2);
+    GenericFoo<Number, ArrayList<Double>, Long, DepE> four =
+        genericFooFactory.create(
+            intAndStringAccessorArrayList, INT_AND_STRING_ACCESSOR, DepE.VALUE_2);
     assertThat(three.getDepA()).isEqualTo(3);
     ImmutableList<Long> unusedLongList = three.getDepB();
     assertThat(three.getDepB()).containsExactly(3L);
@@ -124,8 +128,7 @@ public class DependencyInjectionIntegrationTest {
   @Test
   public void guiceInjectedPackageSpanningFactory() {
     ReferencePackageFactory referencePackageFactory =
-        Guice.createInjector(new GuiceModule())
-            .getInstance(ReferencePackageFactory.class);
+        Guice.createInjector(new GuiceModule()).getInstance(ReferencePackageFactory.class);
     ReferencePackage referencePackage = referencePackageFactory.create(5);
     OtherPackage otherPackage = referencePackage.otherPackage();
     assertThat(otherPackage.referencePackageFactory()).isNotSameInstanceAs(referencePackageFactory);
diff --git a/factory/src/main/java/com/google/auto/factory/AutoFactory.java b/factory/src/main/java/com/google/auto/factory/AutoFactory.java
index 2ef84cc3..3b5d90ea 100644
--- a/factory/src/main/java/com/google/auto/factory/AutoFactory.java
+++ b/factory/src/main/java/com/google/auto/factory/AutoFactory.java
@@ -32,7 +32,7 @@ import java.lang.annotation.Target;
  *
  * @author Gregory Kick
  */
-@Target({ TYPE, CONSTRUCTOR })
+@Target({TYPE, CONSTRUCTOR})
 public @interface AutoFactory {
   /**
    * The <i>simple</i> name of the generated factory; the factory is always generated in the same
@@ -50,7 +50,7 @@ public @interface AutoFactory {
   /**
    * A list of interfaces that the generated factory is required to implement.
    */
-  Class<?>[] implementing() default { };
+  Class<?>[] implementing() default {};
 
   /**
    * The type that the generated factory is require to extend.
diff --git a/factory/src/main/java/com/google/auto/factory/Provided.java b/factory/src/main/java/com/google/auto/factory/Provided.java
index e81e4aa6..226a16f4 100644
--- a/factory/src/main/java/com/google/auto/factory/Provided.java
+++ b/factory/src/main/java/com/google/auto/factory/Provided.java
@@ -26,4 +26,4 @@ import java.lang.annotation.Target;
  * @author Gregory Kick
  */
 @Target(PARAMETER)
-public @interface Provided { }
+public @interface Provided {}
diff --git a/factory/src/main/java/com/google/auto/factory/processor/AnnotationValues.java b/factory/src/main/java/com/google/auto/factory/processor/AnnotationValues.java
index b767c47f..53d38a40 100644
--- a/factory/src/main/java/com/google/auto/factory/processor/AnnotationValues.java
+++ b/factory/src/main/java/com/google/auto/factory/processor/AnnotationValues.java
@@ -32,24 +32,29 @@ final class AnnotationValues {
   static boolean asBoolean(AnnotationValue value) {
     return value.accept(
         new SimpleAnnotationValueVisitor6<Boolean, Void>() {
-          @Override protected Boolean defaultAction(Object o, Void p) {
+          @Override
+          protected Boolean defaultAction(Object o, Void p) {
             throw new IllegalArgumentException();
           }
 
-          @Override public Boolean visitBoolean(boolean b, Void p) {
+          @Override
+          public Boolean visitBoolean(boolean b, Void p) {
             return b;
           }
-        }, null);
+        },
+        null);
   }
 
   static TypeElement asType(AnnotationValue value) {
     return value.accept(
         new SimpleAnnotationValueVisitor6<TypeElement, Void>() {
-          @Override protected TypeElement defaultAction(Object o, Void p) {
+          @Override
+          protected TypeElement defaultAction(Object o, Void p) {
             throw new IllegalArgumentException();
           }
 
-          @Override public TypeElement visitType(TypeMirror t, Void p) {
+          @Override
+          public TypeElement visitType(TypeMirror t, Void p) {
             return t.accept(
                 new SimpleTypeVisitor6<TypeElement, Void>() {
                   @Override
@@ -59,12 +64,14 @@ final class AnnotationValues {
 
                   @Override
                   public TypeElement visitDeclared(DeclaredType t, Void p) {
-                    return Iterables.getOnlyElement(ElementFilter.typesIn(
-                        ImmutableList.of(t.asElement())));
+                    return Iterables.getOnlyElement(
+                        ElementFilter.typesIn(ImmutableList.of(t.asElement())));
                   }
-                }, null);
+                },
+                null);
           }
-        }, null);
+        },
+        null);
   }
 
   static ImmutableList<? extends AnnotationValue> asList(AnnotationValue value) {
@@ -80,6 +87,7 @@ final class AnnotationValues {
               List<? extends AnnotationValue> vals, Void p) {
             return ImmutableList.copyOf(vals);
           }
-        }, null);
+        },
+        null);
   }
 }
diff --git a/factory/src/main/java/com/google/auto/factory/processor/AutoFactoryDeclaration.java b/factory/src/main/java/com/google/auto/factory/processor/AutoFactoryDeclaration.java
index ec3642a9..0769b4f0 100644
--- a/factory/src/main/java/com/google/auto/factory/processor/AutoFactoryDeclaration.java
+++ b/factory/src/main/java/com/google/auto/factory/processor/AutoFactoryDeclaration.java
@@ -54,12 +54,19 @@ import javax.lang.model.util.Elements;
 @AutoValue
 abstract class AutoFactoryDeclaration {
   abstract TypeElement targetType();
+
   abstract Element target();
+
   abstract Optional<String> className();
+
   abstract TypeElement extendingType();
+
   abstract ImmutableSet<TypeElement> implementingTypes();
+
   abstract boolean allowSubclasses();
+
   abstract AnnotationMirror mirror();
+
   abstract ImmutableMap<String, AnnotationValue> valuesMap();
 
   PackageAndClass getFactoryName() {
@@ -97,8 +104,9 @@ abstract class AutoFactoryDeclaration {
     Optional<AutoFactoryDeclaration> createIfValid(Element element) {
       checkNotNull(element);
       AnnotationMirror mirror = Mirrors.getAnnotationMirror(element, AutoFactory.class).get();
-      checkArgument(Mirrors.getQualifiedName(mirror.getAnnotationType()).
-          contentEquals(AutoFactory.class.getName()));
+      checkArgument(
+          Mirrors.getQualifiedName(mirror.getAnnotationType())
+              .contentEquals(AutoFactory.class.getName()));
       Map<String, AnnotationValue> values =
           Mirrors.simplifyAnnotationValueMap(elements.getElementValuesWithDefaults(mirror));
       checkState(values.size() == 4);
@@ -107,40 +115,57 @@ abstract class AutoFactoryDeclaration {
       AnnotationValue classNameValue = values.get("className");
       String className = classNameValue.getValue().toString();
       if (!className.isEmpty() && !isValidIdentifier(className)) {
-        messager.printMessage(ERROR,
+        messager.printMessage(
+            ERROR,
             String.format("\"%s\" is not a valid Java identifier", className),
-            element, mirror, classNameValue);
+            element,
+            mirror,
+            classNameValue);
         return Optional.empty();
       }
 
       AnnotationValue extendingValue = checkNotNull(values.get("extending"));
       TypeElement extendingType = AnnotationValues.asType(extendingValue);
       if (extendingType == null) {
-        messager.printMessage(ERROR, "Unable to find the type: " + extendingValue.getValue(),
-                element, mirror, extendingValue);
+        messager.printMessage(
+            ERROR,
+            "Unable to find the type: " + extendingValue.getValue(),
+            element,
+            mirror,
+            extendingValue);
         return Optional.empty();
       } else if (!isValidSupertypeForClass(extendingType)) {
-        messager.printMessage(ERROR,
-            String.format("%s is not a valid supertype for a factory. "
-                + "Supertypes must be non-final classes.",
-                    extendingType.getQualifiedName()),
-            element, mirror, extendingValue);
+        messager.printMessage(
+            ERROR,
+            String.format(
+                "%s is not a valid supertype for a factory. "
+                    + "Supertypes must be non-final classes.",
+                extendingType.getQualifiedName()),
+            element,
+            mirror,
+            extendingValue);
         return Optional.empty();
       }
       ImmutableList<ExecutableElement> noParameterConstructors =
           FluentIterable.from(ElementFilter.constructorsIn(extendingType.getEnclosedElements()))
-              .filter(new Predicate<ExecutableElement>() {
-                @Override public boolean apply(ExecutableElement constructor) {
-                  return constructor.getParameters().isEmpty();
-                }
-              })
+              .filter(
+                  new Predicate<ExecutableElement>() {
+                    @Override
+                    public boolean apply(ExecutableElement constructor) {
+                      return constructor.getParameters().isEmpty();
+                    }
+                  })
               .toList();
       if (noParameterConstructors.isEmpty()) {
-        messager.printMessage(ERROR,
-            String.format("%s is not a valid supertype for a factory. "
-                + "Factory supertypes must have a no-arg constructor.",
-                    extendingType.getQualifiedName()),
-            element, mirror, extendingValue);
+        messager.printMessage(
+            ERROR,
+            String.format(
+                "%s is not a valid supertype for a factory. "
+                    + "Factory supertypes must have a no-arg constructor.",
+                extendingType.getQualifiedName()),
+            element,
+            mirror,
+            extendingValue);
         return Optional.empty();
       } else if (noParameterConstructors.size() > 1) {
         throw new IllegalStateException("Multiple constructors with no parameters??");
diff --git a/factory/src/main/java/com/google/auto/factory/processor/AutoFactoryProcessor.java b/factory/src/main/java/com/google/auto/factory/processor/AutoFactoryProcessor.java
index 91ad9462..bfe795a2 100644
--- a/factory/src/main/java/com/google/auto/factory/processor/AutoFactoryProcessor.java
+++ b/factory/src/main/java/com/google/auto/factory/processor/AutoFactoryProcessor.java
@@ -83,8 +83,9 @@ public final class AutoFactoryProcessor extends AbstractProcessor {
     try {
       doProcess(roundEnv);
     } catch (Throwable e) {
-      messager.printMessage(Kind.ERROR, "Failed to process @AutoFactory annotations:\n"
-          + Throwables.getStackTraceAsString(e));
+      messager.printMessage(
+          Kind.ERROR,
+          "Failed to process @AutoFactory annotations:\n" + Throwables.getStackTraceAsString(e));
     }
     return false;
   }
@@ -127,49 +128,53 @@ public final class AutoFactoryProcessor extends AbstractProcessor {
         simpleNamesToNames(indexedMethods.keySet());
     FactoryWriter factoryWriter = new FactoryWriter(processingEnv, factoriesBeingCreated);
 
-    indexedMethods.asMap().forEach(
-        (factoryName, methodDescriptors) -> {
-          // The sets of classes that are mentioned in the `extending` and `implementing` elements,
-          // respectively, of the @AutoFactory annotations for this factory.
-          ImmutableSet.Builder<TypeMirror> extending = newTypeSetBuilder();
-          ImmutableSortedSet.Builder<TypeMirror> implementing = newTypeSetBuilder();
-          boolean publicType = false;
-          Boolean allowSubclasses = null;
-          boolean skipCreation = false;
-          for (FactoryMethodDescriptor methodDescriptor : methodDescriptors) {
-            extending.add(methodDescriptor.declaration().extendingType().asType());
-            for (TypeElement implementingType :
-                methodDescriptor.declaration().implementingTypes()) {
-              implementing.add(implementingType.asType());
-            }
-            publicType |= methodDescriptor.publicMethod();
-            if (allowSubclasses == null) {
-              allowSubclasses = methodDescriptor.declaration().allowSubclasses();
-            } else if (!allowSubclasses.equals(methodDescriptor.declaration().allowSubclasses())) {
-              skipCreation = true;
-              messager.printMessage(Kind.ERROR,
-                  "Cannot mix allowSubclasses=true and allowSubclasses=false in one factory.",
-                  methodDescriptor.declaration().target(),
-                  methodDescriptor.declaration().mirror(),
-                  methodDescriptor.declaration().valuesMap().get("allowSubclasses"));
-            }
-          }
-          if (!skipCreation) {
-            try {
-              factoryWriter.writeFactory(
-                  FactoryDescriptor.create(
-                      factoryName,
-                      Iterables.getOnlyElement(extending.build()),
-                      implementing.build(),
-                      publicType,
-                      ImmutableSet.copyOf(methodDescriptors),
-                      implementationMethodDescriptors.get(factoryName),
-                      allowSubclasses));
-            } catch (IOException e) {
-              messager.printMessage(Kind.ERROR, "failed: " + e);
-            }
-          }
-        });
+    indexedMethods
+        .asMap()
+        .forEach(
+            (factoryName, methodDescriptors) -> {
+              // The sets of classes that are mentioned in the `extending` and `implementing`
+              // elements, respectively, of the @AutoFactory annotations for this factory.
+              ImmutableSet.Builder<TypeMirror> extending = newTypeSetBuilder();
+              ImmutableSortedSet.Builder<TypeMirror> implementing = newTypeSetBuilder();
+              boolean publicType = false;
+              Boolean allowSubclasses = null;
+              boolean skipCreation = false;
+              for (FactoryMethodDescriptor methodDescriptor : methodDescriptors) {
+                extending.add(methodDescriptor.declaration().extendingType().asType());
+                for (TypeElement implementingType :
+                    methodDescriptor.declaration().implementingTypes()) {
+                  implementing.add(implementingType.asType());
+                }
+                publicType |= methodDescriptor.publicMethod();
+                if (allowSubclasses == null) {
+                  allowSubclasses = methodDescriptor.declaration().allowSubclasses();
+                } else if (!allowSubclasses.equals(
+                    methodDescriptor.declaration().allowSubclasses())) {
+                  skipCreation = true;
+                  messager.printMessage(
+                      Kind.ERROR,
+                      "Cannot mix allowSubclasses=true and allowSubclasses=false in one factory.",
+                      methodDescriptor.declaration().target(),
+                      methodDescriptor.declaration().mirror(),
+                      methodDescriptor.declaration().valuesMap().get("allowSubclasses"));
+                }
+              }
+              if (!skipCreation) {
+                try {
+                  factoryWriter.writeFactory(
+                      FactoryDescriptor.create(
+                          factoryName,
+                          Iterables.getOnlyElement(extending.build()),
+                          implementing.build(),
+                          publicType,
+                          ImmutableSet.copyOf(methodDescriptors),
+                          implementationMethodDescriptors.get(factoryName),
+                          allowSubclasses));
+                } catch (IOException e) {
+                  messager.printMessage(Kind.ERROR, "failed: " + e);
+                }
+              }
+            });
   }
 
   private ImmutableSet<ImplementationMethodDescriptor> implementationMethods(
@@ -180,8 +185,7 @@ public final class AutoFactoryProcessor extends AbstractProcessor {
         ElementFilter.methodsIn(elements.getAllMembers(supertype))) {
       if (implementationMethod.getModifiers().contains(Modifier.ABSTRACT)) {
         ExecutableType methodType =
-            Elements2.getExecutableElementAsMemberOf(
-                types, implementationMethod, supertype);
+            Elements2.getExecutableElementAsMemberOf(types, implementationMethod, supertype);
         ImmutableSet<Parameter> passedParameters =
             Parameter.forParameterList(
                 implementationMethod.getParameters(), methodType.getParameterTypes(), types);
diff --git a/factory/src/main/java/com/google/auto/factory/processor/Elements2.java b/factory/src/main/java/com/google/auto/factory/processor/Elements2.java
index fa00454e..3663f370 100644
--- a/factory/src/main/java/com/google/auto/factory/processor/Elements2.java
+++ b/factory/src/main/java/com/google/auto/factory/processor/Elements2.java
@@ -33,7 +33,7 @@ import javax.lang.model.util.ElementFilter;
 import javax.lang.model.util.Types;
 
 final class Elements2 {
-  private Elements2() { }
+  private Elements2() {}
 
   static ImmutableSet<ExecutableElement> getConstructors(TypeElement type) {
     checkNotNull(type);
diff --git a/factory/src/main/java/com/google/auto/factory/processor/FactoryDescriptor.java b/factory/src/main/java/com/google/auto/factory/processor/FactoryDescriptor.java
index 670d8fba..1a180caf 100644
--- a/factory/src/main/java/com/google/auto/factory/processor/FactoryDescriptor.java
+++ b/factory/src/main/java/com/google/auto/factory/processor/FactoryDescriptor.java
@@ -46,12 +46,19 @@ abstract class FactoryDescriptor {
       };
 
   abstract PackageAndClass name();
+
   abstract TypeMirror extendingType();
+
   abstract ImmutableSet<TypeMirror> implementingTypes();
+
   abstract boolean publicType();
+
   abstract ImmutableSet<FactoryMethodDescriptor> methodDescriptors();
+
   abstract ImmutableSet<ImplementationMethodDescriptor> implementationMethodDescriptors();
+
   abstract boolean allowSubclasses();
+
   abstract ImmutableMap<Key, ProviderField> providers();
 
   final AutoFactoryDeclaration declaration() {
@@ -216,8 +223,7 @@ abstract class FactoryDescriptor {
    * in the same order.
    */
   private static boolean areDuplicateMethodDescriptors(
-      FactoryMethodDescriptor factory,
-      ImplementationMethodDescriptor implementation) {
+      FactoryMethodDescriptor factory, ImplementationMethodDescriptor implementation) {
 
     if (!factory.name().equals(implementation.name())) {
       return false;
diff --git a/factory/src/main/java/com/google/auto/factory/processor/FactoryDescriptorGenerator.java b/factory/src/main/java/com/google/auto/factory/processor/FactoryDescriptorGenerator.java
index 0816aef4..dea42edc 100644
--- a/factory/src/main/java/com/google/auto/factory/processor/FactoryDescriptorGenerator.java
+++ b/factory/src/main/java/com/google/auto/factory/processor/FactoryDescriptorGenerator.java
@@ -53,9 +53,7 @@ final class FactoryDescriptorGenerator {
   private final AutoFactoryDeclaration.Factory declarationFactory;
 
   FactoryDescriptorGenerator(
-      Messager messager,
-      Types types,
-      AutoFactoryDeclaration.Factory declarationFactory) {
+      Messager messager, Types types, AutoFactoryDeclaration.Factory declarationFactory) {
     this.messager = messager;
     this.types = types;
     this.declarationFactory = declarationFactory;
@@ -67,55 +65,63 @@ final class FactoryDescriptorGenerator {
     if (!declaration.isPresent()) {
       return ImmutableSet.of();
     }
-    return element.accept(new ElementKindVisitor6<ImmutableSet<FactoryMethodDescriptor>, Void>() {
-      @Override
-      protected ImmutableSet<FactoryMethodDescriptor> defaultAction(Element e, Void p) {
-        throw new AssertionError("@AutoFactory applied to an impossible element");
-      }
+    return element.accept(
+        new ElementKindVisitor6<ImmutableSet<FactoryMethodDescriptor>, Void>() {
+          @Override
+          protected ImmutableSet<FactoryMethodDescriptor> defaultAction(Element e, Void p) {
+            throw new AssertionError("@AutoFactory applied to an impossible element");
+          }
 
-      @Override
-      public ImmutableSet<FactoryMethodDescriptor> visitTypeAsClass(TypeElement type, Void p) {
-        if (type.getModifiers().contains(ABSTRACT)) {
-          // applied to an abstract factory
-          messager.printMessage(ERROR,
-              "Auto-factory doesn't support being applied to abstract classes.", type, mirror);
-          return ImmutableSet.of();
-        } else {
-          // applied to the type to be created
-          ImmutableSet<ExecutableElement> constructors = Elements2.getConstructors(type);
-          if (constructors.isEmpty()) {
-            return generateDescriptorForDefaultConstructor(declaration.get(), type);
-          } else {
-            return FluentIterable.from(constructors)
-                .transform(new Function<ExecutableElement, FactoryMethodDescriptor>() {
-                  @Override public FactoryMethodDescriptor apply(ExecutableElement constructor) {
-                    return generateDescriptorForConstructor(declaration.get(), constructor);
-                  }
-                })
-                .toSet();
+          @Override
+          public ImmutableSet<FactoryMethodDescriptor> visitTypeAsClass(TypeElement type, Void p) {
+            if (type.getModifiers().contains(ABSTRACT)) {
+              // applied to an abstract factory
+              messager.printMessage(
+                  ERROR,
+                  "Auto-factory doesn't support being applied to abstract classes.",
+                  type,
+                  mirror);
+              return ImmutableSet.of();
+            } else {
+              // applied to the type to be created
+              ImmutableSet<ExecutableElement> constructors = Elements2.getConstructors(type);
+              if (constructors.isEmpty()) {
+                return generateDescriptorForDefaultConstructor(declaration.get(), type);
+              } else {
+                return FluentIterable.from(constructors)
+                    .transform(
+                        new Function<ExecutableElement, FactoryMethodDescriptor>() {
+                          @Override
+                          public FactoryMethodDescriptor apply(ExecutableElement constructor) {
+                            return generateDescriptorForConstructor(declaration.get(), constructor);
+                          }
+                        })
+                    .toSet();
+              }
+            }
           }
-        }
-      }
 
-      @Override
-      public ImmutableSet<FactoryMethodDescriptor> visitTypeAsInterface(TypeElement type, Void p) {
-        // applied to the factory interface
-        messager.printMessage(ERROR,
-            "Auto-factory doesn't support being applied to interfaces.", type, mirror);
-        return ImmutableSet.of();
-      }
+          @Override
+          public ImmutableSet<FactoryMethodDescriptor> visitTypeAsInterface(
+              TypeElement type, Void p) {
+            // applied to the factory interface
+            messager.printMessage(
+                ERROR, "Auto-factory doesn't support being applied to interfaces.", type, mirror);
+            return ImmutableSet.of();
+          }
 
-      @Override
-      public ImmutableSet<FactoryMethodDescriptor> visitExecutableAsConstructor(
-          ExecutableElement e, Void p) {
-        // applied to a constructor of a type to be created
-        return ImmutableSet.of(generateDescriptorForConstructor(declaration.get(), e));
-      }
-    }, null);
+          @Override
+          public ImmutableSet<FactoryMethodDescriptor> visitExecutableAsConstructor(
+              ExecutableElement e, Void p) {
+            // applied to a constructor of a type to be created
+            return ImmutableSet.of(generateDescriptorForConstructor(declaration.get(), e));
+          }
+        },
+        null);
   }
 
-  FactoryMethodDescriptor generateDescriptorForConstructor(final AutoFactoryDeclaration declaration,
-      ExecutableElement constructor) {
+  FactoryMethodDescriptor generateDescriptorForConstructor(
+      final AutoFactoryDeclaration declaration, ExecutableElement constructor) {
     checkNotNull(constructor);
     checkArgument(constructor.getKind() == ElementKind.CONSTRUCTOR);
     TypeElement classElement = MoreElements.asType(constructor.getEnclosingElement());
diff --git a/factory/src/main/java/com/google/auto/factory/processor/FactoryMethodDescriptor.java b/factory/src/main/java/com/google/auto/factory/processor/FactoryMethodDescriptor.java
index 5f4ad294..45259573 100644
--- a/factory/src/main/java/com/google/auto/factory/processor/FactoryMethodDescriptor.java
+++ b/factory/src/main/java/com/google/auto/factory/processor/FactoryMethodDescriptor.java
@@ -31,15 +31,25 @@ import javax.lang.model.type.TypeMirror;
 @AutoValue
 abstract class FactoryMethodDescriptor {
   abstract AutoFactoryDeclaration declaration();
+
   abstract String name();
+
   abstract TypeMirror returnType();
+
   abstract boolean publicMethod();
+
   abstract boolean overridingMethod();
+
   abstract ImmutableSet<Parameter> passedParameters();
+
   abstract ImmutableSet<Parameter> providedParameters();
+
   abstract ImmutableSet<Parameter> creationParameters();
+
   abstract boolean isVarArgs();
+
   abstract ImmutableSet<TypeMirror> exceptions();
+
   abstract Builder toBuilder();
 
   final PackageAndClass factoryName() {
@@ -47,28 +57,39 @@ abstract class FactoryMethodDescriptor {
   }
 
   static Builder builder(AutoFactoryDeclaration declaration) {
-    return new AutoValue_FactoryMethodDescriptor.Builder()
-        .declaration(checkNotNull(declaration));
+    return new AutoValue_FactoryMethodDescriptor.Builder().declaration(checkNotNull(declaration));
   }
 
   @AutoValue.Builder
   abstract static class Builder {
     abstract Builder declaration(AutoFactoryDeclaration declaration);
+
     abstract Builder name(String name);
+
     abstract Builder returnType(TypeMirror returnType);
+
     abstract Builder publicMethod(boolean publicMethod);
+
     abstract Builder overridingMethod(boolean overridingMethod);
+
     abstract Builder passedParameters(Iterable<Parameter> passedParameters);
+
     abstract Builder providedParameters(Iterable<Parameter> providedParameters);
+
     abstract Builder creationParameters(Iterable<Parameter> creationParameters);
+
     abstract Builder isVarArgs(boolean isVarargs);
+
     abstract Builder exceptions(Iterable<? extends TypeMirror> exceptions);
+
     abstract FactoryMethodDescriptor buildImpl();
 
     FactoryMethodDescriptor build() {
       FactoryMethodDescriptor descriptor = buildImpl();
-      checkState(descriptor.creationParameters().equals(
-          Sets.union(descriptor.passedParameters(), descriptor.providedParameters())));
+      checkState(
+          descriptor
+              .creationParameters()
+              .equals(Sets.union(descriptor.passedParameters(), descriptor.providedParameters())));
       return descriptor;
     }
   }
diff --git a/factory/src/main/java/com/google/auto/factory/processor/FactoryWriter.java b/factory/src/main/java/com/google/auto/factory/processor/FactoryWriter.java
index 32373915..512f85ac 100644
--- a/factory/src/main/java/com/google/auto/factory/processor/FactoryWriter.java
+++ b/factory/src/main/java/com/google/auto/factory/processor/FactoryWriter.java
@@ -79,12 +79,10 @@ final class FactoryWriter {
     this.factoriesBeingCreated = factoriesBeingCreated;
   }
 
-  void writeFactory(FactoryDescriptor descriptor)
-      throws IOException {
+  void writeFactory(FactoryDescriptor descriptor) throws IOException {
     String factoryName = descriptor.name().className();
     TypeSpec.Builder factory =
-        classBuilder(factoryName)
-            .addOriginatingElement(descriptor.declaration().targetType());
+        classBuilder(factoryName).addOriginatingElement(descriptor.declaration().targetType());
     generatedAnnotationSpec(
             elements,
             sourceVersion,
@@ -198,8 +196,7 @@ final class FactoryWriter {
     }
   }
 
-  private void addImplementationMethods(
-      TypeSpec.Builder factory, FactoryDescriptor descriptor) {
+  private void addImplementationMethods(TypeSpec.Builder factory, FactoryDescriptor descriptor) {
     for (ImplementationMethodDescriptor methodDescriptor :
         descriptor.implementationMethodDescriptors()) {
       MethodSpec.Builder implementationMethod =
@@ -237,9 +234,7 @@ final class FactoryWriter {
               .map(AnnotationSpec::get)
               .collect(toList());
       ParameterSpec parameterSpec =
-          ParameterSpec.builder(type, parameter.name())
-              .addAnnotations(annotations)
-              .build();
+          ParameterSpec.builder(type, parameter.name()).addAnnotations(annotations).build();
       builder.add(parameterSpec);
     }
     return builder.build();
diff --git a/factory/src/main/java/com/google/auto/factory/processor/ImplementationMethodDescriptor.java b/factory/src/main/java/com/google/auto/factory/processor/ImplementationMethodDescriptor.java
index b5faa272..b2705b7e 100644
--- a/factory/src/main/java/com/google/auto/factory/processor/ImplementationMethodDescriptor.java
+++ b/factory/src/main/java/com/google/auto/factory/processor/ImplementationMethodDescriptor.java
@@ -22,10 +22,15 @@ import javax.lang.model.type.TypeMirror;
 @AutoValue
 abstract class ImplementationMethodDescriptor {
   abstract String name();
+
   abstract TypeMirror returnType();
+
   abstract boolean publicMethod();
+
   abstract ImmutableSet<Parameter> passedParameters();
+
   abstract boolean isVarArgs();
+
   abstract ImmutableSet<TypeMirror> exceptions();
 
   static Builder builder() {
diff --git a/factory/src/main/java/com/google/auto/factory/processor/Key.java b/factory/src/main/java/com/google/auto/factory/processor/Key.java
index 12cfd927..728149eb 100644
--- a/factory/src/main/java/com/google/auto/factory/processor/Key.java
+++ b/factory/src/main/java/com/google/auto/factory/processor/Key.java
@@ -68,8 +68,10 @@ abstract class Key {
     // TODO(gak): check for only one qualifier rather than using the first
     Optional<AnnotationMirror> qualifier =
         annotations.stream()
-            .filter(annotation ->
-                isAnnotationPresent(annotation.getAnnotationType().asElement(), Qualifier.class))
+            .filter(
+                annotation ->
+                    isAnnotationPresent(
+                        annotation.getAnnotationType().asElement(), Qualifier.class))
             .findFirst();
 
     TypeMirror keyType =
diff --git a/factory/src/main/java/com/google/auto/factory/processor/Mirrors.java b/factory/src/main/java/com/google/auto/factory/processor/Mirrors.java
index 9e111875..313fc9ee 100644
--- a/factory/src/main/java/com/google/auto/factory/processor/Mirrors.java
+++ b/factory/src/main/java/com/google/auto/factory/processor/Mirrors.java
@@ -34,20 +34,23 @@ import javax.lang.model.type.TypeMirror;
 import javax.lang.model.util.SimpleElementVisitor6;
 
 final class Mirrors {
-  private Mirrors() { }
+  private Mirrors() {}
 
   static Name getQualifiedName(DeclaredType type) {
-    return type.asElement().accept(new SimpleElementVisitor6<Name, Void>() {
-      @Override
-      protected Name defaultAction(Element e, Void p) {
-        throw new AssertionError("DeclaredTypes should be TypeElements");
-      }
+    return type.asElement()
+        .accept(
+            new SimpleElementVisitor6<Name, Void>() {
+              @Override
+              protected Name defaultAction(Element e, Void p) {
+                throw new AssertionError("DeclaredTypes should be TypeElements");
+              }
 
-      @Override
-      public Name visitType(TypeElement e, Void p) {
-        return e.getQualifiedName();
-      }
-    }, null);
+              @Override
+              public Name visitType(TypeElement e, Void p) {
+                return e.getQualifiedName();
+              }
+            },
+            null);
   }
 
   /** {@code true} if {@code type} is a {@link Provider}. */
@@ -62,8 +65,8 @@ final class Mirrors {
   static ImmutableMap<String, AnnotationValue> simplifyAnnotationValueMap(
       Map<? extends ExecutableElement, ? extends AnnotationValue> annotationValueMap) {
     ImmutableMap.Builder<String, AnnotationValue> builder = ImmutableMap.builder();
-    for (Entry<? extends ExecutableElement, ? extends AnnotationValue> entry
-        : annotationValueMap.entrySet()) {
+    for (Entry<? extends ExecutableElement, ? extends AnnotationValue> entry :
+        annotationValueMap.entrySet()) {
       builder.put(entry.getKey().getSimpleName().toString(), entry.getValue());
     }
     return builder.build();
@@ -73,12 +76,11 @@ final class Mirrors {
    * Get the {@link AnnotationMirror} for the type {@code annotationType} present on the given
    * {@link Element} if it exists.
    */
-  static Optional<AnnotationMirror> getAnnotationMirror(Element element,
-      Class<? extends Annotation> annotationType) {
+  static Optional<AnnotationMirror> getAnnotationMirror(
+      Element element, Class<? extends Annotation> annotationType) {
     String annotationName = annotationType.getName();
     return element.getAnnotationMirrors().stream()
-        .filter(
-            a -> getQualifiedName(a.getAnnotationType()).contentEquals(annotationName))
+        .filter(a -> getQualifiedName(a.getAnnotationType()).contentEquals(annotationName))
         .<AnnotationMirror>map(x -> x) // get rid of wildcard <? extends AnnotationMirror>
         .findFirst();
   }
diff --git a/factory/src/main/java/com/google/auto/factory/processor/Parameter.java b/factory/src/main/java/com/google/auto/factory/processor/Parameter.java
index 57660e0d..5fbb15b0 100644
--- a/factory/src/main/java/com/google/auto/factory/processor/Parameter.java
+++ b/factory/src/main/java/com/google/auto/factory/processor/Parameter.java
@@ -64,6 +64,7 @@ abstract class Parameter {
   abstract String name();
 
   abstract Key key();
+
   abstract Optional<Equivalence.Wrapper<AnnotationMirror>> nullableWrapper();
 
   Optional<AnnotationMirror> nullable() {
diff --git a/factory/src/main/java/com/google/auto/factory/processor/ProvidedChecker.java b/factory/src/main/java/com/google/auto/factory/processor/ProvidedChecker.java
index fe4c1fd2..57b38615 100644
--- a/factory/src/main/java/com/google/auto/factory/processor/ProvidedChecker.java
+++ b/factory/src/main/java/com/google/auto/factory/processor/ProvidedChecker.java
@@ -35,41 +35,53 @@ final class ProvidedChecker {
   }
 
   void checkProvidedParameter(Element element) {
-    checkArgument(isAnnotationPresent(element, Provided.class), "%s not annoated with @Provided",
-        element);
-    element.accept(new ElementKindVisitor6<Void, Void>() {
-      @Override
-      protected Void defaultAction(Element e, Void p) {
-        throw new AssertionError("Provided can only be applied to parameters");
-      }
-
-      @Override
-      public Void visitVariableAsParameter(final VariableElement providedParameter, Void p) {
-        providedParameter.getEnclosingElement().accept(new ElementKindVisitor6<Void, Void>() {
+    checkArgument(
+        isAnnotationPresent(element, Provided.class), "%s not annoated with @Provided", element);
+    element.accept(
+        new ElementKindVisitor6<Void, Void>() {
           @Override
           protected Void defaultAction(Element e, Void p) {
-            raiseError(providedParameter, "@%s may only be applied to constructor parameters");
-            return null;
+            throw new AssertionError("Provided can only be applied to parameters");
           }
 
           @Override
-          public Void visitExecutableAsConstructor(ExecutableElement constructor, Void p) {
-            if (!(annotatedWithAutoFactory(constructor)
-                || annotatedWithAutoFactory(constructor.getEnclosingElement()))) {
-              raiseError(providedParameter,
-                  "@%s may only be applied to constructors requesting an auto-factory");
-            }
+          public Void visitVariableAsParameter(final VariableElement providedParameter, Void p) {
+            providedParameter
+                .getEnclosingElement()
+                .accept(
+                    new ElementKindVisitor6<Void, Void>() {
+                      @Override
+                      protected Void defaultAction(Element e, Void p) {
+                        raiseError(
+                            providedParameter, "@%s may only be applied to constructor parameters");
+                        return null;
+                      }
+
+                      @Override
+                      public Void visitExecutableAsConstructor(
+                          ExecutableElement constructor, Void p) {
+                        if (!(annotatedWithAutoFactory(constructor)
+                            || annotatedWithAutoFactory(constructor.getEnclosingElement()))) {
+                          raiseError(
+                              providedParameter,
+                              "@%s may only be applied to constructors requesting an auto-factory");
+                        }
+                        return null;
+                      }
+                    },
+                    p);
             return null;
           }
-        }, p);
-        return null;
-      }
-    }, null);
+        },
+        null);
   }
 
   private void raiseError(VariableElement providedParameter, String messageFormat) {
-    messager.printMessage(ERROR, String.format(messageFormat, Provided.class.getSimpleName()),
-        providedParameter, Mirrors.getAnnotationMirror(providedParameter, Provided.class).get());
+    messager.printMessage(
+        ERROR,
+        String.format(messageFormat, Provided.class.getSimpleName()),
+        providedParameter,
+        Mirrors.getAnnotationMirror(providedParameter, Provided.class).get());
   }
 
   private static boolean annotatedWithAutoFactory(Element e) {
diff --git a/factory/src/main/java/com/google/auto/factory/processor/ProviderField.java b/factory/src/main/java/com/google/auto/factory/processor/ProviderField.java
index f18def32..99847ec0 100644
--- a/factory/src/main/java/com/google/auto/factory/processor/ProviderField.java
+++ b/factory/src/main/java/com/google/auto/factory/processor/ProviderField.java
@@ -27,7 +27,9 @@ import javax.lang.model.element.AnnotationMirror;
 @AutoValue
 abstract class ProviderField {
   abstract String name();
+
   abstract Key key();
+
   abstract Optional<Equivalence.Wrapper<AnnotationMirror>> nullableWrapper();
 
   Optional<AnnotationMirror> nullable() {
diff --git a/factory/src/main/java/com/google/auto/factory/processor/TypeVariables.java b/factory/src/main/java/com/google/auto/factory/processor/TypeVariables.java
index 1f894732..4bd546e8 100644
--- a/factory/src/main/java/com/google/auto/factory/processor/TypeVariables.java
+++ b/factory/src/main/java/com/google/auto/factory/processor/TypeVariables.java
@@ -38,8 +38,8 @@ final class TypeVariables {
     return type.accept(ReferencedTypeVariables.INSTANCE, new HashSet<>());
   }
 
-  private static final class ReferencedTypeVariables extends
-      SimpleTypeVisitor8<ImmutableSet<TypeVariable>, Set<Element>> {
+  private static final class ReferencedTypeVariables
+      extends SimpleTypeVisitor8<ImmutableSet<TypeVariable>, Set<Element>> {
 
     private static final ReferencedTypeVariables INSTANCE = new ReferencedTypeVariables();
 
@@ -53,8 +53,7 @@ final class TypeVariables {
     }
 
     @Override
-    public ImmutableSet<TypeVariable> visitDeclared(
-        DeclaredType t, Set<Element> visited) {
+    public ImmutableSet<TypeVariable> visitDeclared(DeclaredType t, Set<Element> visited) {
       if (!visited.add(t.asElement())) {
         return ImmutableSet.of();
       }
@@ -66,8 +65,7 @@ final class TypeVariables {
     }
 
     @Override
-    public ImmutableSet<TypeVariable> visitTypeVariable(
-        TypeVariable t, Set<Element> visited) {
+    public ImmutableSet<TypeVariable> visitTypeVariable(TypeVariable t, Set<Element> visited) {
       if (!visited.add(t.asElement())) {
         return ImmutableSet.of();
       }
@@ -79,8 +77,7 @@ final class TypeVariables {
     }
 
     @Override
-    public ImmutableSet<TypeVariable> visitUnion(
-        UnionType t, Set<Element> visited) {
+    public ImmutableSet<TypeVariable> visitUnion(UnionType t, Set<Element> visited) {
       ImmutableSet.Builder<TypeVariable> typeVariables = ImmutableSet.builder();
       for (TypeMirror unionType : t.getAlternatives()) {
         typeVariables.addAll(unionType.accept(this, visited));
@@ -89,8 +86,7 @@ final class TypeVariables {
     }
 
     @Override
-    public ImmutableSet<TypeVariable> visitIntersection(
-        IntersectionType t, Set<Element> visited) {
+    public ImmutableSet<TypeVariable> visitIntersection(IntersectionType t, Set<Element> visited) {
       ImmutableSet.Builder<TypeVariable> typeVariables = ImmutableSet.builder();
       for (TypeMirror intersectionType : t.getBounds()) {
         typeVariables.addAll(intersectionType.accept(this, visited));
@@ -99,8 +95,7 @@ final class TypeVariables {
     }
 
     @Override
-    public ImmutableSet<TypeVariable> visitWildcard(
-        WildcardType t, Set<Element> visited) {
+    public ImmutableSet<TypeVariable> visitWildcard(WildcardType t, Set<Element> visited) {
       ImmutableSet.Builder<TypeVariable> typeVariables = ImmutableSet.builder();
       TypeMirror extendsBound = t.getExtendsBound();
       if (extendsBound != null) {
diff --git a/factory/src/main/java/com/google/auto/factory/processor/package-info.java b/factory/src/main/java/com/google/auto/factory/processor/package-info.java
index 7339020a..4d5b0c01 100644
--- a/factory/src/main/java/com/google/auto/factory/processor/package-info.java
+++ b/factory/src/main/java/com/google/auto/factory/processor/package-info.java
@@ -15,4 +15,4 @@
  * This package contains the annotation processor that implements the
  * {@link com.google.auto.factory.AutoFactory} API.
  */
-package com.google.auto.factory.processor;
\ No newline at end of file
+package com.google.auto.factory.processor;
diff --git a/factory/src/test/java/com/google/auto/factory/processor/AutoFactoryDeclarationTest.java b/factory/src/test/java/com/google/auto/factory/processor/AutoFactoryDeclarationTest.java
index 1b23a65d..7bef2334 100644
--- a/factory/src/test/java/com/google/auto/factory/processor/AutoFactoryDeclarationTest.java
+++ b/factory/src/test/java/com/google/auto/factory/processor/AutoFactoryDeclarationTest.java
@@ -24,7 +24,8 @@ import org.junit.runners.JUnit4;
 
 @RunWith(JUnit4.class)
 public class AutoFactoryDeclarationTest {
-  @Test public void identifiers() {
+  @Test
+  public void identifiers() {
     assertThat(isValidIdentifier("String")).isTrue();
     assertThat(isValidIdentifier("9CantStartWithNumber")).isFalse();
     assertThat(isValidIdentifier("enum")).isFalse();
diff --git a/factory/src/test/java/com/google/auto/factory/processor/AutoFactoryProcessorTest.java b/factory/src/test/java/com/google/auto/factory/processor/AutoFactoryProcessorTest.java
index 49a5357e..0df4c9ca 100644
--- a/factory/src/test/java/com/google/auto/factory/processor/AutoFactoryProcessorTest.java
+++ b/factory/src/test/java/com/google/auto/factory/processor/AutoFactoryProcessorTest.java
@@ -170,6 +170,7 @@ public class AutoFactoryProcessorTest {
         .generatedSourceFile("tests.ConstructorAnnotatedThrowsFactory")
         .hasSourceEquivalentTo(loadExpectedFile("expected/ConstructorAnnotatedThrowsFactory.java"));
   }
+
   @Test
   public void constructorAnnotatedNonFinal() {
     Compilation compilation =
diff --git a/factory/src/test/resources/bad/FactoryExtendingAbstractClassWithConstructorParams.java b/factory/src/test/resources/bad/FactoryExtendingAbstractClassWithConstructorParams.java
index 98c5f667..7c7120bf 100644
--- a/factory/src/test/resources/bad/FactoryExtendingAbstractClassWithConstructorParams.java
+++ b/factory/src/test/resources/bad/FactoryExtendingAbstractClassWithConstructorParams.java
@@ -20,9 +20,9 @@ import tests.FactoryExtendingAbstractClassWithConstructorParams.AbstractFactory;
 
 @AutoFactory(extending = AbstractFactory.class)
 final class FactoryExtendingAbstractClassWithConstructorParams {
-  static abstract class AbstractFactory {
+  abstract static class AbstractFactory {
     protected AbstractFactory(Object obj) {}
-    
+
     abstract FactoryExtendingAbstractClassWithConstructorParams newInstance();
   }
 }
diff --git a/factory/src/test/resources/bad/InvalidCustomName.java b/factory/src/test/resources/bad/InvalidCustomName.java
index 5734ee7f..6d0a2f91 100644
--- a/factory/src/test/resources/bad/InvalidCustomName.java
+++ b/factory/src/test/resources/bad/InvalidCustomName.java
@@ -18,4 +18,4 @@ package tests;
 import com.google.auto.factory.AutoFactory;
 
 @AutoFactory(className = "SillyFactory!")
-final class InvalidCustomName { }
+final class InvalidCustomName {}
diff --git a/factory/src/test/resources/expected/CheckerFrameworkNullableFactory.java b/factory/src/test/resources/expected/CheckerFrameworkNullableFactory.java
index 8e4b1ea4..faa83971 100644
--- a/factory/src/test/resources/expected/CheckerFrameworkNullableFactory.java
+++ b/factory/src/test/resources/expected/CheckerFrameworkNullableFactory.java
@@ -23,9 +23,9 @@ import org.checkerframework.checker.nullness.compatqual.NullableDecl;
 import org.checkerframework.checker.nullness.compatqual.NullableType;
 
 @Generated(
-  value = "com.google.auto.factory.processor.AutoFactoryProcessor",
-  comments = "https://github.com/google/auto/tree/master/factory"
-)
+    value = "com.google.auto.factory.processor.AutoFactoryProcessor",
+    comments = "https://github.com/google/auto/tree/master/factory"
+    )
 final class CheckerFrameworkNullableFactory {
 
   private final Provider<String> java_lang_StringProvider;
diff --git a/factory/src/test/resources/expected/ClassUsingQualifierWithArgsFactory.java b/factory/src/test/resources/expected/ClassUsingQualifierWithArgsFactory.java
index b5bd89c1..8d889eed 100644
--- a/factory/src/test/resources/expected/ClassUsingQualifierWithArgsFactory.java
+++ b/factory/src/test/resources/expected/ClassUsingQualifierWithArgsFactory.java
@@ -20,14 +20,15 @@ import javax.inject.Inject;
 import javax.inject.Provider;
 
 @Generated(
-  value = "com.google.auto.factory.processor.AutoFactoryProcessor",
-  comments = "https://github.com/google/auto/tree/master/factory"
-  )
+    value = "com.google.auto.factory.processor.AutoFactoryProcessor",
+    comments = "https://github.com/google/auto/tree/master/factory"
+    )
 final class ClassUsingQualifierWithArgsFactory {
   private final Provider<String> providedDepAProvider;
 
-  @Inject ClassUsingQualifierWithArgsFactory(
-      @QualifierWithArgs(name="Fred", count=3) Provider<String> providedDepAProvider) {
+  @Inject
+  ClassUsingQualifierWithArgsFactory(
+      @QualifierWithArgs(name = "Fred", count = 3) Provider<String> providedDepAProvider) {
     this.providedDepAProvider = checkNotNull(providedDepAProvider, 1);
   }
 
diff --git a/factory/src/test/resources/expected/ConstructorAnnotatedFactory.java b/factory/src/test/resources/expected/ConstructorAnnotatedFactory.java
index 6e9d242e..22349851 100644
--- a/factory/src/test/resources/expected/ConstructorAnnotatedFactory.java
+++ b/factory/src/test/resources/expected/ConstructorAnnotatedFactory.java
@@ -20,13 +20,14 @@ import javax.inject.Inject;
 import javax.inject.Provider;
 
 @Generated(
-  value = "com.google.auto.factory.processor.AutoFactoryProcessor",
-  comments = "https://github.com/google/auto/tree/master/factory"
-  )
+    value = "com.google.auto.factory.processor.AutoFactoryProcessor",
+    comments = "https://github.com/google/auto/tree/master/factory"
+    )
 final class ConstructorAnnotatedFactory {
   private final Provider<Object> objProvider;
 
-  @Inject ConstructorAnnotatedFactory(Provider<Object> objProvider) {
+  @Inject
+  ConstructorAnnotatedFactory(Provider<Object> objProvider) {
     this.objProvider = checkNotNull(objProvider, 1);
   }
 
diff --git a/factory/src/test/resources/expected/ConstructorAnnotatedNonFinalFactory.java b/factory/src/test/resources/expected/ConstructorAnnotatedNonFinalFactory.java
index 528ea03f..25ec894f 100644
--- a/factory/src/test/resources/expected/ConstructorAnnotatedNonFinalFactory.java
+++ b/factory/src/test/resources/expected/ConstructorAnnotatedNonFinalFactory.java
@@ -20,13 +20,14 @@ import javax.inject.Inject;
 import javax.inject.Provider;
 
 @Generated(
-  value = "com.google.auto.factory.processor.AutoFactoryProcessor",
-  comments = "https://github.com/google/auto/tree/master/factory"
-  )
+    value = "com.google.auto.factory.processor.AutoFactoryProcessor",
+    comments = "https://github.com/google/auto/tree/master/factory"
+    )
 class ConstructorAnnotatedNonFinalFactory {
   private final Provider<Object> objProvider;
-  
-  @Inject ConstructorAnnotatedNonFinalFactory(Provider<Object> objProvider) {
+
+  @Inject
+  ConstructorAnnotatedNonFinalFactory(Provider<Object> objProvider) {
     this.objProvider = checkNotNull(objProvider, 1);
   }
 
@@ -37,11 +38,11 @@ class ConstructorAnnotatedNonFinalFactory {
   ConstructorAnnotatedNonFinal create(String s) {
     return new ConstructorAnnotatedNonFinal(checkNotNull(s, 1));
   }
-  
+
   ConstructorAnnotatedNonFinal create(int i) {
     return new ConstructorAnnotatedNonFinal(checkNotNull(objProvider.get(), 1), i);
   }
-  
+
   ConstructorAnnotatedNonFinal create(char c) {
     return new ConstructorAnnotatedNonFinal(checkNotNull(objProvider.get(), 1), c);
   }
diff --git a/factory/src/test/resources/expected/ConstructorAnnotatedThrowsFactory.java b/factory/src/test/resources/expected/ConstructorAnnotatedThrowsFactory.java
index 13f9e994..05b30fdf 100644
--- a/factory/src/test/resources/expected/ConstructorAnnotatedThrowsFactory.java
+++ b/factory/src/test/resources/expected/ConstructorAnnotatedThrowsFactory.java
@@ -21,13 +21,14 @@ import javax.inject.Inject;
 import javax.inject.Provider;
 
 @Generated(
-  value = "com.google.auto.factory.processor.AutoFactoryProcessor",
-  comments = "https://github.com/google/auto/tree/master/factory"
-  )
+    value = "com.google.auto.factory.processor.AutoFactoryProcessor",
+    comments = "https://github.com/google/auto/tree/master/factory"
+    )
 final class ConstructorAnnotatedThrowsFactory {
   private final Provider<Object> objProvider;
 
-  @Inject ConstructorAnnotatedThrowsFactory(Provider<Object> objProvider) {
+  @Inject
+  ConstructorAnnotatedThrowsFactory(Provider<Object> objProvider) {
     this.objProvider = checkNotNull(objProvider, 1);
   }
 
diff --git a/factory/src/test/resources/expected/CustomNamedFactory.java b/factory/src/test/resources/expected/CustomNamedFactory.java
index c388387c..512c244c 100644
--- a/factory/src/test/resources/expected/CustomNamedFactory.java
+++ b/factory/src/test/resources/expected/CustomNamedFactory.java
@@ -19,11 +19,12 @@ import javax.annotation.processing.Generated;
 import javax.inject.Inject;
 
 @Generated(
-  value = "com.google.auto.factory.processor.AutoFactoryProcessor",
-  comments = "https://github.com/google/auto/tree/master/factory"
-  )
+    value = "com.google.auto.factory.processor.AutoFactoryProcessor",
+    comments = "https://github.com/google/auto/tree/master/factory"
+    )
 final class CustomNamedFactory {
-  @Inject CustomNamedFactory() {}
+  @Inject
+  CustomNamedFactory() {}
 
   SimpleClassCustomName create() {
     return new SimpleClassCustomName();
diff --git a/factory/src/test/resources/expected/CustomNullableFactory.java b/factory/src/test/resources/expected/CustomNullableFactory.java
index 31bb5bfa..c8f2f286 100644
--- a/factory/src/test/resources/expected/CustomNullableFactory.java
+++ b/factory/src/test/resources/expected/CustomNullableFactory.java
@@ -20,9 +20,9 @@ import javax.inject.Inject;
 import javax.inject.Provider;
 
 @Generated(
-  value = "com.google.auto.factory.processor.AutoFactoryProcessor",
-  comments = "https://github.com/google/auto/tree/master/factory"
-  )
+    value = "com.google.auto.factory.processor.AutoFactoryProcessor",
+    comments = "https://github.com/google/auto/tree/master/factory"
+    )
 final class CustomNullableFactory {
 
   private final Provider<Object> objectProvider;
diff --git a/factory/src/test/resources/expected/FactoryExtendingAbstractClassFactory.java b/factory/src/test/resources/expected/FactoryExtendingAbstractClassFactory.java
index c56afb0a..f35b414e 100644
--- a/factory/src/test/resources/expected/FactoryExtendingAbstractClassFactory.java
+++ b/factory/src/test/resources/expected/FactoryExtendingAbstractClassFactory.java
@@ -19,18 +19,20 @@ import javax.annotation.processing.Generated;
 import javax.inject.Inject;
 
 @Generated(
-  value = "com.google.auto.factory.processor.AutoFactoryProcessor",
-  comments = "https://github.com/google/auto/tree/master/factory"
-  )
+    value = "com.google.auto.factory.processor.AutoFactoryProcessor",
+    comments = "https://github.com/google/auto/tree/master/factory"
+    )
 final class FactoryExtendingAbstractClassFactory
     extends FactoryExtendingAbstractClass.AbstractFactory {
-  @Inject FactoryExtendingAbstractClassFactory() {}
+  @Inject
+  FactoryExtendingAbstractClassFactory() {}
 
   FactoryExtendingAbstractClass create() {
     return new FactoryExtendingAbstractClass();
   }
 
-  @Override public FactoryExtendingAbstractClass newInstance() {
+  @Override
+  public FactoryExtendingAbstractClass newInstance() {
     return create();
   }
 }
diff --git a/factory/src/test/resources/expected/FactoryExtendingAbstractClassThrowsFactory.java b/factory/src/test/resources/expected/FactoryExtendingAbstractClassThrowsFactory.java
index c2640f54..402f8946 100644
--- a/factory/src/test/resources/expected/FactoryExtendingAbstractClassThrowsFactory.java
+++ b/factory/src/test/resources/expected/FactoryExtendingAbstractClassThrowsFactory.java
@@ -20,18 +20,20 @@ import javax.annotation.processing.Generated;
 import javax.inject.Inject;
 
 @Generated(
-  value = "com.google.auto.factory.processor.AutoFactoryProcessor",
-  comments = "https://github.com/google/auto/tree/master/factory"
-  )
+    value = "com.google.auto.factory.processor.AutoFactoryProcessor",
+    comments = "https://github.com/google/auto/tree/master/factory"
+    )
 final class FactoryExtendingAbstractClassThrowsFactory
     extends FactoryExtendingAbstractClassThrows.AbstractFactory {
-  @Inject FactoryExtendingAbstractClassThrowsFactory() {}
+  @Inject
+  FactoryExtendingAbstractClassThrowsFactory() {}
 
   FactoryExtendingAbstractClassThrows create() throws IOException, InterruptedException {
     return new FactoryExtendingAbstractClassThrows();
   }
 
-  @Override public FactoryExtendingAbstractClassThrows newInstance() throws Exception {
+  @Override
+  public FactoryExtendingAbstractClassThrows newInstance() throws Exception {
     return create();
   }
 }
diff --git a/factory/src/test/resources/expected/FactoryImplementingCreateMethod_ConcreteClassFactory.java b/factory/src/test/resources/expected/FactoryImplementingCreateMethod_ConcreteClassFactory.java
index 1f3bb0e3..2d8a392d 100644
--- a/factory/src/test/resources/expected/FactoryImplementingCreateMethod_ConcreteClassFactory.java
+++ b/factory/src/test/resources/expected/FactoryImplementingCreateMethod_ConcreteClassFactory.java
@@ -20,15 +20,15 @@ import javax.annotation.processing.Generated;
 import javax.inject.Inject;
 
 @Generated(
-  value = "com.google.auto.factory.processor.AutoFactoryProcessor",
-  comments = "https://github.com/google/auto/tree/master/factory"
-  )
+    value = "com.google.auto.factory.processor.AutoFactoryProcessor",
+    comments = "https://github.com/google/auto/tree/master/factory"
+    )
 final class FactoryImplementingCreateMethod_ConcreteClassFactory
     implements FactoryImplementingCreateMethod.FactoryInterfaceWithCreateMethod {
 
   @Inject
   FactoryImplementingCreateMethod_ConcreteClassFactory() {}
-  
+
   @Override
   public FactoryImplementingCreateMethod.ConcreteClass create() {
     return new FactoryImplementingCreateMethod.ConcreteClass();
@@ -40,11 +40,12 @@ final class FactoryImplementingCreateMethod_ConcreteClassFactory
   }
 
   @Override
-  public FactoryImplementingCreateMethod.ConcreteClass create(List<Integer> genericWithDifferentArgumentName) {
+  public FactoryImplementingCreateMethod.ConcreteClass create(
+      List<Integer> genericWithDifferentArgumentName) {
     return new FactoryImplementingCreateMethod.ConcreteClass(
         checkNotNull(genericWithDifferentArgumentName, 1));
   }
-  
+
   FactoryImplementingCreateMethod.ConcreteClass create(int a, boolean b) {
     return new FactoryImplementingCreateMethod.ConcreteClass(a, b);
   }
diff --git a/factory/src/test/resources/expected/FactoryImplementingGenericInterfaceExtensionFactory.java b/factory/src/test/resources/expected/FactoryImplementingGenericInterfaceExtensionFactory.java
index 3bfc5262..9f2bf0ae 100644
--- a/factory/src/test/resources/expected/FactoryImplementingGenericInterfaceExtensionFactory.java
+++ b/factory/src/test/resources/expected/FactoryImplementingGenericInterfaceExtensionFactory.java
@@ -20,20 +20,23 @@ import javax.inject.Inject;
 import javax.inject.Provider;
 
 @Generated(
-  value = "com.google.auto.factory.processor.AutoFactoryProcessor",
-  comments = "https://github.com/google/auto/tree/master/factory"
-  )
+    value = "com.google.auto.factory.processor.AutoFactoryProcessor",
+    comments = "https://github.com/google/auto/tree/master/factory"
+    )
 final class FactoryImplementingGenericInterfaceExtensionFactory
     implements FactoryImplementingGenericInterfaceExtension.MyFactory {
   private final Provider<String> sProvider;
+
   @Inject
   FactoryImplementingGenericInterfaceExtensionFactory(Provider<String> sProvider) {
     this.sProvider = checkNotNull(sProvider, 1);
   }
+
   FactoryImplementingGenericInterfaceExtension create(Integer i) {
     return new FactoryImplementingGenericInterfaceExtension(
         checkNotNull(sProvider.get(), 1), checkNotNull(i, 2));
   }
+
   @Override
   public FactoryImplementingGenericInterfaceExtension make(Integer arg) {
     return create(arg);
diff --git a/factory/src/test/resources/expected/MixedDepsImplementingInterfacesFactory.java b/factory/src/test/resources/expected/MixedDepsImplementingInterfacesFactory.java
index 19f2c138..ec4089b7 100644
--- a/factory/src/test/resources/expected/MixedDepsImplementingInterfacesFactory.java
+++ b/factory/src/test/resources/expected/MixedDepsImplementingInterfacesFactory.java
@@ -23,15 +23,18 @@ import javax.inject.Provider;
  * @author Gregory Kick
  */
 @Generated(
-  value = "com.google.auto.factory.processor.AutoFactoryProcessor",
-  comments = "https://github.com/google/auto/tree/master/factory"
-)
+    value = "com.google.auto.factory.processor.AutoFactoryProcessor",
+    comments = "https://github.com/google/auto/tree/master/factory"
+    )
 final class MixedDepsImplementingInterfacesFactory
-    implements MixedDepsImplementingInterfaces.FromInt, MixedDepsImplementingInterfaces.FromObject,
-        MixedDepsImplementingInterfaces.MarkerA, MixedDepsImplementingInterfaces.MarkerB {
+    implements MixedDepsImplementingInterfaces.FromInt,
+        MixedDepsImplementingInterfaces.FromObject,
+        MixedDepsImplementingInterfaces.MarkerA,
+        MixedDepsImplementingInterfaces.MarkerB {
   private final Provider<String> sProvider;
 
-  @Inject MixedDepsImplementingInterfacesFactory(Provider<String> sProvider) {
+  @Inject
+  MixedDepsImplementingInterfacesFactory(Provider<String> sProvider) {
     this.sProvider = checkNotNull(sProvider, 1);
   }
 
@@ -43,11 +46,13 @@ final class MixedDepsImplementingInterfacesFactory
     return new MixedDepsImplementingInterfaces(checkNotNull(o, 1));
   }
 
-  @Override public MixedDepsImplementingInterfaces fromInt(int i) {
+  @Override
+  public MixedDepsImplementingInterfaces fromInt(int i) {
     return create(i);
   }
 
-  @Override public MixedDepsImplementingInterfaces fromObject(Object o) {
+  @Override
+  public MixedDepsImplementingInterfaces fromObject(Object o) {
     return create(o);
   }
 
diff --git a/factory/src/test/resources/expected/MultipleFactoriesConflictingParameterNamesFactory.java b/factory/src/test/resources/expected/MultipleFactoriesConflictingParameterNamesFactory.java
index fac6e13a..3eaf3afa 100644
--- a/factory/src/test/resources/expected/MultipleFactoriesConflictingParameterNamesFactory.java
+++ b/factory/src/test/resources/expected/MultipleFactoriesConflictingParameterNamesFactory.java
@@ -22,7 +22,7 @@ import javax.inject.Provider;
 @Generated(
     value = "com.google.auto.factory.processor.AutoFactoryProcessor",
     comments = "https://github.com/google/auto/tree/master/factory"
-)
+    )
 final class MultipleFactoriesConflictingParameterNamesFactory {
 
   private final Provider<String> stringProvider;
diff --git a/factory/src/test/resources/expected/MultipleFactoriesImplementingInterface_ClassAFactory.java b/factory/src/test/resources/expected/MultipleFactoriesImplementingInterface_ClassAFactory.java
index 5ee2b2fe..6fcfb036 100644
--- a/factory/src/test/resources/expected/MultipleFactoriesImplementingInterface_ClassAFactory.java
+++ b/factory/src/test/resources/expected/MultipleFactoriesImplementingInterface_ClassAFactory.java
@@ -19,9 +19,9 @@ import javax.annotation.processing.Generated;
 import javax.inject.Inject;
 
 @Generated(
-  value = "com.google.auto.factory.processor.AutoFactoryProcessor",
-  comments = "https://github.com/google/auto/tree/master/factory"
-  )
+    value = "com.google.auto.factory.processor.AutoFactoryProcessor",
+    comments = "https://github.com/google/auto/tree/master/factory"
+    )
 final class MultipleFactoriesImplementingInterface_ClassAFactory
     implements MultipleFactoriesImplementingInterface.Base.Factory {
   @Inject
diff --git a/factory/src/test/resources/expected/MultipleFactoriesImplementingInterface_ClassBFactory.java b/factory/src/test/resources/expected/MultipleFactoriesImplementingInterface_ClassBFactory.java
index f6540683..56646891 100644
--- a/factory/src/test/resources/expected/MultipleFactoriesImplementingInterface_ClassBFactory.java
+++ b/factory/src/test/resources/expected/MultipleFactoriesImplementingInterface_ClassBFactory.java
@@ -19,9 +19,9 @@ import javax.annotation.processing.Generated;
 import javax.inject.Inject;
 
 @Generated(
-  value = "com.google.auto.factory.processor.AutoFactoryProcessor",
-  comments = "https://github.com/google/auto/tree/master/factory"
-  )
+    value = "com.google.auto.factory.processor.AutoFactoryProcessor",
+    comments = "https://github.com/google/auto/tree/master/factory"
+    )
 final class MultipleFactoriesImplementingInterface_ClassBFactory
     implements MultipleFactoriesImplementingInterface.Base.Factory {
   @Inject
diff --git a/factory/src/test/resources/expected/MultipleProvidedParamsSameKeyFactory.java b/factory/src/test/resources/expected/MultipleProvidedParamsSameKeyFactory.java
index de7bad72..97cc8ac2 100644
--- a/factory/src/test/resources/expected/MultipleProvidedParamsSameKeyFactory.java
+++ b/factory/src/test/resources/expected/MultipleProvidedParamsSameKeyFactory.java
@@ -20,9 +20,9 @@ import javax.inject.Inject;
 import javax.inject.Provider;
 
 @Generated(
-  value = "com.google.auto.factory.processor.AutoFactoryProcessor",
-  comments = "https://github.com/google/auto/tree/master/factory"
-  )
+    value = "com.google.auto.factory.processor.AutoFactoryProcessor",
+    comments = "https://github.com/google/auto/tree/master/factory"
+    )
 final class MultipleProvidedParamsSameKeyFactory {
   private final Provider<String> java_lang_StringProvider;
 
diff --git a/factory/src/test/resources/expected/NestedClassCustomNamedFactory.java b/factory/src/test/resources/expected/NestedClassCustomNamedFactory.java
index bf6a4681..fe7aa1a9 100644
--- a/factory/src/test/resources/expected/NestedClassCustomNamedFactory.java
+++ b/factory/src/test/resources/expected/NestedClassCustomNamedFactory.java
@@ -19,11 +19,12 @@ import javax.annotation.processing.Generated;
 import javax.inject.Inject;
 
 @Generated(
-  value = "com.google.auto.factory.processor.AutoFactoryProcessor",
-  comments = "https://github.com/google/auto/tree/master/factory"
-  )
+    value = "com.google.auto.factory.processor.AutoFactoryProcessor",
+    comments = "https://github.com/google/auto/tree/master/factory"
+    )
 final class NestedClassCustomNamedFactory {
-  @Inject NestedClassCustomNamedFactory() {}
+  @Inject
+  NestedClassCustomNamedFactory() {}
 
   NestedClasses.SimpleNestedClassWithCustomFactory create() {
     return new NestedClasses.SimpleNestedClassWithCustomFactory();
diff --git a/factory/src/test/resources/expected/NestedClasses_SimpleNestedClassFactory.java b/factory/src/test/resources/expected/NestedClasses_SimpleNestedClassFactory.java
index 041737fe..41ecc52e 100644
--- a/factory/src/test/resources/expected/NestedClasses_SimpleNestedClassFactory.java
+++ b/factory/src/test/resources/expected/NestedClasses_SimpleNestedClassFactory.java
@@ -19,12 +19,13 @@ import javax.annotation.processing.Generated;
 import javax.inject.Inject;
 
 @Generated(
-  value = "com.google.auto.factory.processor.AutoFactoryProcessor",
-  comments = "https://github.com/google/auto/tree/master/factory"
-  )
+    value = "com.google.auto.factory.processor.AutoFactoryProcessor",
+    comments = "https://github.com/google/auto/tree/master/factory"
+    )
 final class NestedClasses_SimpleNestedClassFactory {
-  @Inject NestedClasses_SimpleNestedClassFactory() {}
-  
+  @Inject
+  NestedClasses_SimpleNestedClassFactory() {}
+
   NestedClasses.SimpleNestedClass create() {
     return new NestedClasses.SimpleNestedClass();
   }
diff --git a/factory/src/test/resources/expected/OnlyPrimitivesFactory.java b/factory/src/test/resources/expected/OnlyPrimitivesFactory.java
index ec60c58e..b931a222 100644
--- a/factory/src/test/resources/expected/OnlyPrimitivesFactory.java
+++ b/factory/src/test/resources/expected/OnlyPrimitivesFactory.java
@@ -19,11 +19,12 @@ import javax.annotation.processing.Generated;
 import javax.inject.Inject;
 
 @Generated(
-  value = "com.google.auto.factory.processor.AutoFactoryProcessor",
-  comments = "https://github.com/google/auto/tree/master/factory"
-  )
+    value = "com.google.auto.factory.processor.AutoFactoryProcessor",
+    comments = "https://github.com/google/auto/tree/master/factory"
+    )
 final class OnlyPrimitivesFactory {
-  @Inject OnlyPrimitivesFactory() {}
+  @Inject
+  OnlyPrimitivesFactory() {}
 
   OnlyPrimitives create(int i, long l) {
     return new OnlyPrimitives(i, l);
diff --git a/factory/src/test/resources/expected/ProviderArgumentToCreateMethodFactory.java b/factory/src/test/resources/expected/ProviderArgumentToCreateMethodFactory.java
index 4d1a4cf5..75a6291c 100644
--- a/factory/src/test/resources/expected/ProviderArgumentToCreateMethodFactory.java
+++ b/factory/src/test/resources/expected/ProviderArgumentToCreateMethodFactory.java
@@ -22,10 +22,11 @@ import javax.inject.Provider;
 @Generated(
     value = "com.google.auto.factory.processor.AutoFactoryProcessor",
     comments = "https://github.com/google/auto/tree/master/factory"
-)
+    )
 final class ProviderArgumentToCreateMethodFactory
-    implements ProviderArgumentToCreateMethod.CustomCreator{
-  @Inject ProviderArgumentToCreateMethodFactory() {}
+    implements ProviderArgumentToCreateMethod.CustomCreator {
+  @Inject
+  ProviderArgumentToCreateMethodFactory() {}
 
   ProviderArgumentToCreateMethod create(Provider<String> stringProvider) {
     return new ProviderArgumentToCreateMethod(checkNotNull(stringProvider, 1));
diff --git a/factory/src/test/resources/expected/PublicClassFactory.java b/factory/src/test/resources/expected/PublicClassFactory.java
index 06671dc6..9e5c113d 100644
--- a/factory/src/test/resources/expected/PublicClassFactory.java
+++ b/factory/src/test/resources/expected/PublicClassFactory.java
@@ -19,11 +19,12 @@ import javax.annotation.processing.Generated;
 import javax.inject.Inject;
 
 @Generated(
-  value = "com.google.auto.factory.processor.AutoFactoryProcessor",
-  comments = "https://github.com/google/auto/tree/master/factory"
-  )
+    value = "com.google.auto.factory.processor.AutoFactoryProcessor",
+    comments = "https://github.com/google/auto/tree/master/factory"
+    )
 public final class PublicClassFactory {
-  @Inject public PublicClassFactory() {}
+  @Inject
+  public PublicClassFactory() {}
 
   public PublicClass create() {
     return new PublicClass();
diff --git a/factory/src/test/resources/expected/SimpleClassFactory.java b/factory/src/test/resources/expected/SimpleClassFactory.java
index 308d2cdc..4741b752 100644
--- a/factory/src/test/resources/expected/SimpleClassFactory.java
+++ b/factory/src/test/resources/expected/SimpleClassFactory.java
@@ -19,11 +19,12 @@ import javax.annotation.processing.Generated;
 import javax.inject.Inject;
 
 @Generated(
-  value = "com.google.auto.factory.processor.AutoFactoryProcessor",
-  comments = "https://github.com/google/auto/tree/master/factory"
-  )
+    value = "com.google.auto.factory.processor.AutoFactoryProcessor",
+    comments = "https://github.com/google/auto/tree/master/factory"
+    )
 final class SimpleClassFactory {
-  @Inject SimpleClassFactory() {}
+  @Inject
+  SimpleClassFactory() {}
 
   SimpleClass create() {
     return new SimpleClass();
diff --git a/factory/src/test/resources/expected/SimpleClassImplementingMarkerFactory.java b/factory/src/test/resources/expected/SimpleClassImplementingMarkerFactory.java
index 3fd72a2f..17701387 100644
--- a/factory/src/test/resources/expected/SimpleClassImplementingMarkerFactory.java
+++ b/factory/src/test/resources/expected/SimpleClassImplementingMarkerFactory.java
@@ -20,12 +20,13 @@ import javax.annotation.processing.Generated;
 import javax.inject.Inject;
 
 @Generated(
-  value = "com.google.auto.factory.processor.AutoFactoryProcessor",
-  comments = "https://github.com/google/auto/tree/master/factory"
-  )
+    value = "com.google.auto.factory.processor.AutoFactoryProcessor",
+    comments = "https://github.com/google/auto/tree/master/factory"
+    )
 final class SimpleClassImplementingMarkerFactory implements RandomAccess {
-  @Inject SimpleClassImplementingMarkerFactory() {}
-  
+  @Inject
+  SimpleClassImplementingMarkerFactory() {}
+
   SimpleClassImplementingMarker create() {
     return new SimpleClassImplementingMarker();
   }
diff --git a/factory/src/test/resources/expected/SimpleClassImplementingSimpleInterfaceFactory.java b/factory/src/test/resources/expected/SimpleClassImplementingSimpleInterfaceFactory.java
index 1b13c2f0..7dd91bea 100644
--- a/factory/src/test/resources/expected/SimpleClassImplementingSimpleInterfaceFactory.java
+++ b/factory/src/test/resources/expected/SimpleClassImplementingSimpleInterfaceFactory.java
@@ -19,18 +19,20 @@ import javax.annotation.processing.Generated;
 import javax.inject.Inject;
 
 @Generated(
-  value = "com.google.auto.factory.processor.AutoFactoryProcessor",
-  comments = "https://github.com/google/auto/tree/master/factory"
-  )
+    value = "com.google.auto.factory.processor.AutoFactoryProcessor",
+    comments = "https://github.com/google/auto/tree/master/factory"
+    )
 final class SimpleClassImplementingSimpleInterfaceFactory
     implements SimpleClassImplementingSimpleInterface.SimpleInterface {
-  @Inject SimpleClassImplementingSimpleInterfaceFactory() {}
-  
+  @Inject
+  SimpleClassImplementingSimpleInterfaceFactory() {}
+
   SimpleClassImplementingSimpleInterface create() {
     return new SimpleClassImplementingSimpleInterface();
   }
 
-  @Override public SimpleClassImplementingSimpleInterface newInstance() {
+  @Override
+  public SimpleClassImplementingSimpleInterface newInstance() {
     return create();
   }
 }
diff --git a/factory/src/test/resources/expected/SimpleClassMixedDepsFactory.java b/factory/src/test/resources/expected/SimpleClassMixedDepsFactory.java
index ccdea61c..b69ea326 100644
--- a/factory/src/test/resources/expected/SimpleClassMixedDepsFactory.java
+++ b/factory/src/test/resources/expected/SimpleClassMixedDepsFactory.java
@@ -20,14 +20,14 @@ import javax.inject.Inject;
 import javax.inject.Provider;
 
 @Generated(
-  value = "com.google.auto.factory.processor.AutoFactoryProcessor",
-  comments = "https://github.com/google/auto/tree/master/factory"
-  )
+    value = "com.google.auto.factory.processor.AutoFactoryProcessor",
+    comments = "https://github.com/google/auto/tree/master/factory"
+    )
 final class SimpleClassMixedDepsFactory {
   private final Provider<String> providedDepAProvider;
 
-  @Inject SimpleClassMixedDepsFactory(
-      @AQualifier Provider<String> providedDepAProvider) {
+  @Inject
+  SimpleClassMixedDepsFactory(@AQualifier Provider<String> providedDepAProvider) {
     this.providedDepAProvider = checkNotNull(providedDepAProvider, 1);
   }
 
diff --git a/factory/src/test/resources/expected/SimpleClassNonFinalFactory.java b/factory/src/test/resources/expected/SimpleClassNonFinalFactory.java
index d323812e..5ab90306 100644
--- a/factory/src/test/resources/expected/SimpleClassNonFinalFactory.java
+++ b/factory/src/test/resources/expected/SimpleClassNonFinalFactory.java
@@ -19,11 +19,12 @@ import javax.annotation.processing.Generated;
 import javax.inject.Inject;
 
 @Generated(
-  value = "com.google.auto.factory.processor.AutoFactoryProcessor",
-  comments = "https://github.com/google/auto/tree/master/factory"
-  )
+    value = "com.google.auto.factory.processor.AutoFactoryProcessor",
+    comments = "https://github.com/google/auto/tree/master/factory"
+    )
 class SimpleClassNonFinalFactory {
-  @Inject SimpleClassNonFinalFactory() {}
+  @Inject
+  SimpleClassNonFinalFactory() {}
 
   SimpleClassNonFinal create() {
     return new SimpleClassNonFinal();
diff --git a/factory/src/test/resources/expected/SimpleClassNullableParametersFactory.java b/factory/src/test/resources/expected/SimpleClassNullableParametersFactory.java
index e3540386..5b955964 100644
--- a/factory/src/test/resources/expected/SimpleClassNullableParametersFactory.java
+++ b/factory/src/test/resources/expected/SimpleClassNullableParametersFactory.java
@@ -21,9 +21,9 @@ import javax.inject.Inject;
 import javax.inject.Provider;
 
 @Generated(
-  value = "com.google.auto.factory.processor.AutoFactoryProcessor",
-  comments = "https://github.com/google/auto/tree/master/factory"
-  )
+    value = "com.google.auto.factory.processor.AutoFactoryProcessor",
+    comments = "https://github.com/google/auto/tree/master/factory"
+    )
 final class SimpleClassNullableParametersFactory {
   private final Provider<String> providedNullableProvider;
 
diff --git a/factory/src/test/resources/expected/SimpleClassPassedDepsFactory.java b/factory/src/test/resources/expected/SimpleClassPassedDepsFactory.java
index 3260c36e..9cc8a166 100644
--- a/factory/src/test/resources/expected/SimpleClassPassedDepsFactory.java
+++ b/factory/src/test/resources/expected/SimpleClassPassedDepsFactory.java
@@ -19,11 +19,12 @@ import javax.annotation.processing.Generated;
 import javax.inject.Inject;
 
 @Generated(
-  value = "com.google.auto.factory.processor.AutoFactoryProcessor",
-  comments = "https://github.com/google/auto/tree/master/factory"
-  )
+    value = "com.google.auto.factory.processor.AutoFactoryProcessor",
+    comments = "https://github.com/google/auto/tree/master/factory"
+    )
 final class SimpleClassPassedDepsFactory {
-  @Inject SimpleClassPassedDepsFactory() {}
+  @Inject
+  SimpleClassPassedDepsFactory() {}
 
   SimpleClassPassedDeps create(String depA, String depB) {
     return new SimpleClassPassedDeps(checkNotNull(depA, 1), checkNotNull(depB, 2));
diff --git a/factory/src/test/resources/expected/SimpleClassProvidedDepsFactory.java b/factory/src/test/resources/expected/SimpleClassProvidedDepsFactory.java
index 53765700..52448aad 100644
--- a/factory/src/test/resources/expected/SimpleClassProvidedDepsFactory.java
+++ b/factory/src/test/resources/expected/SimpleClassProvidedDepsFactory.java
@@ -20,15 +20,15 @@ import javax.inject.Inject;
 import javax.inject.Provider;
 
 @Generated(
-  value = "com.google.auto.factory.processor.AutoFactoryProcessor",
-  comments = "https://github.com/google/auto/tree/master/factory"
-  )
+    value = "com.google.auto.factory.processor.AutoFactoryProcessor",
+    comments = "https://github.com/google/auto/tree/master/factory"
+    )
 final class SimpleClassProvidedDepsFactory {
   private final Provider<Integer> providedPrimitiveAProvider;
   private final Provider<Integer> providedPrimitiveBProvider;
   private final Provider<String> providedDepAProvider;
   private final Provider<String> providedDepBProvider;
-  
+
   @Inject
   SimpleClassProvidedDepsFactory(
       @AQualifier Provider<Integer> providedPrimitiveAProvider,
@@ -40,7 +40,7 @@ final class SimpleClassProvidedDepsFactory {
     this.providedDepAProvider = checkNotNull(providedDepAProvider, 3);
     this.providedDepBProvider = checkNotNull(providedDepBProvider, 4);
   }
-  
+
   SimpleClassProvidedDeps create() {
     return new SimpleClassProvidedDeps(
         checkNotNull(providedPrimitiveAProvider.get(), 1),
diff --git a/factory/src/test/resources/expected/SimpleClassProvidedProviderDepsFactory.java b/factory/src/test/resources/expected/SimpleClassProvidedProviderDepsFactory.java
index aafdcec2..7bf2372c 100644
--- a/factory/src/test/resources/expected/SimpleClassProvidedProviderDepsFactory.java
+++ b/factory/src/test/resources/expected/SimpleClassProvidedProviderDepsFactory.java
@@ -20,9 +20,9 @@ import javax.inject.Inject;
 import javax.inject.Provider;
 
 @Generated(
-  value = "com.google.auto.factory.processor.AutoFactoryProcessor",
-  comments = "https://github.com/google/auto/tree/master/factory"
-  )
+    value = "com.google.auto.factory.processor.AutoFactoryProcessor",
+    comments = "https://github.com/google/auto/tree/master/factory"
+    )
 final class SimpleClassProvidedProviderDepsFactory {
   private final Provider<String> providedDepAProvider;
   private final Provider<String> providedDepBProvider;
diff --git a/factory/src/test/resources/expected/SimpleClassThrowsFactory.java b/factory/src/test/resources/expected/SimpleClassThrowsFactory.java
index d54dd528..eda503a4 100644
--- a/factory/src/test/resources/expected/SimpleClassThrowsFactory.java
+++ b/factory/src/test/resources/expected/SimpleClassThrowsFactory.java
@@ -20,11 +20,12 @@ import javax.annotation.processing.Generated;
 import javax.inject.Inject;
 
 @Generated(
-  value = "com.google.auto.factory.processor.AutoFactoryProcessor",
-  comments = "https://github.com/google/auto/tree/master/factory"
-  )
+    value = "com.google.auto.factory.processor.AutoFactoryProcessor",
+    comments = "https://github.com/google/auto/tree/master/factory"
+    )
 final class SimpleClassThrowsFactory {
-  @Inject SimpleClassThrowsFactory() {}
+  @Inject
+  SimpleClassThrowsFactory() {}
 
   SimpleClassThrows create() throws IOException, InterruptedException {
     return new SimpleClassThrows();
diff --git a/factory/src/test/resources/expected/SimpleClassVarargsFactory.java b/factory/src/test/resources/expected/SimpleClassVarargsFactory.java
index 51c7f466..ac7c4bdc 100644
--- a/factory/src/test/resources/expected/SimpleClassVarargsFactory.java
+++ b/factory/src/test/resources/expected/SimpleClassVarargsFactory.java
@@ -21,9 +21,10 @@ import javax.inject.Inject;
 @Generated(
     value = "com.google.auto.factory.processor.AutoFactoryProcessor",
     comments = "https://github.com/google/auto/tree/master/factory"
-)
+    )
 final class SimpleClassVarargsFactory implements SimpleClassVarargs.InterfaceWithVarargs {
-  @Inject SimpleClassVarargsFactory() {}
+  @Inject
+  SimpleClassVarargsFactory() {}
 
   SimpleClassVarargs create(String... args) {
     return new SimpleClassVarargs(checkNotNull(args, 1));
diff --git a/factory/src/test/resources/good/ConstructorAnnotated.java b/factory/src/test/resources/good/ConstructorAnnotated.java
index fdc02f35..ddb154f4 100644
--- a/factory/src/test/resources/good/ConstructorAnnotated.java
+++ b/factory/src/test/resources/good/ConstructorAnnotated.java
@@ -19,9 +19,17 @@ import com.google.auto.factory.AutoFactory;
 import com.google.auto.factory.Provided;
 
 final class ConstructorAnnotated {
-  @AutoFactory ConstructorAnnotated() {}
+  @AutoFactory
+  ConstructorAnnotated() {}
+
   ConstructorAnnotated(Object obj) {}
-  @AutoFactory ConstructorAnnotated(String s) {}
-  @AutoFactory ConstructorAnnotated(@Provided Object obj, int i) {}
-  @AutoFactory ConstructorAnnotated(@Provided Object obj, char c) {}
+
+  @AutoFactory
+  ConstructorAnnotated(String s) {}
+
+  @AutoFactory
+  ConstructorAnnotated(@Provided Object obj, int i) {}
+
+  @AutoFactory
+  ConstructorAnnotated(@Provided Object obj, char c) {}
 }
diff --git a/factory/src/test/resources/good/ConstructorAnnotatedNonFinal.java b/factory/src/test/resources/good/ConstructorAnnotatedNonFinal.java
index 5bed1e60..1b10e79e 100644
--- a/factory/src/test/resources/good/ConstructorAnnotatedNonFinal.java
+++ b/factory/src/test/resources/good/ConstructorAnnotatedNonFinal.java
@@ -19,9 +19,17 @@ import com.google.auto.factory.AutoFactory;
 import com.google.auto.factory.Provided;
 
 final class ConstructorAnnotatedNonFinal {
-  @AutoFactory(allowSubclasses = true) ConstructorAnnotatedNonFinal() {}
+  @AutoFactory(allowSubclasses = true)
+  ConstructorAnnotatedNonFinal() {}
+
   ConstructorAnnotatedNonFinal(Object obj) {}
-  @AutoFactory(allowSubclasses = true) ConstructorAnnotatedNonFinal(String s) {}
-  @AutoFactory(allowSubclasses = true) ConstructorAnnotatedNonFinal(@Provided Object obj, int i) {}
-  @AutoFactory(allowSubclasses = true) ConstructorAnnotatedNonFinal(@Provided Object obj, char c) {}
+
+  @AutoFactory(allowSubclasses = true)
+  ConstructorAnnotatedNonFinal(String s) {}
+
+  @AutoFactory(allowSubclasses = true)
+  ConstructorAnnotatedNonFinal(@Provided Object obj, int i) {}
+
+  @AutoFactory(allowSubclasses = true)
+  ConstructorAnnotatedNonFinal(@Provided Object obj, char c) {}
 }
diff --git a/factory/src/test/resources/good/ConstructorAnnotatedThrows.java b/factory/src/test/resources/good/ConstructorAnnotatedThrows.java
index 1a22f562..58a52d0b 100644
--- a/factory/src/test/resources/good/ConstructorAnnotatedThrows.java
+++ b/factory/src/test/resources/good/ConstructorAnnotatedThrows.java
@@ -20,10 +20,17 @@ import com.google.auto.factory.Provided;
 import java.io.IOException;
 
 final class ConstructorAnnotatedThrows {
-  @AutoFactory ConstructorAnnotatedThrows() throws IOException, InterruptedException {}
+  @AutoFactory
+  ConstructorAnnotatedThrows() throws IOException, InterruptedException {}
+
   ConstructorAnnotatedThrows(Object obj) {}
-  @AutoFactory ConstructorAnnotatedThrows(String s) {}
-  @AutoFactory ConstructorAnnotatedThrows(@Provided Object obj, int i) throws IOException {}
-  @AutoFactory ConstructorAnnotatedThrows(@Provided Object obj, char c)
-      throws InterruptedException {}
+
+  @AutoFactory
+  ConstructorAnnotatedThrows(String s) {}
+
+  @AutoFactory
+  ConstructorAnnotatedThrows(@Provided Object obj, int i) throws IOException {}
+
+  @AutoFactory
+  ConstructorAnnotatedThrows(@Provided Object obj, char c) throws InterruptedException {}
 }
diff --git a/factory/src/test/resources/good/FactoryExtendingAbstractClass.java b/factory/src/test/resources/good/FactoryExtendingAbstractClass.java
index 5511e99e..bd3a4dc7 100644
--- a/factory/src/test/resources/good/FactoryExtendingAbstractClass.java
+++ b/factory/src/test/resources/good/FactoryExtendingAbstractClass.java
@@ -20,7 +20,7 @@ import tests.FactoryExtendingAbstractClass.AbstractFactory;
 
 @AutoFactory(extending = AbstractFactory.class)
 final class FactoryExtendingAbstractClass {
-  static abstract class AbstractFactory {
+  abstract static class AbstractFactory {
     abstract FactoryExtendingAbstractClass newInstance();
   }
 }
diff --git a/factory/src/test/resources/good/FactoryExtendingAbstractClassThrows.java b/factory/src/test/resources/good/FactoryExtendingAbstractClassThrows.java
index 52ce2aaa..2ac43f3f 100644
--- a/factory/src/test/resources/good/FactoryExtendingAbstractClassThrows.java
+++ b/factory/src/test/resources/good/FactoryExtendingAbstractClassThrows.java
@@ -23,7 +23,7 @@ import tests.FactoryExtendingAbstractClassThrows.AbstractFactory;
 final class FactoryExtendingAbstractClassThrows {
   FactoryExtendingAbstractClassThrows() throws IOException, InterruptedException {}
 
-  static abstract class AbstractFactory {
+  abstract static class AbstractFactory {
     abstract FactoryExtendingAbstractClassThrows newInstance() throws Exception;
   }
 }
diff --git a/factory/src/test/resources/good/FactoryExtendingAbstractClassWithMultipleConstructors.java b/factory/src/test/resources/good/FactoryExtendingAbstractClassWithMultipleConstructors.java
index 43e94ce1..20e0b838 100644
--- a/factory/src/test/resources/good/FactoryExtendingAbstractClassWithMultipleConstructors.java
+++ b/factory/src/test/resources/good/FactoryExtendingAbstractClassWithMultipleConstructors.java
@@ -20,10 +20,11 @@ import tests.FactoryExtendingAbstractClassWithMultipleConstructors.AbstractFacto
 
 @AutoFactory(extending = AbstractFactory.class)
 final class FactoryExtendingAbstractClassWithMultipleConstructors {
-  static abstract class AbstractFactory {
+  abstract static class AbstractFactory {
     protected AbstractFactory(Object obj) {}
+
     protected AbstractFactory() {}
-    
+
     abstract FactoryExtendingAbstractClassWithMultipleConstructors newInstance();
   }
 }
diff --git a/factory/src/test/resources/good/FactoryImplementingCreateMethod.java b/factory/src/test/resources/good/FactoryImplementingCreateMethod.java
index db15eefe..d2659667 100644
--- a/factory/src/test/resources/good/FactoryImplementingCreateMethod.java
+++ b/factory/src/test/resources/good/FactoryImplementingCreateMethod.java
@@ -26,7 +26,7 @@ final class FactoryImplementingCreateMethod {
     Interface create();
 
     Interface create(int a);
-    
+
     Interface create(List<Integer> generic);
   }
 
diff --git a/factory/src/test/resources/good/MixedDepsImplementingInterfaces.java b/factory/src/test/resources/good/MixedDepsImplementingInterfaces.java
index c7435edd..05ee0df9 100644
--- a/factory/src/test/resources/good/MixedDepsImplementingInterfaces.java
+++ b/factory/src/test/resources/good/MixedDepsImplementingInterfaces.java
@@ -24,18 +24,18 @@ import com.google.auto.factory.Provided;
 final class MixedDepsImplementingInterfaces {
   @AutoFactory(implementing = {FromInt.class, MarkerA.class})
   MixedDepsImplementingInterfaces(@Provided String s, int i) {}
-  
+
   @AutoFactory(implementing = {FromObject.class, MarkerB.class})
   MixedDepsImplementingInterfaces(Object o) {}
 
   interface FromInt {
     MixedDepsImplementingInterfaces fromInt(int i);
   }
-  
+
   interface FromObject {
     MixedDepsImplementingInterfaces fromObject(Object o);
   }
-  
+
   interface MarkerA {}
 
   interface MarkerB {}
diff --git a/factory/src/test/resources/good/MultipleFactoriesImplementingInterface.java b/factory/src/test/resources/good/MultipleFactoriesImplementingInterface.java
index 2eecf1ae..f7709ec0 100644
--- a/factory/src/test/resources/good/MultipleFactoriesImplementingInterface.java
+++ b/factory/src/test/resources/good/MultipleFactoriesImplementingInterface.java
@@ -17,7 +17,7 @@ package tests;
 
 import com.google.auto.factory.AutoFactory;
 
-class MultipleFactoriesImplementingInterface {  
+class MultipleFactoriesImplementingInterface {
   static interface Base {
     static interface Factory {
       public abstract Base abstractNonDefaultCreate();
@@ -25,8 +25,8 @@ class MultipleFactoriesImplementingInterface {
   }
 
   @AutoFactory(implementing = Base.Factory.class)
-  static class ClassA implements Base { }
+  static class ClassA implements Base {}
 
   @AutoFactory(implementing = Base.Factory.class)
   static class ClassB implements Base {}
-}  
+}
diff --git a/factory/src/test/resources/good/MultipleProvidedParamsSameKey.java b/factory/src/test/resources/good/MultipleProvidedParamsSameKey.java
index 21da6c1e..b338d344 100644
--- a/factory/src/test/resources/good/MultipleProvidedParamsSameKey.java
+++ b/factory/src/test/resources/good/MultipleProvidedParamsSameKey.java
@@ -28,7 +28,6 @@ final class MultipleProvidedParamsSameKey {
   private final Provider<String> providerOne;
   private final Provider<String> providerTwo;
 
-
   public MultipleProvidedParamsSameKey(
       @Provided String one,
       @Provided String two,
diff --git a/factory/src/test/resources/good/SimpleClassImplementingMarker.java b/factory/src/test/resources/good/SimpleClassImplementingMarker.java
index 24e3abc0..52a1fd5a 100644
--- a/factory/src/test/resources/good/SimpleClassImplementingMarker.java
+++ b/factory/src/test/resources/good/SimpleClassImplementingMarker.java
@@ -1,11 +1,11 @@
 /*
  * Copyright 2013 Google LLC
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
  * in compliance with the License. You may obtain a copy of the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software distributed under the License
  * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
  * or implied. See the License for the specific language governing permissions and limitations under
@@ -17,5 +17,4 @@ import com.google.auto.factory.AutoFactory;
 import java.util.RandomAccess;
 
 @AutoFactory(implementing = RandomAccess.class)
-class SimpleClassImplementingMarker {
-}
+class SimpleClassImplementingMarker {}
diff --git a/factory/src/test/resources/good/SimpleClassProvidedDeps.java b/factory/src/test/resources/good/SimpleClassProvidedDeps.java
index ffcefd2a..fa9e0c41 100644
--- a/factory/src/test/resources/good/SimpleClassProvidedDeps.java
+++ b/factory/src/test/resources/good/SimpleClassProvidedDeps.java
@@ -1,11 +1,11 @@
 /*
  * Copyright 2013 Google LLC
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
  * in compliance with the License. You may obtain a copy of the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software distributed under the License
  * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
  * or implied. See the License for the specific language governing permissions and limitations under
diff --git a/factory/src/test/resources/support/QualifierWithArgs.java b/factory/src/test/resources/support/QualifierWithArgs.java
index 81e3f84b..89f54eb6 100644
--- a/factory/src/test/resources/support/QualifierWithArgs.java
+++ b/factory/src/test/resources/support/QualifierWithArgs.java
@@ -29,5 +29,6 @@ import javax.inject.Qualifier;
 @Retention(RUNTIME)
 @interface QualifierWithArgs {
   String name();
+
   int count();
 }
diff --git a/service/processor/src/main/java/com/google/auto/service/processor/AutoServiceProcessor.java b/service/processor/src/main/java/com/google/auto/service/processor/AutoServiceProcessor.java
index cb4bc46f..f12299a5 100644
--- a/service/processor/src/main/java/com/google/auto/service/processor/AutoServiceProcessor.java
+++ b/service/processor/src/main/java/com/google/auto/service/processor/AutoServiceProcessor.java
@@ -59,10 +59,10 @@ import javax.tools.StandardLocation;
  * <p>
  * Processor Options:<ul>
  *   <li>{@code -Adebug} - turns on debug statements</li>
-     <li>{@code -Averify=true} - turns on extra verification</li>
+ *   <li>{@code -Averify=true} - turns on extra verification</li>
  * </ul>
  */
-@SupportedOptions({ "debug", "verify" })
+@SupportedOptions({"debug", "verify"})
 public class AutoServiceProcessor extends AbstractProcessor {
 
   @VisibleForTesting
@@ -122,8 +122,8 @@ public class AutoServiceProcessor extends AbstractProcessor {
     }
   }
 
-  private void processAnnotations(Set<? extends TypeElement> annotations,
-      RoundEnvironment roundEnv) {
+  private void processAnnotations(
+      Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
 
     Set<? extends Element> elements = roundEnv.getElementsAnnotatedWith(AutoService.class);
 
@@ -148,9 +148,11 @@ public class AutoServiceProcessor extends AbstractProcessor {
         if (checkImplementer(providerImplementer, providerType, annotationMirror)) {
           providers.put(getBinaryName(providerType), getBinaryName(providerImplementer));
         } else {
-          String message = "ServiceProviders must implement their service provider interface. "
-              + providerImplementer.getQualifiedName() + " does not implement "
-              + providerType.getQualifiedName();
+          String message =
+              "ServiceProviders must implement their service provider interface. "
+                  + providerImplementer.getQualifiedName()
+                  + " does not implement "
+                  + providerType.getQualifiedName();
           error(message, e, annotationMirror);
         }
       }
@@ -170,8 +172,8 @@ public class AutoServiceProcessor extends AbstractProcessor {
           // before we attempt to get the resource in case the behavior
           // of filer.getResource does change to match the spec, but there's
           // no good way to resolve CLASS_OUTPUT without first getting a resource.
-          FileObject existingFile = filer.getResource(StandardLocation.CLASS_OUTPUT, "",
-              resourceFile);
+          FileObject existingFile =
+              filer.getResource(StandardLocation.CLASS_OUTPUT, "", resourceFile);
           log("Looking for existing resource file at " + existingFile.toUri());
           Set<String> oldServices = ServicesFiles.readServiceFile(existingFile.openInputStream());
           log("Existing service entries: " + oldServices);
@@ -192,8 +194,8 @@ public class AutoServiceProcessor extends AbstractProcessor {
         }
 
         log("New service file contents: " + allServices);
-        FileObject fileObject = filer.createResource(StandardLocation.CLASS_OUTPUT, "",
-            resourceFile);
+        FileObject fileObject =
+            filer.createResource(StandardLocation.CLASS_OUTPUT, "", resourceFile);
         try (OutputStream out = fileObject.openOutputStream()) {
           ServicesFiles.writeServiceFile(allServices, out);
         }
@@ -300,8 +302,7 @@ public class AutoServiceProcessor extends AbstractProcessor {
               @Override
               public ImmutableSet<DeclaredType> visitArray(
                   List<? extends AnnotationValue> values, Void v) {
-                return values
-                    .stream()
+                return values.stream()
                     .flatMap(value -> value.accept(this, null).stream())
                     .collect(toImmutableSet());
               }
diff --git a/service/processor/src/main/java/com/google/auto/service/processor/ServicesFiles.java b/service/processor/src/main/java/com/google/auto/service/processor/ServicesFiles.java
index c61b3ba2..75d6cca7 100644
--- a/service/processor/src/main/java/com/google/auto/service/processor/ServicesFiles.java
+++ b/service/processor/src/main/java/com/google/auto/service/processor/ServicesFiles.java
@@ -35,7 +35,7 @@ import java.util.Set;
 final class ServicesFiles {
   public static final String SERVICES_PATH = "META-INF/services";
 
-  private ServicesFiles() { }
+  private ServicesFiles() {}
 
   /**
    * Returns an absolute path to a service file given the class
@@ -96,4 +96,4 @@ final class ServicesFiles {
     }
     writer.flush();
   }
-}
\ No newline at end of file
+}
diff --git a/service/processor/src/main/java/com/google/auto/service/processor/package-info.java b/service/processor/src/main/java/com/google/auto/service/processor/package-info.java
index a9f0adb5..453c95e8 100644
--- a/service/processor/src/main/java/com/google/auto/service/processor/package-info.java
+++ b/service/processor/src/main/java/com/google/auto/service/processor/package-info.java
@@ -15,4 +15,4 @@
  * This package contains the annotation processor that implements the
  * {@link com.google.auto.service.AutoService} API.
  */
-package com.google.auto.service.processor;
\ No newline at end of file
+package com.google.auto.service.processor;
diff --git a/service/processor/src/test/resources/test/AnotherService.java b/service/processor/src/test/resources/test/AnotherService.java
index c096c223..de80f06d 100644
--- a/service/processor/src/test/resources/test/AnotherService.java
+++ b/service/processor/src/test/resources/test/AnotherService.java
@@ -15,4 +15,4 @@
  */
 package test;
 
-interface AnotherService { }
\ No newline at end of file
+interface AnotherService {}
diff --git a/service/processor/src/test/resources/test/AnotherServiceProvider.java b/service/processor/src/test/resources/test/AnotherServiceProvider.java
index c5e5c117..2a023e43 100644
--- a/service/processor/src/test/resources/test/AnotherServiceProvider.java
+++ b/service/processor/src/test/resources/test/AnotherServiceProvider.java
@@ -18,4 +18,4 @@ package test;
 import com.google.auto.service.AutoService;
 
 @AutoService(AnotherService.class)
-public class AnotherServiceProvider implements AnotherService { }
\ No newline at end of file
+public class AnotherServiceProvider implements AnotherService {}
diff --git a/service/processor/src/test/resources/test/Enclosing.java b/service/processor/src/test/resources/test/Enclosing.java
index 26dd5852..24202a59 100644
--- a/service/processor/src/test/resources/test/Enclosing.java
+++ b/service/processor/src/test/resources/test/Enclosing.java
@@ -19,5 +19,5 @@ import com.google.auto.service.AutoService;
 
 public class Enclosing {
   @AutoService(SomeService.class)
-  public static class NestedSomeServiceProvider implements SomeService { }
-}
\ No newline at end of file
+  public static class NestedSomeServiceProvider implements SomeService {}
+}
diff --git a/service/processor/src/test/resources/test/SomeService.java b/service/processor/src/test/resources/test/SomeService.java
index d29c4097..d81cac40 100644
--- a/service/processor/src/test/resources/test/SomeService.java
+++ b/service/processor/src/test/resources/test/SomeService.java
@@ -15,4 +15,4 @@
  */
 package test;
 
-interface SomeService { }
\ No newline at end of file
+interface SomeService {}
diff --git a/service/processor/src/test/resources/test/SomeServiceProvider1.java b/service/processor/src/test/resources/test/SomeServiceProvider1.java
index 008136be..fc2c843c 100644
--- a/service/processor/src/test/resources/test/SomeServiceProvider1.java
+++ b/service/processor/src/test/resources/test/SomeServiceProvider1.java
@@ -18,4 +18,4 @@ package test;
 import com.google.auto.service.AutoService;
 
 @AutoService(SomeService.class)
-public class SomeServiceProvider1 implements SomeService { }
\ No newline at end of file
+public class SomeServiceProvider1 implements SomeService {}
diff --git a/service/processor/src/test/resources/test/SomeServiceProvider2.java b/service/processor/src/test/resources/test/SomeServiceProvider2.java
index 5444996b..b7097d41 100644
--- a/service/processor/src/test/resources/test/SomeServiceProvider2.java
+++ b/service/processor/src/test/resources/test/SomeServiceProvider2.java
@@ -18,4 +18,4 @@ package test;
 import com.google.auto.service.AutoService;
 
 @AutoService(SomeService.class)
-public class SomeServiceProvider2 implements SomeService { }
\ No newline at end of file
+public class SomeServiceProvider2 implements SomeService {}
diff --git a/value/src/it/functional/src/test/java/com/google/auto/value/AutoBuilderTest.java b/value/src/it/functional/src/test/java/com/google/auto/value/AutoBuilderTest.java
index 046763d7..a1c4eccd 100644
--- a/value/src/it/functional/src/test/java/com/google/auto/value/AutoBuilderTest.java
+++ b/value/src/it/functional/src/test/java/com/google/auto/value/AutoBuilderTest.java
@@ -125,13 +125,20 @@ public final class AutoBuilderTest {
     assertThat(x.getBar()).isEqualTo("skidoo");
   }
 
-  enum Truthiness {FALSY, TRUTHY}
+  enum Truthiness {
+    FALSY,
+    TRUTHY
+  }
 
   @interface MyAnnotation {
     String value();
+
     int DEFAULT_ID = -1;
+
     int id() default DEFAULT_ID;
+
     Truthiness DEFAULT_TRUTHINESS = Truthiness.FALSY;
+
     Truthiness truthiness() default Truthiness.FALSY;
   }
 
@@ -145,7 +152,9 @@ public final class AutoBuilderTest {
   @AutoBuilder(callMethod = "myAnnotation")
   interface MyAnnotationBuilder {
     MyAnnotationBuilder value(String x);
+
     MyAnnotationBuilder truthiness(Truthiness x);
+
     MyAnnotation build();
   }
 
@@ -407,7 +416,9 @@ public final class AutoBuilderTest {
   @AutoBuilder(callMethod = "singletonMap")
   interface SingletonMapBuilder<K, V extends Number> {
     SingletonMapBuilder<K, V> key(K key);
+
     SingletonMapBuilder<K, V> value(V value);
+
     Map<K, V> build();
   }
 
@@ -456,6 +467,7 @@ public final class AutoBuilderTest {
   @AutoBuilder(ofClass = SingletonSet.class)
   interface SingletonSetBuilder<E> {
     SingletonSetBuilder<E> setElement(E element);
+
     SingletonSet<E> build();
   }
 
@@ -488,7 +500,9 @@ public final class AutoBuilderTest {
   @AutoBuilder(ofClass = TypedSingletonSet.class)
   interface TypedSingletonSetBuilder<E, T extends E> {
     TypedSingletonSetBuilder<E, T> setElement(T element);
+
     TypedSingletonSetBuilder<E, T> setType(Class<T> type);
+
     TypedSingletonSet<E> build();
   }
 
@@ -510,9 +524,13 @@ public final class AutoBuilderTest {
   @AutoBuilder(callMethod = "pair")
   interface PairBuilder<T> {
     PairBuilder<T> setFirst(T x);
+
     T getFirst();
+
     PairBuilder<T> setSecond(T x);
+
     Optional<T> getSecond();
+
     ImmutableList<T> build();
   }
 
diff --git a/value/src/it/functional/src/test/java/com/google/auto/value/AutoOneOfTest.java b/value/src/it/functional/src/test/java/com/google/auto/value/AutoOneOfTest.java
index c6788736..ee337409 100644
--- a/value/src/it/functional/src/test/java/com/google/auto/value/AutoOneOfTest.java
+++ b/value/src/it/functional/src/test/java/com/google/auto/value/AutoOneOfTest.java
@@ -499,10 +499,7 @@ public class AutoOneOfTest {
     ArrayValue string = ArrayValue.ofString("foo");
     ArrayValue ints1 = ArrayValue.ofInts(new int[] {17, 23});
     ArrayValue ints2 = ArrayValue.ofInts(new int[] {17, 23});
-    new EqualsTester()
-        .addEqualityGroup(string)
-        .addEqualityGroup(ints1, ints2)
-        .testEquals();
+    new EqualsTester().addEqualityGroup(string).addEqualityGroup(ints1, ints2).testEquals();
   }
 
   @Retention(RetentionPolicy.RUNTIME)
@@ -563,7 +560,8 @@ public class AutoOneOfTest {
     private static final long serialVersionUID = 1L;
 
     public enum Kind {
-      EMPTY, STRING,
+      EMPTY,
+      STRING,
     }
 
     public abstract Kind getKind();
diff --git a/value/src/it/functional/src/test/java/com/google/auto/value/AutoValueJava8Test.java b/value/src/it/functional/src/test/java/com/google/auto/value/AutoValueJava8Test.java
index 11aa5c16..82b65b90 100644
--- a/value/src/it/functional/src/test/java/com/google/auto/value/AutoValueJava8Test.java
+++ b/value/src/it/functional/src/test/java/com/google/auto/value/AutoValueJava8Test.java
@@ -178,9 +178,7 @@ public class AutoValueJava8Test {
   public void testNullablePropertyImplementationIsNullable() throws NoSuchMethodException {
     Method method =
         AutoValue_AutoValueJava8Test_NullableProperties.class.getDeclaredMethod("nullableString");
-    assertThat(method.getAnnotatedReturnType().getAnnotations())
-        .asList()
-        .contains(nullable());
+    assertThat(method.getAnnotatedReturnType().getAnnotations()).asList().contains(nullable());
   }
 
   @Test
@@ -214,8 +212,9 @@ public class AutoValueJava8Test {
 
   @Test
   public void testExcludedNullablePropertyImplementation() throws NoSuchMethodException {
-    Method method = AutoValue_AutoValueJava8Test_NullablePropertiesNotCopied.class
-        .getDeclaredMethod("nullableString");
+    Method method =
+        AutoValue_AutoValueJava8Test_NullablePropertiesNotCopied.class.getDeclaredMethod(
+            "nullableString");
     assertThat(method.getAnnotatedReturnType().getAnnotations())
         .asList()
         .doesNotContain(nullable());
@@ -805,6 +804,7 @@ public class AutoValueJava8Test {
     @AutoValue.Builder
     abstract static class Builder {
       abstract Builder maybeJustMaybe(Optional<String> maybe);
+
       abstract OptionalOptional build();
     }
   }
@@ -839,6 +839,7 @@ public class AutoValueJava8Test {
     @AutoValue.Builder
     abstract static class Builder {
       abstract Builder setPredicate(Predicate<? super Integer> predicate);
+
       abstract OptionalExtends build();
     }
   }
diff --git a/value/src/it/functional/src/test/java/com/google/auto/value/AutoValueTest.java b/value/src/it/functional/src/test/java/com/google/auto/value/AutoValueTest.java
index 0cd03732..3a7e7bc4 100644
--- a/value/src/it/functional/src/test/java/com/google/auto/value/AutoValueTest.java
+++ b/value/src/it/functional/src/test/java/com/google/auto/value/AutoValueTest.java
@@ -184,12 +184,15 @@ public class AutoValueTest {
   @AutoValue
   abstract static class StrangeGetters {
     abstract int get1st();
+
     abstract int get_1st(); // by default we'll use _1st where identifiers are needed, so foil that.
 
     @AutoValue.Builder
     abstract static class Builder {
       abstract Builder set1st(int x);
+
       abstract Builder set_1st(int x);
+
       abstract StrangeGetters build();
     }
 
@@ -1898,6 +1901,7 @@ public class AutoValueTest {
       implements ToBuilder<InheritedToBuilder.Builder<T, U>> {
 
     public abstract T t();
+
     public abstract U u();
 
     public static <T, U> Builder<T, U> builder() {
@@ -1907,7 +1911,9 @@ public class AutoValueTest {
     @AutoValue.Builder
     public abstract static class Builder<T, U> {
       public abstract Builder<T, U> setT(T t);
+
       public abstract Builder<T, U> setU(U u);
+
       public abstract InheritedToBuilder<T, U> build();
     }
   }
@@ -2163,6 +2169,7 @@ public class AutoValueTest {
   @AutoValue
   public abstract static class BuilderWithPrefixedGettersAndUnprefixedSetters {
     public abstract String getOAuth();
+
     public abstract String getOBrien();
 
     public static Builder builder() {
@@ -2172,7 +2179,9 @@ public class AutoValueTest {
     @AutoValue.Builder
     public abstract static class Builder {
       public abstract Builder oAuth(String x);
+
       public abstract Builder OBrien(String x);
+
       public abstract BuilderWithPrefixedGettersAndUnprefixedSetters build();
     }
   }
@@ -2181,9 +2190,9 @@ public class AutoValueTest {
   public void testBuilderWithPrefixedGetterAndUnprefixedSetter() {
     BuilderWithPrefixedGettersAndUnprefixedSetters x =
         BuilderWithPrefixedGettersAndUnprefixedSetters.builder()
-        .oAuth("OAuth")
-        .OBrien("Flann")
-        .build();
+            .oAuth("OAuth")
+            .OBrien("Flann")
+            .build();
     assertThat(x.getOAuth()).isEqualTo("OAuth");
     assertThat(x.getOBrien()).isEqualTo("Flann");
   }
@@ -2297,6 +2306,7 @@ public class AutoValueTest {
     @AutoValue.Builder
     abstract static class Builder {
       abstract ImmutableList.Builder<String> listBuilder();
+
       abstract PropertyBuilderInheritsType build();
     }
   }
@@ -3340,6 +3350,7 @@ public class AutoValueTest {
     @AutoValue.Builder
     abstract static class Builder {
       abstract Builder setMetrics(ImmutableSet<? extends Number> metrics);
+
       abstract GenericExtends build();
     }
   }
@@ -3364,6 +3375,7 @@ public class AutoValueTest {
     @AutoValue.Builder
     abstract static class Builder {
       abstract Builder setList(List<String> list);
+
       abstract Child build();
     }
   }
@@ -3407,14 +3419,18 @@ public class AutoValueTest {
   @SuppressWarnings("ClassCanBeStatic")
   static class OuterWithTypeParam<T extends Number> {
     class InnerWithTypeParam<U> {}
+
     class InnerWithoutTypeParam {}
+
     static class Nested {}
   }
 
   @AutoValue
   abstract static class Nesty {
     abstract OuterWithTypeParam<Double>.InnerWithTypeParam<String> innerWithTypeParam();
+
     abstract OuterWithTypeParam<Double>.InnerWithoutTypeParam innerWithoutTypeParam();
+
     abstract OuterWithTypeParam.Nested nested();
 
     static Builder builder() {
@@ -3425,8 +3441,11 @@ public class AutoValueTest {
     abstract static class Builder {
       abstract Builder setInnerWithTypeParam(
           OuterWithTypeParam<Double>.InnerWithTypeParam<String> x);
+
       abstract Builder setInnerWithoutTypeParam(OuterWithTypeParam<Double>.InnerWithoutTypeParam x);
+
       abstract Builder setNested(OuterWithTypeParam.Nested x);
+
       abstract Nesty build();
     }
   }
@@ -3435,11 +3454,12 @@ public class AutoValueTest {
   public void outerWithTypeParam() throws ReflectiveOperationException {
     @SuppressWarnings("UseDiamond") // Currently we compile this with -source 6 in the Eclipse test.
     OuterWithTypeParam<Double> outer = new OuterWithTypeParam<Double>();
-    Nesty nesty = Nesty.builder()
-        .setInnerWithTypeParam(outer.new InnerWithTypeParam<String>())
-        .setInnerWithoutTypeParam(outer.new InnerWithoutTypeParam())
-        .setNested(new OuterWithTypeParam.Nested())
-        .build();
+    Nesty nesty =
+        Nesty.builder()
+            .setInnerWithTypeParam(outer.new InnerWithTypeParam<String>())
+            .setInnerWithoutTypeParam(outer.new InnerWithoutTypeParam())
+            .setNested(new OuterWithTypeParam.Nested())
+            .build();
     Type originalReturnType =
         Nesty.class.getDeclaredMethod("innerWithTypeParam").getGenericReturnType();
     Type generatedReturnType =
@@ -3465,6 +3485,7 @@ public class AutoValueTest {
     @MyAnnotation("thing")
     abstract static class Builder {
       abstract Builder setFoo(String x);
+
       abstract BuilderAnnotationsNotCopied build();
     }
   }
@@ -3489,6 +3510,7 @@ public class AutoValueTest {
     @MyAnnotation("thing")
     abstract static class Builder {
       abstract Builder setFoo(String x);
+
       abstract BuilderAnnotationsCopied build();
     }
   }
@@ -3505,9 +3527,13 @@ public class AutoValueTest {
   @SuppressWarnings({"rawtypes", "unchecked"}) // deliberately checking handling of raw types
   abstract static class DataWithSortedCollectionBuilders<K, V> {
     abstract ImmutableSortedMap<K, V> anImmutableSortedMap();
+
     abstract ImmutableSortedSet<V> anImmutableSortedSet();
+
     abstract ImmutableSortedMap<Integer, V> nonGenericImmutableSortedMap();
+
     abstract ImmutableSortedSet rawImmutableSortedSet();
+
     abstract DataWithSortedCollectionBuilders.Builder<K, V> toBuilder();
 
     static <K, V> DataWithSortedCollectionBuilders.Builder<K, V> builder() {
@@ -3518,14 +3544,20 @@ public class AutoValueTest {
     abstract static class Builder<K, V> {
       abstract DataWithSortedCollectionBuilders.Builder<K, V> anImmutableSortedMap(
           SortedMap<K, V> anImmutableSortedMap);
+
       abstract ImmutableSortedMap.Builder<K, V> anImmutableSortedMapBuilder(
           Comparator<K> keyComparator);
+
       abstract DataWithSortedCollectionBuilders.Builder<K, V> anImmutableSortedSet(
           SortedSet<V> anImmutableSortedSet);
+
       abstract ImmutableSortedSet.Builder<V> anImmutableSortedSetBuilder(Comparator<V> comparator);
+
       abstract ImmutableSortedMap.Builder<Integer, V> nonGenericImmutableSortedMapBuilder(
           Comparator<Integer> keyComparator);
+
       abstract ImmutableSortedSet.Builder rawImmutableSortedSetBuilder(Comparator comparator);
+
       abstract DataWithSortedCollectionBuilders<K, V> build();
     }
   }
@@ -3533,38 +3565,41 @@ public class AutoValueTest {
   @Test
   @SuppressWarnings({"rawtypes", "unchecked"}) // deliberately checking handling of raw types
   public void shouldGenerateBuildersWithComparators() {
-    Comparator<String> stringComparator = new Comparator<String>() {
-      @Override
-      public int compare(String left, String right) {
-        return left.compareTo(right);
-      }
-    };
+    Comparator<String> stringComparator =
+        new Comparator<String>() {
+          @Override
+          public int compare(String left, String right) {
+            return left.compareTo(right);
+          }
+        };
 
-    Comparator<Integer> intComparator = new Comparator<Integer>() {
-      @Override
-      public int compare(Integer o1, Integer o2) {
-        return o1 - o2;
-      }
-    };
+    Comparator<Integer> intComparator =
+        new Comparator<Integer>() {
+          @Override
+          public int compare(Integer o1, Integer o2) {
+            return o1 - o2;
+          }
+        };
 
-    Comparator comparator = new Comparator() {
-      @Override
-      public int compare(Object left, Object right) {
-        return String.valueOf(left).compareTo(String.valueOf(right));
-      }
-    };
+    Comparator comparator =
+        new Comparator() {
+          @Override
+          public int compare(Object left, Object right) {
+            return String.valueOf(left).compareTo(String.valueOf(right));
+          }
+        };
 
     AutoValueTest.DataWithSortedCollectionBuilders.Builder<String, Integer> builder =
         AutoValueTest.DataWithSortedCollectionBuilders.builder();
 
-    builder.anImmutableSortedMapBuilder(stringComparator)
-        .put("Charlie", 1).put("Alfa", 2).put("Bravo", 3);
-    builder.anImmutableSortedSetBuilder(intComparator)
-        .add(1,5,9,3);
-    builder.nonGenericImmutableSortedMapBuilder(intComparator)
-        .put(9, 99).put(1, 11).put(3, 33);
-    builder.rawImmutableSortedSetBuilder(comparator)
-        .add("Bravo", "Charlie", "Alfa");
+    builder
+        .anImmutableSortedMapBuilder(stringComparator)
+        .put("Charlie", 1)
+        .put("Alfa", 2)
+        .put("Bravo", 3);
+    builder.anImmutableSortedSetBuilder(intComparator).add(1, 5, 9, 3);
+    builder.nonGenericImmutableSortedMapBuilder(intComparator).put(9, 99).put(1, 11).put(3, 33);
+    builder.rawImmutableSortedSetBuilder(comparator).add("Bravo", "Charlie", "Alfa");
 
     AutoValueTest.DataWithSortedCollectionBuilders<String, Integer> data = builder.build();
 
diff --git a/value/src/it/functional/src/test/java/com/google/auto/value/GradleTest.java b/value/src/it/functional/src/test/java/com/google/auto/value/GradleTest.java
index d4d0ddcd..f4eb5388 100644
--- a/value/src/it/functional/src/test/java/com/google/auto/value/GradleTest.java
+++ b/value/src/it/functional/src/test/java/com/google/auto/value/GradleTest.java
@@ -42,7 +42,8 @@ public class GradleTest {
   @Rule public TemporaryFolder fakeProject = new TemporaryFolder();
 
   private static final String BUILD_GRADLE_TEXT =
-      String.join("\n",
+      String.join(
+          "\n",
           "plugins {",
           "  id 'java-library'",
           "}",
@@ -50,12 +51,14 @@ public class GradleTest {
           "  maven { url = uri('${localRepository}') }",
           "}",
           "dependencies {",
-          "  compileOnlyApi      'com.google.auto.value:auto-value-annotations:${autoValueVersion}'",
+          "  compileOnlyApi     "
+              + " 'com.google.auto.value:auto-value-annotations:${autoValueVersion}'",
           "  annotationProcessor 'com.google.auto.value:auto-value:${autoValueVersion}'",
           "}");
 
   private static final String FOO_TEXT =
-      String.join("\n",
+      String.join(
+          "\n",
           "package com.example;",
           "",
           "import com.google.auto.value.AutoValue;",
@@ -86,10 +89,15 @@ public class GradleTest {
 
     // Build it the first time.
     BuildResult result1 = buildFakeProject();
-    assertThat(result1.getOutput()).contains(
-        "Full recompilation is required because no incremental change information is available");
-    Path output = fakeProject.getRoot().toPath()
-        .resolve("build/classes/java/main/com/example/AutoValue_Foo.class");
+    assertThat(result1.getOutput())
+        .contains(
+            "Full recompilation is required because no incremental change information is"
+                + " available");
+    Path output =
+        fakeProject
+            .getRoot()
+            .toPath()
+            .resolve("build/classes/java/main/com/example/AutoValue_Foo.class");
     assertThat(Files.exists(output)).isTrue();
 
     // Add a source file to the project.
@@ -111,9 +119,10 @@ public class GradleTest {
   }
 
   private BuildResult buildFakeProject() throws IOException {
-    GradleRunner runner = GradleRunner.create()
-        .withProjectDir(fakeProject.getRoot())
-        .withArguments("--info", "compileJava");
+    GradleRunner runner =
+        GradleRunner.create()
+            .withProjectDir(fakeProject.getRoot())
+            .withArguments("--info", "compileJava");
     if (GRADLE_INSTALLATION.isPresent()) {
       runner.withGradleInstallation(GRADLE_INSTALLATION.get());
     } else {
@@ -132,8 +141,7 @@ public class GradleTest {
     }
     try {
       Path gradleExecutable = Paths.get("/usr/bin/gradle");
-      Path gradleLink =
-          gradleExecutable.resolveSibling(Files.readSymbolicLink(gradleExecutable));
+      Path gradleLink = gradleExecutable.resolveSibling(Files.readSymbolicLink(gradleExecutable));
       if (!gradleLink.endsWith("bin/gradle")) {
         return Optional.empty();
       }
@@ -145,16 +153,19 @@ public class GradleTest {
       Pattern corePattern = Pattern.compile("gradle-core-([0-9]+)\\..*\\.jar");
       try (Stream<Path> files = Files.walk(installationPath.resolve("lib"))) {
         coreJar =
-            files.filter(p -> {
-              Matcher matcher = corePattern.matcher(p.getFileName().toString());
-              if (matcher.matches()) {
-                int version = Integer.parseInt(matcher.group(1));
-                if (version >= 5) {
-                  return true;
-                }
-              }
-              return false;
-            }).findFirst();
+            files
+                .filter(
+                    p -> {
+                      Matcher matcher = corePattern.matcher(p.getFileName().toString());
+                      if (matcher.matches()) {
+                        int version = Integer.parseInt(matcher.group(1));
+                        if (version >= 5) {
+                          return true;
+                        }
+                      }
+                      return false;
+                    })
+                .findFirst();
       }
       return coreJar.map(unused -> installationPath.toFile());
     } catch (IOException e) {
diff --git a/value/src/it/functional/src/test/java/com/google/auto/value/gwt/EmptyExtension.java b/value/src/it/functional/src/test/java/com/google/auto/value/gwt/EmptyExtension.java
index 0476906c..e6f7abf7 100644
--- a/value/src/it/functional/src/test/java/com/google/auto/value/gwt/EmptyExtension.java
+++ b/value/src/it/functional/src/test/java/com/google/auto/value/gwt/EmptyExtension.java
@@ -99,8 +99,7 @@ public class EmptyExtension extends AutoValueExtension {
     if (typeParameters.isEmpty()) {
       return "";
     }
-    return typeParameters
-        .stream()
+    return typeParameters.stream()
         .map(e -> e.getSimpleName().toString())
         .collect(joining(", ", "<", ">"));
   }
diff --git a/value/src/main/java/com/google/auto/value/AutoValue.java b/value/src/main/java/com/google/auto/value/AutoValue.java
index 45a677c9..d7541f65 100644
--- a/value/src/main/java/com/google/auto/value/AutoValue.java
+++ b/value/src/main/java/com/google/auto/value/AutoValue.java
@@ -98,7 +98,7 @@ public @interface AutoValue {
    * <p>If you want to copy annotations from your {@literal @}AutoValue-annotated class's methods to
    * the generated fields in the AutoValue_... implementation, annotate your method
    * with {@literal @}AutoValue.CopyAnnotations. For example, if Example.java is:<pre>
-
+   *
    *   {@code @}Immutable
    *   {@code @}AutoValue
    *   abstract class Example {
diff --git a/value/src/main/java/com/google/auto/value/extension/memoized/processor/MemoizeExtension.java b/value/src/main/java/com/google/auto/value/extension/memoized/processor/MemoizeExtension.java
index 2cf0e7ad..acbe1c03 100644
--- a/value/src/main/java/com/google/auto/value/extension/memoized/processor/MemoizeExtension.java
+++ b/value/src/main/java/com/google/auto/value/extension/memoized/processor/MemoizeExtension.java
@@ -597,9 +597,7 @@ public final class MemoizeExtension extends AutoValueExtension {
   /** Translate a {@link TypeMirror} into a {@link TypeName}, including type annotations. */
   private static TypeName annotatedType(TypeMirror type) {
     List<AnnotationSpec> annotations =
-        type.getAnnotationMirrors().stream()
-            .map(AnnotationSpec::get)
-            .collect(toList());
+        type.getAnnotationMirrors().stream().map(AnnotationSpec::get).collect(toList());
     return TypeName.get(type).annotated(annotations);
   }
 }
diff --git a/value/src/main/java/com/google/auto/value/extension/memoized/processor/MemoizedValidator.java b/value/src/main/java/com/google/auto/value/extension/memoized/processor/MemoizedValidator.java
index 1aa5976c..d250fbc6 100644
--- a/value/src/main/java/com/google/auto/value/extension/memoized/processor/MemoizedValidator.java
+++ b/value/src/main/java/com/google/auto/value/extension/memoized/processor/MemoizedValidator.java
@@ -66,9 +66,7 @@ public final class MemoizedValidator extends AbstractProcessor {
   }
 
   private static boolean isAutoValue(Element element) {
-    return element
-        .getAnnotationMirrors()
-        .stream()
+    return element.getAnnotationMirrors().stream()
         .map(annotation -> MoreTypes.asTypeElement(annotation.getAnnotationType()))
         .anyMatch(type -> type.getQualifiedName().contentEquals("com.google.auto.value.AutoValue"));
   }
diff --git a/value/src/main/java/com/google/auto/value/processor/AutoAnnotationProcessor.java b/value/src/main/java/com/google/auto/value/processor/AutoAnnotationProcessor.java
index edfa41ce..3acf9332 100644
--- a/value/src/main/java/com/google/auto/value/processor/AutoAnnotationProcessor.java
+++ b/value/src/main/java/com/google/auto/value/processor/AutoAnnotationProcessor.java
@@ -461,9 +461,7 @@ public class AutoAnnotationProcessor extends AbstractProcessor {
   }
 
   private static boolean isGwtCompatible(TypeElement annotationElement) {
-    return annotationElement
-        .getAnnotationMirrors()
-        .stream()
+    return annotationElement.getAnnotationMirrors().stream()
         .map(mirror -> mirror.getAnnotationType().asElement())
         .anyMatch(element -> element.getSimpleName().contentEquals("GwtCompatible"));
   }
diff --git a/value/src/main/java/com/google/auto/value/processor/AutoOneOfProcessor.java b/value/src/main/java/com/google/auto/value/processor/AutoOneOfProcessor.java
index a1daebba..711b138c 100644
--- a/value/src/main/java/com/google/auto/value/processor/AutoOneOfProcessor.java
+++ b/value/src/main/java/com/google/auto/value/processor/AutoOneOfProcessor.java
@@ -129,10 +129,8 @@ public class AutoOneOfProcessor extends AutoValueishProcessor {
 
   private DeclaredType mirrorForKindType(TypeElement autoOneOfType) {
     // The annotation is guaranteed to be present by the contract of Processor#process
-    AnnotationMirror oneOfAnnotation =
-        getAnnotationMirror(autoOneOfType, AUTO_ONE_OF_NAME).get();
-    AnnotationValue kindValue =
-        AnnotationMirrors.getAnnotationValue(oneOfAnnotation, "value");
+    AnnotationMirror oneOfAnnotation = getAnnotationMirror(autoOneOfType, AUTO_ONE_OF_NAME).get();
+    AnnotationValue kindValue = AnnotationMirrors.getAnnotationValue(oneOfAnnotation, "value");
     Object value = kindValue.getValue();
     if (value instanceof TypeMirror) {
       TypeMirror kindType = (TypeMirror) value;
@@ -159,9 +157,7 @@ public class AutoOneOfProcessor extends AutoValueishProcessor {
     Map<String, String> transformedPropertyNames =
         propertyNames.stream().collect(toMap(this::transformName, s -> s));
     Map<String, Element> transformedEnumConstants =
-        kindElement
-            .getEnclosedElements()
-            .stream()
+        kindElement.getEnclosedElements().stream()
             .filter(e -> e.getKind().equals(ElementKind.ENUM_CONSTANT))
             .collect(toMap(e -> transformName(e.getSimpleName().toString()), e -> e));
 
@@ -212,8 +208,7 @@ public class AutoOneOfProcessor extends AutoValueishProcessor {
       TypeMirror kindMirror,
       ImmutableSet<ExecutableElement> abstractMethods) {
     Set<ExecutableElement> kindGetters =
-        abstractMethods
-            .stream()
+        abstractMethods.stream()
             .filter(e -> sameType(kindMirror, e.getReturnType()))
             .filter(e -> e.getParameters().isEmpty())
             .collect(toSet());
@@ -270,14 +265,15 @@ public class AutoOneOfProcessor extends AutoValueishProcessor {
       AutoOneOfTemplateVars vars,
       ImmutableMap<ExecutableElement, TypeMirror> propertyMethodsAndTypes,
       ExecutableElement kindGetter) {
-    vars.props = propertySet(
-        propertyMethodsAndTypes, ImmutableListMultimap.of(), ImmutableListMultimap.of());
+    vars.props =
+        propertySet(
+            propertyMethodsAndTypes, ImmutableListMultimap.of(), ImmutableListMultimap.of());
     vars.kindGetter = kindGetter.getSimpleName().toString();
     vars.kindType = TypeEncoder.encode(kindGetter.getReturnType());
     TypeElement javaIoSerializable = elementUtils().getTypeElement("java.io.Serializable");
     vars.serializable =
-        javaIoSerializable != null  // just in case
-        && typeUtils().isAssignable(type.asType(), javaIoSerializable.asType());
+        javaIoSerializable != null // just in case
+            && typeUtils().isAssignable(type.asType(), javaIoSerializable.asType());
   }
 
   @Override
diff --git a/value/src/main/java/com/google/auto/value/processor/AutoValueProcessor.java b/value/src/main/java/com/google/auto/value/processor/AutoValueProcessor.java
index acc01981..837fc573 100644
--- a/value/src/main/java/com/google/auto/value/processor/AutoValueProcessor.java
+++ b/value/src/main/java/com/google/auto/value/processor/AutoValueProcessor.java
@@ -220,8 +220,9 @@ public class AutoValueProcessor extends AutoValueishProcessor {
     ImmutableMap<String, ExecutableElement> properties =
         propertyNameToMethodMap(propertyMethodsAndTypes.keySet());
 
-    ExtensionContext context = new ExtensionContext(
-        processingEnv, type, properties, propertyMethodsAndTypes, abstractMethods);
+    ExtensionContext context =
+        new ExtensionContext(
+            processingEnv, type, properties, propertyMethodsAndTypes, abstractMethods);
     ImmutableList<AutoValueExtension> applicableExtensions = applicableExtensions(type, context);
     ImmutableSet<ExecutableElement> consumedMethods =
         methodsConsumedByExtensions(
@@ -234,8 +235,9 @@ public class AutoValueProcessor extends AutoValueishProcessor {
       propertyMethodsAndTypes =
           propertyMethodsIn(immutableSetDifference(abstractMethods, toBuilderMethods), type);
       properties = propertyNameToMethodMap(propertyMethodsAndTypes.keySet());
-      context = new ExtensionContext(
-          processingEnv, type, properties, propertyMethodsAndTypes, allAbstractMethods);
+      context =
+          new ExtensionContext(
+              processingEnv, type, properties, propertyMethodsAndTypes, allAbstractMethods);
     }
 
     ImmutableSet<ExecutableElement> propertyMethods = propertyMethodsAndTypes.keySet();
diff --git a/value/src/main/java/com/google/auto/value/processor/AutoValueishProcessor.java b/value/src/main/java/com/google/auto/value/processor/AutoValueishProcessor.java
index 1d6f0266..3f949f5b 100644
--- a/value/src/main/java/com/google/auto/value/processor/AutoValueishProcessor.java
+++ b/value/src/main/java/com/google/auto/value/processor/AutoValueishProcessor.java
@@ -293,8 +293,7 @@ abstract class AutoValueishProcessor extends AbstractProcessor {
 
     @Override
     public boolean equals(Object obj) {
-      return obj instanceof GetterProperty
-          && ((GetterProperty) obj).method.equals(method);
+      return obj instanceof GetterProperty && ((GetterProperty) obj).method.equals(method);
     }
 
     @Override
@@ -320,8 +319,7 @@ abstract class AutoValueishProcessor extends AbstractProcessor {
     }
     simpleAnnotationName = annotationType.getSimpleName().toString();
     List<TypeElement> deferredTypes =
-        deferredTypeNames
-            .stream()
+        deferredTypeNames.stream()
             .map(name -> elementUtils().getTypeElement(name))
             .collect(toList());
     if (roundEnv.processingOver()) {
@@ -444,9 +442,7 @@ abstract class AutoValueishProcessor extends AbstractProcessor {
 
   /** Defines the template variables that are shared by AutoValue, AutoOneOf, and AutoBuilder. */
   final void defineSharedVarsForType(
-      TypeElement type,
-      ImmutableSet<ExecutableElement> methods,
-      AutoValueishTemplateVars vars) {
+      TypeElement type, ImmutableSet<ExecutableElement> methods, AutoValueishTemplateVars vars) {
     vars.pkg = TypeSimplifier.packageNameOf(type);
     vars.origClass = TypeSimplifier.classNameOf(type);
     vars.simpleClassName = TypeSimplifier.simpleNameOf(vars.origClass);
@@ -727,8 +723,8 @@ abstract class AutoValueishProcessor extends AbstractProcessor {
       ObjectMethod override = objectMethodToOverride(method);
       boolean canGenerate =
           method.getModifiers().contains(Modifier.ABSTRACT)
-               || isJavaLangObject(MoreElements.asType(method.getEnclosingElement()));
-     if (!override.equals(ObjectMethod.NONE) && canGenerate) {
+              || isJavaLangObject(MoreElements.asType(method.getEnclosingElement()));
+      if (!override.equals(ObjectMethod.NONE) && canGenerate) {
         methodsToGenerate.put(override, method);
       }
     }
@@ -796,8 +792,7 @@ abstract class AutoValueishProcessor extends AbstractProcessor {
    * {@code toString()}.
    */
   ImmutableMap<ExecutableElement, TypeMirror> propertyMethodsIn(
-      Set<ExecutableElement> abstractMethods,
-      TypeElement autoValueOrOneOfType) {
+      Set<ExecutableElement> abstractMethods, TypeElement autoValueOrOneOfType) {
     DeclaredType declaredType = MoreTypes.asDeclared(autoValueOrOneOfType.asType());
     ImmutableSet.Builder<ExecutableElement> properties = ImmutableSet.builder();
     for (ExecutableElement method : abstractMethods) {
@@ -823,7 +818,7 @@ abstract class AutoValueishProcessor extends AbstractProcessor {
     TypeMirror type = getter.getReturnType();
     if (type.getKind() == TypeKind.ARRAY) {
       TypeMirror componentType = MoreTypes.asArray(type).getComponentType();
-     if (componentType.getKind().isPrimitive()) {
+      if (componentType.getKind().isPrimitive()) {
         warnAboutPrimitiveArrays(autoValueClass, getter);
       } else {
         errorReporter.reportError(
@@ -874,7 +869,7 @@ abstract class AutoValueishProcessor extends AbstractProcessor {
     @Override
     public Boolean visitArray(List<? extends AnnotationValue> list, Void p) {
       return list.stream().map(AnnotationValue::getValue).anyMatch("mutable"::equals);
-   }
+    }
   }
 
   /**
@@ -983,8 +978,7 @@ abstract class AutoValueishProcessor extends AbstractProcessor {
     @SuppressWarnings("unchecked")
     List<AnnotationValue> excludedClasses =
         (List<AnnotationValue>) getAnnotationValue(maybeAnnotation.get(), "exclude").getValue();
-    return excludedClasses
-        .stream()
+    return excludedClasses.stream()
         .map(annotationValue -> (DeclaredType) annotationValue.getValue())
         .collect(toCollection(TypeMirrorSet::new));
   }
@@ -994,17 +988,14 @@ abstract class AutoValueishProcessor extends AbstractProcessor {
    * strings that are fully-qualified class names.
    */
   private Set<String> getExcludedAnnotationClassNames(Element element) {
-    return getExcludedAnnotationTypes(element)
-        .stream()
+    return getExcludedAnnotationTypes(element).stream()
         .map(MoreTypes::asTypeElement)
         .map(typeElement -> typeElement.getQualifiedName().toString())
         .collect(toSet());
   }
 
   private static Set<String> getAnnotationsMarkedWithInherited(Element element) {
-    return element
-        .getAnnotationMirrors()
-        .stream()
+    return element.getAnnotationMirrors().stream()
         .filter(a -> isAnnotationPresent(a.getAnnotationType().asElement(), Inherited.class))
         .map(a -> getAnnotationFqName(a))
         .collect(toSet());
@@ -1071,9 +1062,7 @@ abstract class AutoValueishProcessor extends AbstractProcessor {
     Set<String> returnTypeAnnotations =
         getReturnTypeAnnotations(method, this::annotationAppliesToFields);
     Set<String> nonFieldAnnotations =
-        method
-            .getAnnotationMirrors()
-            .stream()
+        method.getAnnotationMirrors().stream()
             .map(a -> a.getAnnotationType().asElement())
             .map(MoreElements::asType)
             .filter(a -> !annotationAppliesToFields(a))
@@ -1091,10 +1080,7 @@ abstract class AutoValueishProcessor extends AbstractProcessor {
 
   private Set<String> getReturnTypeAnnotations(
       ExecutableElement method, Predicate<TypeElement> typeFilter) {
-    return method
-        .getReturnType()
-        .getAnnotationMirrors()
-        .stream()
+    return method.getReturnType().getAnnotationMirrors().stream()
         .map(a -> a.getAnnotationType().asElement())
         .map(MoreElements::asType)
         .filter(typeFilter)
diff --git a/value/src/main/java/com/google/auto/value/processor/GwtCompatibility.java b/value/src/main/java/com/google/auto/value/processor/GwtCompatibility.java
index 72207541..fae4e092 100644
--- a/value/src/main/java/com/google/auto/value/processor/GwtCompatibility.java
+++ b/value/src/main/java/com/google/auto/value/processor/GwtCompatibility.java
@@ -62,9 +62,7 @@ class GwtCompatibility {
         annotationArguments = "";
       } else {
         annotationArguments =
-            getElementValues(annotation)
-                .entrySet()
-                .stream()
+            getElementValues(annotation).entrySet().stream()
                 .map(e -> e.getKey().getSimpleName() + " = " + e.getValue())
                 .collect(joining(", ", "(", ")"));
       }
diff --git a/value/src/main/java/com/google/auto/value/processor/GwtSerialization.java b/value/src/main/java/com/google/auto/value/processor/GwtSerialization.java
index 8cd79433..30ad0926 100644
--- a/value/src/main/java/com/google/auto/value/processor/GwtSerialization.java
+++ b/value/src/main/java/com/google/auto/value/processor/GwtSerialization.java
@@ -99,9 +99,7 @@ class GwtSerialization {
           (vars.pkg.isEmpty() ? "" : vars.pkg + ".") + vars.subclass + "_CustomFieldSerializer";
       vars.serializerClass = TypeSimplifier.simpleNameOf(className);
       vars.props =
-          autoVars.props.stream()
-              .map(p -> new Property((GetterProperty) p))
-              .collect(toList());
+          autoVars.props.stream().map(p -> new Property((GetterProperty) p)).collect(toList());
       vars.classHashString = computeClassHash(autoVars.props, vars.pkg);
       String text = vars.toText();
       text = TypeEncoder.decode(text, processingEnv, vars.pkg, type.asType());
@@ -110,11 +108,11 @@ class GwtSerialization {
   }
 
   public static class Property {
-   private final GetterProperty property;
-   private final boolean isCastingUnchecked;
+    private final GetterProperty property;
+    private final boolean isCastingUnchecked;
 
-     Property(GetterProperty property) {
-     this.property = property;
+    Property(GetterProperty property) {
+      this.property = property;
       this.isCastingUnchecked = TypeSimplifier.isCastingUnchecked(property.getTypeMirror());
     }
 
@@ -255,8 +253,8 @@ class GwtSerialization {
   // Compute a hash that is guaranteed to change if the names, types, or order of the fields
   // change. We use TypeEncoder so that we can get a defined string for types, since
   // TypeMirror.toString() isn't guaranteed to remain the same.
-   private String computeClassHash(Iterable<AutoValueishProcessor.Property> props, String pkg) {
-   CRC32 crc = new CRC32();
+  private String computeClassHash(Iterable<AutoValueishProcessor.Property> props, String pkg) {
+    CRC32 crc = new CRC32();
     String encodedType = TypeEncoder.encode(type.asType()) + ":";
     String decodedType = TypeEncoder.decode(encodedType, processingEnv, "", null);
     if (!decodedType.startsWith(pkg)) {
@@ -265,8 +263,8 @@ class GwtSerialization {
       decodedType = pkg + "." + decodedType;
     }
     crc.update(decodedType.getBytes(UTF_8));
-     for (AutoValueishProcessor.Property prop : props) {
-     String encodedProp = prop + ":" + TypeEncoder.encode(prop.getTypeMirror()) + ";";
+    for (AutoValueishProcessor.Property prop : props) {
+      String encodedProp = prop + ":" + TypeEncoder.encode(prop.getTypeMirror()) + ";";
       String decodedProp = TypeEncoder.decode(encodedProp, processingEnv, pkg, null);
       crc.update(decodedProp.getBytes(UTF_8));
     }
diff --git a/value/src/main/java/com/google/auto/value/processor/TypeSimplifier.java b/value/src/main/java/com/google/auto/value/processor/TypeSimplifier.java
index 290e59e0..e7bab774 100644
--- a/value/src/main/java/com/google/auto/value/processor/TypeSimplifier.java
+++ b/value/src/main/java/com/google/auto/value/processor/TypeSimplifier.java
@@ -140,8 +140,7 @@ final class TypeSimplifier {
     if (typeParameters.isEmpty()) {
       return "";
     } else {
-      return typeParameters
-          .stream()
+      return typeParameters.stream()
           .map(e -> e.getSimpleName().toString())
           .collect(joining(", ", "<", ">"));
     }
@@ -264,8 +263,7 @@ final class TypeSimplifier {
    * {@code Map.Entry} everywhere rather than {@code Entry}.
    */
   private static Set<TypeMirror> topLevelTypes(Types typeUtil, Set<TypeMirror> types) {
-    return types
-        .stream()
+    return types.stream()
         .map(typeMirror -> MoreElements.asType(typeUtil.asElement(typeMirror)))
         .map(typeElement -> topLevelType(typeElement).asType())
         .collect(toCollection(TypeMirrorSet::new));
diff --git a/value/src/test/java/com/google/auto/value/extension/memoized/MemoizedMethodSubject.java b/value/src/test/java/com/google/auto/value/extension/memoized/MemoizedMethodSubject.java
index 18c77368..5d1462d0 100644
--- a/value/src/test/java/com/google/auto/value/extension/memoized/MemoizedMethodSubject.java
+++ b/value/src/test/java/com/google/auto/value/extension/memoized/MemoizedMethodSubject.java
@@ -51,9 +51,6 @@ final class MemoizedMethodSubject extends Subject {
         javac()
             .withProcessors(new AutoValueProcessor(ImmutableList.of(new MemoizeExtension())))
             .compile(file);
-    assertThat(compilation)
-        .hadErrorContaining(error)
-        .inFile(file)
-        .onLineContaining(actual);
+    assertThat(compilation).hadErrorContaining(error).inFile(file).onLineContaining(actual);
   }
 }
diff --git a/value/src/test/java/com/google/auto/value/extension/memoized/MemoizedTest.java b/value/src/test/java/com/google/auto/value/extension/memoized/MemoizedTest.java
index 0bedcf8d..1b2b0e3a 100644
--- a/value/src/test/java/com/google/auto/value/extension/memoized/MemoizedTest.java
+++ b/value/src/test/java/com/google/auto/value/extension/memoized/MemoizedTest.java
@@ -125,7 +125,9 @@ public class MemoizedTest {
     @org.checkerframework.checker.nullness.qual.Nullable
     String nullableWithTypeAnnotation() {
       nullableWithTypeAnnotationCount++;
-      return "nullable derived " + stringWithTypeAnnotation() + " "
+      return "nullable derived "
+          + stringWithTypeAnnotation()
+          + " "
           + nullableWithTypeAnnotationCount;
     }
 
@@ -236,8 +238,9 @@ public class MemoizedTest {
 
   @Before
   public void setUp() {
-    value = new AutoValue_MemoizedTest_Value(
-        "string", "stringWithTypeAnnotation", new HashCodeAndToStringCounter());
+    value =
+        new AutoValue_MemoizedTest_Value(
+            "string", "stringWithTypeAnnotation", new HashCodeAndToStringCounter());
     listValue = new AutoValue_MemoizedTest_ListValue<Integer, String>(0, "hello");
   }
 
@@ -377,8 +380,9 @@ public class MemoizedTest {
     Method nullable =
         AutoValue_MemoizedTest_Value.class.getDeclaredMethod("nullableWithTypeAnnotation");
     AnnotatedType returnType = nullable.getAnnotatedReturnType();
-    assertThat(returnType.isAnnotationPresent(
-                   org.checkerframework.checker.nullness.qual.Nullable.class))
+    assertThat(
+            returnType.isAnnotationPresent(
+                org.checkerframework.checker.nullness.qual.Nullable.class))
         .isTrue();
   }
 
@@ -389,11 +393,13 @@ public class MemoizedTest {
     // [1] @org.checkerframework.checker.nullness.qual.Nullable String stringWithTypeAnnotation,
     // [2] HashCodeAndToStringCounter counter
     // We don't currently copy @javax.annotation.Nullable because it is not a TYPE_USE annotation.
-    Constructor<?> constructor = AutoValue_MemoizedTest_Value.class.getDeclaredConstructor(
-        String.class, String.class, HashCodeAndToStringCounter.class);
+    Constructor<?> constructor =
+        AutoValue_MemoizedTest_Value.class.getDeclaredConstructor(
+            String.class, String.class, HashCodeAndToStringCounter.class);
     AnnotatedType paramType = constructor.getAnnotatedParameterTypes()[1];
-    assertThat(paramType.isAnnotationPresent(
-                   org.checkerframework.checker.nullness.qual.Nullable.class))
+    assertThat(
+            paramType.isAnnotationPresent(
+                org.checkerframework.checker.nullness.qual.Nullable.class))
         .isTrue();
   }
 
@@ -467,8 +473,7 @@ public class MemoizedTest {
 
   @AutoValue
   abstract static class ResourceUriPath<InputT> extends AbstractTypePath<InputT, ResourceUri> {
-    static <InputT> ResourceUriPath<InputT> create(
-        TypeEdgeIterable<InputT, ResourceUri> edges) {
+    static <InputT> ResourceUriPath<InputT> create(TypeEdgeIterable<InputT, ResourceUri> edges) {
       return new AutoValue_MemoizedTest_ResourceUriPath<>(edges);
     }
 
diff --git a/value/src/test/java/com/google/auto/value/extension/serializable/processor/SerializableAutoValueExtensionTest.java b/value/src/test/java/com/google/auto/value/extension/serializable/processor/SerializableAutoValueExtensionTest.java
index 1809bfcf..064406da 100644
--- a/value/src/test/java/com/google/auto/value/extension/serializable/processor/SerializableAutoValueExtensionTest.java
+++ b/value/src/test/java/com/google/auto/value/extension/serializable/processor/SerializableAutoValueExtensionTest.java
@@ -427,8 +427,7 @@ public final class SerializableAutoValueExtensionTest {
     abstract ImmutableMap<String, ImmutableMap<String, Optional<String>>> a();
 
     static ComplexType.Builder builder() {
-      return new AutoValue_SerializableAutoValueExtensionTest_ComplexType
-          .Builder();
+      return new AutoValue_SerializableAutoValueExtensionTest_ComplexType.Builder();
     }
 
     @AutoValue.Builder
diff --git a/value/src/test/java/com/google/auto/value/processor/AutoAnnotationCompilationTest.java b/value/src/test/java/com/google/auto/value/processor/AutoAnnotationCompilationTest.java
index 0227d746..1f79a074 100644
--- a/value/src/test/java/com/google/auto/value/processor/AutoAnnotationCompilationTest.java
+++ b/value/src/test/java/com/google/auto/value/processor/AutoAnnotationCompilationTest.java
@@ -469,9 +469,7 @@ public class AutoAnnotationCompilationTest {
             "  @NotAutoAnnotation Empty notNewEmpty() {}",
             "}");
     Compilation compilation =
-        javac()
-            .withProcessors(new AutoAnnotationProcessor())
-            .compile(erroneousJavaFileObject);
+        javac().withProcessors(new AutoAnnotationProcessor()).compile(erroneousJavaFileObject);
     assertThat(compilation)
         .hadErrorContaining("NotAutoAnnotation")
         .inFile(erroneousJavaFileObject)
diff --git a/value/src/test/java/com/google/auto/value/processor/AutoAnnotationErrorsTest.java b/value/src/test/java/com/google/auto/value/processor/AutoAnnotationErrorsTest.java
index 55a4c5db..094b570d 100644
--- a/value/src/test/java/com/google/auto/value/processor/AutoAnnotationErrorsTest.java
+++ b/value/src/test/java/com/google/auto/value/processor/AutoAnnotationErrorsTest.java
@@ -57,9 +57,7 @@ public class AutoAnnotationErrorsTest {
             "  }",
             "}");
     Compilation compilation =
-        javac()
-            .withProcessors(new AutoAnnotationProcessor())
-            .compile(TEST_ANNOTATION, testSource);
+        javac().withProcessors(new AutoAnnotationProcessor()).compile(TEST_ANNOTATION, testSource);
     assertThat(compilation).succeededWithoutWarnings();
   }
 
@@ -79,9 +77,7 @@ public class AutoAnnotationErrorsTest {
             "  }",
             "}");
     Compilation compilation =
-        javac()
-            .withProcessors(new AutoAnnotationProcessor())
-            .compile(TEST_ANNOTATION, testSource);
+        javac().withProcessors(new AutoAnnotationProcessor()).compile(TEST_ANNOTATION, testSource);
     assertThat(compilation)
         .hadErrorContaining("must be static")
         .inFile(testSource)
@@ -103,9 +99,7 @@ public class AutoAnnotationErrorsTest {
             "  }",
             "}");
     Compilation compilation =
-        javac()
-            .withProcessors(new AutoAnnotationProcessor())
-            .compile(TEST_ANNOTATION, testSource);
+        javac().withProcessors(new AutoAnnotationProcessor()).compile(TEST_ANNOTATION, testSource);
     assertThat(compilation)
         .hadErrorContaining("must be an annotation type, not java.lang.String")
         .inFile(testSource)
@@ -132,9 +126,7 @@ public class AutoAnnotationErrorsTest {
             "  }",
             "}");
     Compilation compilation =
-        javac()
-            .withProcessors(new AutoAnnotationProcessor())
-            .compile(TEST_ANNOTATION, testSource);
+        javac().withProcessors(new AutoAnnotationProcessor()).compile(TEST_ANNOTATION, testSource);
     assertThat(compilation)
         .hadErrorContaining("@AutoAnnotation methods cannot be overloaded")
         .inFile(testSource)
@@ -196,9 +188,7 @@ public class AutoAnnotationErrorsTest {
             "  }",
             "}");
     Compilation compilation =
-        javac()
-            .withProcessors(new AutoAnnotationProcessor())
-            .compile(TEST_ANNOTATION, testSource);
+        javac().withProcessors(new AutoAnnotationProcessor()).compile(TEST_ANNOTATION, testSource);
     assertThat(compilation)
         .hadErrorContaining("method parameter 'fred' must have the same name")
         .inFile(testSource)
@@ -221,9 +211,7 @@ public class AutoAnnotationErrorsTest {
             "  }",
             "}");
     Compilation compilation =
-        javac()
-            .withProcessors(new AutoAnnotationProcessor())
-            .compile(TEST_ANNOTATION, testSource);
+        javac().withProcessors(new AutoAnnotationProcessor()).compile(TEST_ANNOTATION, testSource);
     assertThat(compilation)
         .hadErrorContaining(
             "method parameter 'value' has type java.lang.String "
@@ -267,9 +255,7 @@ public class AutoAnnotationErrorsTest {
               "  }",
               "}");
       Compilation compilation =
-          javac()
-              .withProcessors(new AutoAnnotationProcessor())
-              .compile(testSource, testAnnotation);
+          javac().withProcessors(new AutoAnnotationProcessor()).compile(testSource, testAnnotation);
       assertThat(compilation)
           .hadErrorContaining(
               "method parameter 'value' has type "
@@ -296,9 +282,7 @@ public class AutoAnnotationErrorsTest {
             "  }",
             "}");
     Compilation compilation =
-        javac()
-            .withProcessors(new AutoAnnotationProcessor())
-            .compile(TEST_ANNOTATION, testSource);
+        javac().withProcessors(new AutoAnnotationProcessor()).compile(TEST_ANNOTATION, testSource);
     assertThat(compilation)
         .hadErrorContaining(
             "method parameter 'other' must have the same name as a member of "
@@ -323,9 +307,7 @@ public class AutoAnnotationErrorsTest {
             "  }",
             "}");
     Compilation compilation =
-        javac()
-            .withProcessors(new AutoAnnotationProcessor())
-            .compile(TEST_ANNOTATION, testSource);
+        javac().withProcessors(new AutoAnnotationProcessor()).compile(TEST_ANNOTATION, testSource);
     assertThat(compilation)
         .hadErrorContaining("method needs a parameter with name 'value' and type int")
         .inFile(testSource)
@@ -357,9 +339,7 @@ public class AutoAnnotationErrorsTest {
             "  }",
             "}");
     Compilation compilation =
-        javac()
-            .withProcessors(new AutoAnnotationProcessor())
-            .compile(annotationSource, testSource);
+        javac().withProcessors(new AutoAnnotationProcessor()).compile(annotationSource, testSource);
     assertThat(compilation)
         .hadErrorContaining(
             "@AutoAnnotation cannot yet supply a default value for annotation-valued member "
@@ -399,10 +379,7 @@ public class AutoAnnotationErrorsTest {
             "  }",
             "}");
     Compilation compilation =
-        javac()
-            .withProcessors(new AutoAnnotationProcessor())
-            .compile(annotationSource, testSource);
-    assertThat(compilation)
-        .hadErrorContaining("variable value$ is already defined in constructor");
+        javac().withProcessors(new AutoAnnotationProcessor()).compile(annotationSource, testSource);
+    assertThat(compilation).hadErrorContaining("variable value$ is already defined in constructor");
   }
 }
diff --git a/value/src/test/java/com/google/auto/value/processor/ExtensionTest.java b/value/src/test/java/com/google/auto/value/processor/ExtensionTest.java
index d41fb145..56eaad25 100644
--- a/value/src/test/java/com/google/auto/value/processor/ExtensionTest.java
+++ b/value/src/test/java/com/google/auto/value/processor/ExtensionTest.java
@@ -251,9 +251,7 @@ public class ExtensionTest {
             "  abstract String dizzle();",
             "}");
     Compilation compilation =
-        javac()
-            .withProcessors(new AutoValueProcessor(ImmutableList.of(ext1, ext2)))
-            .compile(impl);
+        javac().withProcessors(new AutoValueProcessor(ImmutableList.of(ext1, ext2))).compile(impl);
     assertThat(compilation)
         .hadErrorContaining("wants to consume a method that was already consumed")
         .inFile(impl)
@@ -597,10 +595,9 @@ public class ExtensionTest {
             "}");
     Compilation compilation =
         javac()
-        .withProcessors(new AutoValueProcessor(ImmutableList.of(new FooExtension())))
-        .compile(javaFileObject);
-    assertThat(compilation)
-        .hadErrorContaining("writeToParcel");
+            .withProcessors(new AutoValueProcessor(ImmutableList.of(new FooExtension())))
+            .compile(javaFileObject);
+    assertThat(compilation).hadErrorContaining("writeToParcel");
     assertThat(compilation)
         .hadWarningContaining(
             "Abstract method is neither a property getter nor a Builder converter, "
@@ -648,13 +645,12 @@ public class ExtensionTest {
             "public abstract class Baz {",
             "}");
     Compilation compilation =
-        javac()
-            .withProcessors(new AutoValueProcessor(badJarLoader))
-            .compile(javaFileObject);
+        javac().withProcessors(new AutoValueProcessor(badJarLoader)).compile(javaFileObject);
     assertThat(compilation).succeeded();
-    assertThat(compilation).hadWarningContaining(
-        "This may be due to a corrupt jar file in the compiler's classpath.\n  "
-            + ServiceConfigurationError.class.getName());
+    assertThat(compilation)
+        .hadWarningContaining(
+            "This may be due to a corrupt jar file in the compiler's classpath.\n  "
+                + ServiceConfigurationError.class.getName());
     assertThat(compilation).generatedSourceFile("foo.bar.AutoValue_Baz");
   }
 
@@ -858,8 +854,12 @@ public class ExtensionTest {
       String sideClassName = "Side_" + context.autoValueClass().getSimpleName();
       String sideClass =
           "" //
-          + "package " + context.packageName() + ";\n"
-          + "class " + sideClassName + " {}\n";
+              + "package "
+              + context.packageName()
+              + ";\n"
+              + "class "
+              + sideClassName
+              + " {}\n";
       Filer filer = context.processingEnvironment().getFiler();
       try {
         String sideClassFqName = context.packageName() + "." + sideClassName;
@@ -913,25 +913,27 @@ public class ExtensionTest {
 
   @Test
   public void propertyTypes() {
-    JavaFileObject parent = JavaFileObjects.forSourceLines(
-        "foo.bar.Parent",
-        "package foo.bar;",
-        "",
-        "import java.util.List;",
-        "",
-        "interface Parent<T> {",
-        "  T thing();",
-        "  List<T> list();",
-        "}");
-    JavaFileObject autoValueClass = JavaFileObjects.forSourceLines(
-        "foo.bar.Baz",
-        "package foo.bar;",
-        "",
-        "import com.google.auto.value.AutoValue;",
-        "",
-        "@AutoValue",
-        "abstract class Baz implements Parent<String> {",
-        "}");
+    JavaFileObject parent =
+        JavaFileObjects.forSourceLines(
+            "foo.bar.Parent",
+            "package foo.bar;",
+            "",
+            "import java.util.List;",
+            "",
+            "interface Parent<T> {",
+            "  T thing();",
+            "  List<T> list();",
+            "}");
+    JavaFileObject autoValueClass =
+        JavaFileObjects.forSourceLines(
+            "foo.bar.Baz",
+            "package foo.bar;",
+            "",
+            "import com.google.auto.value.AutoValue;",
+            "",
+            "@AutoValue",
+            "abstract class Baz implements Parent<String> {",
+            "}");
     ContextChecker checker =
         context -> {
           assertThat(context.builder()).isEmpty();
@@ -956,15 +958,16 @@ public class ExtensionTest {
 
   @Test
   public void finalAutoValueClassName() {
-    JavaFileObject autoValueClass = JavaFileObjects.forSourceLines(
-        "foo.bar.Baz",
-        "package foo.bar;",
-        "",
-        "import com.google.auto.value.AutoValue;",
-        "",
-        "@AutoValue",
-        "abstract class Baz {",
-        "}");
+    JavaFileObject autoValueClass =
+        JavaFileObjects.forSourceLines(
+            "foo.bar.Baz",
+            "package foo.bar;",
+            "",
+            "import com.google.auto.value.AutoValue;",
+            "",
+            "@AutoValue",
+            "abstract class Baz {",
+            "}");
     ContextChecker checker =
         context -> {
           assertThat(context.finalAutoValueClassName()).isEqualTo("foo.bar.AutoValue_Baz");
@@ -983,43 +986,45 @@ public class ExtensionTest {
 
   @Test
   public void builderContext() {
-    JavaFileObject parent = JavaFileObjects.forSourceLines(
-        "foo.bar.Parent",
-        "package foo.bar;",
-        "",
-        "import com.google.common.collect.ImmutableList;",
-        "",
-        "interface Parent<T> {",
-        "  T thing();",
-        "  ImmutableList<T> list();",
-        "}");
-    JavaFileObject autoValueClass = JavaFileObjects.forSourceLines(
-        "foo.bar.Baz",
-        "package foo.bar;",
-        "",
-        "import com.google.auto.value.AutoValue;",
-        "import com.google.common.collect.ImmutableList;",
-        "",
-        "@AutoValue",
-        "abstract class Baz implements Parent<String> {",
-        "  static Builder builder() {",
-        "    return new AutoValue_Baz.Builder();",
-        "  }",
-        "",
-        "  abstract Builder toBuilder();",
-        "",
-        "  @AutoValue.Builder",
-        "  abstract static class Builder {",
-        "    abstract Builder setThing(String x);",
-        "    abstract Builder setList(Iterable<String> x);",
-        "    abstract Builder setList(ImmutableList<String> x);",
-        "    abstract ImmutableList.Builder<String> listBuilder();",
-        "    abstract Baz autoBuild();",
-        "    Baz build() {",
-        "      return autoBuild();",
-        "    }",
-        "  }",
-        "}");
+    JavaFileObject parent =
+        JavaFileObjects.forSourceLines(
+            "foo.bar.Parent",
+            "package foo.bar;",
+            "",
+            "import com.google.common.collect.ImmutableList;",
+            "",
+            "interface Parent<T> {",
+            "  T thing();",
+            "  ImmutableList<T> list();",
+            "}");
+    JavaFileObject autoValueClass =
+        JavaFileObjects.forSourceLines(
+            "foo.bar.Baz",
+            "package foo.bar;",
+            "",
+            "import com.google.auto.value.AutoValue;",
+            "import com.google.common.collect.ImmutableList;",
+            "",
+            "@AutoValue",
+            "abstract class Baz implements Parent<String> {",
+            "  static Builder builder() {",
+            "    return new AutoValue_Baz.Builder();",
+            "  }",
+            "",
+            "  abstract Builder toBuilder();",
+            "",
+            "  @AutoValue.Builder",
+            "  abstract static class Builder {",
+            "    abstract Builder setThing(String x);",
+            "    abstract Builder setList(Iterable<String> x);",
+            "    abstract Builder setList(ImmutableList<String> x);",
+            "    abstract ImmutableList.Builder<String> listBuilder();",
+            "    abstract Baz autoBuild();",
+            "    Baz build() {",
+            "      return autoBuild();",
+            "    }",
+            "  }",
+            "}");
     ContextChecker checker =
         context -> {
           assertThat(context.builder()).isPresent();
@@ -1077,34 +1082,36 @@ public class ExtensionTest {
 
   @Test
   public void builderContextWithInheritance() {
-    JavaFileObject parent = JavaFileObjects.forSourceLines(
-        "foo.bar.Parent",
-        "package foo.bar;",
-        "",
-        "interface Parent<BuilderT> {",
-        "  BuilderT toBuilder();",
-        "  interface Builder<T, BuilderT, BuiltT> {",
-        "    BuilderT setThing(T x);",
-        "    BuiltT build();",
-        "  }",
-        "}");
-    JavaFileObject autoValueClass = JavaFileObjects.forSourceLines(
-        "foo.bar.Baz",
-        "package foo.bar;",
-        "",
-        "import com.google.auto.value.AutoValue;",
-        "",
-        "@AutoValue",
-        "abstract class Baz<T> implements Parent<Baz.Builder<T>> {",
-        "  abstract T thing();",
-        "  static <T> Builder<T> builder() {",
-        "    return new AutoValue_Baz.Builder<>();",
-        "  }",
-        "",
-        "  @AutoValue.Builder",
-        "  abstract static class Builder<T> implements Parent.Builder<T, Builder<T>, Baz<T>> {",
-        "  }",
-        "}");
+    JavaFileObject parent =
+        JavaFileObjects.forSourceLines(
+            "foo.bar.Parent",
+            "package foo.bar;",
+            "",
+            "interface Parent<BuilderT> {",
+            "  BuilderT toBuilder();",
+            "  interface Builder<T, BuilderT, BuiltT> {",
+            "    BuilderT setThing(T x);",
+            "    BuiltT build();",
+            "  }",
+            "}");
+    JavaFileObject autoValueClass =
+        JavaFileObjects.forSourceLines(
+            "foo.bar.Baz",
+            "package foo.bar;",
+            "",
+            "import com.google.auto.value.AutoValue;",
+            "",
+            "@AutoValue",
+            "abstract class Baz<T> implements Parent<Baz.Builder<T>> {",
+            "  abstract T thing();",
+            "  static <T> Builder<T> builder() {",
+            "    return new AutoValue_Baz.Builder<>();",
+            "  }",
+            "",
+            "  @AutoValue.Builder",
+            "  abstract static class Builder<T> implements Parent.Builder<T, Builder<T>, Baz<T>> {",
+            "  }",
+            "}");
     ContextChecker checker =
         context -> {
           assertThat(context.builder()).isPresent();
@@ -1149,26 +1156,27 @@ public class ExtensionTest {
 
   @Test
   public void oddBuilderContext() {
-    JavaFileObject autoValueClass = JavaFileObjects.forSourceLines(
-        "foo.bar.Baz",
-        "package foo.bar;",
-        "",
-        "import com.google.auto.value.AutoValue;",
-        "import com.google.common.collect.ImmutableList;",
-        "",
-        "@AutoValue",
-        "abstract class Baz {",
-        "  abstract String string();",
-        "",
-        "  @AutoValue.Builder",
-        "  abstract static class Builder {",
-        "    abstract Builder setString(String x);",
-        "    abstract Baz oddBuild();",
-        "    Baz build(int butNotReallyBecauseOfThisParameter) {",
-        "      return null;",
-        "    }",
-        "  }",
-        "}");
+    JavaFileObject autoValueClass =
+        JavaFileObjects.forSourceLines(
+            "foo.bar.Baz",
+            "package foo.bar;",
+            "",
+            "import com.google.auto.value.AutoValue;",
+            "import com.google.common.collect.ImmutableList;",
+            "",
+            "@AutoValue",
+            "abstract class Baz {",
+            "  abstract String string();",
+            "",
+            "  @AutoValue.Builder",
+            "  abstract static class Builder {",
+            "    abstract Builder setString(String x);",
+            "    abstract Baz oddBuild();",
+            "    Baz build(int butNotReallyBecauseOfThisParameter) {",
+            "      return null;",
+            "    }",
+            "  }",
+            "}");
     ContextChecker checker =
         context -> {
           assertThat(context.builder()).isPresent();
@@ -1199,25 +1207,26 @@ public class ExtensionTest {
   // https://github.com/google/auto/issues/809
   @Test
   public void propertyErrorShouldNotCrash() {
-    JavaFileObject autoValueClass = JavaFileObjects.forSourceLines(
-        "test.Test",
-        "package test;",
-        "import com.google.auto.value.AutoValue;",
-        "import java.util.List;",
-        "",
-        "@AutoValue",
-        "public abstract class Test {",
-        "  abstract Integer property();",
-        "  abstract List<String> listProperty();",
-        "",
-        "  @AutoValue.Builder",
-        "  public interface Builder {",
-        "    Builder property(Integer property);",
-        "    Builder listProperty(List<String> listProperty);",
-        "    Builder listProperty(Integer listPropertyValues);",
-        "    Test build();",
-        "  }",
-        "}");
+    JavaFileObject autoValueClass =
+        JavaFileObjects.forSourceLines(
+            "test.Test",
+            "package test;",
+            "import com.google.auto.value.AutoValue;",
+            "import java.util.List;",
+            "",
+            "@AutoValue",
+            "public abstract class Test {",
+            "  abstract Integer property();",
+            "  abstract List<String> listProperty();",
+            "",
+            "  @AutoValue.Builder",
+            "  public interface Builder {",
+            "    Builder property(Integer property);",
+            "    Builder listProperty(List<String> listProperty);",
+            "    Builder listProperty(Integer listPropertyValues);",
+            "    Test build();",
+            "  }",
+            "}");
     // We don't actually expect the extension to be invoked. Previously it was, and that led to a
     // NullPointerException when calling .setters() in the checker.
     ContextChecker checker =
diff --git a/value/src/test/java/com/google/auto/value/processor/GeneratedDoesNotExistTest.java b/value/src/test/java/com/google/auto/value/processor/GeneratedDoesNotExistTest.java
index 2e33ddff..18cca5e4 100644
--- a/value/src/test/java/com/google/auto/value/processor/GeneratedDoesNotExistTest.java
+++ b/value/src/test/java/com/google/auto/value/processor/GeneratedDoesNotExistTest.java
@@ -229,9 +229,9 @@ public class GeneratedDoesNotExistTest {
     Processor noGeneratedProcessor = partialProxy(Processor.class, handler);
     Compilation compilation =
         javac()
-        .withOptions(javacOptions)
-        .withProcessors(noGeneratedProcessor)
-        .compile(javaFileObject);
+            .withOptions(javacOptions)
+            .withProcessors(noGeneratedProcessor)
+            .compile(javaFileObject);
     assertThat(compilation).succeededWithoutWarnings();
     assertThat(compilation)
         .generatedSourceFile("foo.bar.AutoValue_Baz")
diff --git a/value/src/test/java/com/google/auto/value/processor/IncrementalExtensionTest.java b/value/src/test/java/com/google/auto/value/processor/IncrementalExtensionTest.java
index 4f526edb..472f62db 100644
--- a/value/src/test/java/com/google/auto/value/processor/IncrementalExtensionTest.java
+++ b/value/src/test/java/com/google/auto/value/processor/IncrementalExtensionTest.java
@@ -62,10 +62,12 @@ public class IncrementalExtensionTest {
     AutoValueExtension nonIsolatingExtension = new NonIsolatingExtension();
     assertThat(nonIsolatingExtension.incrementalType((ProcessingEnvironment) null))
         .isEqualTo(IncrementalExtensionType.UNKNOWN);
-    ImmutableList<AutoValueExtension> extensions = ImmutableList.<AutoValueExtension>builder()
-        .addAll(AutoValueProcessor.extensionsFromLoader(AutoValueProcessor.class.getClassLoader()))
-        .add(nonIsolatingExtension)
-        .build();
+    ImmutableList<AutoValueExtension> extensions =
+        ImmutableList.<AutoValueExtension>builder()
+            .addAll(
+                AutoValueProcessor.extensionsFromLoader(AutoValueProcessor.class.getClassLoader()))
+            .add(nonIsolatingExtension)
+            .build();
 
     AutoValueProcessor processor = new AutoValueProcessor(extensions);
     assertThat(processor.getSupportedOptions())
@@ -77,10 +79,12 @@ public class IncrementalExtensionTest {
     AutoValueExtension isolatingExtension = new IsolatingExtension();
     assertThat(isolatingExtension.incrementalType((ProcessingEnvironment) null))
         .isEqualTo(IncrementalExtensionType.ISOLATING);
-    ImmutableList<AutoValueExtension> extensions = ImmutableList.<AutoValueExtension>builder()
-        .addAll(AutoValueProcessor.extensionsFromLoader(AutoValueProcessor.class.getClassLoader()))
-        .add(isolatingExtension)
-        .build();
+    ImmutableList<AutoValueExtension> extensions =
+        ImmutableList.<AutoValueExtension>builder()
+            .addAll(
+                AutoValueProcessor.extensionsFromLoader(AutoValueProcessor.class.getClassLoader()))
+            .add(isolatingExtension)
+            .build();
 
     AutoValueProcessor processor = new AutoValueProcessor(extensions);
     assertThat(processor.getSupportedOptions())
diff --git a/value/src/test/java/com/google/auto/value/processor/PropertyAnnotationsTest.java b/value/src/test/java/com/google/auto/value/processor/PropertyAnnotationsTest.java
index 8092aa93..48d8cd6e 100644
--- a/value/src/test/java/com/google/auto/value/processor/PropertyAnnotationsTest.java
+++ b/value/src/test/java/com/google/auto/value/processor/PropertyAnnotationsTest.java
@@ -41,8 +41,7 @@ import org.junit.runners.JUnit4;
  */
 @RunWith(JUnit4.class)
 public class PropertyAnnotationsTest {
-  private static final String TEST_ANNOTATION =
-      "@PropertyAnnotationsTest.TestAnnotation";
+  private static final String TEST_ANNOTATION = "@PropertyAnnotationsTest.TestAnnotation";
   private static final String TEST_ARRAY_ANNOTATION =
       "@PropertyAnnotationsTest.TestArrayAnnotation";
 
@@ -449,10 +448,12 @@ public class PropertyAnnotationsTest {
     assertGeneratedMatches(
         getImports(PropertyAnnotationsTest.class),
         ImmutableList.of(
-            TEST_ARRAY_ANNOTATION + "(testEnums = {PropertyAnnotationsTest.TestEnum.A,"
+            TEST_ARRAY_ANNOTATION
+                + "(testEnums = {PropertyAnnotationsTest.TestEnum.A,"
                 + " PropertyAnnotationsTest.TestEnum.B})"),
         ImmutableList.of(
-            TEST_ARRAY_ANNOTATION + "(testEnums = {PropertyAnnotationsTest.TestEnum.A,"
+            TEST_ARRAY_ANNOTATION
+                + "(testEnums = {PropertyAnnotationsTest.TestEnum.A,"
                 + " PropertyAnnotationsTest.TestEnum.B})"));
   }
 
@@ -552,9 +553,7 @@ public class PropertyAnnotationsTest {
             .setImports(getImports(PropertyAnnotationsTest.class))
             .addFieldAnnotations("@Deprecated", "@PropertyAnnotationsTest.InheritedAnnotation")
             .addMethodAnnotations(
-                "@Deprecated",
-                "@PropertyAnnotationsTest.InheritedAnnotation",
-                "@Baz.MethodsOnly")
+                "@Deprecated", "@PropertyAnnotationsTest.InheritedAnnotation", "@Baz.MethodsOnly")
             .build();
 
     Compilation compilation =
diff --git a/value/src/test/java/com/google/auto/value/processor/PropertyNamesTest.java b/value/src/test/java/com/google/auto/value/processor/PropertyNamesTest.java
index 7af240c6..62e8b808 100644
--- a/value/src/test/java/com/google/auto/value/processor/PropertyNamesTest.java
+++ b/value/src/test/java/com/google/auto/value/processor/PropertyNamesTest.java
@@ -34,14 +34,13 @@ public class PropertyNamesTest {
           .put("x", "x")
           .put("", "")
           .build();
-  
+
   @Test
   public void decapitalizeLikeJavaBeans() {
-    NORMAL_CASES
-        .forEach(
-            (input, output) -> {
-              expect.that(PropertyNames.decapitalizeLikeJavaBeans(input)).isEqualTo(output);
-            });
+    NORMAL_CASES.forEach(
+        (input, output) -> {
+          expect.that(PropertyNames.decapitalizeLikeJavaBeans(input)).isEqualTo(output);
+        });
     expect.that(PropertyNames.decapitalizeLikeJavaBeans(null)).isNull();
     expect.that(PropertyNames.decapitalizeLikeJavaBeans("HTMLPage")).isEqualTo("HTMLPage");
     expect.that(PropertyNames.decapitalizeLikeJavaBeans("OAuth")).isEqualTo("OAuth");
@@ -49,11 +48,10 @@ public class PropertyNamesTest {
 
   @Test
   public void decapitalizeNormally() {
-    NORMAL_CASES
-        .forEach(
-            (input, output) -> {
-              expect.that(PropertyNames.decapitalizeNormally(input)).isEqualTo(output);
-            });
+    NORMAL_CASES.forEach(
+        (input, output) -> {
+          expect.that(PropertyNames.decapitalizeNormally(input)).isEqualTo(output);
+        });
     expect.that(PropertyNames.decapitalizeNormally(null)).isNull();
     expect.that(PropertyNames.decapitalizeNormally("HTMLPage")).isEqualTo("hTMLPage");
     expect.that(PropertyNames.decapitalizeNormally("OAuth")).isEqualTo("oAuth");
diff --git a/value/src/test/java/com/google/auto/value/processor/SimplifyWithAnnotationsTest.java b/value/src/test/java/com/google/auto/value/processor/SimplifyWithAnnotationsTest.java
index 39e2dc0e..7bc67790 100644
--- a/value/src/test/java/com/google/auto/value/processor/SimplifyWithAnnotationsTest.java
+++ b/value/src/test/java/com/google/auto/value/processor/SimplifyWithAnnotationsTest.java
@@ -157,8 +157,7 @@ public class SimplifyWithAnnotationsTest {
 
     void testTypeSpellings(TypeElement testClass) {
       ExecutableElement witness =
-          ElementFilter.methodsIn(testClass.getEnclosedElements())
-              .stream()
+          ElementFilter.methodsIn(testClass.getEnclosedElements()).stream()
               .filter(m -> m.getSimpleName().contentEquals("witness"))
               .collect(onlyElement());
       if (witness.getReturnType().getAnnotationMirrors().isEmpty()) {
diff --git a/value/src/test/java/com/google/auto/value/processor/TypeEncoderTest.java b/value/src/test/java/com/google/auto/value/processor/TypeEncoderTest.java
index 095865e4..83951e0a 100644
--- a/value/src/test/java/com/google/auto/value/processor/TypeEncoderTest.java
+++ b/value/src/test/java/com/google/auto/value/processor/TypeEncoderTest.java
@@ -306,6 +306,7 @@ public class TypeEncoderTest {
   @SuppressWarnings("ClassCanBeStatic")
   static class Outer<T extends Number> {
     class InnerWithoutTypeParam {}
+
     class Middle<U> {
       class InnerWithTypeParam<V> {}
     }
diff --git a/value/src/test/java/com/google/auto/value/processor/TypeVariablesTest.java b/value/src/test/java/com/google/auto/value/processor/TypeVariablesTest.java
index 078ef513..895bed25 100644
--- a/value/src/test/java/com/google/auto/value/processor/TypeVariablesTest.java
+++ b/value/src/test/java/com/google/auto/value/processor/TypeVariablesTest.java
@@ -115,10 +115,12 @@ public class TypeVariablesTest {
 
   abstract static class Outer<T, U extends T> {
     abstract Map<T, U> getFoo();
+
     abstract List<? extends T> getBar();
 
     abstract static class Inner<T, U extends T> {
       abstract void setFoo(Map<T, U> foo);
+
       abstract void setBar(List<? extends T> bar);
     }
   }
@@ -165,13 +167,15 @@ public class TypeVariablesTest {
     List<ExecutableElement> immutableMapMethods =
         ElementFilter.methodsIn(immutableMap.getEnclosedElements());
     ExecutableElement copyOf = methodNamed(immutableMapMethods, "copyOf", erasedMap);
-    expect.that(
-        TypeVariables.canAssignStaticMethodResult(
-            copyOf, immutableMapStringInteger, immutableMapStringNumber, typeUtils))
+    expect
+        .that(
+            TypeVariables.canAssignStaticMethodResult(
+                copyOf, immutableMapStringInteger, immutableMapStringNumber, typeUtils))
         .isTrue();
-    expect.that(
-        TypeVariables.canAssignStaticMethodResult(
-            copyOf, immutableMapStringNumber, immutableMapStringInteger, typeUtils))
+    expect
+        .that(
+            TypeVariables.canAssignStaticMethodResult(
+                copyOf, immutableMapStringNumber, immutableMapStringInteger, typeUtils))
         .isFalse();
   }
 
@@ -184,7 +188,9 @@ public class TypeVariablesTest {
     return methods.stream()
         .filter(m -> m.getSimpleName().contentEquals(name))
         .filter(m -> m.getParameters().size() == 1)
-        .filter(m -> typeUtils.isSameType(
+        .filter(
+            m ->
+                typeUtils.isSameType(
                     erasedParameterType, typeUtils.erasure(m.getParameters().get(0).asType())))
         .findFirst()
         .get();