Java 11 upgrade: Merge MemberValueResolver

Author: bithazard

handlebars/src/main/java/com/github/jknack/handlebars/internal/BaseTemplate.java

@@ -25,7 +25,7 @@
 import java.io.IOException;
 import java.io.Writer;
 import java.lang.invoke.MethodHandles;
-import java.lang.reflect.Constructor;
+import java.lang.invoke.MethodType;
 import java.lang.reflect.InvocationHandler;
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
@@ -263,19 +263,13 @@ private boolean isDefault(final Method method) {
           }
 
           private Object invokeDefaultMethod(final Method method, final Class<?> lookupClass,
-              final Object proxy, final Object... args)
-              throws Throwable {
-            // Jumping through these hoops is needed because calling unreflectSpecial requires that
-            // the lookup instance have private access to the special caller. None of the static
-            // factory methods for Lookup will give us an instance with the access modes we need,
-            // so we work around it by calling the private constructor via reflection.
-            Constructor<MethodHandles.Lookup> constructor = MethodHandles.Lookup.class
-                .getDeclaredConstructor(Class.class, int.class);
-            constructor.setAccessible(true);
-            return constructor.newInstance(lookupClass, -1 /* trusted */)
-                .unreflectSpecial(method, lookupClass)
-                .bindTo(proxy)
-                .invokeWithArguments(args);
+              final Object proxy, final Object... args) throws Throwable {
+            MethodType methodType = MethodType.methodType(method.getReturnType(),
+                    method.getParameterTypes());
+            return MethodHandles.lookup()
+                    .findSpecial(lookupClass, method.getName(), methodType, lookupClass)
+                    .bindTo(proxy)
+                    .invokeWithArguments(args);
           }
 
           @Override

handlebars/src/test/java/com/github/jknack/handlebars/CollectionsLengthTest.java

