Merge pull request square#439 from google/moe_sync_0811

Moe sync 8/11

Author: ronshapiro

compiler/src/main/java/dagger/internal/codegen/AbstractComponentWriter.java

@@ -19,6 +19,7 @@
 import static com.google.common.base.CaseFormat.LOWER_CAMEL;
 import static com.google.common.base.CaseFormat.UPPER_CAMEL;
 import static com.google.common.base.Preconditions.checkState;
+import static com.google.common.base.Verify.verify;
 import static com.google.common.collect.Iterables.getOnlyElement;
 import static com.squareup.javapoet.MethodSpec.constructorBuilder;
 import static com.squareup.javapoet.MethodSpec.methodBuilder;
@@ -38,7 +39,6 @@
 import static dagger.internal.codegen.MemberSelect.staticMethod;
 import static dagger.internal.codegen.MembersInjectionBinding.Strategy.NO_OP;
 import static dagger.internal.codegen.Scope.reusableScope;
-import static dagger.internal.codegen.SourceFiles.frameworkTypeUsageStatement;
 import static dagger.internal.codegen.SourceFiles.generatedClassNameForBinding;
 import static dagger.internal.codegen.SourceFiles.membersInjectorNameForType;
 import static dagger.internal.codegen.TypeNames.DELEGATE_FACTORY;
@@ -87,6 +87,7 @@
 import com.squareup.javapoet.CodeBlock;
 import com.squareup.javapoet.FieldSpec;
 import com.squareup.javapoet.MethodSpec;
+import com.squareup.javapoet.ParameterSpec;
 import com.squareup.javapoet.TypeName;
 import com.squareup.javapoet.TypeSpec;
 import com.squareup.javapoet.TypeVariableName;
@@ -103,12 +104,14 @@
 import dagger.producers.internal.MapProducer;
 import dagger.producers.internal.SetOfProducedProducer;
 import dagger.producers.internal.SetProducer;
+import java.util.EnumSet;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import javax.inject.Provider;
 import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.Modifier;
 import javax.lang.model.element.Name;
 import javax.lang.model.element.TypeElement;
 import javax.lang.model.element.VariableElement;
