99 common math types (#101)

* Add basic mapping for BigDecimal and BitInteger
* Fix annotation optional type detection

Author: cuzfrog

annotation/src/main/java/online/sharedtype/SharedType.java

@@ -59,6 +59,7 @@
  * <p>
  * <b>Constants:</b><br>
  * Static fields are treated as constants. Only compile-time resolvable values are supported.
+ * By default, constants are not included, see {@link #includes()}.
  * Only constants in explicitly annotated types will be emitted.
  * </p>
  *
@@ -103,6 +104,15 @@
  * </p><br>
  *
  * <p>
+ * <b>Math types:</b><br>
+ * By default {@link java.math.BigInteger} and {@link java.math.BigDecimal} are emitted number types.
+ * A client can use type mappings to override the emitted types. Default mappings are:
+ * <ul>
+ *     <li>Typescript: {@code number}</li>
+ *     <li>Rust: {@code i128} and {@code f64}</li>
+ * </ul>
+ *
+ * <p>
  * <b>Type literal mappings:</b><br>
  * You dan define any 1-to-1 type mappings via global properties. This is useful when e.g. a 3rd party type is referenced.
  * Note, SharedType will still try to resolve the type and emit it with the mapped name.
@@ -138,18 +148,17 @@
     /**
      * <p>
      * Configure whether to include fields, record components, accessors, or constants in a type.
-     * All included by default.
      * </p>
      * <p>
      * To exclude a particular component, use {@link Ignore}.
-     * Fields and accessors effectively with the same name will be merged.
+     * Fields and accessors with the same name and type will be merged.
      * </p>
      *
      * @see ComponentType#FIELDS
      * @see ComponentType#ACCESSORS
      * @see ComponentType#CONSTANTS
      */
-    ComponentType[] includes() default {ComponentType.FIELDS, ComponentType.ACCESSORS, ComponentType.CONSTANTS};
+    ComponentType[] includes() default {ComponentType.FIELDS, ComponentType.ACCESSORS};
 
     /**
      * Java fields have to reside in a class, which provides a natural namespace.

internal/src/main/java/online/sharedtype/processor/domain/Constants.java

@@ -31,6 +31,9 @@ public final class Constants {
     public static final ConcreteTypeInfo BOXED_INT_TYPE_INFO = ConcreteTypeInfo.ofPredefined("java.lang.Integer", "Integer");
     public static final ConcreteTypeInfo BOXED_LONG_TYPE_INFO = ConcreteTypeInfo.ofPredefined("java.lang.Long", "Long");
     public static final ConcreteTypeInfo BOXED_SHORT_TYPE_INFO = ConcreteTypeInfo.ofPredefined("java.lang.Short", "Short");
+    public static final ConcreteTypeInfo BIG_DECIMAL_TYPE_INFO = ConcreteTypeInfo.ofPredefined("java.math.BigDecimal", "BigDecimal");
+    public static final ConcreteTypeInfo BIG_INTEGER_TYPE_INFO = ConcreteTypeInfo.ofPredefined("java.math.BigInteger", "BigInteger");
+
     public static final ConcreteTypeInfo STRING_TYPE_INFO = ConcreteTypeInfo.ofPredefined("java.lang.String", "String");
     public static final ConcreteTypeInfo VOID_TYPE_INFO = ConcreteTypeInfo.ofPredefined("java.lang.Void", "Void");
     public static final ConcreteTypeInfo OBJECT_TYPE_INFO = ConcreteTypeInfo.ofPredefined("java.lang.Object", "Object");

it/java17/src/main/java/online/sharedtype/it/java17/JavaRecord.java

@@ -9,10 +9,16 @@
 
 import java.util.Collection;
 import java.util.List;
-import java.util.Map;
 import java.util.Set;
 
-@SharedType(constantNamespaced = SharedType.OptionalBool.FALSE)
+@SharedType(
+    constantNamespaced = SharedType.OptionalBool.FALSE,
+    includes = {
+        SharedType.ComponentType.CONSTANTS,
+        SharedType.ComponentType.FIELDS,
+        SharedType.ComponentType.ACCESSORS,
+    }
+)
 public record JavaRecord<T>(
     String string,
     byte primitiveByte,

it/java8/src/main/java/online/sharedtype/it/java8/MyConstants.java

@@ -2,13 +2,13 @@
 
 import online.sharedtype.SharedType;
 
-@SharedType(constantNamespaced = SharedType.OptionalBool.FALSE)
+@SharedType(constantNamespaced = SharedType.OptionalBool.FALSE, includes = SharedType.ComponentType.CONSTANTS)
 final class MyConstants {
     private static final float FLOAT_VALUE = 1.888f;
     private static final Long LONG_VALUE = 999L;
 }
 
-@SharedType
+@SharedType(includes = SharedType.ComponentType.CONSTANTS)
 enum MyEnumConstants {
     ;
     private static final int INT_VALUE = 1;

processor/src/main/java/online/sharedtype/processor/context/Context.java

@@ -6,6 +6,7 @@
 import online.sharedtype.processor.support.annotation.VisibleForTesting;
 
 import javax.annotation.processing.ProcessingEnvironment;
+import javax.lang.model.element.AnnotationMirror;
 import javax.lang.model.element.Element;
 import javax.lang.model.element.ElementKind;
 import javax.lang.model.element.TypeElement;
@@ -100,6 +101,16 @@ public boolean isIgnored(Element element) {
         return false;
     }
 
+    public boolean isOptionalAnnotated(Element element) {
+        for (AnnotationMirror annotationMirror : element.getAnnotationMirrors()) {
+            String annoTypeQualifiedName = annotationMirror.getAnnotationType().toString();
+            if (props.getOptionalAnnotations().contains(annoTypeQualifiedName)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
     public boolean isOptionalType(String qualifiedName) {
         return props.getOptionalContainerTypes().contains(qualifiedName);
     }

processor/src/main/java/online/sharedtype/processor/context/Props.java

@@ -20,7 +20,7 @@ public final class Props {
     private final Typescript typescript;
     private final Rust rust;
 
-    private final Set<Class<? extends Annotation>> optionalAnnotations;
+    private final Set<String> optionalAnnotations;
     private final Set<String> optionalContainerTypes;
     private final Set<String> accessorGetterPrefixes;
     private final Set<String> arraylikeTypeQualifiedNames;

processor/src/main/java/online/sharedtype/processor/context/PropsFactory.java

@@ -45,7 +45,7 @@ public static Props loadProps(@Nullable Path userPropertiesFile) {
     private static Props loadProps(Properties properties) {
         return Props.builder()
             .targets(parseEnumSet(properties, "sharedtype.targets", OutputTarget.class, OutputTarget::valueOf))
-            .optionalAnnotations(parseClassSet(properties, "sharedtype.optional-annotations"))
+            .optionalAnnotations(splitArray(properties.getProperty("sharedtype.optional-annotations")))
             .optionalContainerTypes(splitArray(properties.getProperty("sharedtype.optional-container-types")))
             .accessorGetterPrefixes(splitArray(properties.getProperty("sharedtype.accessor.getter-prefixes")))
             .arraylikeTypeQualifiedNames(splitArray(properties.getProperty("sharedtype.array-like-types")))

processor/src/main/java/online/sharedtype/processor/parser/ClassTypeDefParser.java

@@ -136,7 +136,7 @@ private List<FieldComponentInfo> parseComponents(TypeElement typeElement, Config
             FieldComponentInfo fieldInfo = FieldComponentInfo.builder()
                 .name(tuple.b())
                 .modifiers(element.getModifiers())
-                .optional(ctx.getProps().getOptionalAnnotations().stream().anyMatch(e -> element.getAnnotation(e) != null))
+                .optional(ctx.isOptionalAnnotated(element))
                 .type(typeInfoParser.parse(element.asType(), typeContext))
                 .build();
             fields.add(fieldInfo);

processor/src/main/java/online/sharedtype/processor/parser/ConstantTypeDefParser.java

@@ -104,7 +104,8 @@ private Object parseConstantValue(Element fieldElement, TypeElement ctxTypeEleme
             return ((LiteralTree) valueTree).getValue();
         } else {
             throw new SharedTypeException(String.format("Only literal value is supported for constant field." +
-                " Field: %s in %s", fieldElement.getSimpleName(), ctxTypeElement.getQualifiedName()));
+                " Field: %s in %s. Consider use @SharedType.Ignore to ignore this field or exclude constants generation for this type.",
+                fieldElement.getSimpleName(), ctxTypeElement.getQualifiedName()));
         }
     }
 }

processor/src/main/java/online/sharedtype/processor/parser/type/TypeContext.java

@@ -3,12 +3,14 @@
 import lombok.Builder;
 import lombok.EqualsAndHashCode;
 import lombok.Getter;
+import lombok.ToString;
 import online.sharedtype.processor.domain.DependingKind;
 import online.sharedtype.processor.domain.TypeDef;
 
 @EqualsAndHashCode
 @Builder
 @Getter
+@ToString
 public final class TypeContext {
     /** The context type definition. */
     private final TypeDef typeDef;