Merge pull request square#484 from google/moe_sync_10/27/2016

Moe sync 10/27/2016

Author: ronshapiro

compiler/src/it/functional-tests/src/main/java/test/ParentModule.java

@@ -25,5 +25,4 @@ abstract class ParentModule<A extends Number & Comparable<A>, B, C extends Itera
   static List<Set<String>> provideStaticGenericTypeWithNoTypeParametersInParameterizedModule() {
     return new ArrayList<>();
   }
-
 }

compiler/src/it/functional-tests/src/main/java/test/cycle/Cycles.java

@@ -30,13 +30,15 @@
 
 /**
  * Cycle classes used for testing cyclic dependencies.
- * A <- (E <- D <- B <- C <- Provider<A>, Lazy<A>), (B <- C <- Provider<A>, Lazy<A>)
- * S <- Provider<S>, Lazy<S>
+ *
+ * <pre>
+ * {@literal A ← (E ← D ← B ← C ← Provider<A>, Lazy<A>), (B ← C ← Provider<A>, Lazy<A>)}
+ * {@literal S ← Provider<S>, Lazy<S>}
+ * </pre>
  *
  * @author Tony Bentancur
  * @since 2.0
  */
-
 final class Cycles {
   private Cycles() {}
 

compiler/src/it/functional-tests/src/test/java/test/GenericTest.java

@@ -144,6 +144,5 @@ public class GenericTest {
     GenericComponent component = DaggerGenericComponent.create();
     assertThat(component.iterableInt()).containsExactly(1, 2).inOrder();
     assertThat(component.iterableDouble()).containsExactly(3d, 4d).inOrder();
-    
   }
 }

compiler/src/it/guava-functional-tests/src/main/java/test/optional/OptionalBindingComponents.java

@@ -31,11 +31,7 @@
 import javax.inject.Provider;
 import javax.inject.Qualifier;
 
