GROOVY-11905: Optimize non-capturing lambdas

Author: daniellansun

src/main/java/org/codehaus/groovy/classgen/asm/sc/StaticTypesLambdaWriter.java

@@ -72,6 +72,7 @@
 import static org.objectweb.asm.Opcodes.ALOAD;
 import static org.objectweb.asm.Opcodes.CHECKCAST;
 import static org.objectweb.asm.Opcodes.DUP;
+import static org.objectweb.asm.Opcodes.H_INVOKESTATIC;
 import static org.objectweb.asm.Opcodes.H_INVOKEVIRTUAL;
 import static org.objectweb.asm.Opcodes.ICONST_0;
 import static org.objectweb.asm.Opcodes.INVOKESPECIAL;
@@ -113,27 +114,47 @@ public void writeLambda(final LambdaExpression expression) {
         ClassNode lambdaClass = getOrAddLambdaClass(expression, abstractMethod);
         MethodNode lambdaMethod = lambdaClass.getMethods(DO_CALL).get(0);
 
+        Parameter[] lambdaSharedVariables = expression.getNodeMetaData(LAMBDA_SHARED_VARIABLES);
+        boolean accessingInstanceMembers = isAccessingInstanceMembersOfEnclosingClass(lambdaMethod);
+        // For non-capturing lambdas: make doCall static and use a capture-free invokedynamic,
+        // so LambdaMetafactory creates a singleton instance — just like Java non-capturing lambdas.
+        boolean isNonCapturing = lambdaSharedVariables.length == 0 && !accessingInstanceMembers;
         boolean canDeserialize = controller.getClassNode().hasMethod(createDeserializeLambdaMethodName(lambdaClass), createDeserializeLambdaMethodParams());
-        if (!canDeserialize) {
+
+        if (isNonCapturing) {
+            lambdaMethod.setModifiers(lambdaMethod.getModifiers() | ACC_STATIC);
+            if (expression.isSerializable() && !canDeserialize) {
+                addDeserializeLambdaMethodForEachLambdaExpression(expression, lambdaClass, true);
+                addDeserializeLambdaMethod();
+            }
+        } else if (!canDeserialize) {
             if (expression.isSerializable()) {
-                addDeserializeLambdaMethodForEachLambdaExpression(expression, lambdaClass);
+                addDeserializeLambdaMethodForEachLambdaExpression(expression, lambdaClass, false);
                 addDeserializeLambdaMethod();
             }
-            newGroovyLambdaWrapperAndLoad(lambdaClass, expression, isAccessingInstanceMembersOfEnclosingClass(lambdaMethod));
+            newGroovyLambdaWrapperAndLoad(lambdaClass, expression, accessingInstanceMembers);
         }
 
         MethodVisitor mv = controller.getMethodVisitor();
         mv.visitInvokeDynamicInsn(
                 abstractMethod.getName(),
-                createAbstractMethodDesc(functionalType.redirect(), lambdaClass),
+                isNonCapturing
+                        ? BytecodeHelper.getMethodDescriptor(functionalType.redirect(), Parameter.EMPTY_ARRAY)
+                        : createAbstractMethodDesc(functionalType.redirect(), lambdaClass),
                 createBootstrapMethod(controller.getClassNode().isInterface(), expression.isSerializable()),
-                createBootstrapMethodArguments(createMethodDescriptor(abstractMethod), H_INVOKEVIRTUAL, lambdaClass, lambdaMethod, lambdaMethod.getParameters(), expression.isSerializable())
+                createBootstrapMethodArguments(createMethodDescriptor(abstractMethod),
+                        isNonCapturing ? H_INVOKESTATIC : H_INVOKEVIRTUAL,
+                        lambdaClass, lambdaMethod, lambdaMethod.getParameters(), expression.isSerializable())
         );
         if (expression.isSerializable()) {
             mv.visitTypeInsn(CHECKCAST, "java/io/Serializable");
         }
 
-        controller.getOperandStack().replace(functionalType.redirect(), 1);
+        if (isNonCapturing) {
+            controller.getOperandStack().push(functionalType.redirect());
+        } else {
+            controller.getOperandStack().replace(functionalType.redirect(), 1);
+        }
     }
 
     private static Parameter[] createDeserializeLambdaMethodParams() {
@@ -325,27 +346,32 @@ private void addDeserializeLambdaMethod() {
                 code);
     }
 
-    private void addDeserializeLambdaMethodForEachLambdaExpression(final LambdaExpression expression, final ClassNode lambdaClass) {
+    private void addDeserializeLambdaMethodForEachLambdaExpression(final LambdaExpression expression, final ClassNode lambdaClass, final boolean isNonCapturing) {
         ClassNode enclosingClass = controller.getClassNode();
-        Statement code = block(
-                new BytecodeSequence(new BytecodeInstruction() {
-                    @Override
-                    public void visit(final MethodVisitor mv) {
-                        mv.visitVarInsn(ALOAD, 0);
-                        mv.visitInsn(ICONST_0);
-                        mv.visitMethodInsn(
-                                INVOKEVIRTUAL,
-                                "java/lang/invoke/SerializedLambda",
-                                "getCapturedArg",
-                                "(I)Ljava/lang/Object;",
-                                false);
-                        mv.visitTypeInsn(CHECKCAST, BytecodeHelper.getClassInternalName(lambdaClass));
-                        OperandStack operandStack = controller.getOperandStack();
-                        operandStack.push(lambdaClass);
-                    }
-                }),
-                returnS(expression)
-        );
+        Statement code;
+        if (isNonCapturing) {
+            code = block(returnS(expression));
+        } else {
+            code = block(
+                    new BytecodeSequence(new BytecodeInstruction() {
+                        @Override
+                        public void visit(final MethodVisitor mv) {
+                            mv.visitVarInsn(ALOAD, 0);
+                            mv.visitInsn(ICONST_0);
+                            mv.visitMethodInsn(
+                                    INVOKEVIRTUAL,
+                                    "java/lang/invoke/SerializedLambda",
+                                    "getCapturedArg",
+                                    "(I)Ljava/lang/Object;",
+                                    false);
+                            mv.visitTypeInsn(CHECKCAST, BytecodeHelper.getClassInternalName(lambdaClass));
+                            OperandStack operandStack = controller.getOperandStack();
+                            operandStack.push(lambdaClass);
+                        }
+                    }),
+                    returnS(expression)
+            );
+        }
 
         enclosingClass.addSyntheticMethod(
                 createDeserializeLambdaMethodName(lambdaClass),