remove support for optional primitives, add support for custom mapped primitives

Author: h908714124

core/src/main/java/net/jbock/coerce/BasicInfo.java

@@ -12,18 +12,21 @@ public final class BasicInfo {
 
   public final boolean repeatable;
 
+  public final boolean optional;
+
   public final TypeMirror returnType;
 
   private final String paramName;
 
-  private BasicInfo(boolean repeatable, TypeMirror returnType, String paramName) {
+  private BasicInfo(boolean repeatable, boolean optional, TypeMirror returnType, String paramName) {
     this.repeatable = repeatable;
+    this.optional = optional;
     this.returnType = returnType;
     this.paramName = paramName;
   }
 
-  static BasicInfo create(boolean repeatable, TypeMirror returnType, String paramName) {
-    return new BasicInfo(repeatable, returnType, snakeToCamel(paramName));
+  static BasicInfo create(boolean repeatable, boolean optional, TypeMirror returnType, String paramName) {
+    return new BasicInfo(repeatable, optional, returnType, snakeToCamel(paramName));
   }
 
   public String paramName() {

core/src/main/java/net/jbock/coerce/Coercion.java

@@ -25,11 +25,8 @@ public final class Coercion {
   // helper.build
   private final Optional<CodeBlock> initCollector;
 
-  // impl constructor
-  private final CodeBlock extract;
-
-  // impl constructor
-  private final TypeMirror paramType;
+  // impl constructor param
+  private final ParameterSpec constructorParam;
 
   // impl
   private final FieldSpec field;
@@ -41,16 +38,14 @@ private Coercion(
       Optional<CodeBlock> mapExpr,
       CodeBlock initMapper,
       Optional<CodeBlock> initCollector,
-      CodeBlock extract,
-      TypeMirror paramType,
+      ParameterSpec constructorParam,
       FieldSpec field,
       boolean isDefaultCollector) {
     this.collectorParam = collectorParam;
     this.mapExpr = mapExpr;
     this.initMapper = initMapper;
     this.initCollector = initCollector;
-    this.extract = extract;
-    this.paramType = paramType;
+    this.constructorParam = constructorParam;
     this.field = field;
     this.isDefaultCollector = isDefaultCollector;
   }
@@ -61,11 +56,12 @@ public static Coercion create(
       CodeBlock initMapper,
       TypeMirror mapperReturnType,
       Optional<CodeBlock> initCollector,
-      CodeBlock extract,
-      TypeMirror paramType,
+      TypeMirror constructorParamType,
       BasicInfo basicInfo) {
-    boolean isDefaultCollector = isDefaultCollector(initCollector, paramType, mapperReturnType);
-    return new Coercion(collectorParam, mapExpr, initMapper, initCollector, extract, paramType, basicInfo.fieldSpec(), isDefaultCollector);
+    boolean isDefaultCollector = isDefaultCollector(initCollector, constructorParamType, mapperReturnType);
+    ParameterSpec constructorParam = ParameterSpec.builder(
+        TypeName.get(constructorParamType), basicInfo.paramName()).build();
+    return new Coercion(collectorParam, mapExpr, initMapper, initCollector, constructorParam, basicInfo.fieldSpec(), isDefaultCollector);
   }
 
   /**
@@ -86,18 +82,14 @@ public Optional<CodeBlock> initCollector() {
     return initCollector;
   }
 
-  public TypeName paramType() {
-    return TypeName.get(paramType);
+  public ParameterSpec constructorParam() {
+    return constructorParam;
   }
 
   public FieldSpec field() {
     return field;
   }
 
-  public CodeBlock extract() {
-    return extract;
-  }
-
   public Optional<ParameterSpec> collectorParam() {
     if (skipMapCollect()) {
       return Optional.empty();

core/src/main/java/net/jbock/coerce/CoercionProvider.java

@@ -64,7 +64,7 @@ private Coercion handle(
       TypeElement collectorClass,
       boolean repeatable,
       boolean optional) throws TmpException, SearchHintException {
-    BasicInfo basicInfo = BasicInfo.create(repeatable, sourceMethod.getReturnType(), paramName);
+    BasicInfo basicInfo = BasicInfo.create(repeatable, optional, sourceMethod.getReturnType(), paramName);
     boolean auto = mapperClass == null;
     if (repeatable) {
       if (auto) {
@@ -87,38 +87,37 @@ private Coercion handleSingleAuto(
       boolean optional,
       BasicInfo basicInfo) throws TmpException, SearchHintException {
     TypeMirror returnType = sourceMethod.getReturnType();
-    OptionalInfo optionalInfo = findOptionalInfo(returnType, optional);
-    CoercionFactory enumCoercion = checkEnum(optionalInfo.baseType);
-    if (enumCoercion != null) {
-      return enumCoercion.getCoercion(basicInfo, optionalInfo, Optional.empty());
-    }
-    CoercionFactory factory = StandardCoercions.get(optionalInfo.baseType);
-    if (factory == null) {
-      throw SearchHintException.create("Unknown parameter type. Define a custom mapper.");
-    }
-    if (factory.handlesOptionalPrimitive() && !optional) {
+    Optional<TypeMirror> optionalInfo = findOptionalInfo(returnType, optional);
+    CoercionFactory factory = findCoercion(optionalInfo.orElse(returnType));
+    if (optionalInfo.isPresent() && !optional) {
       throw TmpException.create("Declare this parameter optional.");
     }
-    if (optional && !factory.handlesOptionalPrimitive() && !optionalInfo.optional) {
-      throw TmpException.create("Wrap the parameter type in Optional");
+    if (!optionalInfo.isPresent() && optional) {
+      throw TmpException.create("Wrap the parameter type in Optional.");
     }
     return factory.getCoercion(basicInfo, optionalInfo, Optional.empty());
   }
 
-  // mapper but not repeatable
+  // simple mapper
   private Coercion handleSingle(
       ExecutableElement sourceMethod,
       String paramName,
       TypeElement mapperClass,
       BasicInfo basicInfo,
       boolean optional) throws TmpException {
+    TypeMirror returnType = sourceMethod.getReturnType();
     ParameterSpec mapperParam = ParameterSpec.builder(TypeName.get(mapperClass.asType()), snakeToCamel(paramName) + "Mapper").build();
-    OptionalInfo optionalInfo = findOptionalInfo(sourceMethod.getReturnType(), optional);
-    if (optional && !optionalInfo.optional) {
-      throw TmpException.create("Wrap the parameter type in Optional");
+    Optional<TypeMirror> optionalInfo = findOptionalInfo(returnType, optional);
+    if (optionalInfo.isPresent() && !optional) {
+      throw TmpException.create("Declare this parameter optional.");
+    }
+    if (!optionalInfo.isPresent() && optional) {
+      throw TmpException.create("Wrap the parameter type in Optional.");
     }
-    MapperClassValidator.checkReturnType(mapperClass, optionalInfo.baseType);
-    return MapperCoercion.create(optionalInfo, mapperParam, mapperClass.asType(), basicInfo);
+    TypeMirror boxedReturnType = TypeTool.get().box(returnType);
+    TypeMirror mapperReturnType = optionalInfo.orElse(boxedReturnType);
+    MapperClassValidator.checkReturnType(mapperClass, mapperReturnType);
+    return MapperCoercion.create(mapperReturnType, optionalInfo, Optional.empty(), mapperParam, mapperClass.asType(), basicInfo);
   }
 
   // repeatable with mapper
@@ -131,42 +130,47 @@ private Coercion handleRepeatable(
     CollectorInfo collectorInfo = collectorInfo(sourceMethod, collectorClass);
     MapperClassValidator.checkReturnType(mapperClass, collectorInfo.inputType);
     ParameterSpec mapperParam = ParameterSpec.builder(TypeName.get(mapperClass.asType()), snakeToCamel(paramName) + "Mapper").build();
-    return MapperCoercion.create(OptionalInfo.simple(collectorInfo.inputType), collectorInfo.collectorType(), mapperParam, mapperClass.asType(), basicInfo);
+    return MapperCoercion.create(collectorInfo.inputType, Optional.empty(), collectorInfo.collectorType(), mapperParam, mapperClass.asType(), basicInfo);
   }
 
   // repeatable without mapper
   private Coercion handleRepeatableAuto(
       ExecutableElement sourceMethod,
       TypeElement collectorClass,
-      BasicInfo basicInfo) throws TmpException {
+      BasicInfo basicInfo) throws TmpException, SearchHintException {
     CollectorInfo collectorInfo = collectorInfo(sourceMethod, collectorClass);
-    CoercionFactory coercion = StandardCoercions.get(collectorInfo.inputType);
-    if (coercion == null) {
-      coercion = checkEnum(collectorInfo.inputType);
+    CoercionFactory coercion = findCoercion(collectorInfo.inputType);
+    return coercion.getCoercion(basicInfo, Optional.empty(), collectorInfo.collectorType());
+  }
+
+  private CoercionFactory findCoercion(TypeMirror mirror) throws TmpException, SearchHintException {
+    CoercionFactory standardCoercion = StandardCoercions.get(mirror);
+    if (standardCoercion != null) {
+      return standardCoercion;
     }
-    if (coercion == null || coercion.handlesOptionalPrimitive()) {
-      throw TmpException.create(String.format("Define a mapper for %s", collectorInfo.inputType));
+    boolean isEnum = isEnumType(mirror);
+    if (!isEnum) {
+      throw SearchHintException.create("Unknown parameter type. Define a custom mapper.");
     }
-    OptionalInfo optionalInfo = OptionalInfo.simple(collectorInfo.inputType);
-    return coercion.getCoercion(basicInfo, optionalInfo, collectorInfo.collectorType());
+    return EnumCoercion.create(mirror);
   }
 
-  private CoercionFactory checkEnum(TypeMirror mirror) throws TmpException {
+  private boolean isEnumType(TypeMirror mirror) throws TmpException {
     TypeTool tool = TypeTool.get();
     List<? extends TypeMirror> supertypes = tool.getDirectSupertypes(mirror);
     if (supertypes.isEmpty()) {
       // not an enum
-      return null;
+      return false;
     }
     TypeMirror superclass = supertypes.get(0);
     if (!tool.isSameErasure(superclass, tool.asType(Enum.class))) {
       // not an enum
-      return null;
+      return false;
     }
     if (tool.isPrivateType(mirror)) {
       throw TmpException.create("The enum may not be private.");
     }
-    return EnumCoercion.create(mirror);
+    return true;
   }
 
   private CollectorInfo collectorInfo(

core/src/main/java/net/jbock/coerce/OptionalInfo.java

@@ -6,38 +6,23 @@
 import java.util.List;
 import java.util.Optional;
 
-public class OptionalInfo {
+public final class OptionalInfo {
 
-  public final boolean optional;
-
-  public final TypeMirror baseType;
-
-  private OptionalInfo(boolean optional, TypeMirror baseType) {
-    this.optional = optional;
-    this.baseType = baseType;
-  }
-
-  static OptionalInfo simple(TypeMirror baseType) {
-    return new OptionalInfo(false, baseType);
-  }
-
-  private static OptionalInfo optional(TypeMirror baseType) {
-    return new OptionalInfo(true, baseType);
-  }
-
-  public static OptionalInfo findOptionalInfo(TypeMirror mirror, boolean optional) {
+  // Returns empty unless the return type is of the form Optional<?>.
+  // Note, it can be return emtpy while basicInfo.optional is true,
+  // if the return type is e.g. OptionalInt.
+  public static Optional<TypeMirror> findOptionalInfo(TypeMirror mirror, boolean optional) {
     if (!optional) {
-      return OptionalInfo.simple(mirror);
+      return Optional.empty();
     }
     TypeTool tool = TypeTool.get();
     if (!tool.isSameErasure(mirror, Optional.class)) {
-      return OptionalInfo.simple(mirror);
+      return Optional.empty();
     }
     List<? extends TypeMirror> typeArgs = tool.typeargs(mirror);
     if (typeArgs.isEmpty()) {
-      return OptionalInfo.simple(mirror);
+      return Optional.empty();
     }
-    return OptionalInfo.optional(typeArgs.get(0));
+    return Optional.of(typeArgs.get(0));
   }
-
 }

core/src/main/java/net/jbock/coerce/hint/CollectionHint.java

@@ -1,35 +1,21 @@
 package net.jbock.coerce.hint;
 
-import javax.lang.model.element.Name;
-import javax.lang.model.element.TypeElement;
-import javax.lang.model.type.TypeMirror;
-import java.util.Set;
-import java.util.stream.Collectors;
+import net.jbock.compiler.TypeTool;
 
-import static net.jbock.compiler.HierarchyUtil.getTypeTree;
+import javax.lang.model.type.TypeMirror;
+import java.util.List;
 
 public class CollectionHint extends Hint {
 
   @Override
   public String message(TypeMirror type, boolean repeatable) {
-    Set<String> names = getTypeTree(type).stream()
-        .map(TypeElement::getQualifiedName)
-        .map(Name::toString)
-        .collect(Collectors.toSet());
-    if (names.contains("java.util.List")) {
+    if (TypeTool.get().isSameErasure(type, List.class)) {
       if (!repeatable) {
         return "Declare this parameter repeatable.";
       } else {
         return "Define a custom mapper.";
       }
     }
-    if (names.contains("java.util.Collection") || names.contains("java.util.Map")) {
-      if (!repeatable) {
-        return "Declare this parameter repeatable.";
-      } else {
-        return "Define a custom collector. Alternatively, use List instead.";
-      }
-    }
     return null;
   }
 }

core/src/main/java/net/jbock/coerce/hint/HintProvider.java

@@ -1,7 +1,5 @@
 package net.jbock.coerce.hint;
 
-import net.jbock.coerce.OptionalInfo;
-
 import javax.lang.model.type.TypeKind;
 import javax.lang.model.type.TypeMirror;
 import java.util.Arrays;
@@ -15,6 +13,7 @@ public class HintProvider {
 
   private static final List<Hint> HINTS = Arrays.asList(
       new RawCombinatorHint(),
+      new OptionalPrimitiveHint(),
       new CollectionHint(),
       new ArrayHint(),
       new PrimitiveHint(),
@@ -35,9 +34,9 @@ public Optional<String> findHint(TypeMirror type, boolean repeatable, boolean op
       return findHintSimple(type, repeatable);
     }
     if (optional) {
-      OptionalInfo optionalInfo = findOptionalInfo(type, true);
-      if (optionalInfo.optional) {
-        return findHintSimple(optionalInfo.baseType, repeatable);
+      Optional<TypeMirror> optionalInfo = findOptionalInfo(type, true);
+      if (optionalInfo.isPresent()) {
+        return findHintSimple(optionalInfo.get(), repeatable);
       }
     }
     return findHintSimple(type, repeatable);

core/src/main/java/net/jbock/coerce/hint/OptionalHint.java

@@ -3,30 +3,18 @@
 import javax.lang.model.element.TypeElement;
 import javax.lang.model.type.TypeMirror;
 import java.util.Optional;
-import java.util.OptionalDouble;
-import java.util.OptionalInt;
-import java.util.OptionalLong;
-import java.util.Set;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
 
 import static net.jbock.compiler.HierarchyUtil.getTypeTree;
 
 public class OptionalHint extends Hint {
 
-  private static final Set<String> NAMES = Stream.of(
-      Optional.class,
-      OptionalInt.class,
-      OptionalLong.class,
-      OptionalDouble.class)
-      .map(Class::getCanonicalName)
-      .collect(Collectors.toSet());
+  private static final String NAME = Optional.class.getCanonicalName();
 
   @Override
   public String message(TypeMirror type, boolean repeatable) {
     for (TypeElement mirror : getTypeTree(type)) {
       String qname = mirror.getQualifiedName().toString();
-      if (NAMES.contains(qname)) {
+      if (NAME.equals(qname)) {
         return "Declare this parameter optional.";
       }
     }