repositories {
                            mavenCentral()
                        }
                        dependencies {
                            "implementation"(gradleApi())
                            "implementation"(kotlin("stdlib"))
                        }
                    }
                    project(":v1") {
                        version = "1.0"
                    }

The <<java_gradle_plugin.adoc#java_gradle_plugin,Gradle Plugin Development plugin>> can be used to assist in developing Gradle plugins.

This plugin will automatically apply the <<java_plugin.adoc#java_plugin,Java Plugin>>, add the `gradleApi()` dependency to the `api` configuration, generate the required plugin descriptors in the resulting JAR file, and configure the <<plugins.adoc#sec:plugin_markers,Plugin Marker Artifact>> to be used when publishing.

        }
    }

    private
    suspend fun WriteContext.encode(value: DefaultLocalFileDependencyBackedArtifactSet) {
        // TODO - When the set of files is fixed (eg `gradleApi()` or some hard-coded list of files):
        //   - calculate the attributes for each of the files eagerly rather than writing the mappings

                group = 'com.acme.typed-attributes'
                version = '$version'

                dependencies {
                    implementation localGroovy()
                    implementation gradleApi()
                }

                publishing {
                    repositories {
                        maven {
                            url "${mavenRepo.uri}"
                        }

        !inputArtifactNames.empty
        (inputArtifactNames as Set).size() == inputArtifactNames.size()

        where:
        classpathNotation   | displayName
        'gradleApi()'       | 'Gradle API'
        'gradleTestKit()'   | 'Gradle TestKit'
        'localGroovy()'     | 'Local Groovy'
        'gradleKotlinDsl()' | 'Gradle Kotlin DSL'
    }

        buildScript '''
            plugins {
                id 'java-library'
            }

            dependencies {
                implementation(gradleApi())
            }

            @CacheableTask
            abstract class PrintArtifactIds extends DefaultTask {

                @Input

We believe this situation is very unlikely to occur in real projects, as IDE integration and test execution would not work correctly.
If you need to use the Gradle API, declare a `gradleApi` dependency or use the `java-gradle-plugin` plugin.

==== Configuration cache implementation packages now under `org.gradle.internal`

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import com.gradleup.gr8.EmbeddedJarTask
import com.gradleup.gr8.Gr8Task
import java.util.jar.Attributes

plugins {
    id("gradlebuild.distribution.api-java")
    id("com.gradleup.gr8") version "0.10"
}

description = "Entry point of the Gradle wrapper command"

gradlebuildJava.usedInWorkers()

    def "uses modules to determine gradle API classpath"() {
        when:
        def classpath = provider.findClassPath("GRADLE_API")

        then:
        classpath.asFiles.collect{it.name} == [
            "gradle-worker-main-runtime",
            "gradle-launcher-runtime",
            "gradle-cli-runtime",

public class DefaultScriptClassPathResolver implements ScriptClassPathResolver {

    private static final Set<ClassPathNotation> GRADLE_API_NOTATIONS = EnumSet.of(
        ClassPathNotation.GRADLE_API,
        ClassPathNotation.LOCAL_GROOVY
    );

    public enum InstrumentationPhase {
        NOT_INSTRUMENTED("not-instrumented"),
        ANALYZED_ARTIFACT("analyzed-artifact"),