CALL 'public final fun setContent (content: @[MyComposable] kotlin.Function0<kotlin.Unit>): kotlin.Int declared in p3' type=kotlin.Int origin=null
            content: 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

        // After validation, the current implementations and previous implementations can't be unknown.
        // Moreover, they need to come from an actual Class, not a lambda, since there isn't a way for a unit of work implementation to be a lambda.
        ClassImplementationSnapshot currentImplementation = Cast.uncheckedNonnullCast(thisExecution.getImplementation());

        '''
    }

    def configuredTaskRunsCorrectly() {
        run 'test'
        outputContains 'The parameter is `42`'
        true
    }

    def 'isolated beforeProject action given as Kotlin lambda can capture managed value'() {
        given:
        withSettingsPluginInBuildLogic()

        createDir('build-logic') {
            file('settings.gradle.kts') << ''
            file('build.gradle.kts') << """

        }

        return LogContent.of(result).withNormalizedEol();
    }

    /**
     * Normalize the non-deterministic part of lambda class name.
     *
     * Lambdas do have some non-deterministic class names, depending on when they are loaded.
     * Since we want to assert the Lambda class name for some deprecation warning tests, we replace the non-deterministic part by {@code <non-deterministic>}.
     */

                LAMBDA_EXPRESSION -> list.add(lambda(tree, it))
                ERROR_ELEMENT -> list.add(tree.parsingError(node, it, "Unparsable value argument: \"${node.asText}\""))
                else -> tree.parsingError(it, "Parsing failure, unexpected token type in value arguments: $tokenType")
            }
        }
        return list
    }

    private

\tat org.gradle.api.internal.tasks.execution.ExecuteActionsTaskExecuter$TaskExecution.execute(ExecuteActionsTaskExecuter.java:267)
\tat org.gradle.internal.execution.steps.ExecuteStep.lambda$execute$0(ExecuteStep.java:32)
\tat java.base/java.util.Optional.map(Optional.java:258)
\tat org.gradle.internal.execution.steps.ExecuteStep.execute(ExecuteStep.java:32)

    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,

    /**

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) { }

    }

    @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")