assertThat(output, containsString("my-plugin settings plugin applied"))
        }
    }

    @Test
    @Requires(IntegTestPreconditions.NotEmbeddedExecutor::class)
    fun `should compile correctly with Kotlin explicit api mode`() {
        withBuildScript(
            """
            plugins {
                `kotlin-dsl`
            }

            $repositoriesBlock

            kotlin {

            assertThat(error, containsString("The plugins {} block must not be used here"))
        }
    }

    @Issue("https://github.com/gradle/gradle/issues/20131")
    @Test
    fun `plugin block processed correctly even when preceded by annotation`() {

        withBuildScript(
            """
            @Suppress("DSL_SCOPE_VIOLATION")
            plugins {
                id("base")
            }
            """

            verify(container).named("domainObject")
            verifyNoMoreInteractions()
        }

        assertThat(
            domainObject.foo, // just to prove domainObject's type is inferred correctly
            nullValue()
        )

        assertThat(
            domainObject,
            sameInstance(element)
        )

        inOrder(container, provider) {

            assertSingleFileReport(ReportSeverity.WARNING, EditorMessages.buildConfigurationFailedUsingPrevious)
        }
    }

    @Test
    fun `do not report file warning on script compilation failure in currently edited script`() {
        val editedScript = withBuildScript(
            """
            doNotExists()
            """
        )

        resolvedScriptDependencies(editedScript).apply {

        rootProject.serviceOf<ImplicitImports>().list
    }

    val nonProjectScriptPaths: ScriptClassPath by unsafeLazy {
        ScriptClassPath(
            bin = ClassPath.EMPTY, // Non-project script models currently resolve their base classpath themselves
            src = ClassPath.EMPTY + gradleSourceRoots
        )
    }

    val scriptPaths: ScriptClassPath by unsafeLazy {
        ScriptClassPath(

        }
    }

    private
    var writingState: WritingState = Idle()

    // Start fingerprinting if not already started and not already committed
    // This should be strict but currently this method may be called multiple times when a
    // build invocation both runs tasks and queries models

/**
 * Allows objects that support the [Java Object Serialization](https://docs.oracle.com/javase/8/docs/platform/serialization/spec/serialTOC.html)
 * protocol to be stored in the configuration cache.
 *
 * The implementation is currently limited to serializable classes that
 * either implement the [java.io.Externalizable] interface, or implement the [java.io.Serializable] interface and define one of the following combination of methods:

        // public Kotlin type due to Kotlin `internal` semantics, we check
        // whether the public Java class is also the first public Kotlin type,
        // otherwise we compute a new schema entry with the correct Kotlin type.
        val firstPublicKotlinType = schemaType.firstPublicKotlinAccessorTypeOrSelf
        when {
            firstPublicKotlinType === schemaType -> this
            else -> ProjectSchemaNamedDomainObjectSchema(

                write(it.attributes)
            }
        }

        if (requestedAttributes) {
            // Write the file extension -> transform mappings
            // This currently uses a dummy set of variants to calculate the mappings.
            // Do not write this if it will not be used
            // TODO - simplify extracting the mappings

For this, all code blocks and multi-line snippets should be wrapped in `<code class="language-*****"></code>`.

Make sure the correct language is added to the class name: `language-kotlin`, `language-groovy`, or `language-java`:

```java
/**
 * <pre><code class="language-kotlin">
 * project.ext.prop1 = "foo"
 * task doStuff {