How to correctly determine that an object is a lambda?

A simple way to check if a Runnable - or any other functional interface - has been implemented by a Lambda is to check if the class is synthetic but the interface's function isn't:

Class clz = suspectedObject.getClass();
var isLambda = clz.isSynthetic() && !clz.getDeclaredMethod("run").isSynthetic();

Note that this will also detect function references (this::run) - I don't think there's a way to distinguish between that form and an anonymous lambda.

I want to use this method to log the type of the object in a nicer way - my framework sometime logs the names of provided interface implementations to let the user know in which part of their code they have a problem, and lambda's toString() is next to useless. Not that I've yet figured out what is a useful way to represent the notion of "you should look at this specific lambda and not any of the other dozens of lambdas in your class".

If you know the lambda extends Serializable you could check the synthetic writeReplace method that is generated returns a SerializedLambda as shown below.

import java.io.Serializable;
import java.lang.invoke.SerializedLambda;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.function.Function;

public class IsLambdaExample
{
    public static void main( String[] args )
    {
        System.out.println(
            "Is anonymous inner class a lambda: "+isLambda(
                new SerialisableFunction<Object,Object>(){ public Object apply( Object o ){ return null; } }
            )
        );
        System.out.println( "Is lambda a lambda: "+isLambda( (SerialisableFunction<Object,Object>)o -> null ) );
        System.out.println(
            "Is proxy instance a lambda: "+isLambda(
                (SerialisableFunction)Proxy.newProxyInstance(
                    ClassLoader.getSystemClassLoader(),
                    new Class[]{ SerialisableFunction.class },
                    new InvocationHandler()
                    {
                        @Override
                        public Object invoke( Object proxy, Method method, Object[] args )
                        {
                            return null;
                        }

                        private SerializedLambda writeReplace()
                        {
                            return new SerializedLambda( InvocationHandler.class, "", "", "", 0, "", "", "", "", new Object[]{} );
                        }
                    }
                )
            )
        );
    }

    public static <T extends Function<?,?> & Serializable> Boolean isLambda( T potentialLambda )
    {
        try{
            Class<?> potentialLambdaClass = potentialLambda.getClass();
            if( !potentialLambdaClass.isSynthetic() ){
                return false;
            }
            Method writeReplace = potentialLambdaClass.getDeclaredMethod("writeReplace");
            writeReplace.setAccessible(true);
            Object writeReplaceObject = writeReplace.invoke(potentialLambda);
            return writeReplaceObject != null && SerializedLambda.class.isAssignableFrom( writeReplaceObject.getClass() );
        }
        catch( NoSuchMethodException | IllegalAccessException | InvocationTargetException ignored ){
            return false;
        }
    }

    interface SerialisableFunction<T,U> extends Function<T,U>, Serializable {}
}

public static boolean isLambda(Object obj) {
    return obj.getClass().toString().contains("$$Lambda$");
}