[mlir][NFC] Move the operation interfaces out of Analysis/ and into a new Interfaces/ directory.

[rriddle]

Summary

The interfaces themselves aren't really analyses, they may be used by analyses though. Having them in Analysis can also create cyclic dependencies if an analysis depends on a specific dialect, that also provides one of the interfaces.

[rriddle]

Fix formatting

mlir/docs/ShapeInference.md

 cases (e.g., matrix multiplication of `[a,b]` and `[c,d]` is only defined if `b
 == c`).
 
 Instead of specifying an additional mechanism to specify a shape transfer
 function, the reference implementation of the operation will be used to derive
 the shape function. The reference implementation is general and can support the
 arbitrary computations needed to specify output shapes.
 
-[InferTypeOpInterface]: https://github.com/llvm/llvm-project/tree/master/mlir/include/mlir/Analysis/InferTypeOpInterface.td
+[InferTypeOpInterface]: https://github.com/llvm/llvm-project/tree/master/mlir/include/mlir/Interfaces/InferTypeOpInterface.td
 [ShapedType]: https://github.com/llvm/llvm-project/tree/master/mlir/include/mlir/IR/StandardTypes.h

mlir/docs/Tutorials/Toy/Ch-4.md

 interfaces provide a more refined granularity of information that is specific
 and core to a single operation. The interface that we will be adding here is the
 `CallOpInterface`.
 
 To add this interface we just need to include the definition into our operation
 specification file (`Ops.td`):
 
 ```tablegen
-include "mlir/Analysis/CallInterfaces.td"
+include "mlir/Interfaces/CallInterfaces.td"
 ```
 
 and add it to the traits list of `GenericCallOp`:
 
 ```tablegen
 def GenericCallOp : Toy_Op<"generic_call",
     [DeclareOpInterfaceMethods<CallOpInterface>]> {
   ...

mlir/examples/toy/Ch4/CMakeLists.txt

add_toy_chapter(toyc-ch4
   mlir/Dialect.cpp
   mlir/ShapeInferencePass.cpp
   mlir/ToyCombine.cpp
 
   DEPENDS
   ToyCh4OpsIncGen
   ToyCh4ShapeInferenceInterfaceIncGen
   ToyCh4CombineIncGen
-  MLIRCallOpInterfacesIncGen
   )
 
 include_directories(include/)
 include_directories(${CMAKE_CURRENT_BINARY_DIR})
 include_directories(${CMAKE_CURRENT_BINARY_DIR}/include/)
 target_link_libraries(toyc-ch4
   PRIVATE
     MLIRAnalysis
+    MLIRCallInterfaces
     MLIRIR
     MLIRParser
     MLIRPass
     MLIRTransforms)
 

mlir/examples/toy/Ch4/include/toy/Ops.td

 //===- Ops.td - Toy dialect operation definitions ----------*- tablegen -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Defines the operations of the Toy dialect.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef TOY_OPS
 #define TOY_OPS
 
-include "mlir/Analysis/CallInterfaces.td"
+include "mlir/Interfaces/CallInterfaces.td"
 include "toy/ShapeInferenceInterface.td"
 
 // Provide a definition of the 'toy' dialect in the ODS framework so that we
 // can define our operations.
 def Toy_Dialect : Dialect {
   let name = "toy";
   let cppNamespace = "toy";
 }

mlir/examples/toy/Ch5/CMakeLists.txt

add_toy_chapter(toyc-ch5
   mlir/LowerToAffineLoops.cpp
   mlir/ShapeInferencePass.cpp
   mlir/ToyCombine.cpp
 
   DEPENDS
   ToyCh5ShapeInferenceInterfaceIncGen
   ToyCh5OpsIncGen
   ToyCh5CombineIncGen
-  MLIRCallOpInterfacesIncGen
   )
 
 include_directories(include/)
 include_directories(${CMAKE_CURRENT_BINARY_DIR})
 include_directories(${CMAKE_CURRENT_BINARY_DIR}/include/)
 get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS)
 target_link_libraries(toyc-ch5
   PRIVATE
     ${dialect_libs}
     MLIRAnalysis
+    MLIRCallInterfaces
     MLIRIR
     MLIRParser
     MLIRPass
     MLIRSupport
     MLIRTransforms)

mlir/examples/toy/Ch5/include/toy/Ops.td

 //===- Ops.td - Toy dialect operation definitions ----------*- tablegen -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Defines the operations of the Toy dialect.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef TOY_OPS
 #define TOY_OPS
 
-include "mlir/Analysis/CallInterfaces.td"
+include "mlir/Interfaces/CallInterfaces.td"
 include "toy/ShapeInferenceInterface.td"
 
 // Provide a definition of the 'toy' dialect in the ODS framework so that we
 // can define our operations.
 def Toy_Dialect : Dialect {
   let name = "toy";
   let cppNamespace = "toy";
 }

mlir/examples/toy/Ch6/CMakeLists.txt

add_toy_chapter(toyc-ch6
   mlir/LowerToLLVM.cpp
   mlir/ShapeInferencePass.cpp
   mlir/ToyCombine.cpp
 
   DEPENDS
   ToyCh6ShapeInferenceInterfaceIncGen
   ToyCh6OpsIncGen
   ToyCh6CombineIncGen
-  MLIRCallOpInterfacesIncGen
   )
 
 include_directories(include/)
 include_directories(${CMAKE_CURRENT_BINARY_DIR})
 include_directories(${CMAKE_CURRENT_BINARY_DIR}/include/)
 get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS)
 get_property(conversion_libs GLOBAL PROPERTY MLIR_CONVERSION_LIBS)
 target_link_libraries(toyc-ch6
   PRIVATE
     ${dialect_libs}
     ${conversion_libs}
     MLIRAnalysis
+    MLIRCallInterfaces
     MLIRExecutionEngine
     MLIRIR
     MLIRLLVMIR
     MLIRParser
     MLIRPass
     MLIRSupport
     MLIRTargetLLVMIR
     MLIRTransforms
     )

mlir/examples/toy/Ch6/include/toy/Ops.td

 //===- Ops.td - Toy dialect operation definitions ----------*- tablegen -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Defines the operations of the Toy dialect.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef TOY_OPS
 #define TOY_OPS
 
-include "mlir/Analysis/CallInterfaces.td"
+include "mlir/Interfaces/CallInterfaces.td"
 include "toy/ShapeInferenceInterface.td"
 
 // Provide a definition of the 'toy' dialect in the ODS framework so that we
 // can define our operations.
 def Toy_Dialect : Dialect {
   let name = "toy";
   let cppNamespace = "toy";
 }

mlir/examples/toy/Ch7/CMakeLists.txt

add_toy_chapter(toyc-ch7
   mlir/LowerToLLVM.cpp
   mlir/ShapeInferencePass.cpp
   mlir/ToyCombine.cpp
 
   DEPENDS
   ToyCh7ShapeInferenceInterfaceIncGen
   ToyCh7OpsIncGen
   ToyCh7CombineIncGen
-  MLIRCallOpInterfacesIncGen
   )
 
 include_directories(include/)
 include_directories(${CMAKE_CURRENT_BINARY_DIR})
 include_directories(${CMAKE_CURRENT_BINARY_DIR}/include/)
 get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS)
 get_property(conversion_libs GLOBAL PROPERTY MLIR_CONVERSION_LIBS)
 target_link_libraries(toyc-ch7
   PRIVATE
     ${dialect_libs}
     ${conversion_libs}
     MLIRAnalysis
+    MLIRCallInterfaces
     MLIRExecutionEngine
     MLIRIR
     MLIRParser
     MLIRPass
     MLIRTargetLLVMIR
     MLIRTransforms
     )

mlir/examples/toy/Ch7/include/toy/Ops.td

 //===- Ops.td - Toy dialect operation definitions ----------*- tablegen -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Defines the operations of the Toy dialect.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef TOY_OPS
 #define TOY_OPS
 
-include "mlir/Analysis/CallInterfaces.td"
+include "mlir/Interfaces/CallInterfaces.td"
 include "toy/ShapeInferenceInterface.td"
 
 // Provide a definition of the 'toy' dialect in the ODS framework so that we
 // can define our operations.
 def Toy_Dialect : Dialect {
   let name = "toy";
   let cppNamespace = "toy";
 }

mlir/include/mlir/CMakeLists.txt

-add_subdirectory(Analysis)
 add_subdirectory(Dialect)
 add_subdirectory(IR)
+add_subdirectory(Interfaces)
 add_subdirectory(Transforms)

mlir/include/mlir/Dialect/LLVMIR/LLVMDialect.h

 //===- LLVMDialect.h - MLIR LLVM IR dialect ---------------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines the LLVM IR dialect in MLIR, containing LLVM operations and
 // LLVM type system.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_DIALECT_LLVMIR_LLVMDIALECT_H_
 #define MLIR_DIALECT_LLVMIR_LLVMDIALECT_H_
 
-#include "mlir/Analysis/ControlFlowInterfaces.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/Function.h"
 #include "mlir/IR/OpDefinition.h"
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/IR/TypeSupport.h"
 #include "mlir/IR/Types.h"
+#include "mlir/Interfaces/ControlFlowInterfaces.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Type.h"
 
 #include "mlir/Dialect/LLVMIR/LLVMOpsEnums.h.inc"
 
 namespace llvm {

mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td

 //===-- LLVMOps.td - LLVM IR dialect op definition file ----*- tablegen -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This is the LLVM IR operation definition file.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVMIR_OPS
 #define LLVMIR_OPS
 
 include "mlir/Dialect/LLVMIR/LLVMOpBase.td"
-include "mlir/Analysis/ControlFlowInterfaces.td"
+include "mlir/Interfaces/ControlFlowInterfaces.td"
 
 class LLVM_Builder<string builder> {
   string llvmBuilder = builder;
 }
 
 def LLVM_OneResultOpBuilder : OpBuilder<
   "Builder *, OperationState &result, Type resultType, "
   "ValueRange operands, ArrayRef<NamedAttribute> attributes = {}",

mlir/include/mlir/Dialect/SPIRV/SPIRVControlFlowOps.td

 // to "3.32.17. Control-Flow Instructions" of the SPIR-V specification.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef SPIRV_CONTROLFLOW_OPS
 #define SPIRV_CONTROLFLOW_OPS
 
 include "mlir/Dialect/SPIRV/SPIRVBase.td"
-include "mlir/Analysis/CallInterfaces.td"
-include "mlir/Analysis/ControlFlowInterfaces.td"
+include "mlir/Interfaces/CallInterfaces.td"
+include "mlir/Interfaces/ControlFlowInterfaces.td"
 
 // -----
 
 def SPV_BranchOp : SPV_Op<"Branch", [
     DeclareOpInterfaceMethods<BranchOpInterface>, InFunctionScope,
     Terminator]> {
   let summary = "Unconditional branch to target block.";
 

mlir/include/mlir/Dialect/SPIRV/SPIRVOps.h

 //===- SPIRVOps.h - MLIR SPIR-V operations ----------------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file declares the operations in the SPIR-V dialect.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_DIALECT_SPIRV_SPIRVOPS_H_
 #define MLIR_DIALECT_SPIRV_SPIRVOPS_H_
 
-#include "mlir/Analysis/ControlFlowInterfaces.h"
 #include "mlir/Dialect/SPIRV/SPIRVTypes.h"
 #include "mlir/IR/Function.h"
+#include "mlir/Interfaces/ControlFlowInterfaces.h"
 #include "llvm/Support/PointerLikeTypeTraits.h"
 
 namespace mlir {
 class OpBuilder;
 
 namespace spirv {
 
 // TableGen'erated operation interfaces for querying versions, extensions, and

mlir/include/mlir/Dialect/SPIRV/SPIRVStructureOps.td

 // and module-level operations. The representational form of these ops deviate
 // from the SPIR-V binary format in order to utilize MLIR mechanisms.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef SPIRV_STRUCTURE_OPS
 #define SPIRV_STRUCTURE_OPS
 
-include "mlir/Analysis/CallInterfaces.td"
+include "mlir/Interfaces/CallInterfaces.td"
 include "mlir/Dialect/SPIRV/SPIRVBase.td"
 
 // -----
 
 def SPV_AddressOfOp : SPV_Op<"_address_of", [InFunctionScope, NoSideEffect]> {
   let summary = "Get the address of a global variable.";
 
   let description = [{

mlir/include/mlir/Dialect/StandardOps/IR/Ops.h

 //===- Ops.h - Standard MLIR Operations -------------------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines convenience types for working with standard operations
 // in the MLIR operation set.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_DIALECT_STANDARDOPS_IR_OPS_H
 #define MLIR_DIALECT_STANDARDOPS_IR_OPS_H
 
-#include "mlir/Analysis/CallInterfaces.h"
-#include "mlir/Analysis/ControlFlowInterfaces.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/IR/StandardTypes.h"
+#include "mlir/Interfaces/CallInterfaces.h"
+#include "mlir/Interfaces/ControlFlowInterfaces.h"
 
 // Pull in all enum type definitions and utility function declarations.
 #include "mlir/Dialect/StandardOps/IR/OpsEnums.h.inc"
 
 namespace mlir {
 class AffineMap;
 class Builder;
 class FuncOp;

mlir/include/mlir/Dialect/StandardOps/IR/Ops.td

 //===- Ops.td - Standard operation definitions -------------*- tablegen -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Defines some MLIR standard operations.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef STANDARD_OPS
 #define STANDARD_OPS
 
-include "mlir/Analysis/CallInterfaces.td"
-include "mlir/Analysis/ControlFlowInterfaces.td"
+include "mlir/Interfaces/CallInterfaces.td"
+include "mlir/Interfaces/ControlFlowInterfaces.td"
 include "mlir/IR/OpAsmInterface.td"
 include "mlir/IR/SideEffects.td"
 
 def Std_Dialect : Dialect {
   let name = "std";
   let cppNamespace = "";
 }
 

mlir/include/mlir/IR/Function.h

 //===- Function.h - MLIR Function Class -------------------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Functions are the basic unit of composition in MLIR.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_IR_FUNCTION_H
 #define MLIR_IR_FUNCTION_H
 
-#include "mlir/Analysis/CallInterfaces.h"
 #include "mlir/IR/Block.h"
 #include "mlir/IR/FunctionSupport.h"
 #include "mlir/IR/OpDefinition.h"
 #include "mlir/IR/SymbolTable.h"
+#include "mlir/Interfaces/CallInterfaces.h"
 #include "llvm/Support/PointerLikeTypeTraits.h"
 
 namespace mlir {
 //===--------------------------------------------------------------------===//
 // Function Operation.
 //===--------------------------------------------------------------------===//
 
 /// FuncOp represents a function, or an operation containing one region that

mlir/include/mlir/Interfaces/CMakeLists.txt

 set(LLVM_TARGET_DEFINITIONS CallInterfaces.td)
 mlir_tablegen(CallInterfaces.h.inc -gen-op-interface-decls)
 mlir_tablegen(CallInterfaces.cpp.inc -gen-op-interface-defs)
-add_public_tablegen_target(MLIRCallOpInterfacesIncGen)
+add_public_tablegen_target(MLIRCallInterfacesIncGen)
 
 set(LLVM_TARGET_DEFINITIONS ControlFlowInterfaces.td)
 mlir_tablegen(ControlFlowInterfaces.h.inc -gen-op-interface-decls)
 mlir_tablegen(ControlFlowInterfaces.cpp.inc -gen-op-interface-defs)
 add_public_tablegen_target(MLIRControlFlowInterfacesIncGen)
 
 set(LLVM_TARGET_DEFINITIONS InferTypeOpInterface.td)
 mlir_tablegen(InferTypeOpInterface.h.inc -gen-op-interface-decls)
 mlir_tablegen(InferTypeOpInterface.cpp.inc -gen-op-interface-defs)
-add_public_tablegen_target(MLIRTypeInferOpInterfaceIncGen)
+add_public_tablegen_target(MLIRInferTypeOpInterfaceIncGen)

mlir/include/mlir/Interfaces/CallInterfaces.h

 //===- CallInterfaces.h - Call Interfaces for MLIR --------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains the definitions of the call interfaces defined in
 // `CallInterfaces.td`.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_ANALYSIS_CALLINTERFACES_H
-#define MLIR_ANALYSIS_CALLINTERFACES_H
+#ifndef MLIR_INTERFACES_CALLINTERFACES_H
+#define MLIR_INTERFACES_CALLINTERFACES_H
 
 #include "mlir/IR/SymbolTable.h"
 #include "llvm/ADT/PointerUnion.h"
 
 namespace mlir {
 /// A callable is either a symbol, or an SSA value, that is referenced by a
 /// call-like operation. This represents the destination of the call.
 struct CallInterfaceCallable : public PointerUnion<SymbolRefAttr, Value> {
   using PointerUnion<SymbolRefAttr, Value>::PointerUnion;
 };
 
-#include "mlir/Analysis/CallInterfaces.h.inc"
+#include "mlir/Interfaces/CallInterfaces.h.inc"
 } // end namespace mlir
 
-#endif // MLIR_ANALYSIS_CALLINTERFACES_H
+#endif // MLIR_INTERFACES_CALLINTERFACES_H

mlir/include/mlir/Interfaces/CallInterfaces.td

-//===- CallInterfaces.td - Call Interfaces for ops -*- tablegen ---------*-===//
+//===- CallInterfaces.td - Call Interfaces for ops ---------*- tablegen -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains a set of interfaces that can be used to define information
 // related to call-like and callable operations. Each of which are defined along
 // with the respective interface below.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_CALLINTERFACES
-#define MLIR_CALLINTERFACES
+#ifndef MLIR_INTERFACES_CALLINTERFACES
+#define MLIR_INTERFACES_CALLINTERFACES
 
 include "mlir/IR/OpBase.td"
 
 // `CallInterfaceCallable`: This is a type used to represent a single callable
 // region. A callable is either a symbol, or an SSA value, that is referenced by
 // a call-like operation. This represents the destination of the call.
 
 /// Interface for call-like operations.
InterfaceMethod<[{
         Returns the results types that the callable region produces when
         executed.
       }],
       "ArrayRef<Type>", "getCallableResults"
     >,
   ];
 }
 
-#endif // MLIR_CALLINTERFACES
+#endif // MLIR_INTERFACES_CALLINTERFACES

mlir/include/mlir/Interfaces/ControlFlowInterfaces.h

 //===- ControlFlowInterfaces.h - ControlFlow Interfaces ---------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains the definitions of the branch interfaces defined in
 // `ControlFlowInterfaces.td`.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_ANALYSIS_CONTROLFLOWINTERFACES_H
-#define MLIR_ANALYSIS_CONTROLFLOWINTERFACES_H
+#ifndef MLIR_INTERFACES_CONTROLFLOWINTERFACES_H
+#define MLIR_INTERFACES_CONTROLFLOWINTERFACES_H
 
 #include "mlir/IR/OpDefinition.h"
 
 namespace mlir {
 class BranchOpInterface;
 
 namespace detail {
 /// Erase an operand from a branch operation that is used as a successor
 /// operand. `operandIndex` is the operand within `operands` to be erased.
 void eraseBranchSuccessorOperand(OperandRange operands, unsigned operandIndex,
                                  Operation *op);
 
 /// Return the `BlockArgument` corresponding to operand `operandIndex` in some
 /// successor if `operandIndex` is within the range of `operands`, or None if
 /// `operandIndex` isn't a successor operand index.
 Optional<BlockArgument>
 getBranchSuccessorArgument(Optional<OperandRange> operands,
                            unsigned operandIndex, Block *successor);
 
 /// Verify that the given operands match those of the given successor block.
 LogicalResult verifyBranchSuccessorOperands(Operation *op, unsigned succNo,
                                             Optional<OperandRange> operands);
 } // namespace detail
 
-#include "mlir/Analysis/ControlFlowInterfaces.h.inc"
+#include "mlir/Interfaces/ControlFlowInterfaces.h.inc"
 } // end namespace mlir
 
-#endif // MLIR_ANALYSIS_CONTROLFLOWINTERFACES_H
+#endif // MLIR_INTERFACES_CONTROLFLOWINTERFACES_H

mlir/include/mlir/Interfaces/ControlFlowInterfaces.td

 //===-- ControlFlowInterfaces.td - ControlFlow Interfaces --*- tablegen -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains a set of interfaces that can be used to define information
 // about control flow operations, e.g. branches.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_ANALYSIS_CONTROLFLOWINTERFACES
-#define MLIR_ANALYSIS_CONTROLFLOWINTERFACES
+#ifndef MLIR_INTERFACES_CONTROLFLOWINTERFACES
+#define MLIR_INTERFACES_CONTROLFLOWINTERFACES
 
 include "mlir/IR/OpBase.td"
 
 //===----------------------------------------------------------------------===//
 // BranchOpInterface
 //===----------------------------------------------------------------------===//
 
 def BranchOpInterface : OpInterface<"BranchOpInterface"> {
for (unsigned i = 0, e = $_op->getNumSuccessors(); i != e; ++i) {
       Optional<OperandRange> operands = concreteOp.getSuccessorOperands(i);
       if (failed(detail::verifyBranchSuccessorOperands($_op, i, operands)))
         return failure();
     }
     return success();
   }];
 }
 
-#endif // MLIR_ANALYSIS_CONTROLFLOWINTERFACES
+#endif // MLIR_INTERFACES_CONTROLFLOWINTERFACES

mlir/include/mlir/Interfaces/InferTypeOpInterface.h

 //===- InferTypeOpInterface.h - Infer Type Interfaces -----------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains the definitions of the infer op interfaces defined in
 // `InferTypeOpInterface.td`.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_ANALYSIS_INFERTYPEOPINTERFACE_H_
-#define MLIR_ANALYSIS_INFERTYPEOPINTERFACE_H_
+#ifndef MLIR_INTERFACES_INFERTYPEOPINTERFACE_H_
+#define MLIR_INTERFACES_INFERTYPEOPINTERFACE_H_
 
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/Location.h"
 #include "mlir/IR/OpDefinition.h"
 #include "mlir/Support/LLVM.h"
 #include "llvm/ADT/SmallVector.h"
 
LogicalResult inferReturnTensorTypes(
     ArrayRef<NamedAttribute> attributes, RegionRange regions,
     SmallVectorImpl<Type> &inferredReturnTypes);
 
 /// Verifies that the inferred result types match the actual result types for
 /// the op. Precondition: op implements InferTypeOpInterface.
 LogicalResult verifyInferredResultTypes(Operation *op);
 } // namespace detail
 
-#include "mlir/Analysis/InferTypeOpInterface.h.inc"
+#include "mlir/Interfaces/InferTypeOpInterface.h.inc"
 
 namespace OpTrait {
 
 /// Tensor type inference trait that constructs a tensor from the inferred
 /// shape and elemental types.
 /// Requires: Op implements functions of InferShapedTypeOpInterface.
 template <typename ConcreteType>
 class InferTensorType : public TraitBase<ConcreteType, InferTensorType> {
 public:
   static LogicalResult
   inferReturnTypes(MLIRContext *context, Optional<Location> location,
                    ValueRange operands, ArrayRef<NamedAttribute> attributes,
                    RegionRange regions,
                    SmallVectorImpl<Type> &inferredReturnTypes) {
     return ::mlir::detail::inferReturnTensorTypes(
         ConcreteType::inferReturnTypeComponents, context, location, operands,
         attributes, regions, inferredReturnTypes);
   }
 };
 
 } // namespace OpTrait
 } // namespace mlir
 
-#endif // MLIR_ANALYSIS_INFERTYPEOPINTERFACE_H_
+#endif // MLIR_INTERFACES_INFERTYPEOPINTERFACE_H_

mlir/lib/Analysis/CMakeLists.txt

 set(LLVM_OPTIONAL_SOURCES
   AffineAnalysis.cpp
   AffineStructures.cpp
   CallGraph.cpp
-  ControlFlowInterfaces.cpp
   Dominance.cpp
-  InferTypeOpInterface.cpp
   Liveness.cpp
   LoopAnalysis.cpp
   NestedMatcher.cpp
   SliceAnalysis.cpp
   Utils.cpp
   Verifier.cpp
   )
 
-add_mlir_library(MLIRControlFlowAnalysis
-  ControlFlowInterfaces.cpp
-
-  ADDITIONAL_HEADER_DIRS
-  ${MLIR_MAIN_INCLUDE_DIR}/mlir/Analysis
-
-  DEPENDS
-  MLIRControlFlowInterfacesIncGen
-  )
-target_link_libraries(MLIRControlFlowAnalysis
-  PUBLIC
-  MLIRIR
-  )
-
 add_mlir_library(MLIRAnalysis
   CallGraph.cpp
-  InferTypeOpInterface.cpp
   Liveness.cpp
   SliceAnalysis.cpp
   Dominance.cpp
   Verifier.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Analysis
-
-  DEPENDS
-  MLIRCallOpInterfacesIncGen
-  MLIRTypeInferOpInterfaceIncGen
   )
 
 target_link_libraries(MLIRAnalysis
   PUBLIC
   MLIRAffineOps
+  MLIRCallInterfaces
+  MLIRControlFlowInterfaces
+  MLIRInferTypeOpInterface
   MLIRLoopOps
   )
 
 add_mlir_library(MLIRLoopAnalysis
   AffineAnalysis.cpp
   AffineStructures.cpp
   LoopAnalysis.cpp
   NestedMatcher.cpp
   Utils.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Analysis
-
-  DEPENDS
-  MLIRCallOpInterfacesIncGen
-  MLIRTypeInferOpInterfaceIncGen
   )
 
 target_link_libraries(MLIRLoopAnalysis
   PUBLIC
   MLIRAffineOps
+  MLIRCallInterfaces
+  MLIRControlFlowInterfaces
+  MLIRInferTypeOpInterface
   MLIRLoopOps)

mlir/lib/Analysis/CallGraph.cpp

 //===- CallGraph.cpp - CallGraph analysis for MLIR ------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains interfaces and analyses for defining a nested callgraph.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Analysis/CallGraph.h"
-#include "mlir/Analysis/CallInterfaces.h"
 #include "mlir/IR/Operation.h"
 #include "mlir/IR/SymbolTable.h"
+#include "mlir/Interfaces/CallInterfaces.h"
 #include "llvm/ADT/PointerUnion.h"
 #include "llvm/ADT/SCCIterator.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace mlir;
 
 //===----------------------------------------------------------------------===//
-// CallInterfaces
-//===----------------------------------------------------------------------===//
-
-#include "mlir/Analysis/CallInterfaces.cpp.inc"
-
-//===----------------------------------------------------------------------===//
 // CallGraphNode
 //===----------------------------------------------------------------------===//
 
 /// Returns if this node refers to the indirect/external node.
 bool CallGraphNode::isExternal() const { return !callableRegion; }
 
 /// Return the callable region this node represents. This can only be called
 /// on non-external nodes.

mlir/lib/CMakeLists.txt

 add_subdirectory(Analysis)
 add_subdirectory(Conversion)
 add_subdirectory(Dialect)
 add_subdirectory(EDSC)
 add_subdirectory(ExecutionEngine)
 add_subdirectory(IR)
+add_subdirectory(Interfaces)
 add_subdirectory(Parser)
 add_subdirectory(Pass)
 add_subdirectory(Quantizer)
 add_subdirectory(Support)
 add_subdirectory(TableGen)
 add_subdirectory(Target)
 add_subdirectory(Transforms)
 add_subdirectory(Translation)

mlir/lib/Dialect/LLVMIR/CMakeLists.txt

 add_mlir_dialect_library(MLIRLLVMIR
   IR/LLVMDialect.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/LLVMIR
 
   DEPENDS
-  MLIRControlFlowInterfacesIncGen
   MLIRLLVMOpsIncGen
   MLIRLLVMConversionsIncGen
   )
 target_link_libraries(MLIRLLVMIR
   PUBLIC
   LLVMAsmParser
   LLVMCore
   LLVMSupport
   LLVMFrontendOpenMP
-  MLIRAnalysis
+  MLIRCallInterfaces
+  MLIRControlFlowInterfaces
   MLIROpenMP
   MLIRIR
   MLIRSupport
   )
 
 add_mlir_dialect_library(MLIRNVVMIR
   IR/NVVMDialect.cpp
 

mlir/lib/Dialect/SPIRV/CMakeLists.txt

add_mlir_dialect_library(MLIRSPIRV
   SPIRVLowering.cpp
   SPIRVTypes.cpp
   TargetAndABI.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/SPIRV
 
   DEPENDS
-  MLIRControlFlowInterfacesIncGen
   MLIRSPIRVAvailabilityIncGen
   MLIRSPIRVCanonicalizationIncGen
   MLIRSPIRVEnumAvailabilityIncGen
   MLIRSPIRVEnumsIncGen
   MLIRSPIRVOpsIncGen
   MLIRSPIRVOpUtilsGen
   MLIRSPIRVTargetAndABIIncGen
   )
 target_link_libraries(MLIRSPIRV
   PUBLIC
+  MLIRControlFlowInterfaces
   MLIRIR
   MLIRParser
   MLIRSupport
   MLIRTransforms
   )
 
 add_subdirectory(Serialization)
 add_subdirectory(Transforms)

mlir/lib/Dialect/SPIRV/SPIRVOps.cpp

 //===- SPIRVOps.cpp - MLIR SPIR-V operations ------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines the operations in the SPIR-V dialect.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/SPIRV/SPIRVOps.h"
 
-#include "mlir/Analysis/CallInterfaces.h"
 #include "mlir/Dialect/SPIRV/SPIRVDialect.h"
 #include "mlir/Dialect/SPIRV/SPIRVTypes.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/Function.h"
 #include "mlir/IR/FunctionImplementation.h"
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/IR/StandardTypes.h"
+#include "mlir/Interfaces/CallInterfaces.h"
 #include "mlir/Support/StringExtras.h"
 #include "llvm/ADT/bit.h"
 
 using namespace mlir;
 
 // TODO(antiagainst): generate these strings using ODS.
 static constexpr const char kAlignmentAttrName[] = "alignment";
 static constexpr const char kBranchWeightAttrName[] = "branch_weights";

mlir/lib/Dialect/StandardOps/CMakeLists.txt

 add_mlir_dialect_library(MLIRStandardOps
   IR/Ops.cpp
   EDSC/Builders.cpp
   EDSC/Intrinsics.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/StandardOps
 
   DEPENDS
-  MLIRCallOpInterfacesIncGen
-  MLIRControlFlowInterfacesIncGen
   MLIRStandardOpsIncGen
   )
 target_link_libraries(MLIRStandardOps
   PUBLIC
-  MLIRControlFlowAnalysis
+  MLIRCallInterfaces
+  MLIRControlFlowInterfaces
   MLIREDSC
   MLIRIR
   LLVMSupport
   )

mlir/lib/IR/CMakeLists.txt

 file(GLOB globbed *.c *.cpp)
 add_mlir_library(MLIRIR
   ${globbed}
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/IR
 
   DEPENDS
-  MLIRCallOpInterfacesIncGen
+  MLIRCallInterfacesIncGen
   MLIRSideEffectOpInterfacesIncGen
   MLIROpAsmInterfacesIncGen
   )
 target_link_libraries(MLIRIR
   PUBLIC
   MLIRSupport
   LLVMSupport
   )

mlir/lib/Interfaces/CMakeLists.txt

+set(LLVM_OPTIONAL_SOURCES
+  CallInterfaces.cpp
+  ControlFlowInterfaces.cpp
+  InferTypeOpInterface.cpp
+  )
+
+add_llvm_library(MLIRCallInterfaces
+  CallInterfaces.cpp
+
+  ADDITIONAL_HEADER_DIRS
+  ${MLIR_MAIN_INCLUDE_DIR}/mlir/Interfaces
+  )
+add_dependencies(MLIRCallInterfaces
+  MLIRCallInterfacesIncGen
+  )
+target_link_libraries(MLIRCallInterfaces
+  PUBLIC
+  MLIRIR
+  )
+
+add_llvm_library(MLIRControlFlowInterfaces
+  ControlFlowInterfaces.cpp
+
+  ADDITIONAL_HEADER_DIRS
+  ${MLIR_MAIN_INCLUDE_DIR}/mlir/Interfaces
+  )
+add_dependencies(MLIRControlFlowInterfaces
+  MLIRControlFlowInterfacesIncGen
+  )
+target_link_libraries(MLIRControlFlowInterfaces
+  PUBLIC
+  MLIRIR
+  )
+
+add_llvm_library(MLIRInferTypeOpInterface
+  InferTypeOpInterface.cpp
+
+  ADDITIONAL_HEADER_DIRS
+  ${MLIR_MAIN_INCLUDE_DIR}/mlir/Interfaces
+  )
+add_dependencies(MLIRInferTypeOpInterface
+  MLIRInferTypeOpInterfaceIncGen
+  )
+target_link_libraries(MLIRInferTypeOpInterface
+  PUBLIC
+  MLIRIR
+  )

mlir/lib/Interfaces/CallInterfaces.cpp

+//===- CallInterfaces.cpp - ControlFlow Interfaces ------------------------===//
+//
+// 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/CallInterfaces.h"
+
+using namespace mlir;
+
+//===----------------------------------------------------------------------===//
+// CallInterfaces
+//===----------------------------------------------------------------------===//
+
+#include "mlir/Interfaces/CallInterfaces.cpp.inc"

mlir/lib/Interfaces/ControlFlowInterfaces.cpp

-//===- ControlFlowInterfaces.h - ControlFlow Interfaces -------------------===//
+//===- ControlFlowInterfaces.cpp - ControlFlow Interfaces -----------------===//
 //
 // 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/Analysis/ControlFlowInterfaces.h"
+#include "mlir/Interfaces/ControlFlowInterfaces.h"
 #include "mlir/IR/StandardTypes.h"
 
 using namespace mlir;
 
 //===----------------------------------------------------------------------===//
 // ControlFlowInterfaces
 //===----------------------------------------------------------------------===//
 
-#include "mlir/Analysis/ControlFlowInterfaces.cpp.inc"
+#include "mlir/Interfaces/ControlFlowInterfaces.cpp.inc"
 
 //===----------------------------------------------------------------------===//
 // BranchOpInterface
 //===----------------------------------------------------------------------===//
 
 /// Erase an operand from a branch operation that is used as a successor
 /// operand. 'operandIndex' is the operand within 'operands' to be erased.
 void mlir::detail::eraseBranchSuccessorOperand(OperandRange operands,

mlir/lib/Interfaces/InferTypeOpInterface.cpp

 //===- InferTypeOpInterface.cpp - Infer Type Interfaces ---------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains the definitions of the infer op interfaces defined in
 // `InferTypeOpInterface.td`.
 //
 //===----------------------------------------------------------------------===//
 
-#include "mlir/Analysis/InferTypeOpInterface.h"
+#include "mlir/Interfaces/InferTypeOpInterface.h"
 
 #include "mlir/IR/StandardTypes.h"
 
 using namespace mlir;
 
 namespace mlir {
-#include "mlir/Analysis/InferTypeOpInterface.cpp.inc"
+#include "mlir/Interfaces/InferTypeOpInterface.cpp.inc"
 } // namespace mlir
 
 LogicalResult mlir::detail::inferReturnTensorTypes(
     function_ref<LogicalResult(
         MLIRContext *, Optional<Location> location, ValueRange operands,
         ArrayRef<NamedAttribute> attributes, RegionRange regions,
         SmallVectorImpl<ShapedTypeComponents> &retComponents)>
         componentTypeFn,

mlir/lib/Transforms/Utils/RegionUtils.cpp

 //===- RegionUtils.cpp - Region-related transformation utilities ----------===//
 //
 // 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/Transforms/RegionUtils.h"
-#include "mlir/Analysis/ControlFlowInterfaces.h"
 #include "mlir/IR/Block.h"
 #include "mlir/IR/Operation.h"
 #include "mlir/IR/RegionGraphTraits.h"
 #include "mlir/IR/Value.h"
+#include "mlir/Interfaces/ControlFlowInterfaces.h"
 
 #include "llvm/ADT/DepthFirstIterator.h"
 #include "llvm/ADT/PostOrderIterator.h"
 #include "llvm/ADT/SmallSet.h"
 
 using namespace mlir;
 
 void mlir::replaceAllUsesInRegionWith(Value orig, Value replacement,

mlir/test/lib/IR/CMakeLists.txt

 add_llvm_library(MLIRTestIR
   TestFunc.cpp
   TestMatchers.cpp
   TestSideEffects.cpp
   TestSymbolUses.cpp
 
   ADDITIONAL_HEADER_DIRS
   )
 include_directories(${CMAKE_CURRENT_SOURCE_DIR}/../TestDialect)
 include_directories(${CMAKE_CURRENT_BINARY_DIR}/../TestDialect)
 
 target_link_libraries(MLIRTestIR
   PUBLIC
   MLIRPass
+  MLIRTestDialect
   )

mlir/test/lib/TestDialect/CMakeLists.txt

 mlir_tablegen(TestPatterns.inc -gen-rewriters)
 add_public_tablegen_target(MLIRTestOpsIncGen)
 
 add_llvm_library(MLIRTestDialect
   TestDialect.cpp
   TestPatterns.cpp
 
   DEPENDS
-  MLIRControlFlowInterfacesIncGen
   MLIRTestOpsIncGen
-  MLIRTypeInferOpInterfaceIncGen
 )
 target_link_libraries(MLIRTestDialect
   PUBLIC
-  MLIRAnalysis
+  MLIRControlFlowInterfaces
   MLIRDialect
   MLIRIR
   MLIRLinalgTransforms
   MLIRPass
   MLIRStandardOps
   MLIRTransforms
   MLIRTransformUtils
+  MLIRInferTypeOpInterface
   LLVMSupport
 )

mlir/test/lib/TestDialect/TestDialect.h

 //===- TestDialect.h - MLIR Dialect for testing -----------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines a fake 'test' dialect that can be used for testing things
 // that do not have a respective counterpart in the main source directories.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_TESTDIALECT_H
 #define MLIR_TESTDIALECT_H
 
-#include "mlir/Analysis/CallInterfaces.h"
-#include "mlir/Analysis/ControlFlowInterfaces.h"
-#include "mlir/Analysis/InferTypeOpInterface.h"
 #include "mlir/Dialect/Traits.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/OpDefinition.h"
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/IR/StandardTypes.h"
 #include "mlir/IR/SymbolTable.h"
+#include "mlir/Interfaces/CallInterfaces.h"
+#include "mlir/Interfaces/ControlFlowInterfaces.h"
+#include "mlir/Interfaces/InferTypeOpInterface.h"
 
 #include "TestOpEnums.h.inc"
 
 namespace mlir {
 
 class TestDialect : public Dialect {
 public:
   /// Create the dialect in the given `context`.

mlir/test/lib/TestDialect/TestOps.td

 //===-- TestOps.td - Test dialect operation definitions ----*- tablegen -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef TEST_OPS
 #define TEST_OPS
 
 include "mlir/IR/OpBase.td"
 include "mlir/IR/OpAsmInterface.td"
 include "mlir/IR/SideEffects.td"
-include "mlir/Analysis/ControlFlowInterfaces.td"
-include "mlir/Analysis/CallInterfaces.td"
-include "mlir/Analysis/InferTypeOpInterface.td"
+include "mlir/Interfaces/CallInterfaces.td"
+include "mlir/Interfaces/ControlFlowInterfaces.td"
+include "mlir/Interfaces/InferTypeOpInterface.td"
 
 def TEST_Dialect : Dialect {
   let name = "test";
   let cppNamespace = "";
 }
 
 class TEST_Op<string mnemonic, list<OpTrait> traits = []> :
     Op<TEST_Dialect, mnemonic, traits>;