pushd "staging/src/k8s.io/${repo}" >/dev/null 2>&1
    go mod edit -require "${dep}@${rev}"

    # When replacing with a fork, always add a replace statement in all go.mod
    # files (not just the root of the staging repos!) because there might be
    # indirect dependencies on the fork.
    #
    # This is excessive, but the resulting commit should never be merged, so it
    # isn't that important to get this exactly right.

	pc := getcallerpc()
	doasanwrite(addr, uintptr(len), sp, pc)
}

// Private interface for the runtime.
const asanenabled = true

// asan{read,write} are nosplit because they may be called between
// fork and exec, when the stack must not grow. See issue #50391.

//go:linkname asanread
//go:nosplit
func asanread(addr unsafe.Pointer, sz uintptr) {
	sp := getcallersp()
	pc := getcallerpc()
	doasanread(addr, sz, sp, pc)

<% if (scalaProject) { %>
apply plugin: 'scala'
dependencies {
    implementation 'org.scala-lang:scala-library:2.9.2'
}
tasks.withType(ScalaCompile) {
    scalaCompileOptions.with {
        useAnt = false
        fork = true
        if (!JavaVersion.current().java8Compatible) {
            forkOptions.jvmArgs = ["-XX:MaxPermSize=512m"]
        }
    }
}
<% } %>

task dependencyReport(type: DependencyReportTask) {

# building the commands.
#
# CGO_ENABLED: Controls cgo usage during the build. Set it to 1
# to include all cgo related files, .c and .go file with "cgo"
# build directive, in the build. Set it to 0 to ignore them.

rfork e
if(! test -f run.rc){
	echo 'make.rc must be run from $GOROOT/src' >[1=2]
	exit wrongdir
}

# Clean old generated file that will cause problems in the build.
rm -f ./runtime/runtime_defs.go

            }

            dependencies {
                errorprone("com.google.errorprone:error_prone_core:2.8.0")
            }

            tasks.withType(JavaCompile).configureEach {
                options.fork = true
                options.errorprone {
                    check("DoubleBraceInitialization", net.ltgt.gradle.errorprone.CheckSeverity.ERROR)
                }
            }
        """

                    // ~25MB
                    ext.memoryHog = new byte[1024*1024*25]

                    tasks.withType(JavaCompile).configureEach {
                        options.fork = true
                        options.forkOptions.jvmArgs << "-Dcounter=" + project.property("counter")
                    }
                }
            """
        }
    }

import org.gradle.internal.nativeintegration.services.NativeServices;
import org.gradle.internal.nativeintegration.services.NativeServices.NativeServicesMode;
import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.Fork;
import org.openjdk.jmh.annotations.Level;
import org.openjdk.jmh.annotations.Measurement;
import org.openjdk.jmh.annotations.Scope;
import org.openjdk.jmh.annotations.Setup;
import org.openjdk.jmh.annotations.State;

- [ ] Check ["Allow edit from maintainers" option](https://help.github.com/articles/allowing-changes-to-a-pull-request-branch-created-from-a-fork/) in pull request so that additional changes can be pushed by Gradle team.
- [ ] Provide integration tests (under `<subproject>/src/integTest`) to verify changes from a user perspective.

                compileScala {
                    options.fork = true
                    options.forkOptions.executable = "${TextUtil.normaliseFileSeparators(otherJdk.javaExecutable.absolutePath)}"
                }
            """
        } else {
            buildFile << """
                compileScala {
                    options.fork = true

        buildFile << """
            plugins {
                id 'java'
            }
            ${dependsOnPidCapturingAnnotationProcessor}
            tasks.withType(JavaCompile).configureEach {
                options.fork = true
            }
        """
        file('src/main/java/Foo.java') << blockingFooClass
        def handler = blockingHttpServer.expectAndBlock("/block")

        when:
        startBuild("compileJava")