feat: (javac) support constructor reference

src/main/java/reincarnation/JavaMethodDecompiler.java

@@ -14,6 +14,7 @@
 import static reincarnation.OperandCondition.*;
 import static reincarnation.OperandUtil.*;
 
+import java.lang.reflect.Constructor;
 import java.lang.reflect.Executable;
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
@@ -936,18 +937,23 @@ public void visitInsn(int opcode) {
             break;
 
         case POP:
-            // When the JDK compiler compiles the code including "instance method reference", it
+            // When the compiler compiles the code including "instance method reference", it
             // generates the byte code expressed in following ASM codes.
             //
+            // In Javac
+            // visitInsn(DUP);
+            // visitMethodInsn(INVOKESTATIC, "java/util/Objects","requireNonNull",SIGNATURE, false);
+            // visitInsn(POP);
+            //
+            // In ECJ
             // visitInsn(DUP);
             // visitMethodInsn(INVOKEVIRTUAL, "java/lang/Object","getClass","()Ljava/lang/Class;");
             // visitInsn(POP);
             //
-            // Although i guess that it is the initialization code for the class to
-            // which the lambda method belongs, ECJ doesn't generated such code.
-            // In Javascript runtime, it is a completely unnecessary code,
-            // so we should delete them unconditionally.
-            if (match(DUP, INVOKEVIRTUAL, POP)) {
+            // I guess that it is NULL checker and initialize code for the class to which the lambda
+            // method belongs. It is a completely unnecessary code, so we should remove them
+            // unconditionally.
+            if (match(DUP, INVOKESTATIC, POP) || match(DUP, INVOKEVIRTUAL, POP)) {
                 current.remove(0);
                 break;
             }
@@ -1389,60 +1395,70 @@ public void visitInvokeDynamicInsn(String name, String description, Handle boots
             // detect functional interface
             Class interfaceClass = load(callerType.getReturnType());
 
-            // detect lambda method
             try {
+                // detect lambda method
                 Class lambdaClass = load(handle.getOwner());
+                String lambdaName = handle.getName();
                 Class[] lambdaParameterTypes = load(Type.getArgumentTypes(handle.getDesc()));
-                Method lambdaMethod = lambdaClass.getDeclaredMethod(handle.getName(), lambdaParameterTypes);
+                boolean needInstance = callerType.getArgumentTypes().length != 0;
 
-                if (lambdaMethod.isSynthetic()) {
-                    // ==================================
-                    // Lambda
-                    // ==================================
-                    // build parameter from local environment
-                    int consumableStackSize = callerType.getArgumentTypes().length;
-                    List<Operand> params = new ArrayList();
-
-                    for (int i = consumableStackSize - 1; 0 <= i; i--) {
-                        Operand removed = current.remove(i);
-                        if (removed instanceof OperandLocalVariable local && local.index == 0) {
-                            // ignore "this" variable
-                        } else {
-                            params.add(removed);
-                        }
-                    }
+                source.require(lambdaClass);
 
-                    current.addOperand(new OperandLambda(interfaceClass, lambdaMethod, params, source));
-                } else {
+                switch (handle.getTag()) {
+                case H_INVOKESTATIC:
+                case H_INVOKEVIRTUAL:
+                case H_INVOKEINTERFACE:
                     // ==================================
                     // Method Reference
                     // ==================================
-                    source.require(lambdaClass);
-
-                    boolean needInstance = callerType.getArgumentTypes().length != 0;
-
-                    switch (handle.getTag()) {
-                    case H_INVOKESTATIC:
-                    case H_INVOKEVIRTUAL:
-                    case H_INVOKEINTERFACE:
+                    Method lambdaMethod = lambdaClass.getDeclaredMethod(lambdaName, lambdaParameterTypes);
+                    if (lambdaMethod.isSynthetic()) {
+                        // ==================================
+                        // Lambda
+                        // ==================================
+                        // build parameter from local environment
+                        int consumableStackSize = callerType.getArgumentTypes().length;
+                        List<Operand> params = new ArrayList();
+
+                        for (int i = consumableStackSize - 1; 0 <= i; i--) {
+                            Operand removed = current.remove(i);
+                            if (removed instanceof OperandLocalVariable local && local.index == 0) {
+                                // ignore "this" variable
+                            } else {
+                                params.add(removed);
+                            }
+                        }
+                        current.addOperand(new OperandLambda(interfaceClass, lambdaMethod, params, source));
+                    } else {
                         SpecializedType specialized = new SpecializedType(interfaceClass)
                                 .specializeByReturnAndParamTypes((Type) bootstrapMethodArguments[2])
                                 .specializeBySAM(lambdaMethod);
 
                         current.addOperand(new OperandMethodReference(lambdaMethod, needInstance ? current.remove(0) : null)
                                 .fix(specialized));
-                        break;
+                    }
+                    break;
 
-                    case H_INVOKESPECIAL:
-                    case H_NEWINVOKESPECIAL:
-                        break;
+                case H_INVOKESPECIAL:
+                    break;
 
-                    default:
-                        // If this exception will be thrown, it is bug of this program. So we must
-                        // rethrow
-                        // the wrapped error in here.
-                        throw new Error();
-                    }
+                case H_NEWINVOKESPECIAL:
+                    // ==================================
+                    // Constructor Reference in Javac
+                    // ==================================
+                    Constructor lambdaConstructor = lambdaClass.getDeclaredConstructor(lambdaParameterTypes);
+                    SpecializedType specialized = new SpecializedType(interfaceClass).specializeByReturnType(lambdaClass)
+                            .specializeByParamTypes(lambdaParameterTypes);
+
+                    current.addOperand(new OperandConstructorReference(lambdaConstructor).fix(specialized));
+                    break;
+
+                default:
+                    // If this exception will be thrown, it is bug of this program. So we
+                    // must
+                    // rethrow
+                    // the wrapped error in here.
+                    throw new Error();
                 }
             } catch (Exception e) {
                 throw I.quiet(e);

src/main/java/reincarnation/OperandCondition.java

@@ -289,6 +289,6 @@ protected boolean isValue() {
      */
     @Override
     protected String view() {
-        return "if (" + left.view() + " " + right.view() + ") then " + then.id + " else " + elze.id;
+        return "if (" + left.view() + " " + right.view() + ") then " + then.id + " else " + (elze == null ? "SAME" : elze.id);
     }
 }

src/main/java/reincarnation/OperandConstructorReference.java

@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2024 The REINCARNATION Development Team
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *          https://opensource.org/licenses/MIT
+ */
+package reincarnation;
+
+import java.lang.reflect.Constructor;
+
+import reincarnation.coder.Coder;
+
+class OperandConstructorReference extends Operand {
+
+    /** The lambda body. */
+    private final Constructor reference;
+
+    /**
+     * Create the operand for constructor reference.
+     * 
+     * @param reference
+     */
+    OperandConstructorReference(Constructor reference) {
+        this.reference = reference;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    protected void writeCode(Coder coder) {
+        coder.writeConstructorReference(reference);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    protected boolean isValue() {
+        return true;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    protected String view() {
+        return reference.getName() + "::new";
+    }
+}

src/main/java/reincarnation/OperandLocalVariable.java

@@ -62,7 +62,7 @@ protected boolean isNegatable() {
      * {@inheritDoc}
      */
     @Override
-    public boolean isValue() {
+    protected boolean isValue() {
         return true;
     }
 

src/main/java/reincarnation/OperandMethodCall.java

@@ -13,11 +13,12 @@
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
 import java.lang.reflect.Parameter;
-import java.util.Arrays;
 import java.util.Iterator;
 import java.util.LinkedList;
 import java.util.List;
+import java.util.Set;
 import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 import kiss.I;
 import kiss.Model;
@@ -80,7 +81,14 @@ class OperandMethodCall extends Operand {
      * @return
      */
     private Method find(Class owner, String name, Class[] types) {
-        for (Class type : Model.collectTypes(owner)) {
+        Set<Class> collections = Model.collectTypes(owner);
+
+        // In Javac, when the interface method reference invokes the Object class method,
+        // it is compiled as a call to the interface, not to the object. However, this would fail to
+        // find methods of the Object class, so the Object class is added unconditionally.
+        collections.add(Object.class);
+
+        for (Class type : collections) {
             try {
                 Method method = type.getDeclaredMethod(name, types);
                 int mod = method.getModifiers();
@@ -98,7 +106,9 @@ private Method find(Class owner, String name, Class[] types) {
                 // ignore
             }
         }
-        throw new NoSuchMethodError(owner + "#" + name + Arrays.toString(types));
+        throw new NoSuchMethodError(owner + "#" + name + Stream.of(types)
+                .map(Class::getSimpleName)
+                .collect(Collectors.joining(", ", "(", ")")));
     }
 
     /**

src/main/java/reincarnation/OperandMethodReference.java

@@ -57,6 +57,10 @@ protected boolean isValue() {
      */
     @Override
     protected String view() {
-        return context.view() + "::" + reference.getName();
+        if (context == null) {
+            return reference.getDeclaringClass().getSimpleName() + "::" + reference.getName();
+        } else {
+            return context.view() + "::" + reference.getName();
+        }
     }
 }

src/main/java/reincarnation/coder/Coder.java

@@ -583,6 +583,13 @@ public final void writeEnclose(Code code) {
      */
     public abstract void writeThisConstructorCall(Constructor constructor, List<Code> params);
 
+    /**
+     * Constructor reference.
+     * 
+     * @param constructor A constructor info.
+     */
+    public abstract void writeConstructorReference(Constructor constructor);
+
     /**
      * Method call expression.
      * 

src/main/java/reincarnation/coder/DelegatableCoder.java

@@ -345,6 +345,14 @@ public void writeConstructorCall(Constructor constructor, List<Code> params) {
         coder.writeConstructorCall(constructor, params);
     }
 
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public void writeConstructorReference(Constructor constructor) {
+        coder.writeConstructorReference(constructor);
+    }
+
     /**
      * {@inheritDoc}
      */

src/main/java/reincarnation/coder/java/JavaCoder.java

@@ -753,6 +753,14 @@ public void writeThisConstructorCall(Constructor constructor, List<Code> params)
         }
     }
 
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public void writeConstructorReference(Constructor constructor) {
+        write(name(constructor.getDeclaringClass()), "::new");
+    }
+
     /**
      * {@inheritDoc}
      */