*/
    ComponentArtifactResolveMetadata getArtifactMetadata();

    /**
     * Discovers the set of artifacts belonging to this component, with the type specified. Does not download the artifacts. Any failures are packaged up in the result.
     */
    void resolveArtifactsWithType(ArtifactResolver artifactResolver, ArtifactType artifactType, BuildableArtifactSetResolveResult result);

"""

        given:
        executer.useOnlyRequestedJvmOpts()

        expect:
        succeeds()
    }

    @Requires(IntegTestPreconditions.NotEmbeddedExecutor)
    def "JVM args from gradle.properties packaged in distribution override defaults"() {
        setup:
        requireIsolatedGradleDistribution()
        executer.useOnlyRequestedJvmOpts()

        file('build.gradle') << """

This sample shows how to create a plugin with tasks that have dependency resolution results as inputs.
The plugin is packaged via an included build and is demonstrated on a multi-project build for a Java application.

====

 * limitations under the License.
 */

package org.gradle.execution.plan;

import org.gradle.api.Action;
import org.gradle.internal.build.ExecutionResult;
import org.gradle.internal.service.scopes.Scope;
import org.gradle.internal.service.scopes.ServiceScope;

import javax.annotation.concurrent.ThreadSafe;

/**
 * Responsible for running the work of a build tree, packaged as zero or more {@link ExecutionPlan} instances.
 */

var (
	// SchemeBuilder points to a list of functions added to Scheme.
	SchemeBuilder      = runtime.NewSchemeBuilder(addKnownTypes)
	localSchemeBuilder = &SchemeBuilder
	// AddToScheme is a common registration function for mapping packaged scoped group & version keys to a scheme.
	AddToScheme = localSchemeBuilder.AddToScheme
)

// Adds the list of known types to scheme.
func addKnownTypes(scheme *runtime.Scheme) error {

// Copyright 2019 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package bootstrap_test verifies that the current GOROOT can be used to bootstrap
// itself.
package bootstrap_test

import (
	"fmt"
	"internal/testenv"
	"io"
	"os"
	"os/exec"
	"path/filepath"
	"runtime"
	"strings"
	"testing"
	"time"
)

pluginsRuntimeOnly.description = "To define dependencies to the Gradle modules that represent additional plugins packaged in the distributions (lib/plugins/*.jar)"
val agentsRuntimeOnly by bucket()
agentsRuntimeOnly.description = "To define dependencies to the Gradle modules that represent Java agents packaged in the distribution (lib/agents/*.jar)"

coreRuntimeOnly.withDependencies {

     */
    public abstract DirectoryProperty getDocumentationRenderedRoot();

    /**
     * The collection of rendered documentation.  This is everything laid out as it would be deployed/packaged.
     */
    public abstract ConfigurableFileCollection getRenderedDocumentation();

    // These are all helper methods for configuring the parts of the documentation (DSL ref, javadoc, user manual, etc).

    }

    private static void describeLibraryElements(Object le, StringBuilder sb) {
        String name = toName(le);
        switch (name) {
            case LibraryElements.JAR:
                sb.append("packaged as a jar");
                break;
            case LibraryElements.CLASSES:
                sb.append("preferably in the form of class files");
                break;
            case LibraryElements.RESOURCES:

However, they can become hard to maintain as the build script grows in size and complexity.

*Precompiled Script Plugins* are Kotlin or Groovy DSL scripts compiled into Java class files packaged in a library.
They offer better performance and maintainability compared to script plugins, and they can be reused across different projects.
You can also write them in Groovy DSL but that is not recommended.