Remove using namespace (#74)

Using namespace in headers is prone to generate conflicts, so specify
the namespace explicitly.

Author: Flakebi

include/llvm-dialects/Dialect/OpMap.h

@@ -34,9 +34,6 @@
 #include <tuple>
 #include <type_traits>
 
-using namespace llvm;
-using namespace llvm_dialects;
-
 namespace llvm_dialects {
 
 // Forward declarations.
@@ -58,7 +55,7 @@ template <typename ValueT> class OpMap final {
   friend class OpMapIteratorBase<ValueT, true>;
   friend class OpMapIteratorBase<ValueT, false>;
 
-  using DialectOpKey = std::pair<StringRef, bool>;
+  using DialectOpKey = std::pair<llvm::StringRef, bool>;
 
   struct DialectOpKV final {
     DialectOpKey Key;
@@ -179,10 +176,10 @@ template <typename ValueT> class OpMap final {
 
   FIND_OVERLOAD(OpDescription)
   FIND_CONST_OVERLOAD(OpDescription)
-  FIND_OVERLOAD(Function)
-  FIND_CONST_OVERLOAD(Function)
-  FIND_OVERLOAD(Instruction)
-  FIND_CONST_OVERLOAD(Instruction)
+  FIND_OVERLOAD(llvm::Function)
+  FIND_CONST_OVERLOAD(llvm::Function)
+  FIND_OVERLOAD(llvm::Instruction)
+  FIND_CONST_OVERLOAD(llvm::Instruction)
 
 #undef FIND_CONST_OVERLOAD
 #undef FIND_OVERLOAD
@@ -207,7 +204,7 @@ template <typename ValueT> class OpMap final {
 
   // Try to lookup a function which is either the callee of an intrinsic call
   // or a dialect operation.
-  ValueT lookup(const Function &func) const {
+  ValueT lookup(const llvm::Function &func) const {
     auto it = find(func);
     if (auto val = it.val(); val)
       return *val;
@@ -217,7 +214,7 @@ template <typename ValueT> class OpMap final {
 
   // Try to lookup an instruction which is either an intrinsic instruction,
   // a dialect operation or a core instruction.
-  ValueT lookup(const Instruction &inst) const {
+  ValueT lookup(const llvm::Instruction &inst) const {
     auto it = find(inst);
     if (auto val = it.val(); val)
       return *val;
@@ -377,9 +374,9 @@ template <typename ValueT> class OpMap final {
 #undef GENERATE_ITERATOR_BODY
 
 private:
-  DenseMap<unsigned, ValueT> m_coreOpcodes;
-  DenseMap<unsigned, ValueT> m_intrinsics;
-  SmallVector<DialectOpKV, 1> m_dialectOps;
+  llvm::DenseMap<unsigned, ValueT> m_coreOpcodes;
+  llvm::DenseMap<unsigned, ValueT> m_intrinsics;
+  llvm::SmallVector<DialectOpKV, 1> m_dialectOps;
 
   template <typename... Args> iterator makeIterator(Args &&...args) {
     return iterator(this, std::forward<Args>(args)...);
@@ -406,13 +403,14 @@ template <typename ValueT> class OpMap final {
 template <typename ValueT, bool isConst> class OpMapIteratorBase final {
   using OpMapT =
       std::conditional_t<isConst, const OpMap<ValueT>, OpMap<ValueT>>;
-  using BaseIteratorT =
-      std::conditional_t<isConst,
-                         typename DenseMap<unsigned, ValueT>::const_iterator,
-                         typename DenseMap<unsigned, ValueT>::iterator>;
+  using BaseIteratorT = std::conditional_t<
+      isConst, typename llvm::DenseMap<unsigned, ValueT>::const_iterator,
+      typename llvm::DenseMap<unsigned, ValueT>::iterator>;
   using DialectOpIteratorT = std::conditional_t<
-      isConst, typename SmallVectorImpl<typename OpMapT::DialectOpKV>::const_iterator,
-      typename SmallVectorImpl<typename OpMapT::DialectOpKV>::iterator>;
+      isConst,
+      typename llvm::SmallVectorImpl<
+          typename OpMapT::DialectOpKV>::const_iterator,
+      typename llvm::SmallVectorImpl<typename OpMapT::DialectOpKV>::iterator>;
 
   using InternalValueT = std::conditional_t<isConst, const ValueT, ValueT>;
 
@@ -598,15 +596,15 @@ template <typename ValueT, bool isConst> class OpMapIteratorBase final {
     }
   }
 
-  OpMapIteratorBase(OpMapT *map, const Function &func) : m_map{map} {
+  OpMapIteratorBase(OpMapT *map, const llvm::Function &func) : m_map{map} {
     createFromFunc(func);
   }
 
   // Do a lookup for a given instruction. Mark the iterator as invalid
   // if the instruction is a call-like core instruction.
-  OpMapIteratorBase(OpMapT *map, const Instruction &inst) : m_map{map} {
-    if (auto *CI = dyn_cast<CallInst>(&inst)) {
-      const Function *callee = CI->getCalledFunction();
+  OpMapIteratorBase(OpMapT *map, const llvm::Instruction &inst) : m_map{map} {
+    if (auto *CI = llvm::dyn_cast<llvm::CallInst>(&inst)) {
+      const llvm::Function *callee = CI->getCalledFunction();
       if (callee) {
         createFromFunc(*callee);
         return;
@@ -616,7 +614,7 @@ template <typename ValueT, bool isConst> class OpMapIteratorBase final {
     const unsigned op = inst.getOpcode();
 
     // Construct an invalid iterator.
-    if (op == Instruction::Call || op == Instruction::CallBr) {
+    if (op == llvm::Instruction::Call || op == llvm::Instruction::CallBr) {
       invalidate();
       return;
     }
@@ -697,7 +695,7 @@ template <typename ValueT, bool isConst> class OpMapIteratorBase final {
 private:
   void invalidate() { m_isInvalid = true; }
 
-  void createFromFunc(const Function &func) {
+  void createFromFunc(const llvm::Function &func) {
     if (func.isIntrinsic()) {
       m_iterator = m_map->m_intrinsics.find(func.getIntrinsicID());
 
@@ -710,7 +708,7 @@ template <typename ValueT, bool isConst> class OpMapIteratorBase final {
     createFromDialectOp(func.getName());
   }
 
-  void createFromDialectOp(StringRef funcName) {
+  void createFromDialectOp(llvm::StringRef funcName) {
     size_t idx = 0;
     bool found = false;
     for (auto &dialectOpKV : m_map->m_dialectOps) {

include/llvm-dialects/Dialect/OpSet.h

@@ -32,12 +32,10 @@
 #include "llvm/IR/Instruction.h"
 #include "llvm/IR/Instructions.h"
 
-using namespace llvm;
-
 namespace llvm_dialects {
 
 struct DialectOpPair final {
-  StringRef mnemonic;
+  llvm::StringRef mnemonic;
   bool isOverload;
 
   // Checks whether the current pair is comparable to an OpDescription
@@ -63,7 +61,7 @@ class OpSet final {
   // -------------------------------------------------------------
 
   // Construct an OpSet from a set of core opcodes.
-  static OpSet fromCoreOpcodes(ArrayRef<unsigned> ops) {
+  static OpSet fromCoreOpcodes(llvm::ArrayRef<unsigned> ops) {
     OpSet set;
     for (const unsigned op : ops)
       set.m_coreOpcodes.insert(op);
@@ -72,7 +70,7 @@ class OpSet final {
   }
 
   // Construct an OpSet from a set of intrinsics.
-  static OpSet fromIntrinsicIDs(ArrayRef<unsigned> intrinsicIDs) {
+  static OpSet fromIntrinsicIDs(llvm::ArrayRef<unsigned> intrinsicIDs) {
     OpSet set;
     for (const unsigned intrinsicID : intrinsicIDs)
       set.m_intrinsicIDs.insert(intrinsicID);
@@ -81,7 +79,7 @@ class OpSet final {
   }
 
   // Construct an OpSet from a set of OpDescriptions.
-  static OpSet fromOpDescriptions(ArrayRef<OpDescription> descs) {
+  static OpSet fromOpDescriptions(llvm::ArrayRef<OpDescription> descs) {
     OpSet set;
     for (const OpDescription &desc : descs)
       set.tryInsertOp(desc);
@@ -132,12 +130,12 @@ class OpSet final {
   }
 
   // Checks if `inst` belongs to the OpSet.
-  bool contains(const Instruction &inst) const {
+  bool contains(const llvm::Instruction &inst) const {
     if (containsCoreOp(inst.getOpcode()))
       return true;
 
-    if (auto *CI = dyn_cast<CallInst>(&inst)) {
-      const Function *Callee = CI->getCalledFunction();
+    if (auto *CI = llvm::dyn_cast<llvm::CallInst>(&inst)) {
+      const llvm::Function *Callee = CI->getCalledFunction();
       if (!Callee)
         return false;
 
@@ -148,7 +146,7 @@ class OpSet final {
   }
 
   // Checks if `func` belongs to the OpSet.
-  bool contains(const Function &func) const {
+  bool contains(const llvm::Function &func) const {
     if (func.isIntrinsic() && containsIntrinsicID(func.getIntrinsicID()))
       return true;
 
@@ -158,11 +156,17 @@ class OpSet final {
   // -------------------------------------------------------------
   // Convenience getters to access the internal data structures.
   // -------------------------------------------------------------
-  const DenseSet<unsigned> &getCoreOpcodes() const { return m_coreOpcodes; }
+  const llvm::DenseSet<unsigned> &getCoreOpcodes() const {
+    return m_coreOpcodes;
+  }
 
-  const DenseSet<unsigned> &getIntrinsicIDs() const { return m_intrinsicIDs; }
+  const llvm::DenseSet<unsigned> &getIntrinsicIDs() const {
+    return m_intrinsicIDs;
+  }
 
-  const ArrayRef<DialectOpPair> getDialectOps() const { return m_dialectOps; }
+  const llvm::ArrayRef<DialectOpPair> getDialectOps() const {
+    return m_dialectOps;
+  }
 
 private:
   // Generates an `OpDescription` for a given `OpT`, extracts the
@@ -176,7 +180,7 @@ class OpSet final {
 
   // Checks if `mnemonic` can be described by any of the stored dialect
   // operations.
-  bool isMatchingDialectOp(StringRef mnemonic) const {
+  bool isMatchingDialectOp(llvm::StringRef mnemonic) const {
     for (const auto &dialectOp : m_dialectOps) {
       if (detail::isOperationDecl(mnemonic, dialectOp.isOverload,
                                   dialectOp.mnemonic))
@@ -211,8 +215,8 @@ class OpSet final {
     return desc.getKind() == OpDescription::Kind::DialectWithOverloads;
   }
 
-  DenseSet<unsigned> m_coreOpcodes;
-  DenseSet<unsigned> m_intrinsicIDs;
-  SmallVector<DialectOpPair, 1> m_dialectOps;
+  llvm::DenseSet<unsigned> m_coreOpcodes;
+  llvm::DenseSet<unsigned> m_intrinsicIDs;
+  llvm::SmallVector<DialectOpPair, 1> m_dialectOps;
 };
 } // namespace llvm_dialects