}
                }
            """
            source """
                class Lambda1 {
                    SomeInterface getAnonymous() {
                        return () -> 4;
                    }
                }
            """
            source """
                class Lambda2 {
                    SomeInterface getAnonymous() {
                        return () -> 5;

			return nil
		}
		return apiErr
	}
	return nil
}

// GetObjectLamdbaHandler - GET Object with transformed data via lambda functions
// ----------
// This implementation of the GET operation applies lambda functions and returns the
// response generated via the lambda functions. To use this API, you must have READ access
// to the object.

        'unknown classloader for lambda'             | { -> ImplementationSnapshot.of('SomeClass$$Lambda/23501234324', null) }
        'unknown lambda'                             | { -> ImplementationSnapshot.of('SomeClass$$Lambda/23501234324', SHARED_CLASSLOADER_HASH) }
        'untrackable lambda'                         | { -> ImplementationSnapshot.of('SomeClass$$Lambda/23501234324', SHARED_UNTRACKABLE_LAMBDA, SHARED_CLASSLOADER_HASH) }

    }

    @Issue("https://github.com/gradle/gradle/issues/5510")
    @Ignore("All lambdas are becoming serializable")
    // TODO remove this test if the change making all lambdas serializable is not reverted
    def "task with nested property defined by non-serializable Java lambda fails the build"() {
        // With configuration cache, all lambdas are forced to be serializable, so there won't be anything to report.

                public class LambdaTask extends DefaultTask {

                    // Test with serializable lambdas that should work as-is, as well as non-serializable lambdas which should
                    // be forced to become serializable by the instrumentation:
                    public interface NonSerializableSupplier<T> {
                        T get();
                    }

                    // In theory, it is possible to have a lambda so big, its handling won't fit in a single method, and such a lambda will cause an infinite loop here.
                    // However, the number of captured lambda variables is limited by the max number of method arguments allowed by the JVM.

                errors += UnsupportedSyntax(UnsupportedSyntaxCause.ElementArgumentFormat)
            }
            val lambdas = blockElement.args.filterIsInstance<FunctionArgument.Lambda>()

            val lambda = when (lambdas.size) {
                0 -> null
                1 -> lambdas.single()
                else -> {
                    errors += UnsupportedSyntax(UnsupportedSyntaxCause.ElementMultipleLambdas)

    private val memberFilter: MemberFilter,
    private val configureLambdas: ConfigureLambdaHandler,
) : TypeDiscovery {
    /**
     * Collect everything that potentially looks like types configured by the lambdas.
     * TODO: this may be excessive
     */
    override fun getClassesToVisitFrom(kClass: KClass<*>): Iterable<KClass<*>> =
        kClass.memberFunctions
            .filter { memberFilter.shouldIncludeMember(it) }

        }

        val lambda = call.args.filterIsInstance<FunctionArgument.Lambda>().singleOrNull()
        val (expectsConfigureLambda, requiresConfigureLambda) = semantics.configureBlockRequirement.run { allows to requires }
        if (expectsConfigureLambda) {
            if (lambda != null) {
                withScope(AnalysisScope(currentScopes.last(), configureReceiver, lambda)) {

            "Load your class by using one of Gradle's built-in ways."
        ),
        UNTRACKED_LAMBDA(
            "was implemented by the Java lambda '%s'.",
            "Using Java lambdas is not supported as task inputs.",
            "Use an (anonymous inner) class instead."
        );

        private final String descriptionTemplate;
        private final String reason;