Emit enum with value type alias

Author: cuzfrog

processor/src/main/java/online/sharedtype/processor/writer/converter/RustEnumConverter.java

@@ -2,6 +2,7 @@
 
 import lombok.RequiredArgsConstructor;
 import online.sharedtype.SharedType;
+import online.sharedtype.processor.context.Context;
 import online.sharedtype.processor.domain.component.ComponentInfo;
 import online.sharedtype.processor.domain.component.EnumValueInfo;
 import online.sharedtype.processor.domain.def.EnumDef;
@@ -14,13 +15,15 @@
 import online.sharedtype.processor.writer.render.Template;
 
 import online.sharedtype.processor.support.annotation.Nullable;
+
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Objects;
 import java.util.Set;
 
 @RequiredArgsConstructor
 final class RustEnumConverter extends AbstractEnumConverter {
+    private final Context ctx;
     private final TypeExpressionConverter typeExpressionConverter;
     private final RustMacroTraitsGenerator rustMacroTraitsGenerator;
 
@@ -29,13 +32,15 @@ public Tuple<Template, AbstractTypeExpr> convert(TypeDef typeDef) {
         EnumDef enumDef = (EnumDef) typeDef;
 
         String valueType = getValueTypeExpr(enumDef);
+        boolean hasValue = valueType != null;
         // value can be literal or enum
         EnumExpr value = new EnumExpr(
             enumDef.simpleName(),
             extractEnumValues(enumDef.components()),
             rustMacroTraitsGenerator.generate(enumDef),
-            valueType != null,
-            valueType
+            hasValue,
+            valueType,
+            hasValue && ctx.getProps().getRust().hasEnumValueTypeAlias() ? String.format("%sValue", enumDef.simpleName()) : null
         );
         return Tuple.of(Template.TEMPLATE_RUST_ENUM, value);
     }
@@ -76,7 +81,10 @@ static final class EnumExpr extends AbstractTypeExpr {
         final List<EnumerationExpr> enumerations;
         final Set<String> macroTraits;
         final boolean hasValue;
+        @Nullable
         final String valueType;
+        @Nullable
+        final String valueTypeAlias;
 
         String macroTraitsExpr() {
             return ConversionUtils.buildRustMacroTraitsExpr(macroTraits);

processor/src/main/java/online/sharedtype/processor/writer/converter/TemplateDataConverter.java

@@ -39,7 +39,7 @@ static Set<TemplateDataConverter> rust(Context ctx) {
         TypeExpressionConverter rustLiteralTypeExpressionConverter = TypeExpressionConverter.rustLiteral();
         Set<TemplateDataConverter> converters = new HashSet<>(3);
         converters.add(new RustStructConverter(ctx, rustTypeExpressionConverter, rustMacroTraitsGenerator));
-        converters.add(new RustEnumConverter(rustLiteralTypeExpressionConverter, rustMacroTraitsGenerator));
+        converters.add(new RustEnumConverter(ctx, rustLiteralTypeExpressionConverter, rustMacroTraitsGenerator));
         converters.add(new ConstantConverter(ctx, rustLiteralTypeExpressionConverter, SharedType.TargetType.RUST));
         return converters;
     }

processor/src/main/resources/sharedtype-default.properties

@@ -130,8 +130,9 @@ sharedtype.rust.allow-deadcode=true
 sharedtype.rust.convert-to-snake-case=false
 
 ## Whether to have explicit type alias for enum value type
-## See document for more details
-sharedtype.rust.enum-value-type-alias=false
+## E.g. "pub type MyEnumValue = i32;" will be created for enum type "MyEnum" if its value type is "i32".
+## The type alias will also be used as any constant type that has the same enum type.
+sharedtype.rust.enum-value-type-alias=true
 
 ## Default type macros, comma separated
 sharedtype.rust.default-macros-traits=Debug

processor/src/main/resources/templates/rust/enum.mustache

@@ -8,8 +8,11 @@ pub enum {{name}} {
 {{/enumerations}}
 }
 {{#hasValue}}
+{{#valueTypeAlias}}
+pub type {{valueTypeAlias}} = {{{valueType}}};
+{{/valueTypeAlias}}
 impl {{name}} {
-    pub const fn value(self) -> {{{valueType}}} {
+    pub const fn value(self) -> {{valueTypeAlias}} {
         use {{name}}::*;
         match self {
             {{#enumerations}}
@@ -18,5 +21,4 @@ impl {{name}} {
         }
     }
 }
-
 {{/hasValue}}

processor/src/test/java/online/sharedtype/processor/writer/converter/RustEnumConverterTest.java

@@ -26,7 +26,7 @@ final class RustEnumConverterTest {
     private final ContextMocks ctxMocks = new ContextMocks();
     private final TypeExpressionConverter rustTypeExpressionConverter = mock(TypeExpressionConverter.class);
     private final RustMacroTraitsGenerator rustMacroTraitsGenerator = mock(RustMacroTraitsGenerator.class);
-    private final RustEnumConverter converter = new RustEnumConverter(rustTypeExpressionConverter, rustMacroTraitsGenerator);
+    private final RustEnumConverter converter = new RustEnumConverter(ctxMocks.getContext(), rustTypeExpressionConverter, rustMacroTraitsGenerator);
 
     private final Config config = mock(Config.class);
     @BeforeEach
@@ -106,6 +106,7 @@ void convertEnumWithValues() {
         assertThat(model.macroTraits).containsExactly("TestMacro");
         assertThat(model.hasValue).isTrue();
         assertThat(model.valueType).isEqualTo("i32");
+        assertThat(model.valueTypeAlias).isEqualTo("EnumAValue");
         assertThat(model.enumerations).satisfiesExactly(
             v1 -> {
                 assertThat(v1.name).isEqualTo("Value1");