diff options
Diffstat (limited to 'src/main/java/com/google/devtools/build/lib/skyframe/serialization/autocodec')
4 files changed, 62 insertions, 275 deletions
diff --git a/src/main/java/com/google/devtools/build/lib/skyframe/serialization/autocodec/AutoCodec.java b/src/main/java/com/google/devtools/build/lib/skyframe/serialization/autocodec/AutoCodec.java index be6a2bb47b..b627952a2f 100644 --- a/src/main/java/com/google/devtools/build/lib/skyframe/serialization/autocodec/AutoCodec.java +++ b/src/main/java/com/google/devtools/build/lib/skyframe/serialization/autocodec/AutoCodec.java @@ -73,8 +73,6 @@ public @interface AutoCodec { * <p>Commonly used with the POLYMORPHIC strategy. * * <p>The serialized class must have a codec accessible, static INSTANCE field. - * - * <p>Illegal to use with a non-Void dependency. */ SINGLETON } @@ -88,37 +86,7 @@ public @interface AutoCodec { @Target({ElementType.CONSTRUCTOR, ElementType.METHOD}) @interface Instantiator {} - /** - * Marks a specific constructor parameter as a dependency. - * - * <p>When a constructor selected for the {@code INSTANTIATOR} strategy has one of its parameters - * tagged {@code @Dependency}, {@code @AutoCodec} generates an {@link - * com.google.devtools.build.lib.skyframe.serialization.InjectingObjectCodec} instead of the usual - * {@link com.google.devtools.build.lib.skyframe.serialization.ObjectCodec} with the dependency - * type parameter matching the tagged parameter type. - * - * <p>At deserialization, the {@code @Dependency} tagged parameter will be forwarded from the - * {@code dependency} parameter of {@link - * com.google.devtools.build.lib.skyframe.serialization.InjectingObjectCodec#deserialize}. - * - * <p>A compiler error will result if more than one constructor parameter has the - * {@code @Dependency} annotation or if the annotation itself has a dependency element. - */ - @Target(ElementType.PARAMETER) - @interface Dependency {} - Strategy strategy() default Strategy.INSTANTIATOR; - /** - * Specifies a deserialization dependency. - * - * <p>When non-{@link Void}, generates an {@link - * com.google.devtools.build.lib.skyframe.serialization.InjectingObjectCodec} instead of the usual - * {@link com.google.devtools.build.lib.skyframe.serialization.ObjectCodec} with the dependency - * type parameter matching the returned type. - * - * <p>It is an error to use this in conjunction with {@code @AutoCodec.Dependency}. - */ - Class<?> dependency() default Void.class; /** * Signals that the annotated element is only visible for use by serialization. It should not be diff --git a/src/main/java/com/google/devtools/build/lib/skyframe/serialization/autocodec/AutoCodecProcessor.java b/src/main/java/com/google/devtools/build/lib/skyframe/serialization/autocodec/AutoCodecProcessor.java index 2fc409637b..fc9547daca 100644 --- a/src/main/java/com/google/devtools/build/lib/skyframe/serialization/autocodec/AutoCodecProcessor.java +++ b/src/main/java/com/google/devtools/build/lib/skyframe/serialization/autocodec/AutoCodecProcessor.java @@ -31,12 +31,10 @@ import com.squareup.javapoet.TypeName; import com.squareup.javapoet.TypeSpec; import java.io.IOException; import java.util.List; -import java.util.Map; import java.util.Optional; import java.util.Set; import java.util.stream.Collectors; import java.util.stream.Stream; -import javax.annotation.Nullable; import javax.annotation.processing.AbstractProcessor; import javax.annotation.processing.ProcessingEnvironment; import javax.annotation.processing.Processor; @@ -48,8 +46,6 @@ import javax.lang.model.element.ExecutableElement; import javax.lang.model.element.Modifier; import javax.lang.model.element.TypeElement; import javax.lang.model.element.VariableElement; -import javax.lang.model.type.DeclaredType; -import javax.lang.model.type.MirroredTypeException; import javax.lang.model.type.TypeKind; import javax.lang.model.type.TypeMirror; import javax.lang.model.util.ElementFilter; @@ -98,20 +94,19 @@ public class AutoCodecProcessor extends AbstractProcessor { for (Element element : roundEnv.getElementsAnnotatedWith(AutoCodecUtil.ANNOTATION)) { AutoCodec annotation = element.getAnnotation(AutoCodecUtil.ANNOTATION); TypeElement encodedType = (TypeElement) element; - @Nullable TypeElement dependencyType = getDependencyType(annotation); TypeSpec.Builder codecClassBuilder = null; switch (annotation.strategy()) { case INSTANTIATOR: - codecClassBuilder = buildClassWithInstantiatorStrategy(encodedType, dependencyType); + codecClassBuilder = buildClassWithInstantiatorStrategy(encodedType); break; case PUBLIC_FIELDS: - codecClassBuilder = buildClassWithPublicFieldsStrategy(encodedType, dependencyType); + codecClassBuilder = buildClassWithPublicFieldsStrategy(encodedType); break; case POLYMORPHIC: - codecClassBuilder = buildClassWithPolymorphicStrategy(encodedType, dependencyType); + codecClassBuilder = buildClassWithPolymorphicStrategy(encodedType); break; case SINGLETON: - codecClassBuilder = buildClassWithSingletonStrategy(encodedType, dependencyType); + codecClassBuilder = buildClassWithSingletonStrategy(encodedType); break; default: throw new IllegalArgumentException("Unknown strategy: " + annotation.strategy()); @@ -137,86 +132,29 @@ public class AutoCodecProcessor extends AbstractProcessor { return true; } - /** Returns the type of the annotation dependency or null if the type is {@link Void}. */ - @Nullable - private TypeElement getDependencyType(AutoCodec annotation) { - try { - annotation.dependency(); - throw new AssertionError("Expected MirroredTypeException!"); - } catch (MirroredTypeException e) { - DeclaredType dependencyMirror = (DeclaredType) e.getTypeMirror(); - if (matchesType(dependencyMirror, Void.class)) { - return null; - } - return (TypeElement) dependencyMirror.asElement(); - } - } - - private TypeSpec.Builder buildClassWithInstantiatorStrategy( - TypeElement encodedType, @Nullable TypeElement dependency) { + private TypeSpec.Builder buildClassWithInstantiatorStrategy(TypeElement encodedType) { ExecutableElement constructor = selectInstantiator(encodedType); - PartitionedParameters parameters = isolateDependency(constructor); - if (dependency != null) { - if (parameters.dependency != null) { - throw new IllegalArgumentException( - encodedType.getQualifiedName() - + " has both a @Dependency annotated constructor parameter " - + "and a non-Void dependency element " - + dependency.getQualifiedName()); - } - parameters.dependency = dependency; - } + List<? extends VariableElement> fields = constructor.getParameters(); - TypeSpec.Builder codecClassBuilder = - AutoCodecUtil.initializeCodecClassBuilder(encodedType, parameters.dependency); + TypeSpec.Builder codecClassBuilder = AutoCodecUtil.initializeCodecClassBuilder(encodedType); if (encodedType.getAnnotation(AutoValue.class) == null) { - initializeUnsafeOffsets(codecClassBuilder, encodedType, parameters.fields); - codecClassBuilder.addMethod(buildSerializeMethodWithInstantiator(encodedType, parameters)); + initializeUnsafeOffsets(codecClassBuilder, encodedType, fields); + codecClassBuilder.addMethod(buildSerializeMethodWithInstantiator(encodedType, fields)); } else { codecClassBuilder.addMethod( - buildSerializeMethodWithInstantiatorForAutoValue(encodedType, parameters)); + buildSerializeMethodWithInstantiatorForAutoValue(encodedType, fields)); } MethodSpec.Builder deserializeBuilder = - AutoCodecUtil.initializeDeserializeMethodBuilder(encodedType, parameters.dependency); - buildDeserializeBody(deserializeBuilder, parameters.fields); + AutoCodecUtil.initializeDeserializeMethodBuilder(encodedType); + buildDeserializeBody(deserializeBuilder, fields); addReturnNew(deserializeBuilder, encodedType, constructor); codecClassBuilder.addMethod(deserializeBuilder.build()); return codecClassBuilder; } - private static class PartitionedParameters { - /** Non-dependency parameters. */ - List<VariableElement> fields; - /** Dependency for this codec or null if no such dependency exists. */ - @Nullable TypeElement dependency; - } - - /** Separates any dependency from the constructor parameters. */ - private static PartitionedParameters isolateDependency(ExecutableElement constructor) { - Map<Boolean, List<VariableElement>> splitParameters = - constructor - .getParameters() - .stream() - .collect( - Collectors.partitioningBy( - p -> p.getAnnotation(AutoCodec.Dependency.class) != null)); - PartitionedParameters result = new PartitionedParameters(); - result.fields = splitParameters.get(Boolean.FALSE); - List<VariableElement> dependencies = splitParameters.get(Boolean.TRUE); - if (dependencies.size() > 1) { - throw new IllegalArgumentException( - ((TypeElement) constructor.getEnclosingElement()).getQualifiedName() - + " constructor has multiple Dependency annotations."); - } - if (!dependencies.isEmpty()) { - result.dependency = (TypeElement) ((DeclaredType) dependencies.get(0).asType()).asElement(); - } - return result; - } - private ExecutableElement selectInstantiator(TypeElement encodedType) { List<ExecutableElement> constructors = ElementFilter.constructorsIn(encodedType.getEnclosedElements()); @@ -263,10 +201,10 @@ public class AutoCodecProcessor extends AbstractProcessor { } private MethodSpec buildSerializeMethodWithInstantiator( - TypeElement encodedType, PartitionedParameters parameters) { + TypeElement encodedType, List<? extends VariableElement> fields) { MethodSpec.Builder serializeBuilder = - AutoCodecUtil.initializeSerializeMethodBuilder(encodedType, parameters.dependency); - for (VariableElement parameter : parameters.fields) { + AutoCodecUtil.initializeSerializeMethodBuilder(encodedType); + for (VariableElement parameter : fields) { TypeKind typeKind = parameter.asType().getKind(); switch (typeKind) { case BOOLEAN: @@ -336,10 +274,10 @@ public class AutoCodecProcessor extends AbstractProcessor { } private MethodSpec buildSerializeMethodWithInstantiatorForAutoValue( - TypeElement encodedType, PartitionedParameters parameters) { + TypeElement encodedType, List<? extends VariableElement> fields) { MethodSpec.Builder serializeBuilder = - AutoCodecUtil.initializeSerializeMethodBuilder(encodedType, parameters.dependency); - for (VariableElement parameter : parameters.fields) { + AutoCodecUtil.initializeSerializeMethodBuilder(encodedType); + for (VariableElement parameter : fields) { TypeKind typeKind = parameter.asType().getKind(); String getter = "input." + findGetterForAutoValue(parameter, encodedType) + "()"; switch (typeKind) { @@ -362,19 +300,16 @@ public class AutoCodecProcessor extends AbstractProcessor { return serializeBuilder.build(); } - private TypeSpec.Builder buildClassWithPublicFieldsStrategy( - TypeElement encodedType, @Nullable TypeElement dependency) { - TypeSpec.Builder codecClassBuilder = - AutoCodecUtil.initializeCodecClassBuilder(encodedType, dependency); + private TypeSpec.Builder buildClassWithPublicFieldsStrategy(TypeElement encodedType) { + TypeSpec.Builder codecClassBuilder = AutoCodecUtil.initializeCodecClassBuilder(encodedType); ImmutableList<? extends VariableElement> publicFields = ElementFilter.fieldsIn(env.getElementUtils().getAllMembers(encodedType)) .stream() .filter(this::isPublicField) .collect(toImmutableList()); - codecClassBuilder.addMethod( - buildSerializeMethodWithPublicFields(encodedType, publicFields, dependency)); + codecClassBuilder.addMethod(buildSerializeMethodWithPublicFields(encodedType, publicFields)); MethodSpec.Builder deserializeBuilder = - AutoCodecUtil.initializeDeserializeMethodBuilder(encodedType, dependency); + AutoCodecUtil.initializeDeserializeMethodBuilder(encodedType); buildDeserializeBody(deserializeBuilder, publicFields); addInstantiatePopulateFieldsAndReturn(deserializeBuilder, encodedType, publicFields); codecClassBuilder.addMethod(deserializeBuilder.build()); @@ -390,12 +325,10 @@ public class AutoCodecProcessor extends AbstractProcessor { } private MethodSpec buildSerializeMethodWithPublicFields( - TypeElement encodedType, - List<? extends VariableElement> parameters, - @Nullable TypeElement dependency) { + TypeElement encodedType, List<? extends VariableElement> fields) { MethodSpec.Builder serializeBuilder = - AutoCodecUtil.initializeSerializeMethodBuilder(encodedType, dependency); - for (VariableElement parameter : parameters) { + AutoCodecUtil.initializeSerializeMethodBuilder(encodedType); + for (VariableElement parameter : fields) { String paramAccessor = "input." + parameter.getSimpleName(); TypeKind typeKind = parameter.asType().getKind(); switch (typeKind) { @@ -428,8 +361,8 @@ public class AutoCodecProcessor extends AbstractProcessor { * is to avoid name collisions with variables used internally by AutoCodec. */ private void buildDeserializeBody( - MethodSpec.Builder builder, List<? extends VariableElement> parameters) { - for (VariableElement parameter : parameters) { + MethodSpec.Builder builder, List<? extends VariableElement> fields) { + for (VariableElement parameter : fields) { String paramName = parameter.getSimpleName() + "_"; TypeKind typeKind = parameter.asType().getKind(); switch (typeKind) { @@ -493,14 +426,9 @@ public class AutoCodecProcessor extends AbstractProcessor { /** * Coverts a constructor parameter to a String representing its handle within deserialize. - * - * <p>Uses the handle {@code dependency} for any parameter with the {@link AutoCodec.Dependency} - * annotation. */ private static String handleFromParameter(VariableElement parameter) { - return parameter.getAnnotation(AutoCodec.Dependency.class) != null - ? "dependency" - : (parameter.getSimpleName() + "_"); + return parameter.getSimpleName() + "_"; } /** @@ -595,71 +523,43 @@ public class AutoCodecProcessor extends AbstractProcessor { return Optional.empty(); } - private TypeSpec.Builder buildClassWithPolymorphicStrategy( - TypeElement encodedType, @Nullable TypeElement dependency) { + private TypeSpec.Builder buildClassWithPolymorphicStrategy(TypeElement encodedType) { if (!encodedType.getModifiers().contains(Modifier.ABSTRACT)) { throw new IllegalArgumentException( encodedType + " is not abstract, but POLYMORPHIC was selected as the strategy."); } - TypeSpec.Builder codecClassBuilder = - AutoCodecUtil.initializeCodecClassBuilder(encodedType, dependency); - codecClassBuilder.addMethod(buildPolymorphicSerializeMethod(encodedType, dependency)); - codecClassBuilder.addMethod(buildPolymorphicDeserializeMethod(encodedType, dependency)); + TypeSpec.Builder codecClassBuilder = AutoCodecUtil.initializeCodecClassBuilder(encodedType); + codecClassBuilder.addMethod(buildPolymorphicSerializeMethod(encodedType)); + codecClassBuilder.addMethod(buildPolymorphicDeserializeMethod(encodedType)); return codecClassBuilder; } - private MethodSpec buildPolymorphicSerializeMethod( - TypeElement encodedType, @Nullable TypeElement dependency) { - MethodSpec.Builder builder = - AutoCodecUtil.initializeSerializeMethodBuilder(encodedType, dependency); + private MethodSpec buildPolymorphicSerializeMethod(TypeElement encodedType) { + MethodSpec.Builder builder = AutoCodecUtil.initializeSerializeMethodBuilder(encodedType); TypeName polyClass = TypeName.get(env.getTypeUtils().erasure(encodedType.asType())); - if (dependency == null) { builder.addStatement( "$T.serialize(context, input, $T.class, codedOut, null)", PolymorphicHelper.class, polyClass); - } else { - builder.addStatement( - "$T.serialize(context, input, $T.class, codedOut, $T.ofNullable(dependency))", - PolymorphicHelper.class, - polyClass, - Optional.class); - } return builder.build(); } - private static MethodSpec buildPolymorphicDeserializeMethod( - TypeElement encodedType, @Nullable TypeElement dependency) { - MethodSpec.Builder builder = - AutoCodecUtil.initializeDeserializeMethodBuilder(encodedType, dependency); - if (dependency == null) { + private static MethodSpec buildPolymorphicDeserializeMethod(TypeElement encodedType) { + MethodSpec.Builder builder = AutoCodecUtil.initializeDeserializeMethodBuilder(encodedType); builder.addStatement( "return ($T) $T.deserialize(context, codedIn, null)", TypeName.get(encodedType.asType()), PolymorphicHelper.class); - } else { - builder.addStatement( - "return ($T) $T.deserialize(context, codedIn, $T.ofNullable(dependency))", - TypeName.get(encodedType.asType()), - PolymorphicHelper.class, - Optional.class); - } return builder.build(); } - private static TypeSpec.Builder buildClassWithSingletonStrategy( - TypeElement encodedType, @Nullable TypeElement dependency) { - if (dependency != null) { - throw new IllegalArgumentException( - encodedType + " specifies a dependency, but SINGLETON is selected as the strategy."); - } - TypeSpec.Builder codecClassBuilder = - AutoCodecUtil.initializeCodecClassBuilder(encodedType, dependency); + private static TypeSpec.Builder buildClassWithSingletonStrategy(TypeElement encodedType) { + TypeSpec.Builder codecClassBuilder = AutoCodecUtil.initializeCodecClassBuilder(encodedType); // Serialization is a no-op. codecClassBuilder.addMethod( - AutoCodecUtil.initializeSerializeMethodBuilder(encodedType, dependency).build()); + AutoCodecUtil.initializeSerializeMethodBuilder(encodedType).build()); MethodSpec.Builder deserializeMethodBuilder = - AutoCodecUtil.initializeDeserializeMethodBuilder(encodedType, dependency); + AutoCodecUtil.initializeDeserializeMethodBuilder(encodedType); deserializeMethodBuilder.addStatement("return $T.INSTANCE", TypeName.get(encodedType.asType())); codecClassBuilder.addMethod(deserializeMethodBuilder.build()); return codecClassBuilder; diff --git a/src/main/java/com/google/devtools/build/lib/skyframe/serialization/autocodec/AutoCodecUtil.java b/src/main/java/com/google/devtools/build/lib/skyframe/serialization/autocodec/AutoCodecUtil.java index 4f5409269a..610badc465 100644 --- a/src/main/java/com/google/devtools/build/lib/skyframe/serialization/autocodec/AutoCodecUtil.java +++ b/src/main/java/com/google/devtools/build/lib/skyframe/serialization/autocodec/AutoCodecUtil.java @@ -16,7 +16,6 @@ package com.google.devtools.build.lib.skyframe.serialization.autocodec; import com.google.common.collect.ImmutableList; import com.google.devtools.build.lib.skyframe.serialization.DeserializationContext; -import com.google.devtools.build.lib.skyframe.serialization.InjectingObjectCodec; import com.google.devtools.build.lib.skyframe.serialization.ObjectCodec; import com.google.devtools.build.lib.skyframe.serialization.SerializationContext; import com.google.devtools.build.lib.skyframe.serialization.SerializationException; @@ -29,7 +28,6 @@ import com.squareup.javapoet.TypeName; import com.squareup.javapoet.TypeSpec; import java.io.IOException; import java.util.stream.Collectors; -import javax.annotation.Nullable; import javax.lang.model.element.Element; import javax.lang.model.element.Modifier; import javax.lang.model.element.TypeElement; @@ -41,36 +39,15 @@ class AutoCodecUtil { static final Class<AutoCodec> ANNOTATION = AutoCodec.class; /** - * Initializes a builder for a class implementing {@link ObjectCodec}. - * - * @param encodedType type being serialized - */ - static TypeSpec.Builder initializeCodecClassBuilder(TypeElement encodedType) { - return initializeCodecClassBuilder(encodedType, null); - } - - /** * Initializes a builder for a class of the appropriate type. * - * <p>If the dependency is non-null, then the type is {@link InjectingObjectCodec} otherwise - * {@link ObjectCodec}. - * * @param encodedType type being serialized - * @param dependency type being injected or null */ - static TypeSpec.Builder initializeCodecClassBuilder( - TypeElement encodedType, @Nullable TypeElement dependency) { + static TypeSpec.Builder initializeCodecClassBuilder(TypeElement encodedType) { TypeSpec.Builder builder = TypeSpec.classBuilder(getCodecName(encodedType)); - if (dependency == null) { - return builder.addSuperinterface( - ParameterizedTypeName.get( - ClassName.get(ObjectCodec.class), TypeName.get(encodedType.asType()))); - } return builder.addSuperinterface( ParameterizedTypeName.get( - ClassName.get(InjectingObjectCodec.class), - TypeName.get(encodedType.asType()), - TypeName.get(dependency.asType()))); + ClassName.get(ObjectCodec.class), TypeName.get(encodedType.asType()))); } static MethodSpec.Builder initializeGetEncodedClassMethod(TypeElement encodedType) { @@ -82,21 +59,12 @@ class AutoCodecUtil { ClassName.get(Class.class), TypeName.get(encodedType.asType()))); } - static MethodSpec.Builder initializeSerializeMethodBuilder(TypeElement encodedType) { - return initializeSerializeMethodBuilder(encodedType, null); - } - /** - * Initializes the appropriate deserialize method based on presence of dependency. - * - * <p>{@link InjectingObjectCodec#serialize} if dependency is non-null and {@link - * ObjectCodec#serialize} otherwise. + * Initializes the deserialize method. * * @param encodedType type being serialized - * @param dependency type being injected */ - static MethodSpec.Builder initializeSerializeMethodBuilder( - TypeElement encodedType, @Nullable TypeElement dependency) { + static MethodSpec.Builder initializeSerializeMethodBuilder(TypeElement encodedType) { MethodSpec.Builder builder = MethodSpec.methodBuilder("serialize") .addModifiers(Modifier.PUBLIC) @@ -104,31 +72,18 @@ class AutoCodecUtil { .addAnnotation(Override.class) .addException(SerializationException.class) .addException(IOException.class); - if (dependency != null) { - builder.addParameter(TypeName.get(dependency.asType()), "dependency"); - } return builder .addParameter(SerializationContext.class, "context") .addParameter(TypeName.get(encodedType.asType()), "input") .addParameter(CodedOutputStream.class, "codedOut"); } - /** Initializes {@link ObjectCodec#deserialize}. */ - static MethodSpec.Builder initializeDeserializeMethodBuilder(TypeElement encodedType) { - return initializeDeserializeMethodBuilder(encodedType, null); - } - /** - * Initializes the appropriate deserialize method based on presence of dependency. - * - * <p>{@link InjectingObjectCodec#deserialize} if dependency is non-null and {@link - * ObjectCodec#deserialize} otherwise. + * Initializes the deserialize method. * * @param encodedType type being serialized - * @param dependency type being injected */ - static MethodSpec.Builder initializeDeserializeMethodBuilder( - TypeElement encodedType, @Nullable TypeElement dependency) { + static MethodSpec.Builder initializeDeserializeMethodBuilder(TypeElement encodedType) { MethodSpec.Builder builder = MethodSpec.methodBuilder("deserialize") .addModifiers(Modifier.PUBLIC) @@ -136,9 +91,6 @@ class AutoCodecUtil { .addAnnotation(Override.class) .addException(SerializationException.class) .addException(IOException.class); - if (dependency != null) { - builder.addParameter(TypeName.get(dependency.asType()), "dependency"); - } return builder .addParameter(DeserializationContext.class, "context") .addParameter(CodedInputStream.class, "codedIn"); diff --git a/src/main/java/com/google/devtools/build/lib/skyframe/serialization/autocodec/Marshallers.java b/src/main/java/com/google/devtools/build/lib/skyframe/serialization/autocodec/Marshallers.java index 541b1e3fa6..bb8e6e9495 100644 --- a/src/main/java/com/google/devtools/build/lib/skyframe/serialization/autocodec/Marshallers.java +++ b/src/main/java/com/google/devtools/build/lib/skyframe/serialization/autocodec/Marshallers.java @@ -28,7 +28,6 @@ import com.google.common.collect.Maps; import com.google.common.hash.HashCode; import com.google.devtools.build.lib.collect.nestedset.NestedSet; import com.google.devtools.build.lib.collect.nestedset.NestedSetCodec; -import com.google.devtools.build.lib.skyframe.serialization.InjectingObjectCodec; import com.google.devtools.build.lib.skyframe.serialization.ObjectCodec; import com.google.devtools.build.lib.skyframe.serialization.autocodec.SerializationCodeGenerator.Context; import com.google.devtools.build.lib.skyframe.serialization.autocodec.SerializationCodeGenerator.Marshaller; @@ -806,24 +805,13 @@ class Marshallers { typeParameter); return; } - - if (matchesErased(typeParameterCodec.get().asType(), InjectingObjectCodec.class)) { - context.builder.addStatement( - "$T<$T> $L = new $T<>($T.CODEC, dependency)", - NestedSetCodec.class, - typeParameter, - nestedSetCodec, - NestedSetCodec.class, - typeParameter); - } else { - context.builder.addStatement( - "$T<$T> $L = new $T<>($T.CODEC)", - NestedSetCodec.class, - typeParameter, - nestedSetCodec, - NestedSetCodec.class, - typeParameter); - } + context.builder.addStatement( + "$T<$T> $L = new $T<>($T.CODEC)", + NestedSetCodec.class, + typeParameter, + nestedSetCodec, + NestedSetCodec.class, + typeParameter); context.builder.addStatement( "$L.serialize(context, ($T<$T>) $L, codedOut)", nestedSetCodec, @@ -848,24 +836,13 @@ class Marshallers { typeParameter); return; } - - if (matchesErased(typeParameterCodec.get().asType(), InjectingObjectCodec.class)) { - context.builder.addStatement( - "$T<$T> $L = new $T<>($T.CODEC, dependency)", - NestedSetCodec.class, - typeParameter, - nestedSetCodec, - NestedSetCodec.class, - typeParameter); - } else { - context.builder.addStatement( - "$T<$T> $L = new $T<>($T.CODEC)", - NestedSetCodec.class, - typeParameter, - nestedSetCodec, - NestedSetCodec.class, - typeParameter); - } + context.builder.addStatement( + "$T<$T> $L = new $T<>($T.CODEC)", + NestedSetCodec.class, + typeParameter, + nestedSetCodec, + NestedSetCodec.class, + typeParameter); context.builder.addStatement( "$L = $L.deserialize(context, codedIn)", context.name, nestedSetCodec); } @@ -906,16 +883,11 @@ class Marshallers { if (isSubtypeErased(codecType, ObjectCodec.class)) { context.builder.addStatement( "$T.CODEC.serialize(context, $L, codedOut)", context.getTypeName(), context.name); - } else if (isSubtypeErased(codecType, InjectingObjectCodec.class)) { - context.builder.addStatement( - "$T.CODEC.serialize(dependency, context, $L, codedOut)", - context.getTypeName(), - context.name); } else { throw new IllegalArgumentException( "CODEC field of " + ((TypeElement) context.getDeclaredType().asElement()).getQualifiedName() - + " is neither ObjectCodec nor InjectingCodec"); + + " is not ObjectCodec"); } } @@ -925,16 +897,11 @@ class Marshallers { if (isSubtypeErased(codecType, ObjectCodec.class)) { context.builder.addStatement( "$L = $T.CODEC.deserialize(context, codedIn)", context.name, context.getTypeName()); - } else if (isSubtypeErased(codecType, InjectingObjectCodec.class)) { - context.builder.addStatement( - "$L = $T.CODEC.deserialize(dependency, context, codedIn)", - context.name, - context.getTypeName()); } else { throw new IllegalArgumentException( "CODEC field of " + ((TypeElement) context.getDeclaredType().asElement()).getQualifiedName() - + " is neither ObjectCodec nor InjectingCodec"); + + " is neither ObjectCodec"); } } }; |