}
        return this
    }

    /**
     * Expect a deprecation warning to appear when {@link #build()} or {@link #buildAndFail()} is called
     * for an old version of a third-party plugin. The assumption is that the deprecation has already
     * been fixed in a later version of the plugin, and thus no followup is needed.
     *
     * @param warning the text of the warning to match.
     */

 * of the published library.
 * The following disambiguation rule encodes this assumption for the case where a java library is published
 * with variants using Gradle module metadata. This will allow us to migrate to consuming the new module
 * metadata format by default without breaking a bunch of consumers that depend on this assumption,
 * declaring no preference for a particular variant.
 */
@ServiceScope(Scope.Global.class)

 * This attribute can be used by libraries to indicate that a certain variant is better suited for
 * a certain JVM environment. It does however NOT strictly require environments to match, as the
 * general assumption is that Java libraries can also run on environments they are not optimized for.
 *
 * @since 7.0
 */
public interface TargetJvmEnvironment extends Named {

 *
 * task someTask {} // assumption: produces a text file and declares it as output
 * def sourcedFromTask = resources.text.fromFile(someTask)
 *
 * def sourcedFromArchiveEntry =
 *   resources.text.fromArchiveEntry("path/to/archive.zip", "path/to/archive/entry.txt")
 *
 * configurations { someConfig } // assumption: contains a single archive
 * def sourcedFromConfiguration =

// topology, essentially DoSing the cluster.  In the future we will
// address this problem more fully by using quota and priority, but
// for now this admission controller provides a simple protection, on
// the assumption that the only legitimate use of hard pod
// anti-affinity is to exclude other pods from the same node.

namespace mlir::TF {

// Cluster structure captures all the operations that are assigned to same
// device and can form a legal strict cluster.
// Ops must follow same ordering in their parent block. We rely on this
// assumption to perform analysis.
struct Cluster {
  llvm::SetVector<Operation*> ops;
  std::string target;
};

// Builds the op clusters in the `block`. Ops are filtered by the function

public class ClassGeneratorSuffixRegistry {
    // Use Throwable to record the location where a suffix was registered, to allow diagnostics when a collision is found
    // This may have performance implications, however the assumption is that class generators are global scoped objects that are created once and in very small numbers
    private static final Map<String, Throwable> SUFFIXES = new ConcurrentHashMap<>();

    /**

//
// Note that these criteria are more restrictive than necessary:
//  - they will force a fixed order on operations that read from/write to
//    *different* variables
//  - they make the blanket assumption that any functions called cause or depend
//    on side effects (i.e., access resource variables.)
//
// By moving the logic to compile time, we will be able to do a finer-grained

// not, the same-scale op will not be quantized. This decision is based on the
// current assumption that the performance gain of the same-scale op itself
// could not beat the overhead of the quantize and dequantize routines need to
// be added around that op. When the assumption changes, this policy might
// change as well.
bool IsConnectedWithQuantizedCompsiteFunction(Operation* same_scale_op);

import javax.annotation.Nullable;
import java.io.IOException;
import java.util.Map;

/**
 * Defines the Gson serialization and deserialization for {@link ProblemDefinition} based on the assumption that they have exactly one implementation.
 */
public final class ProblemReportAdapterFactory implements TypeAdapterFactory {

    @Override
    @Nullable
    @SuppressWarnings("unchecked")