@@ -141,6 +144,7 @@ abstract class AbstractComponentWriter {
   private final UniqueNameSet componentFieldNames = new UniqueNameSet();
   private final Map<BindingKey, MemberSelect> memberSelects = new HashMap<>();
   private final Map<BindingKey, MemberSelect> producerFromProviderMemberSelects = new HashMap<>();
+  private final Map<BindingKey, RequestFulfillment> requestFulfillments = Maps.newLinkedHashMap();
   protected final MethodSpec.Builder constructor = constructorBuilder().addModifiers(PRIVATE);
   protected Optional<ClassName> builderName = Optional.absent();
 
@@ -654,11 +658,39 @@ private static ClassName frameworkMapFactoryClassName(BindingType bindingType) {
         ? MAP_OF_PRODUCER_PRODUCER : MAP_PROVIDER_FACTORY;
   }
 
+  // TODO(gak): extract this into a proper factory class
+  private RequestFulfillment getOrCreateRequestFulfillment(BindingKey bindingKey) {
+    RequestFulfillment requestFulfillment = requestFulfillments.get(bindingKey);
+    if (requestFulfillment == null) {
+      /* TODO(gak): it is super convoluted that we create the member selects separately and then
+       * look them up again this way. Now that we have RequestFulfillment, the next step is to
+       * create it and the MemberSelect and the field on demand rather than in a first pass. */
+      MemberSelect memberSelect = getMemberSelect(bindingKey);
+      ResolvedBindings resolvedBindings = graph.resolvedBindings().get(bindingKey);
+      switch (resolvedBindings.bindingType()) {
+        case MEMBERS_INJECTION:
+          requestFulfillment = new MembersInjectorRequestFulfillment(bindingKey, memberSelect);
+          break;
+        case PRODUCTION:
+          requestFulfillment = new ProducerFieldRequestFulfillment(bindingKey, memberSelect);
+          break;
+        case PROVISION:
+          requestFulfillment = new ProviderFieldRequestFulfillment(bindingKey, memberSelect);
+          break;
+        default:
+          throw new AssertionError();
+      }
+      requestFulfillments.put(bindingKey, requestFulfillment);
+    }
+    return requestFulfillment;
+  }
+
   private void implementInterfaceMethods() {
     Set<MethodSignature> interfaceMethods = Sets.newHashSet();
     for (ComponentMethodDescriptor componentMethod :
         graph.componentDescriptor().componentMethods()) {
       if (componentMethod.dependencyRequest().isPresent()) {
+        DependencyRequest interfaceRequest = componentMethod.dependencyRequest().get();
         ExecutableElement methodElement =
             MoreElements.asExecutable(componentMethod.methodElement());
         ExecutableType requestType =
@@ -671,52 +703,67 @@ private void implementInterfaceMethods() {
         if (!interfaceMethods.contains(signature)) {
           interfaceMethods.add(signature);
           MethodSpec.Builder interfaceMethod =
-              methodBuilder(methodElement.getSimpleName().toString())
-                  .addAnnotation(Override.class)
-                  .addModifiers(PUBLIC)
-                  .returns(TypeName.get(requestType.getReturnType()));
-          DependencyRequest interfaceRequest = componentMethod.dependencyRequest().get();
-          BindingKey bindingKey = interfaceRequest.bindingKey();
-          MemberSelect memberSelect = getMemberSelect(bindingKey);
-          CodeBlock memberSelectCodeBlock = memberSelect.getExpressionFor(name);
+              methodSpecForComponentMethod(methodElement, requestType);
+          RequestFulfillment fulfillment =
+              getOrCreateRequestFulfillment(interfaceRequest.bindingKey());
+          CodeBlock codeBlock = fulfillment.getSnippetForDependencyRequest(interfaceRequest, name);
           switch (interfaceRequest.kind()) {
             case MEMBERS_INJECTOR:
               List<? extends VariableElement> parameters = methodElement.getParameters();
               if (parameters.isEmpty()) {
                 // we're returning the framework type
-                interfaceMethod.addStatement("return $L", memberSelectCodeBlock);
+                interfaceMethod.addStatement("return $L", codeBlock);
               } else {
-                Name parameterName = Iterables.getOnlyElement(parameters).getSimpleName();
-                interfaceMethod.addParameter(
-                    TypeName.get(Iterables.getOnlyElement(requestType.getParameterTypes())),
-                    parameterName.toString());
-                interfaceMethod.addStatement(
-                    "$L.injectMembers($L)", memberSelectCodeBlock, parameterName);
+                Name parameterName =
+                    Iterables.getOnlyElement(methodElement.getParameters()).getSimpleName();
+                interfaceMethod.addStatement("$L.injectMembers($L)", codeBlock, parameterName);
                 if (!requestType.getReturnType().getKind().equals(VOID)) {
                   interfaceMethod.addStatement("return $L", parameterName);
                 }
               }
               break;
-            case INSTANCE:
-            case LAZY:
-            case PRODUCED:
-            case PRODUCER:
-            case PROVIDER:
-            case PROVIDER_OF_LAZY:
-            case FUTURE:
-              interfaceMethod.addStatement(
-                  "return $L",
-                  frameworkTypeUsageStatement(memberSelectCodeBlock, interfaceRequest.kind()));
-              break;
             default:
-              throw new AssertionError();
+              interfaceMethod.addStatement("return $L", codeBlock);
+              break;
           }
           component.addMethod(interfaceMethod.build());
         }
       }
     }
   }
 
+  public MethodSpec.Builder methodSpecForComponentMethod(
+      ExecutableElement method, ExecutableType methodType) {
+    String methodName = method.getSimpleName().toString();
+    MethodSpec.Builder methodBuilder = MethodSpec.methodBuilder(methodName);
+
+    methodBuilder.addAnnotation(Override.class);
+
+    Set<Modifier> modifiers = EnumSet.copyOf(method.getModifiers());
+    modifiers.remove(Modifier.ABSTRACT);
+    methodBuilder.addModifiers(modifiers);
+
+    methodBuilder.returns(TypeName.get(methodType.getReturnType()));
+
+    List<? extends VariableElement> parameters = method.getParameters();
+    List<? extends TypeMirror> resolvedParameterTypes = methodType.getParameterTypes();
+    verify(parameters.size() == resolvedParameterTypes.size());
+    for (int i = 0; i < parameters.size(); i++) {
+      VariableElement parameter = parameters.get(i);
+      TypeName type = TypeName.get(resolvedParameterTypes.get(i));
+      String name = parameter.getSimpleName().toString();
+      Set<Modifier> parameterModifiers = parameter.getModifiers();
+      ParameterSpec.Builder parameterBuilder =
+          ParameterSpec.builder(type, name)
+              .addModifiers(parameterModifiers.toArray(new Modifier[0]));
+      methodBuilder.addParameter(parameterBuilder.build());
+    }
+    for (TypeMirror thrownType : method.getThrownTypes()) {
+      methodBuilder.addException(TypeName.get(thrownType));
+    }
+    return methodBuilder;
+  }
+
   private void addSubcomponents() {
     for (Map.Entry<ExecutableElement, BindingGraph> subgraphEntry : graph.subgraphs().entrySet()) {
       SubcomponentWriter subcomponent =

compiler/src/main/java/dagger/internal/codegen/CodeBlocks.java

@@ -40,16 +40,20 @@ static CodeBlock concat(Iterable<CodeBlock> codeBlocks) {
     return join(codeBlocks, "\n");
   }
 
-  static CodeBlock join(Iterable<CodeBlock> codeBlocks, String delimiter) {
-    CodeBlock.Builder builder = CodeBlock.builder();
+  static CodeBlock.Builder join(
+      CodeBlock.Builder builder, Iterable<CodeBlock> codeBlocks, String delimiter) {
     Iterator<CodeBlock> iterator = codeBlocks.iterator();
     while (iterator.hasNext()) {
       builder.add(iterator.next());
       if (iterator.hasNext()) {
         builder.add(delimiter);
       }
     }
-    return builder.build();
+    return builder;
+  }
+
+  static CodeBlock join(Iterable<CodeBlock> codeBlocks, String delimiter) {
+    return join(CodeBlock.builder(), codeBlocks, delimiter).build();
   }
 
   static FluentIterable<CodeBlock> toCodeBlocks(Iterable<? extends TypeMirror> typeMirrors) {
@@ -68,12 +72,12 @@ public CodeBlock apply(TypeMirror typeMirror) {
         }
       };
 
-  static Function<ParameterSpec, CodeBlock> PARAMETER_NAME =
+  static final Function<ParameterSpec, CodeBlock> PARAMETER_NAME =
       new Function<ParameterSpec, CodeBlock>() {
-          @Override
-          public CodeBlock apply(ParameterSpec input) {
-            return CodeBlock.of("$N", input);
-          }
+        @Override
+        public CodeBlock apply(ParameterSpec input) {
+          return CodeBlock.of("$N", input);
+        }
       };
 
   private CodeBlocks() {}

compiler/src/main/java/dagger/internal/codegen/ComponentProcessor.java

@@ -115,7 +115,7 @@ protected Iterable<? extends ProcessingStep> initSteps() {
         new ProductionExecutorModuleGenerator(filer, elements);
 
     DependencyRequest.Factory dependencyRequestFactory =
-        new DependencyRequest.Factory(elements, keyFactory);
+        new DependencyRequest.Factory(keyFactory);
     ProvisionBinding.Factory provisionBindingFactory =
         new ProvisionBinding.Factory(elements, types, keyFactory, dependencyRequestFactory);
     ProductionBinding.Factory productionBindingFactory =

compiler/src/main/java/dagger/internal/codegen/DependencyRequest.java

@@ -23,7 +23,6 @@
 import static com.google.common.base.Preconditions.checkNotNull;
 import static com.google.common.base.Preconditions.checkState;
 import static com.google.common.collect.Iterables.getOnlyElement;
-import static javax.lang.model.util.ElementFilter.constructorsIn;
 
 import com.google.auto.common.MoreTypes;
 import com.google.auto.value.AutoValue;
@@ -40,22 +39,19 @@
 import dagger.internal.codegen.DependencyRequest.Factory.KindAndType;
 import dagger.producers.Produced;
 import dagger.producers.Producer;
-import dagger.producers.internal.AbstractProducer;
 import java.util.List;
 import javax.annotation.CheckReturnValue;
 import javax.inject.Inject;
 import javax.inject.Provider;
 import javax.lang.model.element.AnnotationMirror;
 import javax.lang.model.element.Element;
 import javax.lang.model.element.ExecutableElement;
-import javax.lang.model.element.TypeElement;
 import javax.lang.model.element.VariableElement;
 import javax.lang.model.type.DeclaredType;
 import javax.lang.model.type.ErrorType;
 import javax.lang.model.type.ExecutableType;
 import javax.lang.model.type.TypeKind;
 import javax.lang.model.type.TypeMirror;
-import javax.lang.model.util.Elements;
 import javax.lang.model.util.SimpleTypeVisitor7;
 
 /**
@@ -201,11 +197,9 @@ abstract static class Builder {
    * which may mean that the type will be generated in a later round of processing.
    */
   static final class Factory {
-    private final Elements elements;
     private final Key.Factory keyFactory;
 
-    Factory(Elements elements, Key.Factory keyFactory) {
-      this.elements = elements;
+    Factory(Key.Factory keyFactory) {
       this.keyFactory = keyFactory;
     }
 
@@ -371,15 +365,14 @@ DependencyRequest forProductionImplementationExecutor() {
           .build();
     }
 
-    DependencyRequest forProductionComponentMonitorProvider() {
-      TypeElement element = elements.getTypeElement(AbstractProducer.class.getCanonicalName());
-      for (ExecutableElement constructor : constructorsIn(element.getEnclosedElements())) {
-        if (constructor.getParameters().size() == 2) {
-          // the 2-arg constructor has the appropriate dependency as its first arg
-          return forRequiredVariable(constructor.getParameters().get(0), Optional.of("monitor"));
-        }
-      }
-      throw new AssertionError("expected 2-arg constructor in AbstractProducer");
+    DependencyRequest forProductionComponentMonitor() {
+      Key key = keyFactory.forProductionComponentMonitor();
+      return DependencyRequest.builder()
+          .kind(Kind.PROVIDER)
+          .key(key)
+          .requestElement(MoreTypes.asElement(key.type()))
+          .overriddenVariableName(Optional.of("monitor"))
+          .build();
     }
 
     private DependencyRequest newDependencyRequest(

compiler/src/main/java/dagger/internal/codegen/Key.java

@@ -49,6 +49,7 @@
 import dagger.producers.Producer;
 import dagger.producers.Production;
 import dagger.producers.internal.ProductionImplementation;
+import dagger.producers.monitoring.ProductionComponentMonitor;
 import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.Executor;
@@ -508,6 +509,12 @@ Key forProductionImplementationExecutor() {
           getClassElement(Executor.class).asType());
     }
 
+    Key forProductionComponentMonitor() {
+      return forQualifiedType(
+          Optional.<AnnotationMirror>absent(),
+          getClassElement(ProductionComponentMonitor.class).asType());
+    }
+
     /**
      * If {@code requestKey} is for a {@code Map<K, V>} or {@code Map<K, Produced<V>>}, returns keys
      * for {@code Map<K, Provider<V>>} and {@code Map<K, Producer<V>>} (if Dagger-Producers is on

compiler/src/main/java/dagger/internal/codegen/MembersInjectorRequestFulfillment.java

@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2016 The Dagger Authors.
+ *
+ * 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 dagger.internal.codegen;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static dagger.internal.codegen.BindingKey.Kind.MEMBERS_INJECTION;
+
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.CodeBlock;
+import dagger.internal.codegen.DependencyRequest.Kind;
+
+/** Fulfills requests for {@link MembersInjectionBinding} instances. */
+final class MembersInjectorRequestFulfillment extends RequestFulfillment {
+  private final MemberSelect membersInjectorFieldSelect;
+
+  MembersInjectorRequestFulfillment(
+      BindingKey bindingKey, MemberSelect membersInjectorFieldSelect) {
+    super(bindingKey);
+    checkArgument(bindingKey.kind().equals(MEMBERS_INJECTION));
+    this.membersInjectorFieldSelect = membersInjectorFieldSelect;
+  }
+
+  @Override
+  public CodeBlock getSnippetForDependencyRequest(
+      DependencyRequest request, ClassName requestingClass) {
+    checkArgument(request.kind().equals(Kind.MEMBERS_INJECTOR));
+    return membersInjectorFieldSelect.getExpressionFor(requestingClass);
+  }
+}