[llvm][ADT] Move TypeSwitch class from MLIR to LLVM

[rriddle]

Summary

This class implements a switch-like dispatch statement for a value of 'T' using dyn_cast functionality. Each Case<T> takes a callable to be invoked if the root value isa<T>, the callable is invoked with the result of dyn_cast<T>() as a parameter.

Depends On D78067

[rriddle]

Rebase

flang/lib/Optimizer/Dialect/FIROps.cpp

 //===-- FIROps.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 "flang/Optimizer/Dialect/FIROps.h"
 #include "flang/Optimizer/Dialect/FIRAttr.h"
 #include "flang/Optimizer/Dialect/FIROpsSupport.h"
 #include "flang/Optimizer/Dialect/FIRType.h"
-#include "mlir/ADT/TypeSwitch.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/IR/Diagnostics.h"
 #include "mlir/IR/Function.h"
 #include "mlir/IR/Module.h"
 #include "mlir/IR/StandardTypes.h"
 #include "mlir/IR/SymbolTable.h"
 #include "llvm/ADT/StringSwitch.h"
+#include "llvm/ADT/TypeSwitch.h"
 
 using namespace fir;
 
 /// return true if the sequence type is abstract or the record type is malformed
 /// or contains an abstract sequence type
 static bool verifyInType(mlir::Type inType,
                          llvm::SmallVectorImpl<llvm::StringRef> &visited) {
   if (auto st = inType.dyn_cast<fir::SequenceType>()) {

 }
 
 //===----------------------------------------------------------------------===//
 // LoadOp
 //===----------------------------------------------------------------------===//
 
 /// Get the element type of a reference like type; otherwise null
 static mlir::Type elementTypeOf(mlir::Type ref) {
-  return mlir::TypeSwitch<mlir::Type, mlir::Type>(ref)
+  return llvm::TypeSwitch<mlir::Type, mlir::Type>(ref)
       .Case<ReferenceType, PointerType, HeapType>(
           [](auto type) { return type.getEleTy(); })
       .Default([](mlir::Type) { return mlir::Type{}; });
 }
 
 mlir::ParseResult fir::LoadOp::getElementOf(mlir::Type &ele, mlir::Type ref) {
   if ((ele = elementTypeOf(ref)))
     return mlir::success();

flang/lib/Optimizer/Dialect/FIRType.cpp

 //===-- FIRType.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 "flang/Optimizer/Dialect/FIRType.h"
 #include "flang/Optimizer/Dialect/FIRDialect.h"
-#include "mlir/ADT/TypeSwitch.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/Diagnostics.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/DialectImplementation.h"
 #include "mlir/IR/StandardTypes.h"
 #include "mlir/Parser.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/StringSet.h"
+#include "llvm/ADT/TypeSwitch.h"
 
 using namespace fir;
 
 namespace {
 
 template <typename TYPE>
 TYPE parseIntSingleton(mlir::DialectAsmParser &parser) {
   int kind = 0;
bool isa_ref_type(mlir::Type t) {
   return t.isa<ReferenceType>() || t.isa<PointerType>() || t.isa<HeapType>();
 }
 
 bool isa_aggregate(mlir::Type t) {
   return t.isa<SequenceType>() || t.isa<RecordType>();
 }
 
 mlir::Type dyn_cast_ptrEleTy(mlir::Type t) {
-  return mlir::TypeSwitch<mlir::Type, mlir::Type>(t)
+  return llvm::TypeSwitch<mlir::Type, mlir::Type>(t)
       .Case<fir::ReferenceType, fir::PointerType, fir::HeapType>(
           [](auto p) { return p.getEleTy(); })
       .Default([](mlir::Type) { return mlir::Type{}; });
 }
 
 } // namespace fir
 
 // CHARACTER

llvm/include/llvm/ADT/TypeSwitch.h

 //===- TypeSwitch.h - Switch functionality for RTTI casting -*- 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 implements the TypeSwitch template, which mimics a switch()
 //  statement whose cases are type names.
 //
 //===-----------------------------------------------------------------------===/
 
-#ifndef MLIR_SUPPORT_TYPESWITCH_H
-#define MLIR_SUPPORT_TYPESWITCH_H
+#ifndef LLVM_ADT_TYPESWITCH_H
+#define LLVM_ADT_TYPESWITCH_H
 
-#include "mlir/Support/LLVM.h"
-#include "mlir/Support/STLExtras.h"
 #include "llvm/ADT/Optional.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/Support/Casting.h"
 
-namespace mlir {
+namespace llvm {
 namespace detail {
 
 template <typename DerivedT, typename T> class TypeSwitchBase {
 public:
   TypeSwitchBase(const T &value) : value(value) {}
   TypeSwitchBase(TypeSwitchBase &&other) : value(other.value) {}
   ~TypeSwitchBase() = default;
 
return derived.template Case<CaseT>(caseFn)
         .template Case<CaseT2, CaseTs...>(caseFn);
   }
 
   /// Invoke a case on the derived class, inferring the type of the Case from
   /// the first input of the given callable.
   /// Note: This inference rules for this overload are very simple: strip
   ///       pointers and references.
   template <typename CallableT> DerivedT &Case(CallableT &&caseFn) {
-    using Traits = llvm::function_traits<std::decay_t<CallableT>>;
+    using Traits = function_traits<std::decay_t<CallableT>>;
     using CaseT = std::remove_cv_t<std::remove_pointer_t<
         std::remove_reference_t<typename Traits::template arg_t<0>>>>;
 
     DerivedT &derived = static_cast<DerivedT &>(*this);
     return derived.template Case<CaseT>(std::forward<CallableT>(caseFn));
   }
 
 protected:
   /// Trait to check whether `ValueT` provides a 'dyn_cast' method with type
   /// `CastT`.
   template <typename ValueT, typename CastT>
   using has_dyn_cast_t =
       decltype(std::declval<ValueT &>().template dyn_cast<CastT>());
 
   /// Attempt to dyn_cast the given `value` to `CastT`. This overload is
   /// selected if `value` already has a suitable dyn_cast method.
   template <typename CastT, typename ValueT>
-  static auto
-  castValue(ValueT value,
-            typename std::enable_if_t<
-                llvm::is_detected<has_dyn_cast_t, ValueT, CastT>::value> * =
-                nullptr) {
+  static auto castValue(
+      ValueT value,
+          is_detected<has_dyn_cast_t, ValueT, CastT>::value> * = nullptr) {
     return value.template dyn_cast<CastT>();
   }
 
   /// Attempt to dyn_cast the given `value` to `CastT`. This overload is
   /// selected if llvm::dyn_cast should be used.
   template <typename CastT, typename ValueT>
-  static auto
-  castValue(ValueT value,
-            typename std::enable_if_t<
-                !llvm::is_detected<has_dyn_cast_t, ValueT, CastT>::value> * =
-                nullptr) {
+  static auto castValue(
+      ValueT value,
+          !is_detected<has_dyn_cast_t, ValueT, CastT>::value> * = nullptr) {
     return dyn_cast<CastT>(value);
   }
 
   /// The root value we are switching on.
   const T value;
 };
 } // end namespace detail
 
template <typename CallableT> void Default(CallableT &&defaultFn) {
     if (!foundMatch)
       defaultFn(this->value);
   }
 
 private:
   /// A flag detailing if we have already found a match.
   bool foundMatch = false;
 };
-} // end namespace mlir
+} // end namespace llvm
 
-#endif // MLIR_SUPPORT_TYPESWITCH_H
+#endif // LLVM_ADT_TYPESWITCH_H

llvm/unittests/ADT/CMakeLists.txt

add_llvm_unittest(ADTTests
   StringExtrasTest.cpp
   StringMapTest.cpp
   StringRefTest.cpp
   StringSetTest.cpp
   StringSwitchTest.cpp
   TinyPtrVectorTest.cpp
   TripleTest.cpp
   TwineTest.cpp
+  TypeSwitchTest.cpp
   TypeTraitsTest.cpp
   WaymarkingTest.cpp
   )
 
 target_link_libraries(ADTTests PRIVATE LLVMTestingSupport)
 
 add_dependencies(ADTTests intrinsics_gen)

llvm/unittests/ADT/TypeSwitchTest.cpp

 //===- TypeSwitchTest.cpp - TypeSwitch unit tests -------------------------===//
 //
 // 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/ADT/TypeSwitch.h"
+#include "llvm/ADT/TypeSwitch.h"
 #include "gtest/gtest.h"
 
-using namespace mlir;
+using namespace llvm;
 
 namespace {
 /// Utility classes to setup casting functionality.
 struct Base {
   enum Kind { DerivedA, DerivedB, DerivedC, DerivedD, DerivedE };
   Kind kind;
 };
 template <Base::Kind DerivedKind> struct DerivedImpl : Base {
   DerivedImpl() : Base{DerivedKind} {}
   static bool classof(const Base *base) { return base->kind == DerivedKind; }
 };
 struct DerivedA : public DerivedImpl<Base::DerivedA> {};
 struct DerivedB : public DerivedImpl<Base::DerivedB> {};
 struct DerivedC : public DerivedImpl<Base::DerivedC> {};
 struct DerivedD : public DerivedImpl<Base::DerivedD> {};
 struct DerivedE : public DerivedImpl<Base::DerivedE> {};
 } // end anonymous namespace
 
-TEST(StringSwitchTest, CaseResult) {
+TEST(TypeSwitchTest, CaseResult) {
   auto translate = [](auto value) {
     return TypeSwitch<Base *, int>(&value)
         .Case<DerivedA>([](DerivedA *) { return 0; })
         .Case([](DerivedB *) { return 1; })
         .Case([](DerivedC *) { return 2; })
         .Default([](Base *) { return -1; });
   };
   EXPECT_EQ(0, translate(DerivedA()));
   EXPECT_EQ(1, translate(DerivedB()));
   EXPECT_EQ(2, translate(DerivedC()));
   EXPECT_EQ(-1, translate(DerivedD()));
 }
 
-TEST(StringSwitchTest, CasesResult) {
+TEST(TypeSwitchTest, CasesResult) {
   auto translate = [](auto value) {
     return TypeSwitch<Base *, int>(&value)
         .Case<DerivedA, DerivedB, DerivedD>([](auto *) { return 0; })
         .Case([](DerivedC *) { return 1; })
         .Default([](Base *) { return -1; });
   };
   EXPECT_EQ(0, translate(DerivedA()));
   EXPECT_EQ(0, translate(DerivedB()));
   EXPECT_EQ(1, translate(DerivedC()));
   EXPECT_EQ(0, translate(DerivedD()));
   EXPECT_EQ(-1, translate(DerivedE()));
 }
 
-TEST(StringSwitchTest, CaseVoid) {
+TEST(TypeSwitchTest, CaseVoid) {
   auto translate = [](auto value) {
     int result = -2;
     TypeSwitch<Base *>(&value)
         .Case([&](DerivedA *) { result = 0; })
         .Case([&](DerivedB *) { result = 1; })
         .Case([&](DerivedC *) { result = 2; })
         .Default([&](Base *) { result = -1; });
     return result;
   };
   EXPECT_EQ(0, translate(DerivedA()));
   EXPECT_EQ(1, translate(DerivedB()));
   EXPECT_EQ(2, translate(DerivedC()));
   EXPECT_EQ(-1, translate(DerivedD()));
 }
 
-TEST(StringSwitchTest, CasesVoid) {
+TEST(TypeSwitchTest, CasesVoid) {
   auto translate = [](auto value) {
     int result = -1;
     TypeSwitch<Base *>(&value)
         .Case<DerivedA, DerivedB, DerivedD>([&](auto *) { result = 0; })
         .Case([&](DerivedC *) { result = 1; });
     return result;
   };
   EXPECT_EQ(0, translate(DerivedA()));
   EXPECT_EQ(0, translate(DerivedB()));
   EXPECT_EQ(1, translate(DerivedC()));
   EXPECT_EQ(0, translate(DerivedD()));
   EXPECT_EQ(-1, translate(DerivedE()));
 }

mlir/examples/toy/Ch1/parser/AST.cpp

 //===- AST.cpp - Helper for printing out the Toy AST ----------------------===//
 //
 // 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 implements the AST dump for the Toy language.
 //
 //===----------------------------------------------------------------------===//
 
 #include "toy/AST.h"
 
-#include "mlir/ADT/TypeSwitch.h"
 #include "mlir/Support/STLExtras.h"
 #include "llvm/ADT/Twine.h"
+#include "llvm/ADT/TypeSwitch.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace toy;
 
 namespace {
 
 // RAII helper to manage increasing/decreasing the indentation as we traverse
 // the AST

 // Helper Macro to bump the indentation level and print the leading spaces for
 // the current indentations
 #define INDENT()                                                               \
   Indent level_(curIndent);                                                    \
   indent();
 
 /// Dispatch to a generic expressions to the appropriate subclass using RTTI
 void ASTDumper::dump(ExprAST *expr) {
-  mlir::TypeSwitch<ExprAST *>(expr)
+  llvm::TypeSwitch<ExprAST *>(expr)
       .Case<BinaryExprAST, CallExprAST, LiteralExprAST, NumberExprAST,
             PrintExprAST, ReturnExprAST, VarDeclExprAST, VariableExprAST>(
           [&](auto *node) { this->dump(node); })
       .Default([&](ExprAST *) {
         // No match, fallback to a generic message
         INDENT();
         llvm::errs() << "<unknown Expr, kind " << expr->getKind() << ">\n";
       });

mlir/examples/toy/Ch2/parser/AST.cpp

 //===- AST.cpp - Helper for printing out the Toy AST ----------------------===//
 //
 // 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 implements the AST dump for the Toy language.
 //
 //===----------------------------------------------------------------------===//
 
 #include "toy/AST.h"
 
-#include "mlir/ADT/TypeSwitch.h"
 #include "mlir/Support/STLExtras.h"
 #include "llvm/ADT/Twine.h"
+#include "llvm/ADT/TypeSwitch.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace toy;
 
 namespace {
 
 // RAII helper to manage increasing/decreasing the indentation as we traverse
 // the AST

 // Helper Macro to bump the indentation level and print the leading spaces for
 // the current indentations
 #define INDENT()                                                               \
   Indent level_(curIndent);                                                    \
   indent();
 
 /// Dispatch to a generic expressions to the appropriate subclass using RTTI
 void ASTDumper::dump(ExprAST *expr) {
-  mlir::TypeSwitch<ExprAST *>(expr)
+  llvm::TypeSwitch<ExprAST *>(expr)
       .Case<BinaryExprAST, CallExprAST, LiteralExprAST, NumberExprAST,
             PrintExprAST, ReturnExprAST, VarDeclExprAST, VariableExprAST>(
           [&](auto *node) { this->dump(node); })
       .Default([&](ExprAST *) {
         // No match, fallback to a generic message
         INDENT();
         llvm::errs() << "<unknown Expr, kind " << expr->getKind() << ">\n";
       });

mlir/examples/toy/Ch3/parser/AST.cpp

 //===- AST.cpp - Helper for printing out the Toy AST ----------------------===//
 //
 // 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 implements the AST dump for the Toy language.
 //
 //===----------------------------------------------------------------------===//
 
 #include "toy/AST.h"
 
-#include "mlir/ADT/TypeSwitch.h"
 #include "mlir/Support/STLExtras.h"
 #include "llvm/ADT/Twine.h"
+#include "llvm/ADT/TypeSwitch.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace toy;
 
 namespace {
 
 // RAII helper to manage increasing/decreasing the indentation as we traverse
 // the AST

 // Helper Macro to bump the indentation level and print the leading spaces for
 // the current indentations
 #define INDENT()                                                               \
   Indent level_(curIndent);                                                    \
   indent();
 
 /// Dispatch to a generic expressions to the appropriate subclass using RTTI
 void ASTDumper::dump(ExprAST *expr) {
-  mlir::TypeSwitch<ExprAST *>(expr)
+  llvm::TypeSwitch<ExprAST *>(expr)
       .Case<BinaryExprAST, CallExprAST, LiteralExprAST, NumberExprAST,
             PrintExprAST, ReturnExprAST, VarDeclExprAST, VariableExprAST>(
           [&](auto *node) { this->dump(node); })
       .Default([&](ExprAST *) {
         // No match, fallback to a generic message
         INDENT();
         llvm::errs() << "<unknown Expr, kind " << expr->getKind() << ">\n";
       });

mlir/examples/toy/Ch4/parser/AST.cpp

 //===- AST.cpp - Helper for printing out the Toy AST ----------------------===//
 //
 // 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 implements the AST dump for the Toy language.
 //
 //===----------------------------------------------------------------------===//
 
 #include "toy/AST.h"
 
-#include "mlir/ADT/TypeSwitch.h"
 #include "mlir/Support/STLExtras.h"
 #include "llvm/ADT/Twine.h"
+#include "llvm/ADT/TypeSwitch.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace toy;
 
 namespace {
 
 // RAII helper to manage increasing/decreasing the indentation as we traverse
 // the AST

 // Helper Macro to bump the indentation level and print the leading spaces for
 // the current indentations
 #define INDENT()                                                               \
   Indent level_(curIndent);                                                    \
   indent();
 
 /// Dispatch to a generic expressions to the appropriate subclass using RTTI
 void ASTDumper::dump(ExprAST *expr) {
-  mlir::TypeSwitch<ExprAST *>(expr)
+  llvm::TypeSwitch<ExprAST *>(expr)
       .Case<BinaryExprAST, CallExprAST, LiteralExprAST, NumberExprAST,
             PrintExprAST, ReturnExprAST, VarDeclExprAST, VariableExprAST>(
           [&](auto *node) { this->dump(node); })
       .Default([&](ExprAST *) {
         // No match, fallback to a generic message
         INDENT();
         llvm::errs() << "<unknown Expr, kind " << expr->getKind() << ">\n";
       });

mlir/examples/toy/Ch5/parser/AST.cpp

 //===- AST.cpp - Helper for printing out the Toy AST ----------------------===//
 //
 // 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 implements the AST dump for the Toy language.
 //
 //===----------------------------------------------------------------------===//
 
 #include "toy/AST.h"
 
-#include "mlir/ADT/TypeSwitch.h"
 #include "mlir/Support/STLExtras.h"
 #include "llvm/ADT/Twine.h"
+#include "llvm/ADT/TypeSwitch.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace toy;
 
 namespace {
 
 // RAII helper to manage increasing/decreasing the indentation as we traverse
 // the AST

 // Helper Macro to bump the indentation level and print the leading spaces for
 // the current indentations
 #define INDENT()                                                               \
   Indent level_(curIndent);                                                    \
   indent();
 
 /// Dispatch to a generic expressions to the appropriate subclass using RTTI
 void ASTDumper::dump(ExprAST *expr) {
-  mlir::TypeSwitch<ExprAST *>(expr)
+  llvm::TypeSwitch<ExprAST *>(expr)
       .Case<BinaryExprAST, CallExprAST, LiteralExprAST, NumberExprAST,
             PrintExprAST, ReturnExprAST, VarDeclExprAST, VariableExprAST>(
           [&](auto *node) { this->dump(node); })
       .Default([&](ExprAST *) {
         // No match, fallback to a generic message
         INDENT();
         llvm::errs() << "<unknown Expr, kind " << expr->getKind() << ">\n";
       });

mlir/examples/toy/Ch6/parser/AST.cpp

 //===- AST.cpp - Helper for printing out the Toy AST ----------------------===//
 //
 // 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 implements the AST dump for the Toy language.
 //
 //===----------------------------------------------------------------------===//
 
 #include "toy/AST.h"
 
-#include "mlir/ADT/TypeSwitch.h"
 #include "mlir/Support/STLExtras.h"
 #include "llvm/ADT/Twine.h"
+#include "llvm/ADT/TypeSwitch.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace toy;
 
 namespace {
 
 // RAII helper to manage increasing/decreasing the indentation as we traverse
 // the AST

 // Helper Macro to bump the indentation level and print the leading spaces for
 // the current indentations
 #define INDENT()                                                               \
   Indent level_(curIndent);                                                    \
   indent();
 
 /// Dispatch to a generic expressions to the appropriate subclass using RTTI
 void ASTDumper::dump(ExprAST *expr) {
-  mlir::TypeSwitch<ExprAST *>(expr)
+  llvm::TypeSwitch<ExprAST *>(expr)
       .Case<BinaryExprAST, CallExprAST, LiteralExprAST, NumberExprAST,
             PrintExprAST, ReturnExprAST, VarDeclExprAST, VariableExprAST>(
           [&](auto *node) { this->dump(node); })
       .Default([&](ExprAST *) {
         // No match, fallback to a generic message
         INDENT();
         llvm::errs() << "<unknown Expr, kind " << expr->getKind() << ">\n";
       });

mlir/examples/toy/Ch7/parser/AST.cpp

 //===- AST.cpp - Helper for printing out the Toy AST ----------------------===//
 //
 // 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 implements the AST dump for the Toy language.
 //
 //===----------------------------------------------------------------------===//
 
 #include "toy/AST.h"
 
-#include "mlir/ADT/TypeSwitch.h"
 #include "mlir/Support/STLExtras.h"
 #include "llvm/ADT/Twine.h"
+#include "llvm/ADT/TypeSwitch.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace toy;
 
 namespace {
 
 // RAII helper to manage increasing/decreasing the indentation as we traverse
 // the AST

 // Helper Macro to bump the indentation level and print the leading spaces for
 // the current indentations
 #define INDENT()                                                               \
   Indent level_(curIndent);                                                    \
   indent();
 
 /// Dispatch to a generic expressions to the appropriate subclass using RTTI
 void ASTDumper::dump(ExprAST *expr) {
-  mlir::TypeSwitch<ExprAST *>(expr)
+  llvm::TypeSwitch<ExprAST *>(expr)
       .Case<BinaryExprAST, CallExprAST, LiteralExprAST, NumberExprAST,
             PrintExprAST, ReturnExprAST, StructLiteralExprAST, VarDeclExprAST,
             VariableExprAST>([&](auto *node) { this->dump(node); })
       .Default([&](ExprAST *) {
         // No match, fallback to a generic message
         INDENT();
         llvm::errs() << "<unknown Expr, kind " << expr->getKind() << ">\n";
       });

mlir/include/mlir/Support/LLVM.h

 template <typename KeyT, typename ValueT> struct DenseMapPair;
 }
 template <typename T> struct DenseMapInfo;
 template <typename ValueT, typename ValueInfoT> class DenseSet;
 template <typename KeyT, typename ValueT, typename KeyInfoT, typename BucketT>
 class DenseMap;
 template <typename Fn> class function_ref;
 template <typename IteratorT> class iterator_range;
+template <typename T, typename ResultT> class TypeSwitch;
 
 // Other common classes.
 class raw_ostream;
 class APInt;
 class APFloat;
 } // end namespace llvm
 
 namespace mlir {

 using llvm::SmallPtrSetImpl;
 using llvm::SmallString;
 using llvm::SmallVector;
 using llvm::SmallVectorImpl;
 using llvm::StringLiteral;
 using llvm::StringRef;
 using llvm::TinyPtrVector;
 using llvm::Twine;
+template <typename T, typename ResultT = void>
+using TypeSwitch = llvm::TypeSwitch<T, ResultT>;
 
 // Other common classes.
 using llvm::APFloat;
 using llvm::APInt;
 using llvm::raw_ostream;
 } // namespace mlir
 
 #endif // MLIR_SUPPORT_LLVM_H

mlir/lib/Conversion/StandardToLLVM/StandardToLLVM.cpp

 //===- StandardToLLVM.cpp - Standard to LLVM dialect conversion -----------===//
 //
 // 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 implements a pass to convert MLIR standard and builtin dialects
 // into the LLVM IR dialect.
 //
 //===----------------------------------------------------------------------===//
 
 #include "../PassDetail.h"
-#include "mlir/ADT/TypeSwitch.h"
 #include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h"
 #include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVMPass.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/IR/Module.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/IR/TypeUtilities.h"
 #include "mlir/Support/LogicalResult.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "mlir/Transforms/Passes.h"
 #include "mlir/Transforms/Utils.h"
+#include "llvm/ADT/TypeSwitch.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/Type.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/FormatVariadic.h"
 #include <functional>
 
 using namespace mlir;

mlir/lib/Dialect/SPIRV/Serialization/Serializer.cpp

 //===- Serializer.cpp - MLIR SPIR-V Serialization -------------------------===//
 //
 // 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 MLIR SPIR-V module to SPIR-V binary serialization.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/SPIRV/Serialization.h"
 
-#include "mlir/ADT/TypeSwitch.h"
 #include "mlir/Dialect/SPIRV/SPIRVAttributes.h"
 #include "mlir/Dialect/SPIRV/SPIRVBinaryUtils.h"
 #include "mlir/Dialect/SPIRV/SPIRVDialect.h"
 #include "mlir/Dialect/SPIRV/SPIRVOps.h"
 #include "mlir/Dialect/SPIRV/SPIRVTypes.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/RegionGraphTraits.h"
 #include "mlir/Support/LogicalResult.h"
 #include "mlir/Support/StringExtras.h"
 #include "llvm/ADT/DepthFirstIterator.h"
 #include "llvm/ADT/Sequence.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/TypeSwitch.h"
 #include "llvm/ADT/bit.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 
 #define DEBUG_TYPE "spirv-serialization"
 
 using namespace mlir;
 

mlir/lib/TableGen/Operator.cpp

 //===- Operator.cpp - Operator class --------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Operator wrapper to simplify using TableGen Record defining a MLIR Op.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/TableGen/Operator.h"
-#include "mlir/ADT/TypeSwitch.h"
 #include "mlir/TableGen/OpTrait.h"
 #include "mlir/TableGen/Predicate.h"
 #include "mlir/TableGen/Type.h"
 #include "llvm/ADT/SmallPtrSet.h"
+#include "llvm/ADT/TypeSwitch.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/TableGen/Error.h"
 #include "llvm/TableGen/Record.h"
 
 #define DEBUG_TYPE "mlir-tblgen-operator"
 
 using namespace mlir;

mlir/lib/TableGen/Successor.cpp

 //===- Successor.cpp - Successor class ------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Successor wrapper to simplify using TableGen Record defining a MLIR
 // Successor.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/TableGen/Successor.h"
-#include "mlir/ADT/TypeSwitch.h"
+#include "llvm/ADT/TypeSwitch.h"
 #include "llvm/TableGen/Record.h"
 
 using namespace mlir;
 using namespace mlir::tblgen;
 
 // Returns true if this successor is variadic.
 bool Successor::isVariadic() const {
   return def->isSubClassOf("VariadicSuccessor");
 }

mlir/lib/TableGen/Type.cpp

 //===- Type.cpp - Type class ----------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Type wrapper to simplify using TableGen Record defining a MLIR Type.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/TableGen/Type.h"
-#include "mlir/ADT/TypeSwitch.h"
+#include "llvm/ADT/TypeSwitch.h"
 #include "llvm/TableGen/Record.h"
 
 using namespace mlir;
 using namespace mlir::tblgen;
 
 TypeConstraint::TypeConstraint(const llvm::Record *record)
     : Constraint(Constraint::CK_Type, record) {
   assert(def->isSubClassOf("TypeConstraint") &&

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

 //===- ModuleTranslation.cpp - MLIR to LLVM conversion --------------------===//
 //
 // 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 implements the translation between an MLIR LLVM dialect module and
 // the corresponding LLVMIR module. It only handles core LLVM IR operations.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Target/LLVMIR/ModuleTranslation.h"
 
 #include "DebugTranslation.h"
-#include "mlir/ADT/TypeSwitch.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/Dialect/OpenMP/OpenMPDialect.h"
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/Module.h"
 #include "mlir/IR/StandardTypes.h"
 #include "mlir/Support/LLVM.h"
+#include "llvm/ADT/TypeSwitch.h"
 
 #include "llvm/ADT/SetVector.h"
 #include "llvm/Frontend/OpenMP/OMPIRBuilder.h"
 #include "llvm/IR/BasicBlock.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/LLVMContext.h"

 /// (including OpenMP runtime calls).
 LogicalResult
 ModuleTranslation::convertOmpOperation(Operation &opInst,
                                        llvm::IRBuilder<> &builder) {
   if (!ompBuilder) {
     ompBuilder = std::make_unique<llvm::OpenMPIRBuilder>(*llvmModule);
     ompBuilder->initialize();
   }
-  return mlir::TypeSwitch<Operation *, LogicalResult>(&opInst)
+  return llvm::TypeSwitch<Operation *, LogicalResult>(&opInst)
       .Case([&](omp::BarrierOp) {
         ompBuilder->CreateBarrier(builder.saveIP(), llvm::omp::OMPD_barrier);
         return success();
       })
       .Case([&](omp::TaskwaitOp) {
         ompBuilder->CreateTaskwait(builder.saveIP());
         return success();
       })

mlir/lib/Transforms/Utils/Utils.cpp

 //===- Utils.cpp ---- Misc utilities for code and data transformation -----===//
 //
 // 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 implements miscellaneous transformation routines for non-loop IR
 // structures.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Transforms/Utils.h"
 
-#include "mlir/ADT/TypeSwitch.h"
 #include "mlir/Analysis/AffineAnalysis.h"
 #include "mlir/Analysis/AffineStructures.h"
 #include "mlir/Analysis/Dominance.h"
 #include "mlir/Analysis/Utils.h"
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/Function.h"
 #include "mlir/IR/Module.h"
 #include "mlir/Support/MathExtras.h"
 #include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/TypeSwitch.h"
 using namespace mlir;
 
 /// Return true if this operation dereferences one or more memref's.
 // Temporary utility: will be replaced when this is modeled through
 // side-effects/op traits. TODO(b/117228571)
 static bool isMemRefDereferencingOp(Operation &op) {
   if (isa<AffineLoadOp>(op) || isa<AffineStoreOp>(op) ||
       isa<AffineDmaStartOp>(op) || isa<AffineDmaWaitOp>(op))

mlir/test/lib/Transforms/TestMemRefBoundCheck.cpp

 //===- TestMemRefBoundCheck.cpp - Test out of bound access checks ---------===//
 //
 // 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 implements a pass to check memref accesses for out of bound
 // accesses.
 //
 //===----------------------------------------------------------------------===//
 
-#include "mlir/ADT/TypeSwitch.h"
 #include "mlir/Analysis/AffineAnalysis.h"
 #include "mlir/Analysis/AffineStructures.h"
 #include "mlir/Analysis/Utils.h"
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/Pass/Pass.h"
+#include "llvm/ADT/TypeSwitch.h"
 #include "llvm/Support/Debug.h"
 
 #define DEBUG_TYPE "memref-bound-check"
 
 using namespace mlir;
 
 namespace {
 

mlir/tools/mlir-tblgen/OpFormatGen.cpp

 //===- OpFormatGen.cpp - MLIR operation asm format generator --------------===//
 //
 // 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 "OpFormatGen.h"
-#include "mlir/ADT/TypeSwitch.h"
 #include "mlir/Support/LogicalResult.h"
 #include "mlir/Support/STLExtras.h"
 #include "mlir/TableGen/Format.h"
 #include "mlir/TableGen/GenInfo.h"
 #include "mlir/TableGen/OpClass.h"
 #include "mlir/TableGen/OpInterfaces.h"
 #include "mlir/TableGen/OpTrait.h"
 #include "mlir/TableGen/Operator.h"
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/Sequence.h"
 #include "llvm/ADT/SmallBitVector.h"
 #include "llvm/ADT/StringExtras.h"
+#include "llvm/ADT/TypeSwitch.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/TableGen/Error.h"
 #include "llvm/TableGen/Record.h"
 
 #define DEBUG_TYPE "mlir-tblgen-opformatgen"
 
 using namespace mlir;

mlir/unittests/ADT/CMakeLists.txt

-add_mlir_unittest(MLIRADTTests
-  TypeSwitchTest.cpp
-)
-
-target_link_libraries(MLIRADTTests PRIVATE MLIRSupport LLVMSupport)

mlir/unittests/CMakeLists.txt

 add_custom_target(MLIRUnitTests)
 set_target_properties(MLIRUnitTests PROPERTIES FOLDER "MLIR Tests")
 
 function(add_mlir_unittest test_dirname)
   add_unittest(MLIRUnitTests ${test_dirname} ${ARGN})
 endfunction()
 
-add_subdirectory(ADT)
 add_subdirectory(Dialect)
 add_subdirectory(IR)
 add_subdirectory(Pass)
 add_subdirectory(SDBM)
 add_subdirectory(TableGen)