@Test
    fun `will not parse @ followed by whitespace`() {
        kotlinGrammar.annotation.failToConsumeFrom("@ something")
        kotlinGrammar.annotation.failToConsumeFrom("@\nsomething")
        kotlinGrammar.annotation.failToConsumeFrom("@/*comment*/something")
        kotlinGrammar.annotation.failToConsumeFrom("@/*comment*/ something")
    }

    @Test
    fun `can parse single annotation`() {

            class SomeOverriddenPrecompiledScript : Some {
                override fun something() {
                    println("precompiled overridden")
                }
            }

            SomePrecompiledScript().something()
            SomeOverriddenPrecompiledScript().something()
            """
        )
        withBuildScript(
            """
            import some.Some

        assertThat(
            lex("\n" +
                "/* ... */\n" +
                "// she-bangs! ///////_*&@ because why not! _-|\n" +
                "\n" +
                "#!/something/something\n" +
                "\n" +
                "\n" +
                "/* first file annotation */\n" +
                "@file:Suppress(\"UnstableApiUsage\")\n" +
                "\n" +

                    ++replacementsCount
                    // Use shell's string concatenation: '...'"..." glues contents of quoted and double-quoted strings together.
                    // The result would be something like DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'" \"-javaagent:$APP_HOME/lib/agents/foobar.jar\""
                    line + getAgentOptions("\$APP_HOME").joinToString(separator = " ", prefix = "\" ", postfix = "\"") {

            target.apply<ProjectPlugin>()
            verify(configurationAction).plugin(ProjectPlugin::class.java)
        }
    }

    @Test
    fun `reified apply to extension`() {
        val arbitraryTarget = "something"

        newPluginAwareMock<PluginAware>().run {
            target.applyTo<AnyPlugin>(arbitraryTarget)
            inOrder(configurationAction) {
                verify(configurationAction).plugin(AnyPlugin::class.java)

        closureOf<MutableList<Int>> { add(42) }.call(list)
        assertEquals(42, list.first())
    }

    @Test
    fun `can use closure with single nullable argument call`() {
        var passedIntoClosure: Any? = "Something non null"
        closureOf<Any?> { passedIntoClosure = this }.call(null)
        assertNull(passedIntoClosure)
    }

    @Test
    fun `can use closure with delegate call`() {
        val list = arrayListOf<Int>()

            import org.gradle.api.DefaultTask
            import org.gradle.api.tasks.TaskAction

            abstract class MyTask : DefaultTask() {
                @TaskAction fun action() { println("Doing something") }
            }
        """)
        withFile("build-logic/src/main/kotlin/MyPlugin.kt", """
            import org.gradle.api.Project
            import org.gradle.api.Plugin

        assertThat(
            scriptPlugin(
                "my-script.gradle.kts",
                """

                    // she-bangs! ///////_*&@ because why not! _-|

                    #!/something/something


                    /* first file annotation */
                    @file:Suppress("UnstableApiUsage")

                    // second file annotation //second comment, just for fun

    "CommonProgramFiles(x86)",
    "CommonProgramW6432",
    "ProgramData",
    "ProgramFiles",
    "ProgramFiles(x86)",
    // Simply putting PATH there isn't enough. Windows has case-insensitive env vars but something else fails if the Path variable is published as PATH for test tasks.
    OperatingSystem.current().pathVar,
    "PATHEXT",
)


val credentialsKeywords = listOf(
    "api_key",
    "access_key",

        fn.configure(inner)
    }
}


interface Functional {
    fun configure(inner: Inner)
}


interface GenericFunctional<T> {
    fun configure(something: T)
}


class Inner {
    @get:Restricted
    var x = 0

    @Adding
    fun f() {
        ++x
    }
}


private
val functionalLambdaHandler =