[mlir][IR][NFC] Move CastOpInterface helpers to mlir/Interfaces

[springerm]

Summary

These helpers should not be part of the IR build unit.

The interface is now implemented on builtin.unrealized_conversion_cast with an external model.

Also rename the CastOpInterfaces Bazel target name to CastInterfaces to be consistent with the CMake target name.

[springerm]

rebase

[springerm]

mlir/include/mlir/Interfaces/CastInterfaces.h

31

Note: This registers the unrealized_conversion_cast external model. Such functions are usually located in the build target of the respective dialect, but there is no separate build target for the "builtin" dialect.

[jpienaar]

Looks good, thanks!

mlir/include/mlir/Dialect/EmitC/IR/EmitC.h

 
 #ifndef MLIR_DIALECT_EMITC_IR_EMITC_H
 #define MLIR_DIALECT_EMITC_IR_EMITC_H
 
 #include "mlir/Bytecode/BytecodeOpInterface.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/Dialect.h"
+#include "mlir/Interfaces/CastInterfaces.h"
 #include "mlir/Interfaces/SideEffectInterfaces.h"
 
 #include "mlir/Dialect/EmitC/IR/EmitCDialect.h.inc"
 
 #define GET_ATTRDEF_CLASSES
 #include "mlir/Dialect/EmitC/IR/EmitCAttributes.h.inc"
 
 #define GET_TYPEDEF_CLASSES
 #include "mlir/Dialect/EmitC/IR/EmitCTypes.h.inc"
 
 #define GET_OP_CLASSES
 #include "mlir/Dialect/EmitC/IR/EmitC.h.inc"
 
 #endif // MLIR_DIALECT_EMITC_IR_EMITC_H

mlir/include/mlir/Dialect/Shape/IR/Shape.h

 #include "mlir/Bytecode/BytecodeOpInterface.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/FunctionInterfaces.h"
 #include "mlir/IR/OpDefinition.h"
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/IR/SymbolTable.h"
 #include "mlir/Interfaces/CallInterfaces.h"
