java/dagger/internal/codegen/writing/ComponentImplementation.java - platform/external/dagger2 - Git at Google

 /*
  * 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.writing;

 import static com.google.common.base.CaseFormat.LOWER_CAMEL;
 import static com.google.common.base.CaseFormat.UPPER_CAMEL;
 import static com.google.common.base.CaseFormat.UPPER_UNDERSCORE;
 import static com.google.common.base.Preconditions.checkArgument;
 import static com.google.common.base.Preconditions.checkState;
 import static com.squareup.javapoet.TypeSpec.classBuilder;
 import static dagger.internal.codegen.binding.ComponentCreatorKind.BUILDER;
 import static dagger.internal.codegen.langmodel.Accessibility.isTypeAccessibleFrom;
 import static javax.lang.model.element.Modifier.FINAL;
 import static javax.lang.model.element.Modifier.PRIVATE;
 import static javax.lang.model.element.Modifier.PUBLIC;

 import com.google.common.base.Supplier;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.ListMultimap;
 import com.google.common.collect.MultimapBuilder;
 import com.squareup.javapoet.AnnotationSpec;
 import com.squareup.javapoet.ClassName;
 import com.squareup.javapoet.CodeBlock;
 import com.squareup.javapoet.FieldSpec;
 import com.squareup.javapoet.MethodSpec;
 import com.squareup.javapoet.TypeSpec;
 import dagger.internal.codegen.base.UniqueNameSet;
 import dagger.internal.codegen.binding.BindingGraph;
 import dagger.internal.codegen.binding.BindingRequest;
 import dagger.internal.codegen.binding.ComponentCreatorDescriptor;
 import dagger.internal.codegen.binding.ComponentCreatorKind;
 import dagger.internal.codegen.binding.ComponentDescriptor;
 import dagger.internal.codegen.binding.ComponentRequirement;
 import dagger.internal.codegen.binding.KeyVariableNamer;
 import dagger.internal.codegen.compileroption.CompilerOptions;
 import dagger.internal.codegen.javapoet.TypeSpecs;
 import dagger.model.Key;
 import dagger.model.RequestKind;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
 import java.util.Set;
 import javax.lang.model.element.Modifier;
 import javax.lang.model.element.TypeElement;
 import javax.lang.model.type.TypeMirror;

 /** The implementation of a component type. */
 public final class ComponentImplementation {
   /** A type of field that this component can contain. */
   public enum FieldSpecKind {
     /** A field for a component shard. */
     COMPONENT_SHARD,

     /** A field required by the component, e.g. module instances. */
     COMPONENT_REQUIREMENT_FIELD,

     /**
      * A field for the lock and cached value for {@linkplain PrivateMethodBindingExpression
      * private-method scoped bindings}.
      */
     PRIVATE_METHOD_SCOPED_FIELD,

     /** A framework field for type T, e.g. {@code Provider<T>}. */
     FRAMEWORK_FIELD,

     /** A static field that always returns an absent {@code Optional} value for the binding. */
     ABSENT_OPTIONAL_FIELD
   }

   /** A type of method that this component can contain. */
   // TODO(bcorso, dpb): Change the oder to constructor, initialize, component, then private
   // (including MIM and AOM—why treat those separately?).
   public enum MethodSpecKind {
     /** The component constructor. */
     CONSTRUCTOR,

     /** A builder method for the component. (Only used by the root component.) */
     BUILDER_METHOD,

     /** A private method that wraps dependency expressions. */
     PRIVATE_METHOD,

     /** An initialization method that initializes component requirements and framework types. */
     INITIALIZE_METHOD,

     /** An implementation of a component interface method. */
     COMPONENT_METHOD,

     /** A private method that encapsulates members injection logic for a binding. */
     MEMBERS_INJECTION_METHOD,

     /** A static method that always returns an absent {@code Optional} value for the binding. */
     ABSENT_OPTIONAL_METHOD,

     /**
      * The {@link dagger.producers.internal.CancellationListener#onProducerFutureCancelled(boolean)}
      * method for a production component.
      */
     CANCELLATION_LISTENER_METHOD,
     ;
   }

   /** A type of nested class that this component can contain. */
   public enum TypeSpecKind {
     /** A factory class for a present optional binding. */
     PRESENT_FACTORY,

     /** A class for the component creator (only used by the root component.) */
     COMPONENT_CREATOR,

     /** A provider class for a component provision. */
     COMPONENT_PROVISION_FACTORY,

     /** A class for the subcomponent or subcomponent builder. */
     SUBCOMPONENT
   }

   private ComponentImplementation currentShard = this;
   private final Map<Key, ComponentImplementation> shardsByKey = new HashMap<>();
   private final Optional<ComponentImplementation> shardOwner;
   private final BindingGraph graph;
   private final ClassName name;
   private final TypeSpec.Builder component;
   private final SubcomponentNames subcomponentNames;
   private final CompilerOptions compilerOptions;
   private final CodeBlock externalReferenceBlock;
   private final UniqueNameSet componentFieldNames = new UniqueNameSet();
   private final UniqueNameSet componentMethodNames = new UniqueNameSet();
   private final List<CodeBlock> initializations = new ArrayList<>();
   private final List<CodeBlock> componentRequirementInitializations = new ArrayList<>();
   private final Map<ComponentRequirement, String> componentRequirementParameterNames =
       new HashMap<>();
   private final Set<Key> cancellableProducerKeys = new LinkedHashSet<>();
   private final ListMultimap<FieldSpecKind, FieldSpec> fieldSpecsMap =
       MultimapBuilder.enumKeys(FieldSpecKind.class).arrayListValues().build();
   private final ListMultimap<MethodSpecKind, MethodSpec> methodSpecsMap =
       MultimapBuilder.enumKeys(MethodSpecKind.class).arrayListValues().build();
   private final ListMultimap<TypeSpecKind, TypeSpec> typeSpecsMap =
       MultimapBuilder.enumKeys(TypeSpecKind.class).arrayListValues().build();
   private final List<Supplier<TypeSpec>> typeSuppliers = new ArrayList<>();

   private ComponentImplementation(
       BindingGraph graph,
       ClassName name,
       SubcomponentNames subcomponentNames,
       CompilerOptions compilerOptions) {
     this.graph = graph;
     this.name = name;
     this.component = classBuilder(name);
     this.subcomponentNames = subcomponentNames;
     this.shardOwner = Optional.empty();
     this.externalReferenceBlock = CodeBlock.of("$T.this", name);
     this.compilerOptions = compilerOptions;
   }

   private ComponentImplementation(ComponentImplementation shardOwner, ClassName shardName) {
     this.graph = shardOwner.graph;
     this.name = shardName;
     this.component = classBuilder(shardName);
     this.subcomponentNames = shardOwner.subcomponentNames;
     this.compilerOptions = shardOwner.compilerOptions;
     this.shardOwner = Optional.of(shardOwner);
     String fieldName = UPPER_CAMEL.to(LOWER_CAMEL, name.simpleName());
     String uniqueFieldName = shardOwner.getUniqueFieldName(fieldName);
     this.externalReferenceBlock = CodeBlock.of("$T.this.$N", shardOwner.name, uniqueFieldName);
     shardOwner.addTypeSupplier(() -> generate().build());
     shardOwner.addField(
         FieldSpecKind.COMPONENT_SHARD,
         FieldSpec.builder(name, uniqueFieldName, PRIVATE, FINAL)
             .initializer("new $T()", name)
             .build());
   }

   /** Returns a component implementation for a top-level component. */
   public static ComponentImplementation topLevelComponentImplementation(
       BindingGraph graph,
       ClassName name,
       SubcomponentNames subcomponentNames,
       CompilerOptions compilerOptions) {
     return new ComponentImplementation(graph, name, subcomponentNames, compilerOptions);
   }

   /** Returns a component implementation that is a child of the current implementation. */
   public ComponentImplementation childComponentImplementation(BindingGraph graph) {
     checkState(!shardOwner.isPresent(), "Shards cannot create child components.");
     ClassName childName = getSubcomponentName(graph.componentDescriptor());
     return new ComponentImplementation(graph, childName, subcomponentNames, compilerOptions);
   }

   /** Returns a component implementation that is a shard of the current implementation. */
   public ComponentImplementation shardImplementation(Key key) {
     checkState(!shardOwner.isPresent(), "Shards cannot create other shards.");
     if (!shardsByKey.containsKey(key)) {
       int keysPerShard = compilerOptions.keysPerComponentShard(graph.componentTypeElement());
       if (!shardsByKey.isEmpty() && shardsByKey.size() % keysPerShard == 0) {
         ClassName shardName = name.nestedClass("Shard" + shardsByKey.size() / keysPerShard);
         currentShard = new ComponentImplementation(this, shardName);
       }
       shardsByKey.put(key, currentShard);
     }
     return shardsByKey.get(key);
   }

   /** Returns a reference to this compenent when called from a class nested in this component. */
   public CodeBlock externalReferenceBlock() {
     return externalReferenceBlock;
   }

   // TODO(ronshapiro): see if we can remove this method and instead inject it in the objects that
   // need it.
   /** Returns the binding graph for the component being generated. */
   public BindingGraph graph() {
     return graph;
   }

   /** Returns the descriptor for the component being generated. */
   public ComponentDescriptor componentDescriptor() {
     return graph.componentDescriptor();
   }

   /** Returns the name of the component. */
   public ClassName name() {
     return name;
   }

   /** Returns whether or not the implementation is nested within another class. */
   public boolean isNested() {
     return name.enclosingClassName() != null;
   }

   /**
    * Returns the kind of this component's creator.
    *
    * @throws IllegalStateException if the component has no creator
    */
   private ComponentCreatorKind creatorKind() {
     checkState(componentDescriptor().hasCreator());
     return componentDescriptor()
         .creatorDescriptor()
         .map(ComponentCreatorDescriptor::kind)
         .orElse(BUILDER);
   }

   /**
    * Returns the name of the creator class for this component. It will be a sibling of this
    * generated class unless this is a top-level component, in which case it will be nested.
    */
   public ClassName getCreatorName() {
     return isNested()
         ? name.peerClass(subcomponentNames.getCreatorName(componentDescriptor()))
         : name.nestedClass(creatorKind().typeName());
   }

   /** Returns the name of the nested implementation class for a child component. */
   private ClassName getSubcomponentName(ComponentDescriptor childDescriptor) {
     checkArgument(
         componentDescriptor().childComponents().contains(childDescriptor),
         "%s is not a child component of %s",
         childDescriptor.typeElement(),
         componentDescriptor().typeElement());
     return name.nestedClass(subcomponentNames.get(childDescriptor) + "Impl");
   }

   /**
    * Returns the simple name of the creator implementation class for the given subcomponent creator
    * {@link Key}.
    */
   String getSubcomponentCreatorSimpleName(Key key) {
     return subcomponentNames.getCreatorName(key);
   }

   /** Returns {@code true} if {@code type} is accessible from the generated component. */
   boolean isTypeAccessible(TypeMirror type) {
     return isTypeAccessibleFrom(type, name.packageName());
   }

   /** Adds the given super type to the component. */
   public void addSupertype(TypeElement supertype) {
     TypeSpecs.addSupertype(component, supertype);
   }

   // TODO(dpb): Consider taking FieldSpec, and returning identical FieldSpec with unique name?
   /** Adds the given field to the component. */
   public void addField(FieldSpecKind fieldKind, FieldSpec fieldSpec) {
     fieldSpecsMap.put(fieldKind, fieldSpec);
   }

   // TODO(dpb): Consider taking MethodSpec, and returning identical MethodSpec with unique name?
   /** Adds the given method to the component. */
   public void addMethod(MethodSpecKind methodKind, MethodSpec methodSpec) {
     methodSpecsMap.put(methodKind, methodSpec);
   }

   /** Adds the given annotation to the component. */
   public void addAnnotation(AnnotationSpec annotation) {
     component.addAnnotation(annotation);
   }

   /** Adds the given type to the component. */
   public void addType(TypeSpecKind typeKind, TypeSpec typeSpec) {
     typeSpecsMap.put(typeKind, typeSpec);
   }

   /** Adds a {@link Supplier} for the SwitchingProvider for the component. */
   void addTypeSupplier(Supplier<TypeSpec> typeSpecSupplier) {
     typeSuppliers.add(typeSpecSupplier);
   }

   /** Adds the given code block to the initialize methods of the component. */
   void addInitialization(CodeBlock codeBlock) {
     initializations.add(codeBlock);
   }

   /** Adds the given code block that initializes a {@link ComponentRequirement}. */
   void addComponentRequirementInitialization(CodeBlock codeBlock) {
     componentRequirementInitializations.add(codeBlock);
   }

   /**
    * Marks the given key of a producer as one that should have a cancellation statement in the
    * cancellation listener method of the component.
    */
   void addCancellableProducerKey(Key key) {
     cancellableProducerKeys.add(key);
   }

   /** Returns a new, unique field name for the component based on the given name. */
   String getUniqueFieldName(String name) {
     return componentFieldNames.getUniqueName(name);
   }

   /** Returns a new, unique method name for the component based on the given name. */
   public String getUniqueMethodName(String name) {
     return componentMethodNames.getUniqueName(name);
   }

   /** Returns a new, unique method name for a getter method for the given request. */
   String getUniqueMethodName(BindingRequest request) {
     return uniqueMethodName(request, KeyVariableNamer.name(request.key()));
   }

   private String uniqueMethodName(BindingRequest request, String bindingName) {
     // This name is intentionally made to match the name for fields in fastInit
     // in order to reduce the constant pool size. b/162004246
     String baseMethodName = bindingName
         + (request.isRequestKind(RequestKind.INSTANCE)
             ? ""
             : UPPER_UNDERSCORE.to(UPPER_CAMEL, request.kindName()));
     return getUniqueMethodName(baseMethodName);
   }

   /**
    * Gets the parameter name to use for the given requirement for this component, starting with the
    * given base name if no parameter name has already been selected for the requirement.
    */
   public String getParameterName(ComponentRequirement requirement, String baseName) {
     return componentRequirementParameterNames.computeIfAbsent(
         requirement, r -> getUniqueFieldName(baseName));
   }

   /** Claims a new method name for the component. Does nothing if method name already exists. */
   public void claimMethodName(CharSequence name) {
     componentMethodNames.claim(name);
   }

   /** Returns the list of {@link CodeBlock}s that need to go in the initialize method. */
   public ImmutableList<CodeBlock> getInitializations() {
     return ImmutableList.copyOf(initializations);
   }

   /**
    * Returns a list of {@link CodeBlock}s for initializing {@link ComponentRequirement}s.
    *
    * <p>These initializations are kept separate from {@link #getInitializations()} because they must
    * be executed before the initializations of any framework instance initializations in a
    * superclass implementation that may depend on the instances. We cannot use the same strategy
    * that we use for framework instances (i.e. wrap in a {@link dagger.internal.DelegateFactory} or
    * {@link dagger.producers.internal.DelegateProducer} since the types of these initialized fields
    * have no interface type that we can write a proxy for.
    */
   // TODO(cgdecker): can these be inlined with getInitializations() now that we've turned down
   // ahead-of-time subcomponents?
   public ImmutableList<CodeBlock> getComponentRequirementInitializations() {
     return ImmutableList.copyOf(componentRequirementInitializations);
   }

   /**
    * Returns the list of producer {@link Key}s that need cancellation statements in the cancellation
    * listener method.
    */
   public ImmutableList<Key> getCancellableProducerKeys() {
     return ImmutableList.copyOf(cancellableProducerKeys);
   }

   /** Generates the component and returns the resulting {@link TypeSpec.Builder}. */
   public TypeSpec.Builder generate() {
     modifiers().forEach(component::addModifiers);
     fieldSpecsMap.asMap().values().forEach(component::addFields);
     methodSpecsMap.asMap().values().forEach(component::addMethods);
     typeSpecsMap.asMap().values().forEach(component::addTypes);
     typeSuppliers.stream().map(Supplier::get).forEach(component::addType);
     return component;
   }

   private ImmutableSet<Modifier> modifiers() {
     if (isNested()) {
       return ImmutableSet.of(PRIVATE, FINAL);
     }
     return graph.componentTypeElement().getModifiers().contains(PUBLIC)
         // TODO(ronshapiro): perhaps all generated components should be non-public?
         ? ImmutableSet.of(PUBLIC, FINAL)
         : ImmutableSet.of(FINAL);
   }
 }
	/*
	* 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.writing;

	import static com.google.common.base.CaseFormat.LOWER_CAMEL;
	import static com.google.common.base.CaseFormat.UPPER_CAMEL;
	import static com.google.common.base.CaseFormat.UPPER_UNDERSCORE;
	import static com.google.common.base.Preconditions.checkArgument;
	import static com.google.common.base.Preconditions.checkState;
	import static com.squareup.javapoet.TypeSpec.classBuilder;
	import static dagger.internal.codegen.binding.ComponentCreatorKind.BUILDER;
	import static dagger.internal.codegen.langmodel.Accessibility.isTypeAccessibleFrom;
	import static javax.lang.model.element.Modifier.FINAL;
	import static javax.lang.model.element.Modifier.PRIVATE;
	import static javax.lang.model.element.Modifier.PUBLIC;

	import com.google.common.base.Supplier;
	import com.google.common.collect.ImmutableList;
	import com.google.common.collect.ImmutableSet;
	import com.google.common.collect.ListMultimap;
	import com.google.common.collect.MultimapBuilder;
	import com.squareup.javapoet.AnnotationSpec;
	import com.squareup.javapoet.ClassName;
	import com.squareup.javapoet.CodeBlock;
	import com.squareup.javapoet.FieldSpec;
	import com.squareup.javapoet.MethodSpec;
	import com.squareup.javapoet.TypeSpec;
	import dagger.internal.codegen.base.UniqueNameSet;
	import dagger.internal.codegen.binding.BindingGraph;
	import dagger.internal.codegen.binding.BindingRequest;
	import dagger.internal.codegen.binding.ComponentCreatorDescriptor;
	import dagger.internal.codegen.binding.ComponentCreatorKind;
	import dagger.internal.codegen.binding.ComponentDescriptor;
	import dagger.internal.codegen.binding.ComponentRequirement;
	import dagger.internal.codegen.binding.KeyVariableNamer;
	import dagger.internal.codegen.compileroption.CompilerOptions;
	import dagger.internal.codegen.javapoet.TypeSpecs;
	import dagger.model.Key;
	import dagger.model.RequestKind;
	import java.util.ArrayList;
	import java.util.HashMap;
	import java.util.LinkedHashSet;
	import java.util.List;
	import java.util.Map;
	import java.util.Optional;
	import java.util.Set;
	import javax.lang.model.element.Modifier;
	import javax.lang.model.element.TypeElement;
	import javax.lang.model.type.TypeMirror;

	/** The implementation of a component type. */
	public final class ComponentImplementation {
	/** A type of field that this component can contain. */
	public enum FieldSpecKind {
	/** A field for a component shard. */
	COMPONENT_SHARD,

	/** A field required by the component, e.g. module instances. */
	COMPONENT_REQUIREMENT_FIELD,

	/**
	* A field for the lock and cached value for {@linkplain PrivateMethodBindingExpression
	* private-method scoped bindings}.
	*/
	PRIVATE_METHOD_SCOPED_FIELD,

	/** A framework field for type T, e.g. {@code Provider<T>}. */
	FRAMEWORK_FIELD,

	/** A static field that always returns an absent {@code Optional} value for the binding. */
	ABSENT_OPTIONAL_FIELD
	}

	/** A type of method that this component can contain. */
	// TODO(bcorso, dpb): Change the oder to constructor, initialize, component, then private
	// (including MIM and AOM—why treat those separately?).
	public enum MethodSpecKind {
	/** The component constructor. */
	CONSTRUCTOR,

	/** A builder method for the component. (Only used by the root component.) */
	BUILDER_METHOD,

	/** A private method that wraps dependency expressions. */
	PRIVATE_METHOD,

	/** An initialization method that initializes component requirements and framework types. */
	INITIALIZE_METHOD,

	/** An implementation of a component interface method. */
	COMPONENT_METHOD,

	/** A private method that encapsulates members injection logic for a binding. */
	MEMBERS_INJECTION_METHOD,

	/** A static method that always returns an absent {@code Optional} value for the binding. */
	ABSENT_OPTIONAL_METHOD,

	/**
	* The {@link dagger.producers.internal.CancellationListener#onProducerFutureCancelled(boolean)}
	* method for a production component.
	*/
	CANCELLATION_LISTENER_METHOD,
	;
	}

	/** A type of nested class that this component can contain. */
	public enum TypeSpecKind {
	/** A factory class for a present optional binding. */
	PRESENT_FACTORY,

	/** A class for the component creator (only used by the root component.) */
	COMPONENT_CREATOR,

	/** A provider class for a component provision. */
	COMPONENT_PROVISION_FACTORY,

	/** A class for the subcomponent or subcomponent builder. */
	SUBCOMPONENT
	}

	private ComponentImplementation currentShard = this;
	private final Map<Key, ComponentImplementation> shardsByKey = new HashMap<>();
	private final Optional<ComponentImplementation> shardOwner;
	private final BindingGraph graph;
	private final ClassName name;
	private final TypeSpec.Builder component;
	private final SubcomponentNames subcomponentNames;
	private final CompilerOptions compilerOptions;
	private final CodeBlock externalReferenceBlock;
	private final UniqueNameSet componentFieldNames = new UniqueNameSet();
	private final UniqueNameSet componentMethodNames = new UniqueNameSet();
	private final List<CodeBlock> initializations = new ArrayList<>();
	private final List<CodeBlock> componentRequirementInitializations = new ArrayList<>();
	private final Map<ComponentRequirement, String> componentRequirementParameterNames =
	new HashMap<>();
	private final Set<Key> cancellableProducerKeys = new LinkedHashSet<>();
	private final ListMultimap<FieldSpecKind, FieldSpec> fieldSpecsMap =
	MultimapBuilder.enumKeys(FieldSpecKind.class).arrayListValues().build();
	private final ListMultimap<MethodSpecKind, MethodSpec> methodSpecsMap =
	MultimapBuilder.enumKeys(MethodSpecKind.class).arrayListValues().build();
	private final ListMultimap<TypeSpecKind, TypeSpec> typeSpecsMap =
	MultimapBuilder.enumKeys(TypeSpecKind.class).arrayListValues().build();
	private final List<Supplier<TypeSpec>> typeSuppliers = new ArrayList<>();

	private ComponentImplementation(
	BindingGraph graph,
	ClassName name,
	SubcomponentNames subcomponentNames,
	CompilerOptions compilerOptions) {
	this.graph = graph;
	this.name = name;
	this.component = classBuilder(name);
	this.subcomponentNames = subcomponentNames;
	this.shardOwner = Optional.empty();
	this.externalReferenceBlock = CodeBlock.of("$T.this", name);
	this.compilerOptions = compilerOptions;
	}

	private ComponentImplementation(ComponentImplementation shardOwner, ClassName shardName) {
	this.graph = shardOwner.graph;
	this.name = shardName;
	this.component = classBuilder(shardName);
	this.subcomponentNames = shardOwner.subcomponentNames;
	this.compilerOptions = shardOwner.compilerOptions;
	this.shardOwner = Optional.of(shardOwner);
	String fieldName = UPPER_CAMEL.to(LOWER_CAMEL, name.simpleName());
	String uniqueFieldName = shardOwner.getUniqueFieldName(fieldName);
	this.externalReferenceBlock = CodeBlock.of("$T.this.$N", shardOwner.name, uniqueFieldName);
	shardOwner.addTypeSupplier(() -> generate().build());
	shardOwner.addField(
	FieldSpecKind.COMPONENT_SHARD,
	FieldSpec.builder(name, uniqueFieldName, PRIVATE, FINAL)
	.initializer("new $T()", name)
	.build());
	}

	/** Returns a component implementation for a top-level component. */
	public static ComponentImplementation topLevelComponentImplementation(
	BindingGraph graph,
	ClassName name,
	SubcomponentNames subcomponentNames,
	CompilerOptions compilerOptions) {
	return new ComponentImplementation(graph, name, subcomponentNames, compilerOptions);
	}

	/** Returns a component implementation that is a child of the current implementation. */
	public ComponentImplementation childComponentImplementation(BindingGraph graph) {
	checkState(!shardOwner.isPresent(), "Shards cannot create child components.");
	ClassName childName = getSubcomponentName(graph.componentDescriptor());
	return new ComponentImplementation(graph, childName, subcomponentNames, compilerOptions);
	}

	/** Returns a component implementation that is a shard of the current implementation. */
	public ComponentImplementation shardImplementation(Key key) {
	checkState(!shardOwner.isPresent(), "Shards cannot create other shards.");
	if (!shardsByKey.containsKey(key)) {
	int keysPerShard = compilerOptions.keysPerComponentShard(graph.componentTypeElement());
	if (!shardsByKey.isEmpty() && shardsByKey.size() % keysPerShard == 0) {
	ClassName shardName = name.nestedClass("Shard" + shardsByKey.size() / keysPerShard);
	currentShard = new ComponentImplementation(this, shardName);
	}
	shardsByKey.put(key, currentShard);
	}
	return shardsByKey.get(key);
	}

	/** Returns a reference to this compenent when called from a class nested in this component. */
	public CodeBlock externalReferenceBlock() {
	return externalReferenceBlock;
	}

	// TODO(ronshapiro): see if we can remove this method and instead inject it in the objects that
	// need it.
	/** Returns the binding graph for the component being generated. */
	public BindingGraph graph() {
	return graph;
	}

	/** Returns the descriptor for the component being generated. */
	public ComponentDescriptor componentDescriptor() {
	return graph.componentDescriptor();
	}

	/** Returns the name of the component. */
	public ClassName name() {
	return name;
	}

	/** Returns whether or not the implementation is nested within another class. */
	public boolean isNested() {
	return name.enclosingClassName() != null;
	}

	/**
	* Returns the kind of this component's creator.
	*
	* @throws IllegalStateException if the component has no creator
	*/
	private ComponentCreatorKind creatorKind() {
	checkState(componentDescriptor().hasCreator());
	return componentDescriptor()
	.creatorDescriptor()
	.map(ComponentCreatorDescriptor::kind)
	.orElse(BUILDER);
	}

	/**
	* Returns the name of the creator class for this component. It will be a sibling of this
	* generated class unless this is a top-level component, in which case it will be nested.
	*/
	public ClassName getCreatorName() {
	return isNested()
	? name.peerClass(subcomponentNames.getCreatorName(componentDescriptor()))
	: name.nestedClass(creatorKind().typeName());
	}

	/** Returns the name of the nested implementation class for a child component. */
	private ClassName getSubcomponentName(ComponentDescriptor childDescriptor) {
	checkArgument(
	componentDescriptor().childComponents().contains(childDescriptor),
	"%s is not a child component of %s",
	childDescriptor.typeElement(),
	componentDescriptor().typeElement());
	return name.nestedClass(subcomponentNames.get(childDescriptor) + "Impl");
	}

	/**
	* Returns the simple name of the creator implementation class for the given subcomponent creator
	* {@link Key}.
	*/
	String getSubcomponentCreatorSimpleName(Key key) {
	return subcomponentNames.getCreatorName(key);
	}

	/** Returns {@code true} if {@code type} is accessible from the generated component. */
	boolean isTypeAccessible(TypeMirror type) {
	return isTypeAccessibleFrom(type, name.packageName());
	}

	/** Adds the given super type to the component. */
	public void addSupertype(TypeElement supertype) {
	TypeSpecs.addSupertype(component, supertype);
	}

	// TODO(dpb): Consider taking FieldSpec, and returning identical FieldSpec with unique name?
	/** Adds the given field to the component. */
	public void addField(FieldSpecKind fieldKind, FieldSpec fieldSpec) {
	fieldSpecsMap.put(fieldKind, fieldSpec);
	}

	// TODO(dpb): Consider taking MethodSpec, and returning identical MethodSpec with unique name?
	/** Adds the given method to the component. */
	public void addMethod(MethodSpecKind methodKind, MethodSpec methodSpec) {
	methodSpecsMap.put(methodKind, methodSpec);
	}

	/** Adds the given annotation to the component. */
	public void addAnnotation(AnnotationSpec annotation) {
	component.addAnnotation(annotation);
	}

	/** Adds the given type to the component. */
	public void addType(TypeSpecKind typeKind, TypeSpec typeSpec) {
	typeSpecsMap.put(typeKind, typeSpec);
	}

	/** Adds a {@link Supplier} for the SwitchingProvider for the component. */
	void addTypeSupplier(Supplier<TypeSpec> typeSpecSupplier) {
	typeSuppliers.add(typeSpecSupplier);
	}

	/** Adds the given code block to the initialize methods of the component. */
	void addInitialization(CodeBlock codeBlock) {
	initializations.add(codeBlock);
	}

	/** Adds the given code block that initializes a {@link ComponentRequirement}. */
	void addComponentRequirementInitialization(CodeBlock codeBlock) {
	componentRequirementInitializations.add(codeBlock);
	}

	/**
	* Marks the given key of a producer as one that should have a cancellation statement in the
	* cancellation listener method of the component.
	*/
	void addCancellableProducerKey(Key key) {
	cancellableProducerKeys.add(key);
	}

	/** Returns a new, unique field name for the component based on the given name. */
	String getUniqueFieldName(String name) {
	return componentFieldNames.getUniqueName(name);
	}

	/** Returns a new, unique method name for the component based on the given name. */
	public String getUniqueMethodName(String name) {
	return componentMethodNames.getUniqueName(name);
	}

	/** Returns a new, unique method name for a getter method for the given request. */
	String getUniqueMethodName(BindingRequest request) {
	return uniqueMethodName(request, KeyVariableNamer.name(request.key()));
	}

	private String uniqueMethodName(BindingRequest request, String bindingName) {
	// This name is intentionally made to match the name for fields in fastInit
	// in order to reduce the constant pool size. b/162004246
	String baseMethodName = bindingName
	+ (request.isRequestKind(RequestKind.INSTANCE)
	? ""
	: UPPER_UNDERSCORE.to(UPPER_CAMEL, request.kindName()));
	return getUniqueMethodName(baseMethodName);
	}

	/**
	* Gets the parameter name to use for the given requirement for this component, starting with the
	* given base name if no parameter name has already been selected for the requirement.
	*/
	public String getParameterName(ComponentRequirement requirement, String baseName) {
	return componentRequirementParameterNames.computeIfAbsent(
	requirement, r -> getUniqueFieldName(baseName));
	}

	/** Claims a new method name for the component. Does nothing if method name already exists. */
	public void claimMethodName(CharSequence name) {
	componentMethodNames.claim(name);
	}

	/** Returns the list of {@link CodeBlock}s that need to go in the initialize method. */
	public ImmutableList<CodeBlock> getInitializations() {
	return ImmutableList.copyOf(initializations);
	}

	/**
	* Returns a list of {@link CodeBlock}s for initializing {@link ComponentRequirement}s.
	*
	* <p>These initializations are kept separate from {@link #getInitializations()} because they must
	* be executed before the initializations of any framework instance initializations in a
	* superclass implementation that may depend on the instances. We cannot use the same strategy
	* that we use for framework instances (i.e. wrap in a {@link dagger.internal.DelegateFactory} or
	* {@link dagger.producers.internal.DelegateProducer} since the types of these initialized fields
	* have no interface type that we can write a proxy for.
	*/
	// TODO(cgdecker): can these be inlined with getInitializations() now that we've turned down
	// ahead-of-time subcomponents?
	public ImmutableList<CodeBlock> getComponentRequirementInitializations() {
	return ImmutableList.copyOf(componentRequirementInitializations);
	}

	/**
	* Returns the list of producer {@link Key}s that need cancellation statements in the cancellation
	* listener method.
	*/
	public ImmutableList<Key> getCancellableProducerKeys() {
	return ImmutableList.copyOf(cancellableProducerKeys);
	}

	/** Generates the component and returns the resulting {@link TypeSpec.Builder}. */
	public TypeSpec.Builder generate() {
	modifiers().forEach(component::addModifiers);
	fieldSpecsMap.asMap().values().forEach(component::addFields);
	methodSpecsMap.asMap().values().forEach(component::addMethods);
	typeSpecsMap.asMap().values().forEach(component::addTypes);
	typeSuppliers.stream().map(Supplier::get).forEach(component::addType);
	return component;
	}

	private ImmutableSet<Modifier> modifiers() {
	if (isNested()) {
	return ImmutableSet.of(PRIVATE, FINAL);
	}
	return graph.componentTypeElement().getModifiers().contains(PUBLIC)
	// TODO(ronshapiro): perhaps all generated components should be non-public?
	? ImmutableSet.of(PUBLIC, FINAL)
	: ImmutableSet.of(FINAL);
	}
	}