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

     * 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;

                    // 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.

        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

     * 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;

          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

        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

                      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

  input: "TensorSliceDataset"
  attr {
    key: "Targuments"
    value {
      list {
      }
    }
  }
  attr {
    key: "f"
    value {
      func {
        name: "__inference_Dataset_map_<lambda>_8"
      }
    }
  }
  attr {
    key: "output_shapes"
    value {
      list {
        shape {
        }
      }
    }
  }
  attr {
    key: "output_types"
    value {