write(original)

        expect:
        original == written
    }

    def "serializes lambda implementation properties"() {
        def lambda = TestLambdas.createTrackableLambda()
        def original = ImplementationSnapshot.of(lambda.getClass().name, lambda, TestHashCodes.hashCodeFrom(1234))
        write(original)

        expect:
        original == written
    }

     * to avoid the extra class for the lambda (and maybe more for memoizingSupplier itself) and the
     * indirection.
     *
     * One thing to *avoid* is a change to make each Logger user use memoizingSupplier directly:
     * That may introduce an extra class for each lambda (currently a dozen).
     */
    Logger local = logger;
    if (local != null) {
      return local;

      VALUE_PARAMETER name:bottomBarContent index:1 type:@[MyComposable] kotlin.Function0<kotlin.Unit>
        EXPRESSION_BODY
          FUN_EXPR type=kotlin.Function0<kotlin.Unit> origin=LAMBDA
            FUN LOCAL_FUNCTION_FOR_LAMBDA name:<anonymous> visibility:local modality:FINAL <> () returnType:kotlin.Unit
              annotations:
                MyComposable
              BLOCK_BODY

        f(valueCaptor1.lambda as MyFunctionalInterface<String>)
        assertEquals("test", valueCaptor1.value)

        val valueCaptor2 = customConfigureLambdas.produceValueCaptor(typeOf<MyFunctionalInterface<*>>())
        f(valueCaptor2.lambda as MyFunctionalInterface<String>)
        assertEquals("test", valueCaptor2.value)

 *
 * <p>Null nodes are strictly forbidden.
 *
 * <p>Because this is an abstract class, not an interface, you can't use a lambda expression to
 * implement it:
 *
 * <pre>{@code
 * // won't work
 * TreeTraverser<NodeType> traverser = node -> node.getChildNodes();
 * }</pre>
 *
 * Instead, you can pass a lambda expression to the {@code using} factory method:
 *
 * <pre>{@code

          x: FUN_EXPR type=kotlin.Function0<@[MyComposable] kotlin.Function0<kotlin.Unit>> origin=LAMBDA
            FUN LOCAL_FUNCTION_FOR_LAMBDA name:<anonymous> visibility:local modality:FINAL <> () returnType:@[MyComposable] kotlin.Function0<kotlin.Unit>
              annotations:
                MyComposable

     * to avoid the extra class for the lambda (and maybe more for memoizingSupplier itself) and the
     * indirection.
     *
     * One thing to *avoid* is a change to make each Logger user use memoizingSupplier directly:
     * That may introduce an extra class for each lambda (currently a dozen).
     */
    Logger local = logger;
    if (local != null) {
      return local;

        verify(extra).set("property", 42)

        // And to prove the type is inferred correctly
        use(property)
    }

    @Test
    fun `can initialize extra property using lambda expression`() {

        val extra = mock<ExtraPropertiesExtension> {
            on { get("property") } doReturn 42
        }

        val property by extra { 42 }

        // property is set eagerly

 */

package org.gradle.api.internal.lambdas;

import org.gradle.api.Action;
import org.gradle.api.Transformer;
import org.gradle.api.specs.Spec;
import org.gradle.internal.Factory;

import java.io.Serializable;
import java.util.concurrent.Callable;
import java.util.function.BiFunction;
import java.util.function.Supplier;

/**
 * Provides a mechanism for creating Java lambdas that can be stored to the configuration cache.

                      CONST Int type=kotlin.Int value=4
                      CONST Int type=kotlin.Int value=5
                  predicate: FUN_EXPR type=kotlin.Function1<kotlin.Int, kotlin.Boolean> origin=LAMBDA
                    FUN LOCAL_FUNCTION_FOR_LAMBDA name:<anonymous> visibility:local modality:FINAL <> (it:kotlin.Int) returnType:kotlin.Boolean
                      VALUE_PARAMETER name:it index:0 type:kotlin.Int