Use enumValueTypeAlias for constant type annotation for rust

cuzfrog · cuzfrog · commit 3f0b75a6672c · 2025-06-07T12:09:35.000-04:00
diff --git a/internal/src/main/java/online/sharedtype/processor/domain/def/ConcreteTypeDef.java b/internal/src/main/java/online/sharedtype/processor/domain/def/ConcreteTypeDef.java
@@ -29,6 +29,7 @@ public abstract class ConcreteTypeDef implements TypeDef {
 
     /**
      * Register a counterpart typeInfo.
+     * <b>Note:</b> This method should not be called from outside, please use {@link ConcreteTypeInfo#shallowResolved()}
      */
     public abstract void linkTypeInfo(ConcreteTypeInfo typeInfo);
 }
diff --git a/internal/src/main/java/online/sharedtype/processor/domain/def/EnumDef.java b/internal/src/main/java/online/sharedtype/processor/domain/def/EnumDef.java
@@ -54,6 +54,13 @@ public TypeInfo getComponentValueType() {
         }
         return enumValueInfos.get(0).value().getValueType();
     }
+    /** @return true if component value has a different type other than this enumType, i.e. when enumValue is defined */
+    public boolean hasComponentValueType() {
+        return !getComponentValueType().equals(typeInfo);
+    }
+    public String valueTypeAlias() {
+        return String.format("%sValue", simpleName);
+    }
 
     @Override
     public Set<ConcreteTypeInfo> typeInfoSet() {
diff --git a/internal/src/main/java/online/sharedtype/processor/domain/value/EnumConstantValue.java b/internal/src/main/java/online/sharedtype/processor/domain/value/EnumConstantValue.java
@@ -9,9 +9,11 @@
 @EqualsAndHashCode(callSuper = true)
 public final class EnumConstantValue extends LiteralValue {
     private static final long serialVersionUID = -6711930218877737970L;
+    private final ConcreteTypeInfo enumType;
     private final String enumConstantName;
-    EnumConstantValue(String enumConstantName, ConcreteTypeInfo valueType, Object value) {
+    EnumConstantValue(ConcreteTypeInfo enumType, String enumConstantName, ConcreteTypeInfo valueType, Object value) {
         super(valueType, value);
+        this.enumType = enumType;
         this.enumConstantName = enumConstantName;
     }
 
diff --git a/internal/src/main/java/online/sharedtype/processor/domain/value/ValueHolder.java b/internal/src/main/java/online/sharedtype/processor/domain/value/ValueHolder.java
@@ -2,7 +2,6 @@
 
 import online.sharedtype.processor.domain.Constants;
 import online.sharedtype.processor.domain.type.ConcreteTypeInfo;
-import online.sharedtype.processor.domain.type.TypeInfo;
 
 import java.io.Serializable;
 
@@ -27,15 +26,15 @@ static ValueHolder of(ConcreteTypeInfo valueType, Object value) {
         }
     }
 
-    static EnumConstantValue ofEnum(String enumConstantName, ConcreteTypeInfo valueType, Object value) {
+    static EnumConstantValue ofEnum(ConcreteTypeInfo enumType, String enumConstantName, ConcreteTypeInfo valueType, Object value) {
         ConcreteTypeInfo actualValueType = valueType;
         Object actualValue = value;
         while (actualValue instanceof ValueHolder) {
             ValueHolder valueHolder = (ValueHolder) actualValue;
             actualValueType = valueHolder.getValueType();
             actualValue = valueHolder.getValue();
         }
-        return new EnumConstantValue(enumConstantName, actualValueType, actualValue);
+        return new EnumConstantValue(enumType, enumConstantName, actualValueType, actualValue);
     }
 
     LiteralValue NULL = new LiteralValue(Constants.NULL_TYPE_INFO,null);
diff --git a/processor/src/main/java/online/sharedtype/processor/parser/ClassTypeDefParser.java b/processor/src/main/java/online/sharedtype/processor/parser/ClassTypeDefParser.java
@@ -76,7 +76,7 @@ public List<TypeDef> parse(TypeElement typeElement) {
         classDef.directSupertypes().addAll(parseSupertypes(typeElement));
 
         TypeInfo typeInfo = typeInfoParser.parse(typeElement.asType(), typeElement);
-        classDef.linkTypeInfo((ConcreteTypeInfo) typeInfo);
+        ((ConcreteTypeInfo) typeInfo).markShallowResolved(classDef);
         return Collections.singletonList(classDef);
     }
 
diff --git a/processor/src/main/java/online/sharedtype/processor/parser/EnumTypeDefParser.java b/processor/src/main/java/online/sharedtype/processor/parser/EnumTypeDefParser.java
@@ -62,7 +62,7 @@ public List<TypeDef> parse(TypeElement typeElement) {
             .build();
         enumDef.components().addAll(parseEnumConstants(typeElement, enumConstantElems));
         TypeInfo typeInfo = typeInfoParser.parse(typeElement.asType(), typeElement);
-        enumDef.linkTypeInfo((ConcreteTypeInfo) typeInfo);
+        ((ConcreteTypeInfo) typeInfo).markShallowResolved(enumDef);
         return Collections.singletonList(enumDef);
     }
 
diff --git a/processor/src/main/java/online/sharedtype/processor/parser/value/EnumValueParser.java b/processor/src/main/java/online/sharedtype/processor/parser/value/EnumValueParser.java
@@ -33,9 +33,9 @@ public ValueHolder resolve(Element enumConstantElement, TypeElement enumTypeElem
         VariableElement enumConstant = (VariableElement) enumConstantElement;
         String enumConstantName = enumConstant.getSimpleName().toString();
         EnumCtorIndex ctorArgIdx = resolveCtorIndex(enumTypeElement);
+        ConcreteTypeInfo enumTypeInfo = (ConcreteTypeInfo) typeInfoParser.parse(enumTypeElement.asType(), enumTypeElement);
         if (ctorArgIdx == EnumCtorIndex.NONE) {
-            ConcreteTypeInfo typeInfo = (ConcreteTypeInfo) typeInfoParser.parse(enumTypeElement.asType(), enumTypeElement);
-            return ValueHolder.ofEnum(enumConstantName, typeInfo, enumConstantName);
+            return ValueHolder.ofEnum(enumTypeInfo, enumConstantName, enumTypeInfo, enumConstantName);
         }
 
         Tree tree = ctx.getTrees().getTree(enumConstant);
@@ -58,7 +58,7 @@ public ValueHolder resolve(Element enumConstantElement, TypeElement enumTypeElem
                     return ValueHolder.NULL;
                 }
             }
-            return ValueHolder.ofEnum(enumConstantName, valueType, value);
+            return ValueHolder.ofEnum(enumTypeInfo, enumConstantName, valueType, value);
         } else if (tree == null) {
             ctx.error(enumConstant, "Literal value cannot be parsed from enum constant: %s of enum %s, because source tree from the element is null." +
                     " This could mean at the time of the annotation processing, the source tree was not available." +
diff --git a/processor/src/main/java/online/sharedtype/processor/writer/converter/ConstantConverter.java b/processor/src/main/java/online/sharedtype/processor/writer/converter/ConstantConverter.java
@@ -7,6 +7,7 @@
 import online.sharedtype.processor.domain.component.ComponentInfo;
 import online.sharedtype.processor.domain.component.ConstantField;
 import online.sharedtype.processor.domain.def.ConstantNamespaceDef;
+import online.sharedtype.processor.domain.def.EnumDef;
 import online.sharedtype.processor.domain.def.TypeDef;
 import online.sharedtype.processor.domain.type.ConcreteTypeInfo;
 import online.sharedtype.processor.domain.value.EnumConstantValue;
@@ -22,7 +23,6 @@
 @RequiredArgsConstructor
 final class ConstantConverter implements TemplateDataConverter {
     private final Context ctx;
-    @Nullable
     private final TypeExpressionConverter typeExpressionConverter;
     private final SharedType.TargetType targetType;
 
@@ -46,11 +46,24 @@ public Tuple<Template, AbstractTypeExpr> convert(TypeDef typeDef) {
     private ConstantExpr toConstantExpr(ConstantField constantField, TypeDef contextTypeDef) {
         return new ConstantExpr(
             constantField,
-            typeExpressionConverter == null ? null : typeExpressionConverter.toTypeExpr(constantField.value().getValueType(), contextTypeDef),
+            toConstantTypeExpr(constantField, contextTypeDef),
             toConstantValue(constantField)
         );
     }
 
+    private String toConstantTypeExpr(ConstantField constantField, TypeDef contextTypeDef) {
+        if (targetType == SharedType.TargetType.RUST && constantField.value() instanceof EnumConstantValue) {
+            EnumConstantValue enumConstantValue = (EnumConstantValue) constantField.value();
+            ConcreteTypeInfo enumTypeInfo = enumConstantValue.getEnumType();
+            EnumDef enumTypeDef = (EnumDef) enumTypeInfo.typeDef();
+            if (enumTypeDef.hasComponentValueType() && ctx.getProps().getRust().hasEnumValueTypeAlias()) {
+                return enumTypeDef.valueTypeAlias();
+            }
+        }
+
+        return typeExpressionConverter.toTypeExpr(constantField.value().getValueType(), contextTypeDef);
+    }
+
     private String toConstantValue(ConstantField constantField) {
         if (targetType == SharedType.TargetType.RUST) {
             ConcreteTypeInfo type = constantField.value().getValueType();
diff --git a/processor/src/main/java/online/sharedtype/processor/writer/converter/RustEnumConverter.java b/processor/src/main/java/online/sharedtype/processor/writer/converter/RustEnumConverter.java
@@ -8,7 +8,6 @@
 import online.sharedtype.processor.domain.def.EnumDef;
 import online.sharedtype.processor.domain.def.TypeDef;
 import online.sharedtype.processor.domain.type.ConcreteTypeInfo;
-import online.sharedtype.processor.domain.type.TypeInfo;
 import online.sharedtype.processor.domain.value.EnumConstantValue;
 import online.sharedtype.processor.support.utils.Tuple;
 import online.sharedtype.processor.writer.converter.type.TypeExpressionConverter;
@@ -40,19 +39,17 @@ public Tuple<Template, AbstractTypeExpr> convert(TypeDef typeDef) {
             rustMacroTraitsGenerator.generate(enumDef),
             hasValue,
             valueType,
-            hasValue && ctx.getProps().getRust().hasEnumValueTypeAlias() ? String.format("%sValue", enumDef.simpleName()) : null
+            hasValue && ctx.getProps().getRust().hasEnumValueTypeAlias() ? enumDef.valueTypeAlias() : null
         );
         return Tuple.of(Template.TEMPLATE_RUST_ENUM, value);
     }
 
     @Nullable
     private String getValueTypeExpr(EnumDef enumDef) {
-        TypeInfo componentValueType = enumDef.getComponentValueType();
-        TypeInfo enumTypeInfo = enumDef.typeInfoSet().iterator().next();
-        if (enumTypeInfo.equals(componentValueType)) {
-            return null;
+        if (enumDef.hasComponentValueType()) {
+            return typeExpressionConverter.toTypeExpr(enumDef.getComponentValueType(), enumDef);
         }
-        return typeExpressionConverter.toTypeExpr(componentValueType, enumDef);
+        return null;
     }
 
     private List<EnumerationExpr> extractEnumValues(List<EnumValueInfo> components) {
diff --git a/processor/src/main/java/online/sharedtype/processor/writer/converter/TemplateDataConverter.java b/processor/src/main/java/online/sharedtype/processor/writer/converter/TemplateDataConverter.java
@@ -20,7 +20,7 @@ static Set<TemplateDataConverter> typescript(Context ctx) {
         Set<TemplateDataConverter> converters = new HashSet<>(3);
         converters.add(new TypescriptInterfaceConverter(ctx, TypeExpressionConverter.typescript(ctx)));
         converters.add(new TypescriptEnumConverter(ctx));
-        converters.add(new ConstantConverter(ctx, null, SharedType.TargetType.TYPESCRIPT));
+        converters.add(new ConstantConverter(ctx, TypeExpressionConverter.nullOp(), SharedType.TargetType.TYPESCRIPT));
         return converters;
     }
 
@@ -36,7 +36,7 @@ static Set<TemplateDataConverter> go(Context ctx) {
     static Set<TemplateDataConverter> rust(Context ctx) {
         RustMacroTraitsGenerator rustMacroTraitsGenerator = new RustMacroTraitsGeneratorImpl(ctx);
         TypeExpressionConverter rustTypeExpressionConverter = TypeExpressionConverter.rust(ctx);
-        TypeExpressionConverter rustLiteralTypeExpressionConverter = TypeExpressionConverter.rustLiteral();
+        TypeExpressionConverter rustLiteralTypeExpressionConverter = TypeExpressionConverter.rustLiteral(ctx);
         Set<TemplateDataConverter> converters = new HashSet<>(3);
         converters.add(new RustStructConverter(ctx, rustTypeExpressionConverter, rustMacroTraitsGenerator));
         converters.add(new RustEnumConverter(ctx, rustLiteralTypeExpressionConverter, rustMacroTraitsGenerator));
diff --git a/processor/src/main/java/online/sharedtype/processor/writer/converter/type/RustLiteralTypeExpressionConverter.java b/processor/src/main/java/online/sharedtype/processor/writer/converter/type/RustLiteralTypeExpressionConverter.java
@@ -1,6 +1,9 @@
 package online.sharedtype.processor.writer.converter.type;
 
+import lombok.RequiredArgsConstructor;
+import online.sharedtype.processor.context.Context;
 import online.sharedtype.processor.domain.Constants;
+import online.sharedtype.processor.domain.def.EnumDef;
 import online.sharedtype.processor.domain.def.TypeDef;
 import online.sharedtype.processor.domain.type.ConcreteTypeInfo;
 import online.sharedtype.processor.domain.type.TypeInfo;
@@ -9,19 +12,29 @@
 import java.util.HashSet;
 import java.util.Set;
 
-final class RustConstantLiteralTypeExpressionConverter implements TypeExpressionConverter {
+@RequiredArgsConstructor
+final class RustLiteralTypeExpressionConverter implements TypeExpressionConverter {
     private static final Set<ConcreteTypeInfo> STRING_TYPES = new HashSet<>(3);
     static {
         STRING_TYPES.add(Constants.STRING_TYPE_INFO);
         STRING_TYPES.addAll(Constants.MATH_TYPES);
     }
 
+    private final Context ctx;
+
     @Override
     public String toTypeExpr(TypeInfo typeInfo, TypeDef contextTypeDef) {
         if (!(typeInfo instanceof ConcreteTypeInfo)) {
             throw new SharedTypeInternalError(String.format("Literal types must be concrete types, but got: %s in %s", typeInfo, contextTypeDef));
         }
         ConcreteTypeInfo concreteTypeInfo = (ConcreteTypeInfo) typeInfo;
+        if (concreteTypeInfo.getKind() == ConcreteTypeInfo.Kind.ENUM) {
+            EnumDef enumDef = (EnumDef) concreteTypeInfo.typeDef();
+            if (enumDef.hasComponentValueType() && ctx.getProps().getRust().hasEnumValueTypeAlias()) {
+                return enumDef.valueTypeAlias();
+            }
+        }
+
         if (STRING_TYPES.contains(concreteTypeInfo)) {
             return "&'static str";
         }
diff --git a/processor/src/main/java/online/sharedtype/processor/writer/converter/type/TypeExpressionConverter.java b/processor/src/main/java/online/sharedtype/processor/writer/converter/type/TypeExpressionConverter.java
@@ -4,8 +4,11 @@
 import online.sharedtype.processor.context.Context;
 import online.sharedtype.processor.domain.def.TypeDef;
 import online.sharedtype.processor.domain.type.TypeInfo;
+import online.sharedtype.processor.support.annotation.Nullable;
 
 public interface TypeExpressionConverter {
+    /** @return null when it's nullOp impl, e.g. typescript constant generation does not need type info. */
+    @Nullable
     String toTypeExpr(TypeInfo typeInfo, TypeDef contextTypeDef);
 
     static TypeExpressionConverter typescript(Context ctx) {
@@ -20,8 +23,12 @@ static TypeExpressionConverter rust(Context ctx) {
         return new RustTypeExpressionConverter(ctx);
     }
 
-    static TypeExpressionConverter rustLiteral() {
-        return new RustConstantLiteralTypeExpressionConverter();
+    static TypeExpressionConverter rustLiteral(Context ctx) {
+        return new RustLiteralTypeExpressionConverter(ctx);
+    }
+
+    static TypeExpressionConverter nullOp() {
+        return (typeInfo, contextTypeDef) -> null;
     }
 
     @RequiredArgsConstructor
diff --git a/processor/src/test/java/online/sharedtype/processor/domain/def/EnumDefTest.java b/processor/src/test/java/online/sharedtype/processor/domain/def/EnumDefTest.java
@@ -30,7 +30,9 @@ void componentValueType() {
         EnumDef enumDef = EnumDef.builder()
             .qualifiedName("com.github.cuzfrog.EnumA").simpleName("EnumA")
             .enumValueInfos(Collections.singletonList(
-                EnumValueInfo.builder().name("Value1").value(ValueHolder.ofEnum("Value1", Constants.BOOLEAN_TYPE_INFO, true)).build()
+                EnumValueInfo.builder().name("Value1")
+                    .value(ValueHolder.ofEnum(enumTypeInfo, "Value1", Constants.BOOLEAN_TYPE_INFO, true))
+                    .build()
             ))
             .typeInfo(enumTypeInfo)
             .build();
diff --git a/processor/src/test/java/online/sharedtype/processor/domain/value/ValueHolderTest.java b/processor/src/test/java/online/sharedtype/processor/domain/value/ValueHolderTest.java
@@ -23,6 +23,7 @@ void getNestedValue() {
             ValueHolder.of(
                 enumType,
                 ValueHolder.ofEnum(
+                    enumType,
                     "ENUM_CONST",
                     STRING_TYPE_INFO,
                     ValueHolder.of(STRING_TYPE_INFO, ValueHolder.of(STRING_TYPE_INFO, "Value1"))
diff --git a/processor/src/test/java/online/sharedtype/processor/parser/ClassTypeDefParserTest.java b/processor/src/test/java/online/sharedtype/processor/parser/ClassTypeDefParserTest.java
@@ -146,10 +146,12 @@ void ignoreGlobalConfiguredField() {
         var fieldElement = ctxMocks.declaredTypeVariable("field333", string.type()).withElementKind(ElementKind.FIELD).element();
         var typeElement = ctxMocks.typeElement("com.github.cuzfrog.Abc")
             .withEnclosedElements(
-
+                fieldElement
             )
             .element();
         when(ctxMocks.getContext().isIgnored(fieldElement)).thenReturn(true);
+        var typeInfo = ConcreteTypeInfo.builder().qualifiedName("com.github.cuzfrog.Abc").build();
+        when(typeInfoParser.parse(typeElement.asType(), typeElement)).thenReturn(typeInfo);
 
         var classDef = parser.parse(typeElement).get(0);
         assertThat(classDef.components()).isEmpty();
diff --git a/processor/src/test/java/online/sharedtype/processor/parser/EnumTypeDefParserTest.java b/processor/src/test/java/online/sharedtype/processor/parser/EnumTypeDefParserTest.java
@@ -58,9 +58,9 @@ void simpleEnum() {
 
         ConcreteTypeInfo typeInfo = ConcreteTypeInfo.builder().qualifiedName("com.github.cuzfrog.EnumA").build();
         when(typeInfoParser.parse(enumType.type(), enumType.element())).thenReturn(typeInfo);
-        var value1 = ValueHolder.ofEnum(enumConstant1.getSimpleName().toString(), Constants.STRING_TYPE_INFO, "Value1");
+        var value1 = ValueHolder.ofEnum(typeInfo, enumConstant1.getSimpleName().toString(), Constants.STRING_TYPE_INFO, "Value1");
         when(valueParser.resolve(enumConstant1, enumType.element())).thenReturn(value1);
-        var value2 = ValueHolder.ofEnum(enumConstant2.getSimpleName().toString(), Constants.STRING_TYPE_INFO,"Value2");
+        var value2 = ValueHolder.ofEnum(typeInfo, enumConstant2.getSimpleName().toString(), Constants.STRING_TYPE_INFO,"Value2");
         when(valueParser.resolve(enumConstant2, enumType.element())).thenReturn(value2);
 
         EnumDef typeDef = (EnumDef) parser.parse(enumType.element()).getFirst();
diff --git a/processor/src/test/java/online/sharedtype/processor/parser/value/EnumValueParserTest.java b/processor/src/test/java/online/sharedtype/processor/parser/value/EnumValueParserTest.java
@@ -78,7 +78,7 @@ void enumReferencingEnum() {
             .thenReturn(new EnumCtorIndex(0, enumConstant1));
         reset(valueResolverBackend);
         when(valueResolverBackend.recursivelyResolve(any()))
-            .thenReturn(ValueHolder.ofEnum("AnotherEnumConstant1", anotherEnumTypeInfo, "AnotherEnumConstant1"));
+            .thenReturn(ValueHolder.ofEnum(null, "AnotherEnumConstant1", anotherEnumTypeInfo, "AnotherEnumConstant1"));
 
         EnumConstantValue value1 = (EnumConstantValue) resolver.resolve(enumConstant1, enumType.element());
         assertThat(value1.getEnumConstantName()).isEqualTo(enumConstant1.getSimpleName().toString());
diff --git a/processor/src/test/java/online/sharedtype/processor/resolver/LoopTypeResolverTest.java b/processor/src/test/java/online/sharedtype/processor/resolver/LoopTypeResolverTest.java
@@ -159,8 +159,8 @@ void resolveSimpleEnum() {
         EnumDef typeDef = EnumDef.builder()
             .qualifiedName("com.github.cuzfrog.EnumA").simpleName("EnumA")
             .enumValueInfos(Arrays.asList(
-                EnumValueInfo.builder().name("Value1").value(ValueHolder.ofEnum("Value1", enumType, "Value1")).build(),
-                EnumValueInfo.builder().name("Value2").value(ValueHolder.ofEnum("Value2", enumType, "Value2")).build()
+                EnumValueInfo.builder().name("Value1").value(ValueHolder.ofEnum(enumType, "Value1", enumType, "Value1")).build(),
+                EnumValueInfo.builder().name("Value2").value(ValueHolder.ofEnum(enumType, "Value2", enumType, "Value2")).build()
             ))
             .build();
 
diff --git a/processor/src/test/java/online/sharedtype/processor/writer/converter/ConstantConverterRustTest.java b/processor/src/test/java/online/sharedtype/processor/writer/converter/ConstantConverterRustTest.java
diff --git a/processor/src/test/java/online/sharedtype/processor/writer/converter/ConstantConverterTypescriptTest.java b/processor/src/test/java/online/sharedtype/processor/writer/converter/ConstantConverterTypescriptTest.java
diff --git a/processor/src/test/java/online/sharedtype/processor/writer/converter/GoEnumConverterTest.java b/processor/src/test/java/online/sharedtype/processor/writer/converter/GoEnumConverterTest.java
diff --git a/processor/src/test/java/online/sharedtype/processor/writer/converter/RustEnumConverterTest.java b/processor/src/test/java/online/sharedtype/processor/writer/converter/RustEnumConverterTest.java
diff --git a/processor/src/test/java/online/sharedtype/processor/writer/converter/RustStructConverterTest.java b/processor/src/test/java/online/sharedtype/processor/writer/converter/RustStructConverterTest.java
diff --git a/processor/src/test/java/online/sharedtype/processor/writer/converter/TypescriptEnumConverterTest.java b/processor/src/test/java/online/sharedtype/processor/writer/converter/TypescriptEnumConverterTest.java
diff --git a/processor/src/test/java/online/sharedtype/processor/writer/converter/type/RustTypeExpressionConverterTest.java b/processor/src/test/java/online/sharedtype/processor/writer/converter/type/RustTypeExpressionConverterTest.java

Original file line number	Diff line number	Diff line change
`@@ -29,6 +29,7 @@ public abstract class ConcreteTypeDef implements TypeDef {`
`29`	`29`
`30`	`30`	`/**`
`31`	`31`	`* Register a counterpart typeInfo.`
	`32`	`+ * <b>Note:</b> This method should not be called from outside, please use {@link ConcreteTypeInfo#shallowResolved()}`
`32`	`33`	`*/`
`33`	`34`	`public abstract void linkTypeInfo(ConcreteTypeInfo typeInfo);`
`34`	`35`	`}`
Original file line number	Diff line number	Diff line change
`@@ -54,6 +54,13 @@ public TypeInfo getComponentValueType() {`
`54`	`54`	`}`
`55`	`55`	`return enumValueInfos.get(0).value().getValueType();`
`56`	`56`	`}`
	`57`	`+ /** @return true if component value has a different type other than this enumType, i.e. when enumValue is defined */`
	`58`	`+ public boolean hasComponentValueType() {`
	`59`	`+ return !getComponentValueType().equals(typeInfo);`
	`60`	`+ }`
	`61`	`+ public String valueTypeAlias() {`
	`62`	`+ return String.format("%sValue", simpleName);`
	`63`	`+ }`
`57`	`64`
`58`	`65`	`@Override`
`59`	`66`	`public Set<ConcreteTypeInfo> typeInfoSet() {`
Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,6 @@`
`2`	`2`
`3`	`3`	`import online.sharedtype.processor.domain.Constants;`
`4`	`4`	`import online.sharedtype.processor.domain.type.ConcreteTypeInfo;`
`5`		`-import online.sharedtype.processor.domain.type.TypeInfo;`
`6`	`5`
`7`	`6`	`import java.io.Serializable;`
`8`	`7`
`@@ -27,15 +26,15 @@ static ValueHolder of(ConcreteTypeInfo valueType, Object value) {`
`27`	`26`	`}`
`28`	`27`	`}`
`29`	`28`
`30`		`- static EnumConstantValue ofEnum(String enumConstantName, ConcreteTypeInfo valueType, Object value) {`
	`29`	`+ static EnumConstantValue ofEnum(ConcreteTypeInfo enumType, String enumConstantName, ConcreteTypeInfo valueType, Object value) {`
`31`	`30`	`ConcreteTypeInfo actualValueType = valueType;`
`32`	`31`	`Object actualValue = value;`
`33`	`32`	`while (actualValue instanceof ValueHolder) {`
`34`	`33`	`ValueHolder valueHolder = (ValueHolder) actualValue;`
`35`	`34`	`actualValueType = valueHolder.getValueType();`
`36`	`35`	`actualValue = valueHolder.getValue();`
`37`	`36`	`}`
`38`		`- return new EnumConstantValue(enumConstantName, actualValueType, actualValue);`
	`37`	`+ return new EnumConstantValue(enumType, enumConstantName, actualValueType, actualValue);`
`39`	`38`	`}`
`40`	`39`
`41`	`40`	`LiteralValue NULL = new LiteralValue(Constants.NULL_TYPE_INFO,null);`
Original file line number	Diff line number	Diff line change
`@@ -76,7 +76,7 @@ public List<TypeDef> parse(TypeElement typeElement) {`
`76`	`76`	`classDef.directSupertypes().addAll(parseSupertypes(typeElement));`
`77`	`77`
`78`	`78`	`TypeInfo typeInfo = typeInfoParser.parse(typeElement.asType(), typeElement);`
`79`		`- classDef.linkTypeInfo((ConcreteTypeInfo) typeInfo);`
	`79`	`+ ((ConcreteTypeInfo) typeInfo).markShallowResolved(classDef);`
`80`	`80`	`return Collections.singletonList(classDef);`
`81`	`81`	`}`
`82`	`82`
Original file line number	Diff line number	Diff line change
`@@ -62,7 +62,7 @@ public List<TypeDef> parse(TypeElement typeElement) {`
`62`	`62`	`.build();`
`63`	`63`	`enumDef.components().addAll(parseEnumConstants(typeElement, enumConstantElems));`
`64`	`64`	`TypeInfo typeInfo = typeInfoParser.parse(typeElement.asType(), typeElement);`
`65`		`- enumDef.linkTypeInfo((ConcreteTypeInfo) typeInfo);`
	`65`	`+ ((ConcreteTypeInfo) typeInfo).markShallowResolved(enumDef);`
`66`	`66`	`return Collections.singletonList(enumDef);`
`67`	`67`	`}`
`68`	`68`
Original file line number	Diff line number	Diff line change
`@@ -33,9 +33,9 @@ public ValueHolder resolve(Element enumConstantElement, TypeElement enumTypeElem`
`33`	`33`	`VariableElement enumConstant = (VariableElement) enumConstantElement;`
`34`	`34`	`String enumConstantName = enumConstant.getSimpleName().toString();`
`35`	`35`	`EnumCtorIndex ctorArgIdx = resolveCtorIndex(enumTypeElement);`
	`36`	`+ ConcreteTypeInfo enumTypeInfo = (ConcreteTypeInfo) typeInfoParser.parse(enumTypeElement.asType(), enumTypeElement);`
`36`	`37`	`if (ctorArgIdx == EnumCtorIndex.NONE) {`
`37`		`- ConcreteTypeInfo typeInfo = (ConcreteTypeInfo) typeInfoParser.parse(enumTypeElement.asType(), enumTypeElement);`
`38`		`- return ValueHolder.ofEnum(enumConstantName, typeInfo, enumConstantName);`
	`38`	`+ return ValueHolder.ofEnum(enumTypeInfo, enumConstantName, enumTypeInfo, enumConstantName);`
`39`	`39`	`}`
`40`	`40`
`41`	`41`	`Tree tree = ctx.getTrees().getTree(enumConstant);`
`@@ -58,7 +58,7 @@ public ValueHolder resolve(Element enumConstantElement, TypeElement enumTypeElem`
`58`	`58`	`return ValueHolder.NULL;`
`59`	`59`	`}`
`60`	`60`	`}`
`61`		`- return ValueHolder.ofEnum(enumConstantName, valueType, value);`
	`61`	`+ return ValueHolder.ofEnum(enumTypeInfo, enumConstantName, valueType, value);`
`62`	`62`	`} else if (tree == null) {`
`63`	`63`	`ctx.error(enumConstant, "Literal value cannot be parsed from enum constant: %s of enum %s, because source tree from the element is null." +`
`64`	`64`	`" This could mean at the time of the annotation processing, the source tree was not available." +`