Support serializable lambdas for up-to-date checks

[wolfs]

Gradle currently doesn't support Java lambdas (aka invoke dynamic implementations of classes) since it is unable to track the implementation for the classes the JVM generates at runtime. For serializable lambdas, Gradle could extract enough information to track the implementation and therefore support those as task actions. This is especially interesting, since Kotlin 1.5 by default generates invoke dynamic calls when a lambda implements a SAM type.

As a next step we could automatically make the lambdas we use for doLast etc. serializable.

Design spec

---

cc: @gradle/execution

[wolfs]

See #10751 for the deprecation of Java lambdas as task actions.

[wolfs]

I did an investigation what we need to do to support serializable lambdas. This snippet allows you to obtain a SerializedLambda object from something implemented by a serializable lambda:

private static Optional<SerializedLambda> serializedLambdaFor(Object lambda) {
    if (!(lambda instanceof Serializable)) {
        return Optional.empty();
    }
    for (Class<?> lambdaClass = lambda.getClass(); lambdaClass != null; lambdaClass = lambdaClass.getSuperclass()) {
        try {
            Method replaceMethod = lambdaClass.getDeclaredMethod("writeReplace");
            replaceMethod.setAccessible(true);
            Object serializedForm = replaceMethod.invoke(lambda);
            if (serializedForm instanceof SerializedLambda) {
                return Optional.of((SerializedLambda) serializedForm);
            } else {
                return Optional.empty();
            }
        } catch (NoSuchMethodException e) {
            // continue
        } catch (InvocationTargetException | IllegalAccessException e) {
            return Optional.empty();
        }
    }
    return Optional.empty();
}

Running this on a task action implemented by a serializable lambda gives something like this:

I suppose we need to capture the fields of this object and the implementation snapshot of the capturing class. We will also need to capture the capturedArgs.

All of this seems to be doable, though we'll need to change some part of our infrastructure since passing around the Class<?> object of the action won't be enough any more.

[lptr]

Can we use ImplementationSnapshot to carry this information for serializable lambdas?

[wolfs]

Can we use ImplementationSnapshot to carry this information for serializable lambdas?

We can't use the current class, though I suppose we can create a subclass which has the necessary information and adds it accordingly to the hasher. We can create this new class in TaskActionWrapper.getActionImplementation to create the right ImplementationSnapshot subclass. This would allow using serializable lambdas for task actions, but not for nested inputs.

For fixing the problem for nested inputs we need to create the right snapshot when we attach the class object as an input property, since the class object won't be enough anymore for the snapshotter to determine the implementation snapshot.

[stale]

This issue has been automatically marked as stale because it has not had recent activity. Given the limited bandwidth of the team, it will be automatically closed if no further activity occurs. If you're interested in how we try to keep the backlog in a healthy state, please read our blog post on how we refine our backlog. If you feel this is something you could contribute, please have a look at our Contributor Guide. Thank you for your contribution.

[melix]

unstale