* The [entryPoint] is stored and checked in [leaveDynamicCall] later.
     */
    fun enterDynamicCall(entryPoint: Any)

    /**
     * End tracking a dynamic call.
     * The [entryPoint] should match the one passed to [enterDynamicCall].
     */
    fun leaveDynamicCall(entryPoint: Any)

    /**

    /**
     * Checks if the command-line argument looks like JVM switch that applies gradle instrumentation agent.
     * If the returned value is {@code true} then the argument is definitely a java agent application.
     * However, only the name of the agent jar is checked, so it is possible to have false positives and false negatives.
     *
     * @param jvmArg the argument to check

import org.jetbrains.kotlin.analysis.api.types.KaTypeNullability
import org.jetbrains.kotlin.analysis.api.types.KaTypeProjection
import org.jetbrains.kotlin.analysis.api.types.KaUsualClassType
import org.jetbrains.kotlin.types.checker.NewCapturedType

internal class KaFe10NewCapturedType(
    override val fe10Type: NewCapturedType,
    override val analysisContext: Fe10AnalysisContext
) : KaCapturedType(), KaFe10Type {

        //  It is also possible to have the agent attached at runtime, without the flag, so flag checking is preferred.
        jvmOptions.setAllJvmArgs(arguments.stream().filter(arg -> !AgentUtils.isGradleInstrumentationAgentSwitch(arg)).collect(Collectors.toList()));
        return jvmOptions;
    }

    /**
     * Returns a new tree starting at this node, filtering the children.
     * Note that this node will not be filtered and only the children
     * and its descendant will be checked.
     *
     * @param filter the filter to apply
     * @return a new filtered graph
     */
    @Nonnull
    Node filter(@Nonnull Predicate<Node> filter);

    /**

import org.gradle.api.UncheckedIOException;

import javax.annotation.Nullable;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.util.concurrent.Callable;

/**
 * Wraps a checked exception. Carries no other context.
 */
public final class UncheckedException extends RuntimeException {
    private UncheckedException(Throwable cause) {
        super(cause);
    }

		ErrorLog:  log.New(&httpServerErrorLogWriter{}, "", 0),
		Handler:   s.httpsMux,
		TLSConfig: tlsConfig,
	}

	// register istiodReadyHandler on the httpsMux so that readiness can also be checked remotely
	s.httpsMux.HandleFunc("/ready", s.istiodReadyHandler)

 * <p>
 * It is possible to have an agent in the classpath without actually applying it, so checking for the availability of the class is not enough.
 */
class AgentControl {
    private static final String INSTRUMENTATION_AGENT_CLASS_NAME = "org.gradle.instrumentation.agent.Agent";

    private AgentControl() {}

    /**
     * Checks if the instrumentation agent class is applied to the current JVM.
     *

absl::Status MiniDynamicBuffer::AddString(const char* str, size_t len) {
  // If `data_.size() + len` is greater than `SIZE_MAX` then the left hand side
  // will overflow to something less than max_length_. After checking `len <=
  // max_length_` we can use this subtraction to check for overflow.
  if (len > max_length_ || data_.size() >= max_length_ - len)
    return absl::ResourceExhaustedError("Buffer overflow");
  data_.resize(data_.size() + len);

func (p *Process) pidWait() (*ProcessState, error) {
	// TODO(go.dev/issue/67642): When there are concurrent Wait calls, one
	// may wait on the wrong process if the PID is reused after the
	// completes its wait.
	//
	// Checking for statusDone here would not be a complete fix, as the PID
	// could still be waited on and reused prior to blockUntilWaitable.
	switch p.pidStatus() {
	case statusReleased:
		return nil, syscall.EINVAL
	}