import com.google.common.annotations.GwtCompatible;
import com.google.errorprone.annotations.CanIgnoreReturnValue;
import javax.annotation.CheckForNull;
import org.checkerframework.checker.nullness.qual.Nullable;

/**
 * Static convenience methods that help a method or constructor check whether it was invoked
 * correctly (that is, whether its <i>preconditions</i> were met).
 *

import org.gradle.test.preconditions.UnitTestPreconditions
import org.gradle.util.Path
import org.gradle.util.internal.ToBeImplemented
import spock.lang.Issue

import javax.annotation.Nullable
import java.util.function.Consumer

import static org.gradle.internal.snapshot.CaseSensitivity.CASE_SENSITIVE

class DefaultExecutionPlanParallelTest extends AbstractExecutionPlanSpec {

        "multipleOf": { "type": "number", "format": "double" },
        "not": {
          "$ref": "#/definitions/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaProps"
        },
        "nullable": { "type": "boolean" },
        "oneOf": {
          "type": "array",
          "items": {
            "default": {},

      return getArgsMutable();
    }

    // Returns the callee of this operation.
    CallInterfaceCallable getCallableForCallee() { return getFAttr(); }
    // Sets the callee from the callable
    void setCalleeFromCallable(::mlir::CallInterfaceCallable callee);

    // Returns the resolved callee function of this operation.
    // Prefer passing in SymbolTableCollection to reduce lookup costs by

  // Adds the TPUReplicateMetatdataOp and TPUCompilationResultOp ops to the
  // function called by the provided 'caller'.
  mlir::CallInterfaceCallable callable = caller.getCallableForCallee();
  mlir::SymbolRefAttr sym = callable.dyn_cast<mlir::SymbolRefAttr>();
  auto func = llvm::dyn_cast<mlir::func::FuncOp>(
      mlir::SymbolTable::lookupNearestSymbolFrom(caller, sym));
  OpBuilder builder(func.getBody());

				"has(self.setNullableStr) && self.setNullableStr == 'v3'":   4,
				// We treat null fields as absent fields, not as null valued fields.
				// Note that this is different than how we treat nullable list items or map values.
				"type(self.setNullableStr) != null_type": 4,

				// a field that is set to null is treated the same as an absent field in validation rules
				"!has(self.setToNullNullableStr)": 2,
			},

					Type: "object",
				},
				AdditionalProperties: &schema.StructuralOrBool{
					Bool: true,
					Structural: &schema.Structural{
						Generic: schema.Generic{
							Type:     "boolean",
							Nullable: false,
						},
					},
				},
				ValidationExtensions: schema.ValidationExtensions{
					XValidations: apiextensions.ValidationRules{
						{
							Rule:    "size(self) > 0",

This includes instances of `Callable`, such as closures, allowing for lazy evaluation of the property values.
Be aware that the types `FileCollection` and `FileTree` are ``Iterable<File>``s.

                    is FirResolvedNamedReference -> when (calleeReference.resolvedSymbol) {
                        // `calleeReference.resolvedSymbol` isn't guaranteed to be callable. For example, function type parameters used in
                        // expression positions (e.g. `T` in `println(T)`) are parsed as `KtSimpleNameExpression` and built into

        return importAffectsUsagesOfClassesWithSameName(classToImport, importAllInParent)
    }

    /**
     * Same as above, but for more general callable symbols.
     *
     * Currently only checks constructor calls, assuming `true` for everything else.
     */