GOGCCFLAGS="-fPIC -arch arm64 -pthread -fno-caret-diagnostics -Qunused-arguments -fmessage-length=0 -fdebug-prefix-map=/var/folders/44/nbbyll_10jd0z8rj_qxm43740000gn/T/go-build2331607515=/tmp/go-build -gno-record-gcc-switches -fno-common"
      render: shell
    validations:
      required: true

  - type: textarea
    id: what-did-you-do
    attributes:
      label: "What did you do?"

			n += 4
		case SI4:
			n += 5
		case SI5:
			n += 6
		case SI6:
			n += 7
		case SI7:
			n += 8
		}
	}
	sink = n
}

// A simple random number generator used to make switches conditionally predictable.
type rng uint64

func newRNG() rng {
	return 1
}
func (r rng) next(predictable bool) rng {
	if predictable {
		return r + 1
	}

    )

    /**
     * Modifies the start script injecting -javaagent flags. The start script file is updated in-place by appending Java agent switches to 'DEFAULT_JVM_OPTS' variable declaration.
     */
    private
    fun File.injectAgentOptions(separator: String) {
        if (agentJarNames.isEmpty()) {
            return
        }

# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

# This script switches to the preferred version for specified module.
# Usage: `hack/pin-dependency.sh $MODULE $SHA-OR-TAG`.
# Example: `hack/pin-dependency.sh github.com/docker/docker 501cb131a7b7`.

set -o errexit
set -o nounset

== Choosing a log level

You can choose different log levels from the command line switches shown in <<#logLevelCommandLineOptions, Log level command-line options>>.

You can also configure the log level using <<build_environment.adoc#sec:gradle_configuration_properties,`gradle.properties`>>.

In <<#stacktraces,Stacktrace command-line options>> you can find the command line switches which affect stacktrace logging.

[[logLevelCommandLineOptions]]

env TESTGO_VERSION=go1.21
env TESTGO_VERSION_SWITCH=switch

# First, test 'go mod download' outside of a module.
#
# There is no go.mod file into which we can record the selected toolchain,
# so unfortunately these version switches won't be as reproducible as other
# go commands, but that's still preferable to failing entirely or downloading
# a module zip that we don't understand.

# GOTOOLCHAIN=auto should run the newer toolchain
env GOTOOLCHAIN=auto

	} else if b.gccSupportsFlag(compiler, "-fdebug-prefix-map=a=b") {
		defs = append(defs, "-fdebug-prefix-map="+b.WorkDir+"=/tmp/go-build")
	}
	if b.gccSupportsFlag(compiler, "-gno-record-gcc-switches") {
		defs = append(defs, "-gno-record-gcc-switches")
	}
	return b.Shell(a).run(p.Dir, p.ImportPath, nil, compiler, "-Wall", "-g",
		"-I", a.Objdir, "-I", inc, "-o", ofile, defs, "-c", cfile)
}

	m.Inter = inter
	m.Type = typ
	// The hash is used in type switches. However, compiler statically generates itab's
	// for all interface/type pairs used in switches (which are added to itabTable
	// in itabsinit). The dynamically-generated itab's never participate in type switches,
	// and thus the hash is irrelevant.
	// Note: m.Hash is _not_ the hash used for the runtime itabTable hash table.

//
// runtime.cgocall (below) calls entersyscall so as not to block
// other goroutines or the garbage collector, and then calls
// runtime.asmcgocall(_cgo_Cfunc_f, frame).
//
// runtime.asmcgocall (in asm_$GOARCH.s) switches to the m->g0 stack
// (assumed to be an operating system-allocated stack, so safe to run
// gcc-compiled code on) and calls _cgo_Cfunc_f(frame).
//
// _cgo_Cfunc_f invokes the actual C function f with arguments

If a developer continuously changes a single file, there is likely no need to rebuild all the other files in the project.

However, what happens when the same developer switches to a new branch created last week?
The files are rebuilt, even though the developer is building something that has been built before.

This is where a *build cache* is helpful.