-/**
- * Classes to support {@link OptionalBindingComponentsPresentTest}, {@link
- * OptionalBindingComponentsAbsentTest} and {@link
- * test.optional.a.OptionalBindingComponentsWithInaccessibleTypesTest}.
- */
+/** Classes to support testing {@code BindsOptionalOf} functionality. */
 public final class OptionalBindingComponents {
 
   /** A qualifier. */

compiler/src/it/producers-functional-tests/src/main/java/producerstest/binds/FooOfStrings.java

@@ -17,12 +17,11 @@
 package producerstest.binds;
 
 /**
- * This is not marked with {@link javax.inject.Inject @Inject} (like the {@link dagger.Provides
- * @Provides} version in {@link test.bind.FooOfStrings}), to test that {@link dagger.Binds @Binds}
- * properly translate to {@link dagger.internal.codegen.ProductionBinding}s when the right-hand-side
- * of the method is also a production binding. We force this by adding a {@link
- * dagger.producers.Produces @Produces} method to add it to the graph instead of relying on the
- * {@link dagger.internal.codegen.ProvisionBinding} that would be created by default with an {@code
- * @Inject} constructor.
+ * This is not marked with {@link javax.inject.Inject @Inject} in order to test that {@link
+ * dagger.Binds @Binds} properly translate to {@link dagger.internal.codegen.ProductionBinding}s
+ * when the right-hand-side of the method is also a production binding. We force this by adding a
+ * {@link dagger.producers.Produces @Produces} method to add it to the graph instead of relying on
+ * the {@link dagger.internal.codegen.ProvisionBinding} that would be created by default with an
+ * {@code @Inject} constructor.
  */
 final class FooOfStrings implements Foo<String> {}

compiler/src/it/producers-functional-tests/src/main/java/producerstest/optional/OptionalBindingComponents.java

@@ -34,12 +34,10 @@
 import java.lang.annotation.Retention;
 import java.util.concurrent.Executor;
 import java.util.concurrent.Executors;
+import javax.inject.Provider;
 import javax.inject.Qualifier;
 
-/**
- * Classes to support {@link OptionalBindingComponentsAbsentTest} and {@link
- * OptionalBindingComponentsPresentTest}.
- */
+/** Classes to support testing {@code BindsOptionalOf} functionality. */
 final class OptionalBindingComponents {
 
   /** A qualifier. */

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

@@ -27,10 +27,11 @@
 import static dagger.internal.codegen.AbstractComponentWriter.InitializationState.DELEGATED;
 import static dagger.internal.codegen.AbstractComponentWriter.InitializationState.INITIALIZED;
 import static dagger.internal.codegen.AbstractComponentWriter.InitializationState.UNINITIALIZED;
-import static dagger.internal.codegen.AnnotationSpecs.SUPPRESS_WARNINGS_UNCHECKED;
+import static dagger.internal.codegen.AnnotationSpecs.Suppression.RAWTYPES;
+import static dagger.internal.codegen.AnnotationSpecs.Suppression.UNCHECKED;
 import static dagger.internal.codegen.BindingKey.contribution;
 import static dagger.internal.codegen.CodeBlocks.makeParametersCodeBlock;
-import static dagger.internal.codegen.ContributionBinding.FactoryCreationStrategy.ENUM_INSTANCE;
+import static dagger.internal.codegen.ContributionBinding.FactoryCreationStrategy.SINGLETON_INSTANCE;
 import static dagger.internal.codegen.ErrorMessages.CANNOT_RETURN_NULL_FROM_NON_NULLABLE_COMPONENT_METHOD;
 import static dagger.internal.codegen.MapKeys.getMapKeyExpression;
 import static dagger.internal.codegen.MemberSelect.emptyFrameworkMapFactory;
@@ -40,6 +41,7 @@
 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.bindingTypeElementTypeVariableNames;
 import static dagger.internal.codegen.SourceFiles.generatedClassNameForBinding;
 import static dagger.internal.codegen.SourceFiles.membersInjectorNameForType;
 import static dagger.internal.codegen.TypeNames.DELEGATE_FACTORY;
@@ -198,12 +200,8 @@ protected AbstractComponentWriter(
         parent.optionalFactories);
   }
 
-  protected final TypeElement componentDefinitionType() {
-    return graph.componentDescriptor().componentDefinitionType();
-  }
-
   protected final ClassName componentDefinitionTypeName() {
-    return ClassName.get(componentDefinitionType());
+    return ClassName.get(graph.componentType());
   }
 
   /**
@@ -374,7 +372,7 @@ private void addBuildMethod(
       if (componentCanMakeNewInstances(builderFieldEntry.getKey())) {
         buildMethod.addCode(
             "if ($1N == null) { this.$1N = new $2T(); }", builderField, builderField.type);
-      } else if (requiresAPassedInstance(elements, builderFieldEntry.getKey())) {
+      } else if (requiresAPassedInstance(elements, types, builderFieldEntry.getKey())) {
         buildMethod.addCode(
             "if ($N == null) { throw new $T($T.class.getCanonicalName() + $S); }",
             builderField,
@@ -537,7 +535,7 @@ private FieldSpec addFrameworkField(
             contributionBindingField.name());
     contributionField.addModifiers(PRIVATE);
     if (useRawType) {
-      contributionField.addAnnotation(AnnotationSpecs.SUPPRESS_WARNINGS_RAWTYPES);
+      contributionField.addAnnotation(AnnotationSpecs.suppressWarnings(RAWTYPES));
     }
 
     FieldSpec field = contributionField.build();
@@ -568,7 +566,7 @@ private Optional<MemberSelect> staticMemberSelect(ResolvedBindings resolvedBindi
     switch (bindingKey.kind()) {
       case CONTRIBUTION:
         ContributionBinding contributionBinding = resolvedBindings.contributionBinding();
-        if (contributionBinding.factoryCreationStrategy().equals(ENUM_INSTANCE)
+        if (contributionBinding.factoryCreationStrategy().equals(SINGLETON_INSTANCE)
             && !contributionBinding.scope().isPresent()) {
           switch (contributionBinding.bindingKind()) {
             case SYNTHETIC_MULTIBOUND_MAP:
@@ -589,7 +587,7 @@ private Optional<MemberSelect> staticMemberSelect(ResolvedBindings resolvedBindi
             case PROVISION:
               if (bindingKey.key().type().getKind().equals(DECLARED)) {
                 ImmutableList<TypeVariableName> typeVariables =
-                    SourceFiles.bindingTypeElementTypeVariableNames(contributionBinding);
+                    bindingTypeElementTypeVariableNames(contributionBinding);
                 if (!typeVariables.isEmpty()) {
                   List<? extends TypeMirror> typeArguments =
                       ((DeclaredType) bindingKey.key().type()).getTypeArguments();
@@ -696,7 +694,7 @@ private void implementInterfaceMethods() {
         ExecutableType requestType =
             MoreTypes.asExecutable(
                 types.asMemberOf(
-                    MoreTypes.asDeclared(componentDefinitionType().asType()), methodElement));
+                    MoreTypes.asDeclared(graph.componentType().asType()), methodElement));
         MethodSignature signature =
             MethodSignature.fromExecutableType(
                 methodElement.getSimpleName().toString(), requestType);
@@ -795,7 +793,7 @@ private void initializeFrameworkTypes() {
                * initializing a raw field in this method, but the structure of this code makes it
                * awkward to pass that bit through.  This will be cleaned up when we no longer
                * separate fields and initilization as we do now. */
-              .addAnnotation(SUPPRESS_WARNINGS_UNCHECKED)
+              .addAnnotation(AnnotationSpecs.suppressWarnings(UNCHECKED))
               .addCode(CodeBlocks.concat(partition));
       if (builderName.isPresent()) {
         initializeMethod.addParameter(builderName.get(), "builder", FINAL);
@@ -856,7 +854,7 @@ private Optional<CodeBlock> initializeContributionBinding(BindingKey bindingKey)
                         binding.scope().isPresent()
                             ? decorateForScope(delegatingCodeBlock, binding.scope().get())
                             : delegatingCodeBlock))));
