Allow varargs on @AutoFactory methods

Github: Fixes google/auto#326

-------------
Created by MOE: https://github.com/google/moe
MOE_MIGRATED_REVID=130784801

8 files changed, 121 insertions, 43 deletions

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 fc466997..954cf2ac 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
@@ -104,45 +104,11 @@ public final class AutoFactoryProcessor extends AbstractProcessor {
       if (declaration.isPresent()) {
         String factoryName = declaration.get().getFactoryName();
         TypeElement extendingType = declaration.get().extendingType();
-        List<ExecutableElement> supertypeMethods =
-            ElementFilter.methodsIn(elements.getAllMembers(extendingType));
-        for (ExecutableElement supertypeMethod : supertypeMethods) {
-          if (supertypeMethod.getModifiers().contains(Modifier.ABSTRACT)) {
-            ExecutableType methodType = Elements2.getExecutableElementAsMemberOf(
-                types, supertypeMethod, extendingType);
-            ImmutableSet<Parameter> passedParameters =
-                Parameter.forParameterList(
-                    supertypeMethod.getParameters(), methodType.getParameterTypes(), types);
-            implementationMethodDescriptorsBuilder.put(
-                factoryName,
-                ImplementationMethodDescriptor.builder()
-                    .name(supertypeMethod.getSimpleName().toString())
-                    .returnType(getAnnotatedType(element))
-                    .publicMethod()
-                    .passedParameters(passedParameters)
-                    .build());
-          }
-        }
+        implementationMethodDescriptorsBuilder.putAll(
+            factoryName, implementationMethods(extendingType, element));
         for (TypeElement implementingType : declaration.get().implementingTypes()) {
-          List<ExecutableElement> interfaceMethods =
-              ElementFilter.methodsIn(elements.getAllMembers(implementingType));
-          for (ExecutableElement interfaceMethod : interfaceMethods) {
-            if (interfaceMethod.getModifiers().contains(Modifier.ABSTRACT)) {
-              ExecutableType methodType = Elements2.getExecutableElementAsMemberOf(
-                  types, interfaceMethod, implementingType);
-              ImmutableSet<Parameter> passedParameters =
-                  Parameter.forParameterList(
-                      interfaceMethod.getParameters(), methodType.getParameterTypes(), types);
-              implementationMethodDescriptorsBuilder.put(
-                  factoryName,
-                  ImplementationMethodDescriptor.builder()
-                      .name(interfaceMethod.getSimpleName().toString())
-                      .returnType(getAnnotatedType(element))
-                      .publicMethod()
-                      .passedParameters(passedParameters)
-                      .build());
-            }
-          }
+          implementationMethodDescriptorsBuilder.putAll(
+              factoryName, implementationMethods(implementingType, element));
         }
       }
 
@@ -207,6 +173,32 @@ public final class AutoFactoryProcessor extends AbstractProcessor {
     }
   }
 
