* someGraphAlgorithm(startNode, MyNode::getChildren);
 * }</pre>
 *
 * <p>If you have some other mechanism for returning the successors of a node, or one that doesn't
 * return an {@code Iterable<? extends N>}, then you can use a lambda to perform a more general
 * transformation:
 *
 * <pre>{@code
 * someGraphAlgorithm(startNode, node -> ImmutableList.of(node.leftChild(), node.rightChild()));
 * }</pre>
 *

    val schema = schemaFromTypes(TopLevelForAnalysisFilterTest::class, listOf(TopLevelForAnalysisFilterTest::class, NestedForAnalysisFilterTest::class))

    @Test
    fun `filtering a function calls also filters out its lambda`() {
        val result = schema.resolve(
            """
            n1 {
                x = 4
            }
            n2 {
                x = 5
            }
            """.trimIndent(),

     * For data classes the `copy`, `component{N}`, `toString`, `equals`, `hashCode` functions are generated
     * For enum classes the `valueOf` & `values` functions are generated
     * For lambda the `it` implicit parameter is generated
     */
    SOURCE_MEMBER_GENERATED,

    /**
     * A Kotlin declaration came from some .class file
     */
    LIBRARY,

    /**

  EXPECT_EQ(f.Call<Integer>(Integer(3))->get(), 6);
}

TEST(TypeUneraseCallTest, TestLambda) {
  // Test a trivial lambda that doubles an integer.
  Callable c(
      TFLIB_CALLABLE_ADAPTOR([](Integer a) { return Integer(a.get() * 2); }));
  EXPECT_EQ(c.Call<Integer>(Integer(3))->get(), 6);
  // Testa lambda that has captured state (call count).
  int call_count = 0;

            // Property accessors can use their bodies if not blocks.
            is KtPropertyAccessor ->
                parent.bodyExpression == child && doesPropertyAccessorUseBody(parent, child)

            // Lambdas do not use their expression-blocks if they are inferred
            // to be of unit type
            is KtFunctionLiteral ->
                parent.bodyBlockExpression == child && !returnsUnit(parent)

	quarkus/extensions/jsonb/runtime/pom.xml
quarkus/extensions/amazon-lambda-http/deployment/pom.xml
	quarkus/core/deployment/pom.xml
	quarkus/extensions/security/deployment/pom.xml
	quarkus/extensions/vertx-http/deployment/pom.xml
	quarkus/extensions/amazon-lambda/deployment/pom.xml
	quarkus/extensions/amazon-lambda-http/runtime/pom.xml
	quarkus/extensions/amazon-lambda-http/http-event-server/pom.xml

 * someGraphAlgorithm(startNode, MyNode::getChildren);
 * }</pre>
 *
 * <p>If you have some other mechanism for returning the successors of a node, or one that doesn't
 * return an {@code Iterable<? extends N>}, then you can use a lambda to perform a more general
 * transformation:
 *
 * <pre>{@code
 * someGraphAlgorithm(startNode, node -> ImmutableList.of(node.leftChild(), node.rightChild()));
 * }</pre>
 *

    }

    @Override
    public String toString() {
      return "Functions.toStringFunction()";
    }
  }

  /**
   * Returns the identity function.
   *
   * <p><b>Discouraged:</b> Prefer using a lambda like {@code v -> v}, which is shorter and often
   * more readable.
   */
  // implementation is "fully variant"; E has become a "pass-through" type
  @SuppressWarnings("unchecked")

import org.gradle.internal.declarativedsl.schemaBuilder.schemaFromTypes
import kotlin.test.Test
import kotlin.test.assertEquals


object LambdaOverloadResolutionTest {
    @Test
    fun `functions with and without lambda get disambiguated at runtime`() {
        val schema = schemaFromTypes(MyTopLevelReceiver::class, listOf(MyTopLevelReceiver::class, AddedObject::class))

        val code = """
            addSomething(1) { }

import javax.inject.Inject;
import java.io.File;
import java.io.OutputStreamWriter;

import static java.util.Collections.singleton;
import static org.gradle.api.internal.lambdas.SerializableLambdas.action;
import static org.gradle.api.internal.lambdas.SerializableLambdas.callable;
import static org.gradle.plugins.ear.EarPlugin.DEFAULT_LIB_DIR_NAME;

/**
 * Assembles an EAR archive.
 */