-      case ENUM_INSTANCE:
+      case SINGLETON_INSTANCE:
         if (!binding.scope().isPresent()) {
           return Optional.absent();
         }

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

@@ -16,15 +16,32 @@
 
 package dagger.internal.codegen;
 
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.base.Ascii;
+import com.google.common.base.Preconditions;
+import com.google.common.collect.Lists;
 import com.squareup.javapoet.AnnotationSpec;
+import java.util.Arrays;
 
 final class AnnotationSpecs {
+  enum Suppression {
+    RAWTYPES,
+    UNCHECKED,
+    ;
 
-  static final AnnotationSpec SUPPRESS_WARNINGS_UNCHECKED = suppressWarnings("unchecked");
-  static final AnnotationSpec SUPPRESS_WARNINGS_RAWTYPES = suppressWarnings("rawtypes");
+    @Override
+    public String toString() {
+      return Ascii.toLowerCase(name());
+    }
+  }
 
-  private static AnnotationSpec suppressWarnings(String value) {
-    return AnnotationSpec.builder(SuppressWarnings.class).addMember("value", "$S", value).build();
+  static AnnotationSpec suppressWarnings(Suppression first, Suppression... rest) {
+    checkNotNull(first);
+    Arrays.stream(rest).forEach(Preconditions::checkNotNull);
+    AnnotationSpec.Builder builder = AnnotationSpec.builder(SuppressWarnings.class);
+    Lists.asList(first, rest).forEach(suppression -> builder.addMember("value", "$S", suppression));
+    return builder.build();
   }
 
   private AnnotationSpecs() {}

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

@@ -22,6 +22,7 @@
 
 import com.google.auto.common.MoreElements;
 import com.google.auto.value.AutoValue;
+import com.google.auto.value.extension.memoized.Memoized;
 import com.google.common.base.Optional;
 import com.google.common.collect.FluentIterable;
 import com.google.common.collect.ImmutableList;
@@ -112,10 +113,10 @@ final Set<DependencyRequest> dependencies() {
    * binding keys:
    *
    * <dl>
-   * <dt>{@code T}
-   * <dd>{@code String t}
-   * <dt>{@code String}
-   * <dd>{@code String string}
+   *   <dt>{@code T}
+   *   <dd>{@code String t}
+   *   <dt>{@code String}
+   *   <dd>{@code String string}
    * </dl>
    *
    * <p>Note that the sets returned by this method when called on the same binding will be equal,
@@ -124,6 +125,7 @@ final Set<DependencyRequest> dependencies() {
   /* TODO(dpb): The stable-order postcondition is actually hard to verify in code for two equal
    * instances of Binding, because it really depends on the order of the binding's dependencies,
    * and two equal instances of Binding may have the same dependencies in a different order. */
+  @Memoized
   ImmutableList<FrameworkDependency> frameworkDependencies() {
     return ImmutableList.copyOf(
         dependencyAssociations()
@@ -158,6 +160,7 @@ static DependencyAssociation create(
    * multiple times if the {@linkplain Binding#unresolved() unresolved} binding requires it. If that
    * distinction is not important, the entries can be merged into a single mapping.
    */
+  @Memoized
   ImmutableList<DependencyAssociation> dependencyAssociations() {
     BindingTypeMapper bindingTypeMapper = BindingTypeMapper.forBindingType(bindingType());
     ImmutableList.Builder<DependencyAssociation> frameworkDependencies = ImmutableList.builder();
@@ -179,6 +182,7 @@ ImmutableList<DependencyAssociation> dependencyAssociations() {
    * Returns the mapping from each {@linkplain #dependencies dependency} to its associated {@link
    * FrameworkDependency}.
    */
+  @Memoized
   ImmutableMap<DependencyRequest, FrameworkDependency> dependenciesToFrameworkDependenciesMap() {
     ImmutableMap.Builder<DependencyRequest, FrameworkDependency> frameworkDependencyMap =
         ImmutableMap.builder();

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

@@ -17,26 +17,53 @@
 package dagger.internal.codegen;
 
 import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.collect.Sets.immutableEnumSet;
 import static dagger.internal.codegen.ConfigurationAnnotations.getModuleSubcomponents;
 import static dagger.internal.codegen.ErrorMessages.stripCommonTypePrefixes;
 import static dagger.internal.codegen.MoreAnnotationMirrors.simpleName;
 import static dagger.internal.codegen.Util.AS_DECLARED_TYPE;
+import static javax.lang.model.type.TypeKind.DECLARED;
+import static javax.lang.model.type.TypeKind.EXECUTABLE;
 
 import com.google.auto.common.MoreElements;
 import com.google.auto.common.MoreTypes;
 import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Iterables;
 import javax.lang.model.element.Element;
+import javax.lang.model.type.TypeKind;
 import javax.lang.model.type.TypeMirror;
 
 /**
  * Formats a {@link BindingDeclaration} into a {@link String} suitable for use in error messages.
  */
 final class BindingDeclarationFormatter extends Formatter<BindingDeclaration> {
+  private static final ImmutableSet<TypeKind> FORMATTABLE_ELEMENT_TYPE_KINDS =
+      immutableEnumSet(EXECUTABLE, DECLARED);
+
   private final MethodSignatureFormatter methodSignatureFormatter;
+  private final KeyFormatter keyFormatter;
 
-  BindingDeclarationFormatter(MethodSignatureFormatter methodSignatureFormatter) {
+  BindingDeclarationFormatter(
+      MethodSignatureFormatter methodSignatureFormatter, KeyFormatter keyFormatter) {
     this.methodSignatureFormatter = methodSignatureFormatter;
+    this.keyFormatter = keyFormatter;
+  }
+
+  /**
+   * Returns {@code true} for declarations that this formatter can format. Specifically:
+   *
+   * <ul>
+   * <li>Those with {@linkplain BindingDeclaration#bindingElement() binding elements} that are
+   *     methods, constructors, or types.
+   * </ul>
+   */
+  boolean canFormat(BindingDeclaration bindingDeclaration) {
+    if (bindingDeclaration.bindingElement().isPresent()) {
+      return FORMATTABLE_ELEMENT_TYPE_KINDS.contains(
+          bindingDeclaration.bindingElement().get().asType().getKind());
+    }
+    return false;
   }
 
   @Override