+  private ImmutableSet<ImplementationMethodDescriptor> implementationMethods(
+      TypeElement supertype, Element autoFactoryElement) {
+    ImmutableSet.Builder<ImplementationMethodDescriptor> implementationMethodsBuilder =
+        ImmutableSet.builder();
+    for (ExecutableElement implementationMethod :
+        ElementFilter.methodsIn(elements.getAllMembers(supertype))) {
+      if (implementationMethod.getModifiers().contains(Modifier.ABSTRACT)) {
+        ExecutableType methodType =
+            Elements2.getExecutableElementAsMemberOf(
+                types, implementationMethod, supertype);
+        ImmutableSet<Parameter> passedParameters =
+            Parameter.forParameterList(
+                implementationMethod.getParameters(), methodType.getParameterTypes(), types);
+        implementationMethodsBuilder.add(
+            ImplementationMethodDescriptor.builder()
+                .name(implementationMethod.getSimpleName().toString())
+                .returnType(getAnnotatedType(autoFactoryElement))
+                .publicMethod()
+                .passedParameters(passedParameters)
+                .isVarArgs(implementationMethod.isVarArgs())
+                .build());
+      }
+    }
+    return implementationMethodsBuilder.build();
+  }
+
   private TypeMirror getAnnotatedType(Element element) {
     List<TypeElement> types = ImmutableList.of();
     while (types.isEmpty()) {
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 00de30ac..339ed645 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
@@ -142,6 +142,7 @@ final class FactoryDescriptorGenerator {
         .providedParameters(providedParameters)
         .passedParameters(passedParameters)
         .creationParameters(Parameter.forParameterList(constructor.getParameters(), types))
+        .isVarArgs(constructor.isVarArgs())
         .build();
   }
 
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 59b6178a..1307622e 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
@@ -39,6 +39,7 @@ abstract class FactoryMethodDescriptor {
   abstract ImmutableSet<Parameter> providedParameters();
   abstract ImmutableSet<Parameter> creationParameters();
   abstract Builder toBuilder();
+  abstract boolean isVarArgs();
 
   final String factoryName() {
     return declaration().getFactoryName();
@@ -48,7 +49,8 @@ abstract class FactoryMethodDescriptor {
     return new AutoValue_FactoryMethodDescriptor.Builder()
         .declaration(checkNotNull(declaration))
         .publicMethod(false)
-        .overridingMethod(false);
+        .overridingMethod(false)
+        .isVarArgs(false);
   }
 
   @AutoValue.Builder
@@ -61,6 +63,7 @@ abstract class FactoryMethodDescriptor {
     abstract Builder passedParameters(Iterable<Parameter> passedParameters);
     abstract Builder providedParameters(Iterable<Parameter> providedParameters);
     abstract Builder creationParameters(Iterable<Parameter> creationParameters);
+    abstract Builder isVarArgs(boolean isVarargs);
     abstract FactoryMethodDescriptor buildImpl();
 
     FactoryMethodDescriptor build() {
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 813da323..cf3ec89a 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
@@ -124,10 +124,11 @@ final class FactoryWriter {
   }
 
   private void addFactoryMethods(TypeSpec.Builder factory, FactoryDescriptor descriptor) {
-    for (final FactoryMethodDescriptor methodDescriptor : descriptor.methodDescriptors()) {
+    for (FactoryMethodDescriptor methodDescriptor : descriptor.methodDescriptors()) {
       MethodSpec.Builder method =
           MethodSpec.methodBuilder(methodDescriptor.name())
-              .returns(TypeName.get(methodDescriptor.returnType()));
+              .returns(TypeName.get(methodDescriptor.returnType()))
+              .varargs(methodDescriptor.isVarArgs());
       if (methodDescriptor.overridingMethod()) {
         method.addAnnotation(Override.class);
       }
@@ -176,7 +177,8 @@ final class FactoryWriter {
       MethodSpec.Builder implementationMethod =
           methodBuilder(methodDescriptor.name())
               .addAnnotation(Override.class)
-              .returns(TypeName.get(methodDescriptor.returnType()));
+              .returns(TypeName.get(methodDescriptor.returnType()))
+              .varargs(methodDescriptor.isVarArgs());
       if (methodDescriptor.publicMethod()) {
         implementationMethod.addModifiers(PUBLIC);
       }
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 573f0958..88f91ca1 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
@@ -25,9 +25,12 @@ abstract class ImplementationMethodDescriptor {
   abstract TypeMirror returnType();
   abstract boolean publicMethod();
   abstract ImmutableSet<Parameter> passedParameters();
+  abstract boolean isVarArgs();
 
   static Builder builder() {
-    return new AutoValue_ImplementationMethodDescriptor.Builder().publicMethod(true);
+    return new AutoValue_ImplementationMethodDescriptor.Builder()
+        .publicMethod(true)
+        .isVarArgs(false);
   }
 
   @AutoValue.Builder
@@ -36,6 +39,7 @@ abstract class ImplementationMethodDescriptor {
     abstract Builder returnType(TypeMirror returnTypeElement);
     abstract Builder publicMethod(boolean publicMethod);
     abstract Builder passedParameters(Iterable<Parameter> passedParameters);
+    abstract Builder isVarArgs(boolean isVarargs);
     abstract ImplementationMethodDescriptor build();
 
     Builder publicMethod() {
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 bf172bc0..58228ee4 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
@@ -387,4 +387,12 @@ public class AutoFactoryProcessorTest {
             JavaFileObjects.forResource(
                 "expected/MultipleFactoriesConflictingParameterNamesFactory.java"));
   }
+
+  @Test public void factoryVarargs() {
+    assertThat(JavaFileObjects.forResource("good/SimpleClassVarargs.java"))
+        .processedWith(new AutoFactoryProcessor())
+        .compilesWithoutError()
+        .and()
+        .generatesSources(JavaFileObjects.forResource("expected/SimpleClassVarargsFactory.java"));
+  }
 }
diff --git a/factory/src/test/resources/expected/SimpleClassVarargsFactory.java b/factory/src/test/resources/expected/SimpleClassVarargsFactory.java
new file mode 100644
index 00000000..e8b13161
--- /dev/null
+++ b/factory/src/test/resources/expected/SimpleClassVarargsFactory.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2016 Google, Inc.
+ *
+ * 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 the License.
+ */
+package tests;
+
+import com.google.auto.factory.internal.Preconditions;
+import javax.annotation.Generated;
+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() {}
+
+  SimpleClassVarargs create(String... args) {
+    return new SimpleClassVarargs(Preconditions.checkNotNull(args, 1));
+  }
+
+  @Override
+  public SimpleClassVarargs build(String... args) {
+    return create(args);
+  }
+}
diff --git a/factory/src/test/resources/good/SimpleClassVarargs.java b/factory/src/test/resources/good/SimpleClassVarargs.java
new file mode 100644
index 00000000..125f35eb
--- /dev/null
+++ b/factory/src/test/resources/good/SimpleClassVarargs.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2016 Google, Inc.
+ *
+ * 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 the License.
+ */
+package tests;
+
+import com.google.auto.factory.AutoFactory;
+
+@AutoFactory(implementing = SimpleClassVarargs.InterfaceWithVarargs.class)
+final class SimpleClassVarargs {
+  private final String[] args;
+
+  SimpleClassVarargs(String... args) {
+    this.args = args;
+  }
+
+  interface InterfaceWithVarargs {
+    SimpleClassVarargs build(String... args);
+  }
+}