+#include "mlir/Interfaces/CastInterfaces.h"
 #include "mlir/Interfaces/ControlFlowInterfaces.h"
 #include "mlir/Interfaces/InferTypeOpInterface.h"
 #include "mlir/Interfaces/SideEffectInterfaces.h"
 
 #define GET_TYPEDEF_CLASSES
 #include "mlir/Dialect/Shape/IR/ShapeOpsTypes.h.inc"
 
 namespace mlir {

mlir/include/mlir/IR/BuiltinOps.h

 
 #ifndef MLIR_IR_BUILTINOPS_H_
 #define MLIR_IR_BUILTINOPS_H_
 
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/IR/OwningOpRef.h"
 #include "mlir/IR/RegionKindInterface.h"
 #include "mlir/IR/SymbolTable.h"
-#include "mlir/Interfaces/CastInterfaces.h"
 #include "mlir/Interfaces/DataLayoutInterfaces.h"
 #include "mlir/Interfaces/SideEffectInterfaces.h"
 #include "llvm/Support/PointerLikeTypeTraits.h"
 
 //===----------------------------------------------------------------------===//
 // Dialect Operations
 //===----------------------------------------------------------------------===//
 

mlir/include/mlir/IR/BuiltinOps.td

def ModuleOp : Builtin_Op<"module", [
   let skipDefaultBuilders = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // UnrealizedConversionCastOp
 //===----------------------------------------------------------------------===//
 
 def UnrealizedConversionCastOp : Builtin_Op<"unrealized_conversion_cast", [
-    DeclareOpInterfaceMethods<CastOpInterface>, Pure
+    Pure
   ]> {
   let summary = "An unrealized conversion from one set of types to another";
   let description = [{
     An `unrealized_conversion_cast` operation represents an unrealized
     conversion from one set of types to another, that is used to enable the
     inter-mixing of different type systems. This operation should not be
     attributed any special representational or execution semantics, and is
     generally only intended to be used to satisfy the temporary intermixing of
def UnrealizedConversionCastOp : Builtin_Op<"unrealized_conversion_cast", [
   }];
 
   let arguments = (ins Variadic<AnyType>:$inputs);
   let results = (outs Variadic<AnyType>:$outputs);
   let assemblyFormat = [{
     ($inputs^ `:` type($inputs))? `to` type($outputs) attr-dict
   }];
   let hasFolder = 1;
+  let hasVerifier = 1;
 }
 
 #endif // BUILTIN_OPS

mlir/include/mlir/IR/OpDefinition.h

if (Dialect *dialect = name.getDialect())
       return dialect->getRegisteredInterfaceForOp<ConcreteType>(name);
     return nullptr;
   }
 
   /// Allow access to `getInterfaceFor`.
   friend InterfaceBase;
 };
 
-//===----------------------------------------------------------------------===//
-// CastOpInterface utilities
-//===----------------------------------------------------------------------===//
-
-// These functions are out-of-line implementations of the methods in
-// CastOpInterface, which avoids them being template instantiated/duplicated.
-namespace impl {
-/// Attempt to fold the given cast operation.
-LogicalResult foldCastInterfaceOp(Operation *op,
-                                  ArrayRef<Attribute> attrOperands,
-                                  SmallVectorImpl<OpFoldResult> &foldResults);
-/// Attempt to verify the given cast operation.
-LogicalResult verifyCastInterfaceOp(
-    Operation *op, function_ref<bool(TypeRange, TypeRange)> areCastCompatible);
-} // namespace impl
 } // namespace mlir
 
 namespace llvm {
 
 template <typename T>
 struct DenseMapInfo<T,
                     std::enable_if_t<std::is_base_of<mlir::OpState, T>::value &&
                                      !mlir::detail::IsInterface<T>::value>> {

mlir/include/mlir/InitAllDialects.h

 #include "mlir/Dialect/Tosa/IR/TosaOps.h"
 #include "mlir/Dialect/Transform/IR/TransformDialect.h"
 #include "mlir/Dialect/Transform/PDLExtension/PDLExtension.h"
 #include "mlir/Dialect/Vector/IR/VectorOps.h"
 #include "mlir/Dialect/Vector/TransformOps/VectorTransformOps.h"
 #include "mlir/Dialect/Vector/Transforms/BufferizableOpInterfaceImpl.h"
 #include "mlir/Dialect/X86Vector/X86VectorDialect.h"
 #include "mlir/IR/Dialect.h"
+#include "mlir/Interfaces/CastInterfaces.h"
 
 namespace mlir {
 
 /// Add all the MLIR dialects to the provided registry.
 inline void registerAllDialects(DialectRegistry &registry) {
   // clang-format off
   registry.insert<acc::OpenACCDialect,
                   affine::AffineDialect,
inline void registerAllDialects(DialectRegistry &registry) {
   vector::registerTransformDialectExtension(registry);
 
   // Register all external models.
   affine::registerValueBoundsOpInterfaceExternalModels(registry);
   arith::registerBufferizableOpInterfaceExternalModels(registry);
   arith::registerValueBoundsOpInterfaceExternalModels(registry);
   bufferization::func_ext::registerBufferizableOpInterfaceExternalModels(
       registry);
+  builtin::registerCastOpInterfaceExternalModels(registry);
   linalg::registerBufferizableOpInterfaceExternalModels(registry);
   linalg::registerTilingInterfaceExternalModels(registry);
   linalg::registerValueBoundsOpInterfaceExternalModels(registry);
   memref::registerBufferizableOpInterfaceExternalModels(registry);
   memref::registerRuntimeVerifiableOpInterfaceExternalModels(registry);
   memref::registerValueBoundsOpInterfaceExternalModels(registry);
   memref::registerMemorySlotExternalModels(registry);
   scf::registerBufferizableOpInterfaceExternalModels(registry);

mlir/include/mlir/Interfaces/CastInterfaces.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_INTERFACES_CASTINTERFACES_H
 #define MLIR_INTERFACES_CASTINTERFACES_H
 
 #include "mlir/IR/OpDefinition.h"
 
+namespace mlir {
+class DialectRegistry;
+
+namespace impl {
+/// Attempt to fold the given cast operation.
+LogicalResult foldCastInterfaceOp(Operation *op,
+                                  ArrayRef<Attribute> attrOperands,
+                                  SmallVectorImpl<OpFoldResult> &foldResults);
+
+/// Attempt to verify the given cast operation.
+LogicalResult verifyCastInterfaceOp(Operation *op);
+} // namespace impl
+
+namespace builtin {
+void registerCastOpInterfaceExternalModels(DialectRegistry &registry);
+} // namespace builtin
+} // namespace mlir
+
 /// Include the generated interface declarations.
 #include "mlir/Interfaces/CastInterfaces.h.inc"
 
 #endif // MLIR_INTERFACES_CASTINTERFACES_H

mlir/include/mlir/Interfaces/CastInterfaces.td

def CastOpInterface : OpInterface<"CastOpInterface"> {
   let extraTraitClassDeclaration = [{
     /// Attempt to fold the given cast operation.
     static LogicalResult foldTrait(Operation *op, ArrayRef<Attribute> operands,
                                    SmallVectorImpl<OpFoldResult> &results) {
       return impl::foldCastInterfaceOp(op, operands, results);
     }
   }];
   let verify = [{
-    return impl::verifyCastInterfaceOp($_op, ConcreteOp::areCastCompatible);
+    return impl::verifyCastInterfaceOp($_op);
   }];
 }
 
 #endif // MLIR_INTERFACES_CASTINTERFACES

mlir/lib/Dialect/Arith/IR/CMakeLists.txt

add_mlir_dialect_library(MLIRArithDialect
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/Arith
 
   DEPENDS
   MLIRArithOpsIncGen
   MLIRArithOpsInterfacesIncGen
 
   LINK_LIBS PUBLIC
+  MLIRCastInterfaces
   MLIRDialect
   MLIRInferIntRangeCommon
   MLIRInferIntRangeInterface
   MLIRInferTypeOpInterface
   MLIRIR
   )
 
 add_mlir_dialect_library(MLIRArithValueBoundsOpInterfaceImpl

mlir/lib/Dialect/Transform/IR/CMakeLists.txt

 add_mlir_dialect_library(MLIRTransformDialect
   MatchInterfaces.cpp
   TransformAttrs.cpp
   TransformDialect.cpp
   TransformInterfaces.cpp
   TransformOps.cpp
   TransformTypes.cpp
 
   DEPENDS
   MLIRMatchInterfacesIncGen
   MLIRTransformDialectIncGen
   MLIRTransformInterfacesIncGen
 
   LINK_LIBS PUBLIC
+  MLIRCastInterfaces
   MLIRIR
   MLIRParser
   MLIRRewrite
   MLIRSideEffectInterfaces
   MLIRTransforms
   MLIRTransformDialectUtils
   )

mlir/lib/IR/BuiltinDialect.cpp

if (!inputOp || inputOp.getResults() != operands ||
       inputOp.getOperandTypes() != results.getTypes())
     return failure();
 
   // If everything matches up, we can fold the passthrough.
   foldResults.append(inputOp->operand_begin(), inputOp->operand_end());
   return success();
 }
 
-bool UnrealizedConversionCastOp::areCastCompatible(TypeRange inputs,
-                                                   TypeRange outputs) {
-  // `UnrealizedConversionCastOp` is agnostic of the input/output types.
-  return true;
+LogicalResult UnrealizedConversionCastOp::verify() {
+  // TODO: The verifier of external models is not called. This op verifier can
+  // be removed when that is fixed.
+  if (getNumResults() == 0)
+    return emitOpError() << "expected at least one result for cast operation";
+  return success();
 }
 
 //===----------------------------------------------------------------------===//
 // TableGen'd op method definitions
 //===----------------------------------------------------------------------===//
 
 #define GET_OP_CLASSES
 #include "mlir/IR/BuiltinOps.cpp.inc"

mlir/lib/IR/Operation.cpp

 }
 
 bool OpTrait::hasElementwiseMappableTraits(Operation *op) {
   return op->hasTrait<Elementwise>() && op->hasTrait<Scalarizable>() &&
          op->hasTrait<Vectorizable>() && op->hasTrait<Tensorizable>();
 }
 
 //===----------------------------------------------------------------------===//
-// CastOpInterface
-//===----------------------------------------------------------------------===//
-
-/// Attempt to fold the given cast operation.
-LogicalResult
-impl::foldCastInterfaceOp(Operation *op, ArrayRef<Attribute> attrOperands,
-                          SmallVectorImpl<OpFoldResult> &foldResults) {
-  OperandRange operands = op->getOperands();
-  if (operands.empty())
-    return failure();
-  ResultRange results = op->getResults();
-
-  // Check for the case where the input and output types match 1-1.
-  if (operands.getTypes() == results.getTypes()) {
-    foldResults.append(operands.begin(), operands.end());
-    return success();
-  }
-
-  return failure();
-}
-
-/// Attempt to verify the given cast operation.
-LogicalResult impl::verifyCastInterfaceOp(
-    Operation *op, function_ref<bool(TypeRange, TypeRange)> areCastCompatible) {
-  auto resultTypes = op->getResultTypes();
-  if (resultTypes.empty())
-    return op->emitOpError()
-           << "expected at least one result for cast operation";
-
-  auto operandTypes = op->getOperandTypes();
-  if (!areCastCompatible(operandTypes, resultTypes)) {
-    InFlightDiagnostic diag = op->emitOpError("operand type");
-    if (operandTypes.empty())
-      diag << "s []";
-    else if (llvm::size(operandTypes) == 1)
-      diag << " " << *operandTypes.begin();
-    else
-      diag << "s " << operandTypes;
-    return diag << " and result type" << (resultTypes.size() == 1 ? " " : "s ")
-                << resultTypes << " are cast incompatible";
-  }
-
-  return success();
-}
-
-//===----------------------------------------------------------------------===//
 // Misc. utils
 //===----------------------------------------------------------------------===//
 
 /// Insert an operation, generated by `buildTerminatorOp`, at the end of the
 /// region's only block if it does not have a terminator already. If the region
 /// is empty, insert a new block first. `buildTerminatorOp` should return the
 /// terminator operation to insert.
 void impl::ensureRegionTerminator(

mlir/lib/Interfaces/CastInterfaces.cpp

 //===- CastInterfaces.cpp -------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Interfaces/CastInterfaces.h"
 
+#include "mlir/IR/BuiltinDialect.h"
+#include "mlir/IR/BuiltinOps.h"
+
 using namespace mlir;
 
 //===----------------------------------------------------------------------===//
+// Helper functions for CastOpInterface
+//===----------------------------------------------------------------------===//
+
+/// Attempt to fold the given cast operation.
+LogicalResult
+impl::foldCastInterfaceOp(Operation *op, ArrayRef<Attribute> attrOperands,
+                          SmallVectorImpl<OpFoldResult> &foldResults) {
+  OperandRange operands = op->getOperands();
+  if (operands.empty())
+    return failure();
+  ResultRange results = op->getResults();
+
+  // Check for the case where the input and output types match 1-1.
+  if (operands.getTypes() == results.getTypes()) {
+    foldResults.append(operands.begin(), operands.end());
+    return success();
+  }
+
+  return failure();
+}
+
+/// Attempt to verify the given cast operation.
+LogicalResult impl::verifyCastInterfaceOp(Operation *op) {
+  auto resultTypes = op->getResultTypes();
+  if (resultTypes.empty())
+    return op->emitOpError()
+           << "expected at least one result for cast operation";
+
+  auto operandTypes = op->getOperandTypes();
+  if (!cast<CastOpInterface>(op).areCastCompatible(operandTypes, resultTypes)) {
+    InFlightDiagnostic diag = op->emitOpError("operand type");
+    if (operandTypes.empty())
+      diag << "s []";
+    else if (llvm::size(operandTypes) == 1)
+      diag << " " << *operandTypes.begin();
+    else
+      diag << "s " << operandTypes;
+    return diag << " and result type" << (resultTypes.size() == 1 ? " " : "s ")
+                << resultTypes << " are cast incompatible";
+  }
+
+  return success();
+}
+
+//===----------------------------------------------------------------------===//
+// External model for BuiltinDialect ops
+//===----------------------------------------------------------------------===//
+
+namespace mlir {
+namespace {
+// This interface cannot be implemented directly on the op because the IR build
+// unit cannot depend on the Interfaces build unit.
+struct UnrealizedConversionCastOpInterface
+    : CastOpInterface::ExternalModel<UnrealizedConversionCastOpInterface,
+                                     UnrealizedConversionCastOp> {
+  static bool areCastCompatible(TypeRange inputs, TypeRange outputs) {
+    // `UnrealizedConversionCastOp` is agnostic of the input/output types.
+    return true;
+  }
+};
+} // namespace
+} // namespace mlir
+
+void mlir::builtin::registerCastOpInterfaceExternalModels(
+    DialectRegistry &registry) {
+  registry.addExtension(+[](MLIRContext *ctx, BuiltinDialect *dialect) {
+    UnrealizedConversionCastOp::attachInterface<
+        UnrealizedConversionCastOpInterface>(*ctx);
+  });
+}
+
+//===----------------------------------------------------------------------===//
 // Table-generated class definitions
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Interfaces/CastInterfaces.cpp.inc"

mlir/test/lib/Tools/PDLL/CMakeLists.txt

add_mlir_library(MLIRTestPDLL
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Tools/PDLL
 
   DEPENDS
   MLIRTestPDLLPatternsIncGen
 
   LINK_LIBS PUBLIC
+  MLIRCastInterfaces
   MLIRIR
   MLIRPass
   MLIRSupport
   MLIRTestDialect
   MLIRTransformUtils
   )
 
 target_include_directories(MLIRTestPDLL
   PRIVATE
   ${CMAKE_CURRENT_SOURCE_DIR}/../../Dialect/Test
   ${CMAKE_CURRENT_BINARY_DIR}/../../Dialect/Test
   )

mlir/test/lib/Tools/PDLL/TestPDLL.cpp

 //===- TestPDLByteCode.cpp - Test PDLL functionality ----------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/PDL/IR/PDL.h"
 #include "mlir/Dialect/PDLInterp/IR/PDLInterp.h"
+#include "mlir/Interfaces/CastInterfaces.h"
 #include "mlir/Parser/Parser.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Pass/PassManager.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 
 using namespace mlir;
 
 #include "TestPDLLPatterns.h.inc"

mlir/tools/mlir-opt/CMakeLists.txt

 endif()
 
 set(LIBS
   ${dialect_libs}
   ${conversion_libs}
   ${test_libs}
   MLIRAffineAnalysis
   MLIRAnalysis
+  MLIRCastInterfaces
   MLIRDialect
   MLIROptLib
   MLIRParser
   MLIRPass
   MLIRTransforms
   MLIRTransformUtils
   MLIRSupport
   MLIRIR

utils/bazel/llvm-project-overlay/mlir/BUILD.bazel

srcs = glob([
         "lib/IR/*.cpp",
         "lib/IR/*.h",
     ]),
     hdrs = glob([
         "include/mlir/IR/*.h",
     ]) + [
         "include/mlir/Bytecode/BytecodeImplementation.h",
         "include/mlir/Interfaces/CallInterfaces.h",
-        "include/mlir/Interfaces/CastInterfaces.h",
         "include/mlir/Interfaces/DataLayoutInterfaces.h",
         "include/mlir/Interfaces/FoldInterfaces.h",
         "include/mlir/Interfaces/SideEffectInterfaces.h",
     ],
     includes = ["include"],
     deps = [
         ":BuiltinAttributeInterfacesIncGen",
         ":BuiltinAttributesIncGen",
         ":BuiltinDialectBytecodeGen",
         ":BuiltinDialectIncGen",
         ":BuiltinLocationAttributesIncGen",
         ":BuiltinOpsIncGen",
         ":BuiltinTypeInterfacesIncGen",
         ":BuiltinTypesIncGen",
         ":CallOpInterfacesIncGen",
-        ":CastOpInterfacesIncGen",
         ":DataLayoutInterfacesIncGen",
         ":FunctionInterfacesIncGen",
         ":InferTypeOpInterfaceIncGen",
         ":OpAsmInterfaceIncGen",
         ":RegionKindInterfaceIncGen",
         ":SideEffectInterfacesIncGen",
         ":Support",
         ":SymbolInterfacesIncGen",
srcs = glob([
         "lib/Dialect/EmitC/IR/*.cpp",
     ]),
     hdrs = glob([
         "include/mlir/Dialect/EmitC/IR/*.h",
     ]),
     includes = ["include"],
     deps = [
         ":BytecodeOpInterface",
+        ":CastInterfaces",
         ":EmitCAttributesIncGen",
         ":EmitCOpsIncGen",
         ":IR",
         ":SideEffectInterfaces",
         "//llvm:Support",
     ],
 )
 

 cc_library(
     name = "ShapeDialect",
     srcs = glob(["lib/Dialect/Shape/IR/*.cpp"]),
     hdrs = ["include/mlir/Dialect/Shape/IR/Shape.h"],
     includes = ["include"],
     deps = [
         ":ArithDialect",
         ":BytecodeOpInterface",
+        ":CastInterfaces",
         ":ControlFlowInterfaces",
         ":Dialect",
         ":FuncDialect",
         ":IR",
         ":InferTypeOpInterface",
         ":MLIRShapeCanonicalizationIncGen",
         ":ShapeOpsIncGen",
         ":SideEffectInterfaces",
hdrs = glob([
         "include/mlir/Dialect/Func/IR/*.h",
         "include/mlir/Dialect/Func/Utils/*.h",
     ]) + ["include/mlir/Transforms/InliningUtils.h"],
     includes = ["include"],
     deps = [
         ":ArithDialect",
         ":BytecodeOpInterface",
         ":CallOpInterfaces",
-        ":CastOpInterfaces",
+        ":CastInterfaces",
         ":CommonFolders",
         ":ControlFlowDialect",
         ":ControlFlowInterfaces",
         ":FuncIncGen",
         ":IR",
         ":InferTypeOpInterface",
         ":SideEffectInterfaces",
         ":Support",
hdrs = [
         "include/mlir/Dialect/Tensor/IR/ValueBoundsOpInterfaceImpl.h",
     ],
     includes = ["include"],
     deps = [
         ":AffineDialect",
         ":ArithDialect",
         ":ArithUtils",
         ":BytecodeOpInterface",
-        ":CastOpInterfaces",
+        ":CastInterfaces",
         ":ComplexDialect",
         ":ControlFlowInterfaces",
         ":DestinationStyleOpInterface",
         ":DialectUtils",
         ":IR",
         ":InferTypeOpInterface",
         ":ParallelCombiningOpInterface",
         ":ShapedOpInterfaces",
cc_library(
     deps = [
         ":CallOpInterfacesIncGen",
         ":IR",
         "//llvm:Support",
     ],
 )
 
 gentbl_cc_library(
-    name = "CastOpInterfacesIncGen",
+    name = "CastInterfacesIncGen",
     strip_include_prefix = "include",
     tbl_outs = [
         (
             ["-gen-op-interface-decls"],
             "include/mlir/Interfaces/CastInterfaces.h.inc",
         ),
         (
             ["-gen-op-interface-defs"],
             "include/mlir/Interfaces/CastInterfaces.cpp.inc",
         ),
     ],
     tblgen = ":mlir-tblgen",
     td_file = "include/mlir/Interfaces/CastInterfaces.td",
     deps = [":CastInterfacesTdFiles"],
 )
 
 cc_library(
-    name = "CastOpInterfaces",
+    name = "CastInterfaces",
     srcs = ["lib/Interfaces/CastInterfaces.cpp"],
     hdrs = ["include/mlir/Interfaces/CastInterfaces.h"],
     includes = ["include"],
     deps = [
-        ":CastOpInterfacesIncGen",
+        ":CastInterfacesIncGen",
         ":IR",
         "//llvm:Support",
     ],
 )
 
 gentbl_cc_library(
     name = "ControlFlowInterfacesIncGen",
     strip_include_prefix = "include",
deps = [
         ":ArmSVETransforms",
         ":AsyncDialect",
         ":AsyncPassIncGen",
         ":AsyncToLLVM",
         ":AsyncTransforms",
         ":BufferizationDialect",
         ":BufferizationTransformOps",
         ":BufferizationTransforms",
+        ":CastInterfaces",
         ":ComplexDialect",
         ":ComplexToLLVM",
         ":ComplexToLibm",
         ":ComplexToSPIRV",
         ":ControlFlowDialect",
         ":ConversionPasses",
         ":DLTIDialect",
         ":EmitCDialect",

 
 cc_library(
     name = "IndexDialect",
     srcs = glob(["lib/Dialect/Index/IR/*.cpp"]),
     hdrs = glob(["include/mlir/Dialect/Index/IR/*.h"]),
     includes = ["include"],
     deps = [
         ":BytecodeOpInterface",
+        ":CastInterfaces",
         ":IR",
         ":IndexEnumsIncGen",
         ":IndexOpsIncGen",
         ":InferIntRangeCommon",
         ":InferIntRangeInterface",
         ":InferTypeOpInterface",
         "//llvm:Support",
     ],

 cc_library(
     name = "TransformDialect",
     srcs = glob(["lib/Dialect/Transform/IR/*.cpp"]),
     hdrs = glob(["include/mlir/Dialect/Transform/IR/*.h"]),
     deps = [
         ":Analysis",
         ":BytecodeOpInterface",
         ":CallOpInterfaces",
+        ":CastInterfaces",
         ":ControlFlowInterfaces",
         ":IR",
         ":Rewrite",
         ":SideEffectInterfaces",
         ":Support",
         ":TransformDialectEnumsIncGen",
         ":TransformDialectIncGen",
         ":TransformDialectInterfacesIncGen",
cc_library(
     ],
     includes = ["include"],
     deps = [
         ":ArithBaseIncGen",
         ":ArithCanonicalizationIncGen",
         ":ArithOpsIncGen",
         ":ArithOpsInterfacesIncGen",
         ":BytecodeOpInterface",
+        ":CastInterfaces",
         ":CommonFolders",
         ":IR",
         ":InferIntRangeCommon",
         ":InferIntRangeInterface",
         ":InferTypeOpInterface",
         ":SideEffectInterfaces",
         ":VectorInterfaces",
         "//llvm:Support",
hdrs = [
         "include/mlir/Dialect/MemRef/IR/ValueBoundsOpInterfaceImpl.h",
         "include/mlir/Dialect/MemRef/Utils/MemRefUtils.h",
     ],
     includes = ["include"],
     deps = [
         ":ArithDialect",
         ":ArithUtils",
         ":BytecodeOpInterface",
+        ":CastInterfaces",
         ":ComplexDialect",
         ":ControlFlowInterfaces",
         ":CopyOpInterface",
         ":DialectUtils",
         ":IR",
         ":InferTypeOpInterface",
         ":MemRefBaseIncGen",
         ":MemRefOpsIncGen",

utils/bazel/llvm-project-overlay/mlir/examples/toy/Ch4/BUILD.bazel

cc_binary(
     ] + glob(["include/toy/*.h"]),
     includes = ["include/"],
     deps = [
         ":ToyCombineIncGen",
         ":ToyInterfacesIncGen",
         ":ToyOpsIncGen",
         "//llvm:Support",
         "//mlir:Analysis",
-        "//mlir:CastOpInterfaces",
+        "//mlir:CastInterfaces",
         "//mlir:IR",
         "//mlir:Parser",
         "//mlir:Pass",
         "//mlir:SideEffectInterfaces",
         "//mlir:Support",
         "//mlir:TransformUtils",
         "//mlir:Transforms",
     ],
 )

utils/bazel/llvm-project-overlay/mlir/examples/toy/Ch5/BUILD.bazel

deps = [
         ":ToyInterfacesIncGen",
         ":ToyOpsIncGen",
         "//llvm:Support",
         "//mlir:AffineDialect",
         "//mlir:AffineTransforms",
         "//mlir:AllPassesAndDialects",
         "//mlir:Analysis",
         "//mlir:ArithDialect",
-        "//mlir:CastOpInterfaces",
+        "//mlir:CastInterfaces",
         "//mlir:FuncDialect",
         "//mlir:IR",
         "//mlir:MemRefDialect",
         "//mlir:Parser",
         "//mlir:Pass",
         "//mlir:SideEffectInterfaces",
         "//mlir:Support",
         "//mlir:TransformUtils",
         "//mlir:Transforms",
     ],
 )

utils/bazel/llvm-project-overlay/mlir/examples/toy/Ch6/BUILD.bazel

deps = [
         "//mlir:AffineDialect",
         "//mlir:AffineToStandard",
         "//mlir:AffineTransforms",
         "//mlir:AllPassesAndDialects",
         "//mlir:Analysis",
         "//mlir:ArithDialect",
         "//mlir:ArithToLLVM",
         "//mlir:BuiltinToLLVMIRTranslation",
-        "//mlir:CastOpInterfaces",
+        "//mlir:CastInterfaces",
         "//mlir:ControlFlowToLLVM",
         "//mlir:ExecutionEngine",
         "//mlir:ExecutionEngineUtils",
         "//mlir:FuncDialect",
         "//mlir:FuncToLLVM",
         "//mlir:IR",
         "//mlir:LLVMCommonConversion",
         "//mlir:LLVMDialect",

utils/bazel/llvm-project-overlay/mlir/examples/toy/Ch7/BUILD.bazel

deps = [
         "//mlir:AffineDialect",
         "//mlir:AffineToStandard",
         "//mlir:AffineTransforms",
         "//mlir:AllPassesAndDialects",
         "//mlir:Analysis",
         "//mlir:ArithDialect",
         "//mlir:ArithToLLVM",
         "//mlir:BuiltinToLLVMIRTranslation",
-        "//mlir:CastOpInterfaces",
+        "//mlir:CastInterfaces",
         "//mlir:ControlFlowToLLVM",
         "//mlir:ExecutionEngine",
         "//mlir:ExecutionEngineUtils",
         "//mlir:FuncDialect",
         "//mlir:FuncToLLVM",
         "//mlir:IR",
         "//mlir:LLVMCommonConversion",
         "//mlir:LLVMDialect",

utils/bazel/llvm-project-overlay/mlir/test/BUILD.bazel

 
 cc_library(
     name = "TestPDLL",
     srcs = ["lib/Tools/PDLL/TestPDLL.cpp"],
     includes = ["lib/Tools/PDLL"],
     deps = [
         ":TestDialect",
         ":TestPDLLPatternsIncGen",
+        "//mlir:CastInterfaces",
         "//mlir:IR",
         "//mlir:PDLDialect",
         "//mlir:PDLInterpDialect",
         "//mlir:Parser",
         "//mlir:Pass",
         "//mlir:Support",
         "//mlir:TransformUtils",
     ],
 )