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

 /*
  * Copyright (C) 2019 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.auto.common.AnnotationMirrors.getAnnotationValue;
 import static com.google.auto.common.MoreElements.getAnnotationMirror;
 import static com.google.auto.common.MoreElements.isAnnotationPresent;
 import static com.squareup.javapoet.MethodSpec.methodBuilder;
 import static dagger.internal.codegen.BindingRequest.bindingRequest;
 import static dagger.internal.codegen.DaggerStreams.toImmutableList;
 import static dagger.internal.codegen.DaggerStreams.toImmutableSet;
 import static dagger.internal.codegen.MoreAnnotationValues.asAnnotationValues;
 import static dagger.internal.codegen.serialization.ProtoSerialization.fromAnnotationValue;
 import static javax.lang.model.element.Modifier.FINAL;
 import static javax.lang.model.util.ElementFilter.methodsIn;
 import static javax.lang.model.util.ElementFilter.typesIn;

 import com.google.auto.common.MoreTypes;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableSet;
 import com.squareup.javapoet.ClassName;
 import com.squareup.javapoet.MethodSpec;
 import com.squareup.javapoet.TypeName;
 import dagger.internal.ComponentDefinitionType;
 import dagger.internal.ConfigureInitializationParameters;
 import dagger.internal.ModifiableBinding;
 import dagger.internal.ModifiableModule;
 import dagger.internal.codegen.ComponentImplementation.ConfigureInitializationMethod;
 import dagger.internal.codegen.serialization.BindingRequestProto;
 import dagger.internal.codegen.serialization.ComponentRequirementProto;
 import dagger.internal.codegen.serialization.FrameworkTypeWrapper;
 import dagger.internal.codegen.serialization.KeyProto;
 import dagger.model.Key;
 import dagger.model.RequestKind;
 import java.util.Optional;
 import javax.inject.Inject;
 import javax.lang.model.element.AnnotationMirror;
 import javax.lang.model.element.AnnotationValue;
 import javax.lang.model.element.ExecutableElement;
 import javax.lang.model.element.TypeElement;
 import javax.lang.model.type.TypeMirror;

 /**
  * Reconstructs {@link ComponentImplementation}s that have already been compiled. Uses metadata
  * annotations on the generated type and it's methods to reconstitute the equivalent {@link
  * ComponentImplementation} state.
  */
 final class DeserializedComponentImplementationBuilder {
   private final CompilerOptions compilerOptions;
   private final ComponentCreatorImplementationFactory componentCreatorImplementationFactory;
   private final TypeProtoConverter typeProtoConverter;
   private final KeyFactory keyFactory;

   @Inject
   DeserializedComponentImplementationBuilder(
       CompilerOptions compilerOptions,
       ComponentCreatorImplementationFactory componentCreatorImplementationFactory,
       TypeProtoConverter typeProtoConverter,
       KeyFactory keyFactory) {
     this.compilerOptions = compilerOptions;
     this.componentCreatorImplementationFactory = componentCreatorImplementationFactory;
     this.typeProtoConverter = typeProtoConverter;
     this.keyFactory = keyFactory;
   }

   /** Creates a new {@link ComponentImplementation} from a compiled component. */
   ComponentImplementation create(ComponentDescriptor component, TypeElement generatedComponent) {
     Optional<ComponentImplementation> superclassImplementation =
         deserializedSuperclassImplementation(
             component, MoreTypes.asTypeElement(generatedComponent.getSuperclass()));

     ComponentImplementation componentImplementation =
         ComponentImplementation.forDeserializedComponent(
             component,
             ClassName.get(generatedComponent),
             generatedComponent.getNestingKind(),
             superclassImplementation,
             compilerOptions);

     componentImplementation.setCreatorImplementation(
         superclassImplementation.isPresent()
             ? Optional.empty()
             : componentCreatorImplementationFactory.create(
                 componentImplementation, Optional.empty()));

     // TODO(b/117833324): Consider omitting superclass implementations, so that only one instance of
     // ComponentImplementation needs to be created (in most cases, we don't care about nested levels
     // of superclass implementations, except for the base implementation). If that's possible, use
     // getLocalAndInheritedMethods instead of getEnclosedElements() here.
     for (ExecutableElement method : methodsIn(generatedComponent.getEnclosedElements())) {
       getAnnotationMirror(method, ModifiableBinding.class)
           .asSet()
           .forEach(
               annotation ->
                   addModifiableBindingMethod(componentImplementation, method, annotation));

       getAnnotationMirror(method, ModifiableModule.class)
           .asSet()
           .forEach(
               annotation -> addModifiableModuleMethod(componentImplementation, method, annotation));

       getAnnotationMirror(method, ConfigureInitializationParameters.class)
           .asSet()
           .forEach(
               annotation ->
                   setConfigureInitializationMethod(componentImplementation, method, annotation));
     }

     for (TypeElement nestedType : typesIn(generatedComponent.getEnclosedElements())) {
       addChildImplementation(component, componentImplementation, nestedType);
     }

     return componentImplementation;
   }

   private Optional<ComponentImplementation> deserializedSuperclassImplementation(
       ComponentDescriptor component, TypeElement superclassElement) {
     return isAnnotationPresent(superclassElement, ComponentDefinitionType.class)
         ? Optional.of(create(component, superclassElement))
         : Optional.empty();
   }

   private void addModifiableBindingMethod(
       ComponentImplementation componentImplementation,
       ExecutableElement method,
       AnnotationMirror metadataAnnotation) {
     ModifiableBindingType modifiableBindingType =
         ModifiableBindingType.valueOf(
             getAnnotationValue(metadataAnnotation, "modifiableBindingType").getValue().toString());

     BindingRequest request =
         parseBindingRequest(getAnnotationValue(metadataAnnotation, "bindingRequest"));

     ImmutableList<Key> multibindingContributions =
         asAnnotationValues(getAnnotationValue(metadataAnnotation, "multibindingContributions"))
             .stream()
             .map(this::parseKey)
             .collect(toImmutableList());

     componentImplementation.addModifiableBindingMethod(
         modifiableBindingType,
         request,
         method.getReturnType(),
         methodDeclaration(method),
         method.getModifiers().contains(FINAL));
     componentImplementation.registerImplementedMultibindingKeys(request, multibindingContributions);
   }

   private BindingRequest fromProto(BindingRequestProto bindingRequest) {
     Key key = keyFactory.fromProto(bindingRequest.getKey());
     return bindingRequest.getFrameworkType().equals(FrameworkTypeWrapper.FrameworkType.UNKNOWN)
         ? bindingRequest(key, RequestKind.valueOf(bindingRequest.getRequestKind().name()))
         : bindingRequest(key, FrameworkType.valueOf(bindingRequest.getFrameworkType().name()));
   }

   /**
    * Returns a {@link MethodSpec} for a {@link
    * dagger.internal.codegen.ModifiableBindingMethods.ModifiableBindingMethod}. The method contents
    * are not relevant since this represents a method that has already been compiled.
    *
    * <p>Ideally this could be {@code MethodSpec.overriding(method).build()}, but that doesn't work
    * for {@code final} methods
    */
   private MethodSpec methodDeclaration(ExecutableElement method) {
     return methodBuilder(method.getSimpleName().toString())
         .addModifiers(method.getModifiers())
         .returns(TypeName.get(method.getReturnType()))
         .build();
   }

   private void addModifiableModuleMethod(
       ComponentImplementation componentImplementation,
       ExecutableElement method,
       AnnotationMirror metadataAnnotation) {
     ComponentRequirement moduleRequirement =
         parseComponentRequirement(getAnnotationValue(metadataAnnotation, "value"));
     componentImplementation.registerModifiableModuleMethod(
         moduleRequirement, method.getSimpleName().toString());
   }

   private void setConfigureInitializationMethod(
       ComponentImplementation componentImplementation,
       ExecutableElement method,
       AnnotationMirror metadataAnnotation) {
     ImmutableSet<ComponentRequirement> parameters =
         asAnnotationValues(getAnnotationValue(metadataAnnotation, "value")).stream()
             .map(this::parseComponentRequirement)
             .collect(toImmutableSet());

     componentImplementation.setConfigureInitializationMethod(
         ConfigureInitializationMethod.create(MethodSpec.overriding(method).build(), parameters));
   }

   private void addChildImplementation(
       ComponentDescriptor component,
       ComponentImplementation componentImplementation,
       TypeElement nestedType) {
     getAnnotationMirror(nestedType, ComponentDefinitionType.class)
         .transform(annotation -> (TypeMirror) getAnnotationValue(annotation, "value").getValue())
         .transform(MoreTypes::asTypeElement)
         .asSet()
         .forEach(
             componentDefinitionType -> {
               ComponentDescriptor child =
                   component.childComponentsByElement().get(componentDefinitionType);
               componentImplementation.addChild(child, create(child, nestedType));
             });
   }

   private Key parseKey(AnnotationValue annotationValue) {
     return keyFactory.fromProto(
         fromAnnotationValue(annotationValue, KeyProto.getDefaultInstance()));
   }

   private BindingRequest parseBindingRequest(AnnotationValue annotationValue) {
     return fromProto(
         fromAnnotationValue(annotationValue, BindingRequestProto.getDefaultInstance()));
   }

   private ComponentRequirement parseComponentRequirement(AnnotationValue annotationValue) {
     return fromProto(
         fromAnnotationValue(annotationValue, ComponentRequirementProto.getDefaultInstance()));
   }

   private ComponentRequirement fromProto(ComponentRequirementProto proto) {
     switch (proto.getRequirementCase()) {
       case MODULE:
         return ComponentRequirement.forModule(typeProtoConverter.fromProto(proto.getModule()));
       case DEPENDENCY:
         return ComponentRequirement.forDependency(
             typeProtoConverter.fromProto(proto.getDependency()));
       case BOUND_INSTANCE:
         return ComponentRequirement.forBoundInstance(
             keyFactory.fromProto(proto.getBoundInstance().getKey()),
             proto.getBoundInstance().getNullable(),
             proto.getBoundInstance().getVariableName());
       case REQUIREMENT_NOT_SET:
         // fall through
     }
     throw new AssertionError(proto);
   }
 }
	/*
	* Copyright (C) 2019 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.auto.common.AnnotationMirrors.getAnnotationValue;
	import static com.google.auto.common.MoreElements.getAnnotationMirror;
	import static com.google.auto.common.MoreElements.isAnnotationPresent;
	import static com.squareup.javapoet.MethodSpec.methodBuilder;
	import static dagger.internal.codegen.BindingRequest.bindingRequest;
	import static dagger.internal.codegen.DaggerStreams.toImmutableList;
	import static dagger.internal.codegen.DaggerStreams.toImmutableSet;
	import static dagger.internal.codegen.MoreAnnotationValues.asAnnotationValues;
	import static dagger.internal.codegen.serialization.ProtoSerialization.fromAnnotationValue;
	import static javax.lang.model.element.Modifier.FINAL;
	import static javax.lang.model.util.ElementFilter.methodsIn;
	import static javax.lang.model.util.ElementFilter.typesIn;

	import com.google.auto.common.MoreTypes;
	import com.google.common.collect.ImmutableList;
	import com.google.common.collect.ImmutableSet;
	import com.squareup.javapoet.ClassName;
	import com.squareup.javapoet.MethodSpec;
	import com.squareup.javapoet.TypeName;
	import dagger.internal.ComponentDefinitionType;
	import dagger.internal.ConfigureInitializationParameters;
	import dagger.internal.ModifiableBinding;
	import dagger.internal.ModifiableModule;
	import dagger.internal.codegen.ComponentImplementation.ConfigureInitializationMethod;
	import dagger.internal.codegen.serialization.BindingRequestProto;
	import dagger.internal.codegen.serialization.ComponentRequirementProto;
	import dagger.internal.codegen.serialization.FrameworkTypeWrapper;
	import dagger.internal.codegen.serialization.KeyProto;
	import dagger.model.Key;
	import dagger.model.RequestKind;
	import java.util.Optional;
	import javax.inject.Inject;
	import javax.lang.model.element.AnnotationMirror;
	import javax.lang.model.element.AnnotationValue;
	import javax.lang.model.element.ExecutableElement;
	import javax.lang.model.element.TypeElement;
	import javax.lang.model.type.TypeMirror;

	/**
	* Reconstructs {@link ComponentImplementation}s that have already been compiled. Uses metadata
	* annotations on the generated type and it's methods to reconstitute the equivalent {@link
	* ComponentImplementation} state.
	*/
	final class DeserializedComponentImplementationBuilder {
	private final CompilerOptions compilerOptions;
	private final ComponentCreatorImplementationFactory componentCreatorImplementationFactory;
	private final TypeProtoConverter typeProtoConverter;
	private final KeyFactory keyFactory;

	@Inject
	DeserializedComponentImplementationBuilder(
	CompilerOptions compilerOptions,
	ComponentCreatorImplementationFactory componentCreatorImplementationFactory,
	TypeProtoConverter typeProtoConverter,
	KeyFactory keyFactory) {
	this.compilerOptions = compilerOptions;
	this.componentCreatorImplementationFactory = componentCreatorImplementationFactory;
	this.typeProtoConverter = typeProtoConverter;
	this.keyFactory = keyFactory;
	}

	/** Creates a new {@link ComponentImplementation} from a compiled component. */
	ComponentImplementation create(ComponentDescriptor component, TypeElement generatedComponent) {
	Optional<ComponentImplementation> superclassImplementation =
	deserializedSuperclassImplementation(
	component, MoreTypes.asTypeElement(generatedComponent.getSuperclass()));

	ComponentImplementation componentImplementation =
	ComponentImplementation.forDeserializedComponent(
	component,
	ClassName.get(generatedComponent),
	generatedComponent.getNestingKind(),
	superclassImplementation,
	compilerOptions);

	componentImplementation.setCreatorImplementation(
	superclassImplementation.isPresent()
	? Optional.empty()
	: componentCreatorImplementationFactory.create(
	componentImplementation, Optional.empty()));

	// TODO(b/117833324): Consider omitting superclass implementations, so that only one instance of
	// ComponentImplementation needs to be created (in most cases, we don't care about nested levels
	// of superclass implementations, except for the base implementation). If that's possible, use
	// getLocalAndInheritedMethods instead of getEnclosedElements() here.
	for (ExecutableElement method : methodsIn(generatedComponent.getEnclosedElements())) {
	getAnnotationMirror(method, ModifiableBinding.class)
	.asSet()
	.forEach(
	annotation ->
	addModifiableBindingMethod(componentImplementation, method, annotation));

	getAnnotationMirror(method, ModifiableModule.class)
	.asSet()
	.forEach(
	annotation -> addModifiableModuleMethod(componentImplementation, method, annotation));

	getAnnotationMirror(method, ConfigureInitializationParameters.class)
	.asSet()
	.forEach(
	annotation ->
	setConfigureInitializationMethod(componentImplementation, method, annotation));
	}

	for (TypeElement nestedType : typesIn(generatedComponent.getEnclosedElements())) {
	addChildImplementation(component, componentImplementation, nestedType);
	}

	return componentImplementation;
	}

	private Optional<ComponentImplementation> deserializedSuperclassImplementation(
	ComponentDescriptor component, TypeElement superclassElement) {
	return isAnnotationPresent(superclassElement, ComponentDefinitionType.class)
	? Optional.of(create(component, superclassElement))
	: Optional.empty();
	}

	private void addModifiableBindingMethod(
	ComponentImplementation componentImplementation,
	ExecutableElement method,
	AnnotationMirror metadataAnnotation) {
	ModifiableBindingType modifiableBindingType =
	ModifiableBindingType.valueOf(
	getAnnotationValue(metadataAnnotation, "modifiableBindingType").getValue().toString());

	BindingRequest request =
	parseBindingRequest(getAnnotationValue(metadataAnnotation, "bindingRequest"));

	ImmutableList<Key> multibindingContributions =
	asAnnotationValues(getAnnotationValue(metadataAnnotation, "multibindingContributions"))
	.stream()
	.map(this::parseKey)
	.collect(toImmutableList());

	componentImplementation.addModifiableBindingMethod(
	modifiableBindingType,
	request,
	method.getReturnType(),
	methodDeclaration(method),
	method.getModifiers().contains(FINAL));
	componentImplementation.registerImplementedMultibindingKeys(request, multibindingContributions);
	}

	private BindingRequest fromProto(BindingRequestProto bindingRequest) {
	Key key = keyFactory.fromProto(bindingRequest.getKey());
	return bindingRequest.getFrameworkType().equals(FrameworkTypeWrapper.FrameworkType.UNKNOWN)
	? bindingRequest(key, RequestKind.valueOf(bindingRequest.getRequestKind().name()))
	: bindingRequest(key, FrameworkType.valueOf(bindingRequest.getFrameworkType().name()));
	}

	/**
	* Returns a {@link MethodSpec} for a {@link
	* dagger.internal.codegen.ModifiableBindingMethods.ModifiableBindingMethod}. The method contents
	* are not relevant since this represents a method that has already been compiled.
	*
	* <p>Ideally this could be {@code MethodSpec.overriding(method).build()}, but that doesn't work
	* for {@code final} methods
	*/
	private MethodSpec methodDeclaration(ExecutableElement method) {
	return methodBuilder(method.getSimpleName().toString())
	.addModifiers(method.getModifiers())
	.returns(TypeName.get(method.getReturnType()))
	.build();
	}

	private void addModifiableModuleMethod(
	ComponentImplementation componentImplementation,
	ExecutableElement method,
	AnnotationMirror metadataAnnotation) {
	ComponentRequirement moduleRequirement =
	parseComponentRequirement(getAnnotationValue(metadataAnnotation, "value"));
	componentImplementation.registerModifiableModuleMethod(
	moduleRequirement, method.getSimpleName().toString());
	}

	private void setConfigureInitializationMethod(
	ComponentImplementation componentImplementation,
	ExecutableElement method,
	AnnotationMirror metadataAnnotation) {
	ImmutableSet<ComponentRequirement> parameters =
	asAnnotationValues(getAnnotationValue(metadataAnnotation, "value")).stream()
	.map(this::parseComponentRequirement)
	.collect(toImmutableSet());

	componentImplementation.setConfigureInitializationMethod(
	ConfigureInitializationMethod.create(MethodSpec.overriding(method).build(), parameters));
	}

	private void addChildImplementation(
	ComponentDescriptor component,
	ComponentImplementation componentImplementation,
	TypeElement nestedType) {
	getAnnotationMirror(nestedType, ComponentDefinitionType.class)
	.transform(annotation -> (TypeMirror) getAnnotationValue(annotation, "value").getValue())
	.transform(MoreTypes::asTypeElement)
	.asSet()
	.forEach(
	componentDefinitionType -> {
	ComponentDescriptor child =
	component.childComponentsByElement().get(componentDefinitionType);
	componentImplementation.addChild(child, create(child, nestedType));
	});
	}

	private Key parseKey(AnnotationValue annotationValue) {
	return keyFactory.fromProto(
	fromAnnotationValue(annotationValue, KeyProto.getDefaultInstance()));
	}

	private BindingRequest parseBindingRequest(AnnotationValue annotationValue) {
	return fromProto(
	fromAnnotationValue(annotationValue, BindingRequestProto.getDefaultInstance()));
	}

	private ComponentRequirement parseComponentRequirement(AnnotationValue annotationValue) {
	return fromProto(
	fromAnnotationValue(annotationValue, ComponentRequirementProto.getDefaultInstance()));
	}

	private ComponentRequirement fromProto(ComponentRequirementProto proto) {
	switch (proto.getRequirementCase()) {
	case MODULE:
	return ComponentRequirement.forModule(typeProtoConverter.fromProto(proto.getModule()));
	case DEPENDENCY:
	return ComponentRequirement.forDependency(
	typeProtoConverter.fromProto(proto.getDependency()));
	case BOUND_INSTANCE:
	return ComponentRequirement.forBoundInstance(
	keyFactory.fromProto(proto.getBoundInstance().getKey()),
	proto.getBoundInstance().getNullable(),
	proto.getBoundInstance().getVariableName());
	case REQUIREMENT_NOT_SET:
	// fall through
	}
	throw new AssertionError(proto);
	}
	}