.build.gradle.kts
[source,kotlin]
----
plugins {
    alias(libs.plugins.jetbrains.intellij)
}
----

TIP: `jetbrains-intellij` is available as the Gradle generated safe accessor: `jetbrains.intellij`.

[.text-right]

@EventScope(Scope.Build::class)
interface CoupledProjectsListener {
    /**
     * Notified when the build logic for a [referrer] project accesses the mutable state of some other [target] project.
     *
     * The [referrer] and [target] might represent the same project, and the listener implementation
     * should handle this specifically, probably ignoring such calls, as a project is naturally coupled with itself.
     */

            """
            myFun {
                a = "x"
                a = b
                b = f(a = "x")
                b = f(a = "x") { test() }
                call(x = { }) // TODO: right now, it is reported as an unsupported language feature FunctionDeclaration, report it in a more precise way?
                multiLambda({ }, { })
                1
                a.b()
                a.x = 1

For example, a property that specifies the output directory for a compilation task may start with a value specified by a plugin.
Then a build script might change the value to some custom location, then this value is used by the task when it runs.
However, once the task starts to run, we want to prevent further property changes.

----

A new set of publishing tasks are now available called `publish`, and `publishToMavenLocal`.

Similarly, the new tasks from the Maven Publish plugin are now available in IntelliJ in the Gradle right-hand pane.

image::tutorial/intellij-idea-plugin.png[]

== Step 3. Configuring the Plugin
Add the publishing information to your `build.gradle(.kts)` file:

[.multi-language-sample]
=====

                            // The artifact rule report/css/*.css => performanceResultsDir is there to clean up the target directory.
                            // If we don't clean that up there might be leftover json files from other report builds running on the same machine.
                            """

import org.gradle.api.tasks.TaskFilePropertyBuilder;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/**
 * Container for {@link TaskPropertyRegistration}s that might not have a name. The container
 * ensures that whenever parameters are iterated they are always assigned a name.
 */

Still, conceptually such modules can contain different variants or might have dependency constraints they just omitted (or wrongly defined as dependencies).
In the next sections, we explore a number existing oss modules with such incomplete metadata and the rules for adding the missing metadata information.

    api(project(":resources"))
    api(projects.serviceProvider)
    api(project(":snapshots"))

    api(libs.groovy)
    api(libs.inject)
    api(libs.kotlinStdlib)

    // TODO - it might be good to allow projects to contribute state to save and restore, rather than have this project know about everything
    implementation(projects.beanSerializationServices)
    implementation(projects.buildEvents)

    }

    /**
     * Writes the specified byte to this output stream. The general contract for <code>write</code> is that one byte is
     * written to the output stream. The byte to be written is the eight low-order bits of the argument <code>b</code>.
     * The 24 high-order bits of <code>b</code> are ignored.
     *
     * @param b the <code>byte</code> to write