remove unnecessary code

Author: h908714124

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

@@ -33,7 +33,7 @@ static CollectorInfo getCollectorInfo(TypeMirror returnType, TypeElement collect
 
   private static TypeMirror getCollectorType(TypeElement collectorClass) throws TmpException {
     TypeTool tool = TypeTool.get();
-    Resolver resolver = Resolver.resolve(tool.declared(Supplier.class), collectorClass.asType(), "T");
+    Resolver resolver = Resolver.resolve(tool.declared(Supplier.class), collectorClass.asType());
     TypeMirror typeMirror = resolver.resolveTypevars().orElseThrow(() -> boom("not a Supplier"));
     if (tool.eql(typeMirror, tool.erasure(typeMirror))) {
       throw boom("the supplier must be parameterized");

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

@@ -33,7 +33,7 @@ static TypeMirror checkReturnType(TypeElement mapperClass, TypeMirror expectedRe
 
   private static TypeMirror getFunctionType(TypeElement mapperClass) throws TmpException {
     TypeTool tool = TypeTool.get();
-    Resolver resolver = Resolver.resolve(tool.declared(Supplier.class), mapperClass.asType(), "T");
+    Resolver resolver = Resolver.resolve(tool.declared(Supplier.class), mapperClass.asType());
     TypeMirror typeMirror = resolver.resolveTypevars().orElseThrow(() -> boom("not a Supplier"));
     if (tool.eql(typeMirror, tool.erasure(typeMirror))) {
       throw boom("the supplier must be parameterized");
@@ -50,7 +50,7 @@ private static TypeMirror getFunctionType(TypeElement mapperClass) throws TmpExc
 
   private static TypeMirror resolveFunctionType(TypeMirror functionType) throws TmpException {
     TypeTool tool = TypeTool.get();
-    Resolver resolver = Resolver.resolve(tool.declared(Function.class), functionType, "T", "R");
+    Resolver resolver = Resolver.resolve(tool.declared(Function.class), functionType);
     return resolver.resolveTypevars().orElseThrow(() -> boom("The supplier must supply a Function"));
   }
 

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

@@ -4,114 +4,39 @@
 
 import javax.lang.model.element.TypeElement;
 import javax.lang.model.element.TypeParameterElement;
-import javax.lang.model.type.DeclaredType;
-import javax.lang.model.type.TypeKind;
 import javax.lang.model.type.TypeMirror;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
-import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
-import java.util.Map.Entry;
 import java.util.Optional;
 
 import static net.jbock.compiler.HierarchyUtil.getTypeTree;
 
 class Resolver {
 
-  private final Map<Integer, String> names;
-  private final Map<String, TypeMirror> results = new HashMap<>();
-  private final List<Extension> extensions = new ArrayList<>();
+  private final List<Extension> extensions;
 
-  private Resolver(Map<Integer, String> names) {
-    this.names = names;
-  }
-
-  private void setResults(Map<String, TypeMirror> results) {
-    this.results.clear();
-    this.results.putAll(results);
-  }
-
-  private void setNames(Map<Integer, String> names) {
-    this.names.clear();
-    this.names.putAll(names);
-  }
-
-  private void clearNames() {
-    this.names.clear();
-  }
-
-  private void step(Extension extension) {
-    TypeElement b = extension.baseClass();
-    DeclaredType x = extension.extensionClass();
-    Map<Integer, String> newNames = new LinkedHashMap<>();
-    Map<String, TypeMirror> newResults = new LinkedHashMap<>(results);
-    List<? extends TypeMirror> xParams = x.getTypeArguments();
-    List<? extends TypeParameterElement> bParams = b.getTypeParameters();
-    for (Entry<Integer, String> entry : names.entrySet()) {
-      if (xParams.isEmpty()) {
-        // failure: raw type
-        results.clear();
-        return;
-      }
-      TypeMirror xParam = xParams.get(entry.getKey());
-      if (xParam.getKind() == TypeKind.TYPEVAR) {
-        for (int i = 0; i < bParams.size(); i++) {
-          TypeParameterElement bParam = bParams.get(i);
-          if (bParam.toString().equals(xParam.toString())) {
-            newNames.put(i, entry.getValue());
-            break;
-          }
-        }
-      } else {
-        newResults.put(entry.getValue(), xParam);
-      }
-    }
-    setResults(newResults);
-    setNames(newNames);
-  }
-
-  static Resolver resolve(TypeMirror goal, TypeMirror start, String... typevars) {
-    Map<Integer, String> map = new HashMap<>();
-    for (int i = 0; i < typevars.length; i++) {
-      String typevar = typevars[i];
-      map.put(i, typevar);
-    }
-    return resolve(goal, start, map);
+  private Resolver(List<Extension> extensions) {
+    List<Extension> reversed = new ArrayList<>(extensions);
+    Collections.reverse(reversed);
+    this.extensions = Collections.unmodifiableList(reversed);
   }
 
-  private static Resolver resolve(
+  static Resolver resolve(
       TypeMirror goal,
-      TypeMirror start,
-      Map<Integer, String> names) {
+      TypeMirror start) {
     List<TypeElement> family = getTypeTree(start);
-    Resolver resolver = new Resolver(names);
     Extension extension;
     TypeTool tool = TypeTool.get();
     TypeMirror nextGoal = tool.erasure(goal);
+    List<Extension> extensions = new ArrayList<>();
     while ((extension = findExtension(family, nextGoal)) != null) {
-      resolver.step(extension);
-      resolver.extensions.add(extension);
+      extensions.add(extension);
       nextGoal = tool.erasure(extension.baseClass().asType());
     }
-    if (resolver.names.isEmpty()) {
-      // everything resolved
-      return resolver;
-    }
-    if (tool.eql(nextGoal, tool.erasure(start))) {
-      List<? extends TypeMirror> typeargs = tool.typeargs(start);
-      Map<String, TypeMirror> results = new LinkedHashMap<>();
-      for (Entry<Integer, String> entry : resolver.names.entrySet()) {
-        if (entry.getKey() < typeargs.size()) {
-          results.put(entry.getValue(), typeargs.get(entry.getKey()));
-        }
-      }
-      results.putAll(resolver.results);
-      resolver.clearNames();
-      resolver.setResults(results);
-    }
-    return resolver;
+    return new Resolver(extensions);
   }
 
   private static Extension findExtension(List<TypeElement> family, TypeMirror qname) {
@@ -138,17 +63,10 @@ private static Extension findExtension(TypeElement typeElement, TypeMirror qname
     return null;
   }
 
-  private List<Extension> reverseExtensions() {
-    List<Extension> reversed = new ArrayList<>(this.extensions);
-    Collections.reverse(reversed);
-    return reversed;
-  }
-
   Optional<TypeMirror> resolveTypevars() {
     if (extensions.isEmpty()) {
       return Optional.empty();
     }
-    List<Extension> extensions = reverseExtensions();
     TypeMirror x = extensions.get(0).extensionClass();
     for (int i = 1; i < extensions.size(); i++) {
       Extension extension = extensions.get(i);
@@ -169,6 +87,6 @@ private static TypeMirror resolveStep(TypeMirror x, Extension ex1) {
 
   @Override
   public String toString() {
-    return String.format("%s %s", names, results);
+    return extensions.toString();
   }
 }