import org.gradle.internal.service.ServiceRegistrationProvider;
import org.gradle.internal.service.ServiceRegistry;
import org.gradle.tooling.internal.provider.action.BuildActionSerializer;

/**
 * Global services shared by all Gradle daemon clients in a given process.
 */
public class DaemonClientGlobalServices implements ServiceRegistrationProvider {
    @Provides
    Serializer<BuildAction> createBuildActionSerializer() {

import org.gradle.test.precondition.Requires
import org.gradle.test.preconditions.IntegTestPreconditions
import org.gradle.wrapper.WrapperExecutor
import org.junit.Rule
import spock.lang.Shared

import static org.gradle.internal.hash.Hashing.sha256

@Requires(value = IntegTestPreconditions.NotEmbeddedExecutor, reason = NOT_EMBEDDED_REASON)
@LocalOnly(because = "https://github.com/gradle/gradle-private/issues/3799")

type HasProg struct {
	array [1024]*byte
}

type Dep struct {
	X int
}

func (d *Dep) Method() int {
	// This code below causes various go.itab.* symbols to be generated in
	// the shared library. Similar code in ../exe/exe.go results in
	// exercising https://golang.org/issues/17594
	reflect.TypeOf(os.Stdout).Elem()
	return 10
}

func F() int {
	defer func() {}()
	return V
}

    fun main(args: Array<String>) {
        printResolutionResults(
            schema.resolve(
                """
                    val myB = b()

                    a = myB
                    val myD = newD("shared")

                    val c1 = c(1)
                    c1.x = c1.f(c1.y)
                    c1.d = myD

                    c(2) {
                        x = f("another test")

 * limitations under the License.
 */

plugins {
    id("gradlebuild.distribution.api-java")
}

description = "Declarations to define JVM toolchains shared between launcher and daemon"

dependencies {
    api(libs.inject)
    api(libs.jsr305)

    api(project(":stdlib-java-extensions"))
    api(project(":base-services"))
    api(project(":core-api"))

	SGOFUNC
	SGCBITS
	SRODATA
	SFUNCTAB

	SELFROSECT

	// Read-only sections with relocations.
	//
	// Types STYPE-SFUNCTAB above are written to the .rodata section by default.
	// When linking a shared object, some conceptually "read only" types need to
	// be written to by relocations and putting them in a section called
	// ".rodata" interacts poorly with the system linkers. The GNU linkers

When Go code is built with options like -buildmode=c-shared, it will
be run as part of an existing non-Go program. The non-Go code may
have already installed signal handlers when the Go code starts (that
may also happen in unusual cases when using cgo or SWIG; in that case,
the discussion here applies).  For -buildmode=c-archive the Go runtime
will initialize signals at global constructor time.  For
-buildmode=c-shared the Go runtime will initialize signals when the

import java.util.function.BiFunction;
import java.util.function.BinaryOperator;

/**
 * Utility class to help with using {@link java.util.stream.Stream#reduce(Object, BiFunction, BinaryOperator)}.
 * Promote to a more shared subproject if useful.
 */
public abstract class Combiners {

    /**
     * We know the stream we are processing is handled sequentially, and hence there is no need for a combiner.
     */

plugins {
    id("gradlebuild.distribution.api-java")
    id("gradlebuild.instrumented-project")
}

description = """Contains some base and shared classes for JVM language support, like AbstractCompile class and BaseForkOptions classes,
JVM-specific dependencies blocks and JVM test suite interfaces."""

errorprone {
    disabledChecks.addAll(
        "OverridesJavaxInjectableMethod", // 1 occurrences
        "UnusedMethod", // 1 occurrences

    api(project(":serialization"))
    api(project(":logging"))
    api(project(":stdlib-java-extensions"))

    // The client should not depend on core or core-api, but core still contains some types that are shared between the client and daemon
    api(project(":core-api"))
    api(project(":core"))

    implementation(libs.guava)
    implementation(libs.slf4jApi)
    implementation(project(":io"))