protected IncrementalChangesContext(IncrementalChangesContext parent) {
        this(parent, parent.getRebuildReasons(), parent.getChanges().orElse(null));
    }

    /**
     * Returns the reasons to re-execute the work, empty if there's no reason to re-execute.
     */
    public ImmutableList<String> getRebuildReasons() {
        return rebuildReasons;
    }

    /**

    TypeAccessibility.Accessible(type)


internal
fun inaccessible(type: SchemaType, vararg reasons: InaccessibilityReason) =
    inaccessible(type, reasons.toList())


internal
fun inaccessible(type: SchemaType, reasons: List<InaccessibilityReason>): TypeAccessibility =
    TypeAccessibility.Inaccessible(type, reasons)


private
fun classLoaderScopeOf(scriptTarget: Any) = when (scriptTarget) {

    /**
     * Returns the selector that was attempted to be resolved. This may not be the same as the requested component.
     */
    ComponentSelector getAttempted();

    /**
     * Returns the reasons why the failed selector was attempted.
     */
    ComponentSelectionReason getAttemptedReason();

    /**
     * The failure that occurred.
     */
    Throwable getFailure();

    | org.gradle.dependency.bundling |          | external     |
    | org.gradle.jvm.environment     |          | standard-jvm |
    | org.gradle.jvm.version         |          | 11           |
   Selection reasons:
      - By conflict resolution: On capability log4j:log4j use slf4j in place of log4j

log4j:log4j:1.2.16 -> org.slf4j:log4j-over-slf4j:1.7.10
\--- org.apache.zookeeper:zookeeper:3.4.9
     \--- compileClasspath

            return cachingState
                .whenDisabled()
                .map(CachingState.Disabled::getDisabledReasons)
                .map(reasons -> reasons.get(0));
        }
    }

package org.gradle.tooling;

/**
 * Thrown when the client is trying to acquire a model that is unknown to the Tooling API.
 * <p>
 * The exception extends {@link UnsupportedVersionException} only for backwards compatibility reasons.
 *
 * @since 1.0-milestone-8
 */
public class UnknownModelException extends UnsupportedVersionException {

    public UnknownModelException(String message) {
        super(message);
    }

// another group ("example"). This happens if a type is moved to a different
// group. It's not recommended to move types across groups, though Kubernetes
// have a few cases due to historical reasons. This package is for tests.

#include "tensorflow/core/common_runtime/optimization_registry.h"

namespace tensorflow {

// Clones or moves nodes from within a cluster to outside the cluster if
// profitable.  There are two reasons why we do this:
//
//  - Reducing device-to-host copies.
//  - Reducing the number of XLA recompilations.
class PartiallyDeclusterPass : public GraphOptimizationPass {
 public:

		return failureReasons, nil
	}
	// InsufficientResourceError is not a reason to reject a critical pod.
	// Instead of rejecting, we free up resources to admit it, if no other reasons for rejection exist.
	nonResourceReasons := []lifecycle.PredicateFailureReason{}
	resourceReasons := []*admissionRequirement{}
	for _, reason := range failureReasons {
		if r, ok := reason.(*lifecycle.InsufficientResourceError); ok {

	model.ClusterUpdate:   pushTriggers.With(typeTag.Value(string(model.ClusterUpdate))),
}

func recordPushTriggers(reasons model.ReasonStats) {
	for r, cnt := range reasons {
		t, f := triggerMetric[r]
		if f {
			t.RecordInt(int64(cnt))
		} else {
			pushTriggers.With(typeTag.Value(string(r))).Increment()
		}
	}
}