import org.gradle.cache.Cache;
import org.gradle.internal.hash.HashCode;

/**
 * The build scoped compile caches.
 *
 * NOTE: This class cannot be renamed because it used to leak onto the public API
 * and some community plugins still depend on it in their byte code.
 */
public interface GeneralCompileCaches {
    Cache<HashCode, ClassSetAnalysisData> getClassSetAnalysisCache();

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.platform.base;

import org.gradle.api.Incubating;

/**
 * A dependency onto a specific binary of a library published by a project.
 */
@Incubating
public interface LibraryBinaryDependencySpec extends DependencySpec {

    /**

 * limitations under the License.
 */

package org.gradle.platform.base;

import org.gradle.api.Incubating;

import javax.annotation.Nullable;

/**
 * A dependency onto a module.
 */
@Incubating
public interface ModuleDependencySpec extends DependencySpec {

    /**
     * The group of the module this dependency specification refers to.
     *
     * @return the module group name

 * limitations under the License.
 */

package org.gradle.platform.base;

import org.gradle.api.Incubating;

import javax.annotation.Nullable;

/**
 * A dependency onto a library published by a project.
 */
@Incubating
public interface ProjectDependencySpec extends DependencySpec {

    /**
     * Returns the project path of the project this dependency refers to.
     *

     */
    static final int CROSS_PROJECT_CLASS_DEPENDENCY_LEVEL = 2
    /**
     * How many sibling classes are put onto one 'level' in the class dependency tree
     */
    static final int CLASSES_ON_LEVEL = 3
    /**
     * How many sibling project are put onto one 'level' in the project dependency tree
     */
    static final int PROJECTS_ON_LEVEL = 3

 *
 * It is important that the cleanup only occurs when nobody uses the classloader anymore, which means when no consumer retains a strong reference onto a {@link CachedClassLoader}. If we directly put
 * the cached classloader as a value of the map, then it cannot be reclaimed, and will never be cleaned up. If we just use a SoftReference to the cached class loader, then the reference will be

    // We can only clone the constant op or const->dequantize combo. The latter
    // case is useful for float16 quantization. Since all ops have been
    // legalized to tflite ops, so we only care about ConstOp or QConstOp or
    // mlir constant op.
    Operation* input_op = operand.getDefiningOp();
    if (input_op == nullptr) return failure();

    Attribute attr;
    if (matchPattern(input_op, m_Constant(&attr))) {

	default:
		if n.Op() == ir.ONAME {
			n := n.(*ir.Name)
			base.Errorf("%v is not a top level statement", n.Sym())
		} else {
			base.Errorf("%v is not a top level statement", n.Op())
		}
		ir.Dump("nottop", n)
		return n

	case ir.OAS,
		ir.OASOP,
		ir.OAS2,
		ir.OAS2DOTTYPE,
		ir.OAS2RECV,
		ir.OAS2FUNC,
		ir.OAS2MAPR,
		ir.OCLEAR,
		ir.OCLOSE,
		ir.OCOPY,
		ir.OCALLINTER,
		ir.OCALL,

// Checks if the data format is "NDHWC".
def IsDataFormatNDHWC : ConstantAttr<TF_ConvnetDataFormatAttr, "\"NDHWC\"">;

// Checks if the op is constant op.
def IsConstTensor :  Constraint<CPred<"dyn_cast_or_null<TF::ConstOp>($0.getDefiningOp())">>;

// Checks if the element value has a float type.
def IsFloatElementsAttr : ElementsAttrBase<
  CPred<"$_self.isa<ElementsAttr>() && "

}

TEST_F(LegalizationOpConfigTest, ChecksDynamicPadderOps) {
  EXPECT_TRUE(
      IsDynamicPadderOp(TypeID::get<TF::XlaSetDynamicDimensionSizeOp>()));
  EXPECT_FALSE(IsDynamicPadderOp(TypeID::get<TF::ConstOp>()));
}

// This test is kind of odd. We go through all the Tensorflow types and check
// whether they are legalized with MLIR, TF2XLA, or both. Ideally the sets are