@@ -8,7 +8,7 @@
 
 public class CollectionsLengthTest extends AbstractTest {
 
-  static class SizeAndLength {
+  public static class SizeAndLength {
     int size;
     int length;
 

handlebars/src/test/java/com/github/jknack/handlebars/TypeSafeTemplateDefaultMethodTest.java

@@ -19,7 +19,7 @@ public String getName() {
     }
   }
 
-  interface UserTemplate extends TypeSafeTemplate<User> {
+  public interface UserTemplate extends TypeSafeTemplate<User> {
     default String renderUpperCase(User user) throws IOException {
       return apply(user).toUpperCase();
     }

handlebars/src/test/java/mustache/specs/SpecRunner.java

@@ -17,18 +17,17 @@
  */
 package mustache.specs;
 
-import java.lang.reflect.Method;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
 
 import org.junit.runner.Description;
 import org.junit.runners.Parameterized;
+import org.junit.runners.model.FrameworkMethod;
+import org.junit.runners.model.TestClass;
 
 public class SpecRunner extends Parameterized {
-
   private List<String> labels;
-
   private Description labelledDescription;
 
   public SpecRunner(final Class<?> cl) throws Throwable {
@@ -37,120 +36,28 @@ public SpecRunner(final Class<?> cl) throws Throwable {
     generateLabelledDescription();
   }
 
-  private void initialiseLabels() throws Exception {
-    Collection<Object[]> parameterArrays = getParameterArrays();
+  private void initialiseLabels() throws Throwable {
+    Collection<Object[]> parameterArrays = getParameterArrays4_4();
     labels = new ArrayList<String>();
     for (Object[] parameterArray : parameterArrays) {
       Spec spec = (Spec) parameterArray[0];
       labels.add(spec.name());
     }
-
-  }
-
-  private Collection<Object[]> getParameterArrays() throws Exception {
-    Method testClassMethod = getDeclaredMethod(this.getClass(),
-        "getTestClass");
-    Class<?> returnType = testClassMethod.getReturnType();
-    if (returnType == Class.class) {
-      return getParameterArrays4_3();
-    } else {
-      return getParameterArrays4_4();
-    }
-  }
-
-  private Collection<Object[]> getParameterArrays4_3() throws Exception {
-    Object[][] methodCalls = new Object[][] {new Object[] {"getTestClass" } };
-    Class<?> cl = invokeMethodChain(this, methodCalls);
-    Method[] methods = cl.getMethods();
-
-    Method parametersMethod = null;
-    for (Method method : methods) {
-      boolean providesParameters = method
-          .isAnnotationPresent(Parameters.class);
-      if (!providesParameters) {
-        continue;
-      }
-
-      if (parametersMethod != null) {
-        throw new Exception(
-            "Only one method should be annotated with @Labels");
-      }
-
-      parametersMethod = method;
-    }
-
-    if (parametersMethod == null) {
-      throw new Exception("No @Parameters method found");
-    }
-
-    @SuppressWarnings("unchecked")
-    Collection<Object[]> parameterArrays =
-        (Collection<Object[]>) parametersMethod
-            .invoke(null);
-    return parameterArrays;
-
-  }
-
-  private Collection<Object[]> getParameterArrays4_4() throws Exception {
-    Object[][] methodCalls = new Object[][] {
-        new Object[] {"getTestClass" },
-        new Object[] {"getAnnotatedMethods", Class.class,
-            Parameters.class },
-        new Object[] {"get", int.class, 0 },
-        // use array type for varargs (equivalent (almost))
-        new Object[] {"invokeExplosively", Object.class, null,
-            Object[].class, new Object[] {} } };
-    Collection<Object[]> parameterArrays = invokeMethodChain(this,
-        methodCalls);
-    return parameterArrays;
   }
 
   @SuppressWarnings("unchecked")
-  private <T> T invokeMethodChain(Object object, final Object[][] methodCalls)
-      throws Exception {
-    for (Object[] methodCall : methodCalls) {
-      String methodName = (String) methodCall[0];
-      int parameterCount = (methodCall.length - 1) / 2;
-      Class<?>[] classes = new Class<?>[parameterCount];
-      Object[] arguments = new Object[parameterCount];
-      for (int i = 1; i < methodCall.length; i += 2) {
-        Class<?> cl = (Class<?>) methodCall[i];
-        Object argument = methodCall[i + 1];
-        int index = (i - 1) / 2; // messy!
-        classes[index] = cl;
-        arguments[index] = argument;
-      }
-      Method method = getDeclaredMethod(object.getClass(), methodName,
-          classes);
-      method.setAccessible(true);
-      object = method.invoke(object, arguments);
-    }
-    return (T) object;
-  }
-
-  // iterates through super-classes until found. Throws NoSuchMethodException
-  // if not
-  private Method getDeclaredMethod(Class<?> cl, final String methodName,
-      final Class<?>... parameterTypes) throws NoSuchMethodException {
-    do {
-      try {
-        Method method = cl
-            .getDeclaredMethod(methodName, parameterTypes);
-        return method;
-      } catch (NoSuchMethodException e) {
-        // do nothing - just fall through to the below
-      }
-      cl = cl.getSuperclass();
-    } while (cl != null);
-    throw new NoSuchMethodException("Method " + methodName
-        + "() not found in hierarchy");
+  private Collection<Object[]> getParameterArrays4_4() throws Throwable {
+    TestClass testClass = this.getTestClass();
+    List<FrameworkMethod> annotatedMethods = testClass.getAnnotatedMethods(Parameters.class);
+    FrameworkMethod frameworkMethod = annotatedMethods.get(0);
+    return (Collection<Object[]>)frameworkMethod.invokeExplosively(testClass);
   }
 
   private void generateLabelledDescription() throws Exception {
     Description originalDescription = super.getDescription();
     labelledDescription = Description
         .createSuiteDescription(originalDescription.getDisplayName());
-    ArrayList<Description> childDescriptions = originalDescription
+    List<Description> childDescriptions = originalDescription
         .getChildren();
     int childCount = childDescriptions.size();
     if (childCount != labels.size()) {
@@ -163,7 +70,7 @@ private void generateLabelledDescription() throws Exception {
       String label = labels.get(i);
       Description newDescription = Description
           .createSuiteDescription(label);
-      ArrayList<Description> grandChildren = childDescription
+      List<Description> grandChildren = childDescription
           .getChildren();
       for (Description grandChild : grandChildren) {
         newDescription.addChild(grandChild);
@@ -176,5 +83,4 @@ private void generateLabelledDescription() throws Exception {
   public Description getDescription() {
     return labelledDescription;
   }
-
 }