[LLDB] Remove cases of using namespace llvm:: from header file

[shafik]

Summary

We have two cases where we do some form of using namespace llvm:: in LLDB headers. I remove those cases and modified the effected files to either use the fully qualified name of using namespace inside a function.

[shafik]

I used using namespace in a few functions but I am not committed to this approach. So I am happy to hear feedback on whether we want to just use fully qualified names everywhere instead or nail down a criteria as to when it is acceptable.

We also have using namespace lldb in a few header files but I wanted to tackle that separately based on the feedback on this.

[kastiglione]

For the .cpp files with hundreds of lines modified, what do you think about adding using namespace llvm::dwarf; to those? For starters DWARFExpression.cpp, DWARFAbbreviationDeclaration.cpp, and SymbolFileDWARF.cpp.

[kastiglione]

sorry Shafik I see that you've asked that very question. I'll give a +1 to making use of using namespace within .cpp files, especially where a namespace is used pervasively. When a file uses it only a namespace infrequently, I think explicit is reasonable.

[labath]

I think it's reasonable to be able to refer to the dwarf constants from within the dwarf plugin via their base names alone. The implementation -- a top-level using namespace llvm::dwarf -- is not reasonable, but that's because the plugin is very old, and completely unnamespaced.

For the newer plugins, we've started putting them in a sub-namespace of lldb_private, which means they cannot be accidentally referenced from the core code, but they can easily reference (without qualification) symbols defined in the core libraries.

If we put the dwarf plugin into a (e.g.) lldb_private::dwarf namespace, then I think it would be ok to put a using namespace llvm::dwarf into that namespace, even in a header -- because those symbols would only be visible to symbols which are in that namespace.

In other words, I'd have the dwarf plugin do what the minidump plugin is doing (disclaimer: I wrote most of that plugin).

Anyway, I'm not married to that approach, but that's what I would do...

[tschuett]

I found this:
https://llvm.org/docs/CodingStandards.html#use-namespace-qualifiers-to-implement-previously-declared-functions

[shafik]

In D120836#3355167, @labath wrote:

I think it's reasonable to be able to refer to the dwarf constants from within the dwarf plugin via their base names alone. The implementation -- a top-level using namespace llvm::dwarf -- is not reasonable, but that's because the plugin is very old, and completely unnamespaced.

For the newer plugins, we've started putting them in a sub-namespace of lldb_private, which means they cannot be accidentally referenced from the core code, but they can easily reference (without qualification) symbols defined in the core libraries.

If we put the dwarf plugin into a (e.g.) lldb_private::dwarf namespace, then I think it would be ok to put a using namespace llvm::dwarf into that namespace, even in a header -- because those symbols would only be visible to symbols which are in that namespace.

In other words, I'd have the dwarf plugin do what the minidump plugin is doing (disclaimer: I wrote most of that plugin).

Anyway, I'm not married to that approach, but that's what I would do...

If I understand correctly you are proposing that I do:

namespace lldb_private {
namespace dwarf {
  using namespace llvm::dwarf;
}
}

in lldb/include/lldb/Core/dwarf.h and then in the .cpp files:

using namespace lldb_private;
using namespace dwarf;

That sounds reasonable to me.

Then I would revert the changes to the minidump files, since they are already using this strategy.

[labath]

In D120836#3355245, @shafik wrote:

In D120836#3355167, @labath wrote:

I think it's reasonable to be able to refer to the dwarf constants from within the dwarf plugin via their base names alone. The implementation -- a top-level using namespace llvm::dwarf -- is not reasonable, but that's because the plugin is very old, and completely unnamespaced.

For the newer plugins, we've started putting them in a sub-namespace of lldb_private, which means they cannot be accidentally referenced from the core code, but they can easily reference (without qualification) symbols defined in the core libraries.

If we put the dwarf plugin into a (e.g.) lldb_private::dwarf namespace, then I think it would be ok to put a using namespace llvm::dwarf into that namespace, even in a header -- because those symbols would only be visible to symbols which are in that namespace.

In other words, I'd have the dwarf plugin do what the minidump plugin is doing (disclaimer: I wrote most of that plugin).

Anyway, I'm not married to that approach, but that's what I would do...

If I understand correctly you are proposing that I do:

namespace lldb_private {
namespace dwarf {
  using namespace llvm::dwarf;
}
}

in lldb/include/lldb/Core/dwarf.h and then in the .cpp files:

using namespace lldb_private;
using namespace dwarf;

Yes, that's the general idea. I'm not entirely sure how to apply that to the DWARFExpression class, since it is not really a part of the dwarf plugin. But all of the uses of dwarf constants are in the cpp file, so I suppose a using namespace llvm::dwarf in DWARFExpression.cpp file should suffice.

[shafik]

Updating diff based on comments

[JDevlieghere]

lldb/source/Expression/DWARFExpression.cpp

46

Why not lldb_private::dwarf?

lldb/source/Plugins/SymbolFile/DWARF/AppleDWARFIndex.cpp

19

Wouldn't it be more consistent to use lldb_private::dwarf everywhere?

[JDevlieghere]

lldb/source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.cpp

35

Oh no...

[shafik]

lldb/source/Expression/DWARFExpression.cpp

46

I think I started out with this file and must have written that by mistake.

lldb/source/Plugins/SymbolFile/DWARF/AppleDWARFIndex.cpp

19

Yeah, I was trying to match the style of how it was done for minidump, see source/Plugins/Process/minidump/MinidumpParser.cpp.

Since we need access to both namespaces but in files that did already have using namespace lldb_private; I just used the less verbose version.

I can see arguments for just being verbose everywhere.

lldb/source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.cpp

35

Yeah I noticed that was going to put that on a list of things to do, didn't feel right mixing that in here as well.

[JDevlieghere]

lldb/source/Plugins/SymbolFile/DWARF/AppleDWARFIndex.cpp

19

Maybe it's just preference? Curious to hear from @labath why he did it that way. Personally I prefer the slightly more verbose one because it's self contained.

lldb/source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.cpp

35

Totally!

[labath]

lldb/source/Plugins/SymbolFile/DWARF/AppleDWARFIndex.cpp

19

Actually, I totally agree with you here. I think I did not personally write that using directive. I recall noticing it (during review, or during subsequent edits), but not considering it worth the trouble of changing it.

So +1 to verbose using directives.

[shafik]

Moved to using namespace lldb_private::dwarf everywhere since the consensus is that being verbose is preferred.

lldb/include/lldb/Core/dwarf.h

 #define LLDB_CORE_DWARF_H
 
 #include "lldb/Utility/RangeMap.h"
 #include <cstdint>
 
 // Get the DWARF constant definitions from llvm
 #include "llvm/BinaryFormat/Dwarf.h"
 
-// and stuff them in our default namespace
+namespace lldb_private {
+namespace dwarf {
   using namespace llvm::dwarf;
+}
+}
 
 typedef uint32_t dw_uleb128_t;
 typedef int32_t dw_sleb128_t;
 typedef uint16_t dw_attr_t;
 typedef uint16_t dw_form_t;
 typedef llvm::dwarf::Tag dw_tag_t;
 typedef uint64_t dw_addr_t; // Dwarf address define that must be big enough for
                             // any addresses in the compile units that get

lldb/include/lldb/Symbol/DWARFCallFrameInfo.h

uint8_t lsda_addr_encoding;   // The encoding of the LSDA address in the FDE
                                   // augmentation data
     lldb::addr_t personality_loc; // (file) address of the pointer to the
                                   // personality routine
     lldb_private::UnwindPlan::Row initial_row;
 
     CIE(dw_offset_t offset)
         : cie_offset(offset), version(-1), code_align(0), data_align(0),
           return_addr_reg_num(LLDB_INVALID_REGNUM), inst_offset(0),
-          inst_length(0), ptr_encoding(0), lsda_addr_encoding(DW_EH_PE_omit),
+          inst_length(0), ptr_encoding(0),
+          lsda_addr_encoding(llvm::dwarf::DW_EH_PE_omit),
           personality_loc(LLDB_INVALID_ADDRESS) {}
   };
 
   typedef std::shared_ptr<CIE> CIESP;
 
   typedef std::map<dw_offset_t, CIESP> cie_map_t;
 
   // Start address (file address), size, offset of FDE location used for

lldb/source/Expression/DWARFExpression.cpp

 #include "lldb/Target/Thread.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugLoc.h"
 #include "llvm/DebugInfo/DWARF/DWARFExpression.h"
 
 #include "Plugins/SymbolFile/DWARF/DWARFUnit.h"
 
 using namespace lldb;
 using namespace lldb_private;
+using namespace llvm::dwarf;
 
 static lldb::addr_t
 ReadAddressFromDebugAddrSection(const DWARFUnit *dwarf_cu,
                                 uint32_t index) {
   uint32_t index_size = dwarf_cu->GetAddressByteSize();
   dw_offset_t addr_base = dwarf_cu->GetAddrBase();
   lldb::offset_t offset = addr_base + index * index_size;
   const DWARFDataExtractor &data =

lldb/source/Plugins/SymbolFile/DWARF/AppleDWARFIndex.cpp

 #include "Plugins/SymbolFile/DWARF/DWARFUnit.h"
 #include "Plugins/SymbolFile/DWARF/LogChannelDWARF.h"
 
 #include "lldb/Core/Module.h"
 #include "lldb/Symbol/Function.h"
 
 using namespace lldb_private;
 using namespace lldb;
+using namespace dwarf;
 
 std::unique_ptr<AppleDWARFIndex> AppleDWARFIndex::Create(
     Module &module, DWARFDataExtractor apple_names,
     DWARFDataExtractor apple_namespaces, DWARFDataExtractor apple_types,
     DWARFDataExtractor apple_objc, DWARFDataExtractor debug_str) {
   auto apple_names_table_up = std::make_unique<DWARFMappedHash::MemoryTable>(
       apple_names, debug_str, ".apple_names");
   if (!apple_names_table_up->IsValid())

lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

 #include <cstdio>
 #define DEBUG_PRINTF(fmt, ...) printf(fmt, __VA_ARGS__)
 #else
 #define DEBUG_PRINTF(fmt, ...)
 #endif
 
 using namespace lldb;
 using namespace lldb_private;
+using namespace dwarf;
 DWARFASTParserClang::DWARFASTParserClang(TypeSystemClang &ast)
     : m_ast(ast), m_die_to_decl_ctx(), m_decl_ctx_to_die() {}
 
 DWARFASTParserClang::~DWARFASTParserClang() = default;
 
 static AccessType DW_ACCESS_to_AccessType(uint32_t dwarf_accessibility) {
   switch (dwarf_accessibility) {
   case DW_ACCESS_public:

lldb/source/Plugins/SymbolFile/DWARF/DWARFAbbreviationDeclaration.cpp

 #include "lldb/Core/dwarf.h"
 #include "lldb/Utility/Stream.h"
 
 #include "llvm/Object/Error.h"
 
 #include "DWARFFormValue.h"
 
 using namespace lldb_private;
+using namespace dwarf;
 
 DWARFAbbreviationDeclaration::DWARFAbbreviationDeclaration() : m_attributes() {}
 
 DWARFAbbreviationDeclaration::DWARFAbbreviationDeclaration(dw_tag_t tag,
                                                            uint8_t has_children)
     : m_code(InvalidCode), m_tag(tag), m_has_children(has_children),
       m_attributes() {}
 

lldb/source/Plugins/SymbolFile/DWARF/DWARFAttribute.cpp

 //===-- DWARFAttribute.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 "DWARFAttribute.h"
 #include "DWARFUnit.h"
 #include "DWARFDebugInfo.h"
 
+using namespace lldb_private::dwarf;
+
 DWARFAttributes::DWARFAttributes() : m_infos() {}
 
 DWARFAttributes::~DWARFAttributes() = default;
 
 uint32_t DWARFAttributes::FindAttributeIndex(dw_attr_t attr) const {
   collection::const_iterator end = m_infos.end();
   collection::const_iterator beg = m_infos.begin();
   collection::const_iterator pos;

lldb/source/Plugins/SymbolFile/DWARF/DWARFDIE.cpp

 
 #include "DWARFASTParser.h"
 #include "DWARFDebugInfo.h"
 #include "DWARFDebugInfoEntry.h"
 #include "DWARFDeclContext.h"
 #include "DWARFUnit.h"
 
 using namespace lldb_private;
+using namespace dwarf;
 
 namespace {
 
 /// Iterate through all DIEs elaborating (i.e. reachable by a chain of
 /// DW_AT_specification and DW_AT_abstract_origin attributes) a given DIE. For
 /// convenience, the starting die is included in the sequence as the first
 /// item.
 class ElaboratingDIEIterator

lldb/source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.cpp

 #include "DWARFDebugRanges.h"
 #include "DWARFDeclContext.h"
 #include "DWARFFormValue.h"
 #include "DWARFUnit.h"
 #include "SymbolFileDWARF.h"
 #include "SymbolFileDWARFDwo.h"
 
 using namespace lldb_private;
+using namespace dwarf;
 using namespace std;
 extern int g_verbose;
 
 // Extract a debug info entry for a given DWARFUnit from the data
 // starting at the offset in offset_ptr
 bool DWARFDebugInfoEntry::Extract(const DWARFDataExtractor &data,
                                   const DWARFUnit *cu,
                                   lldb::offset_t *offset_ptr) {
   m_offset = *offset_ptr;

lldb/source/Plugins/SymbolFile/DWARF/DWARFDebugMacro.cpp

 //===-- DWARFDebugMacro.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 "DWARFDebugMacro.h"
 #include "SymbolFileDWARF.h"
 
 #include "lldb/Symbol/DebugMacros.h"
 
 #include "DWARFDataExtractor.h"
 
 using namespace lldb_private;
+using namespace dwarf;
 
 DWARFDebugMacroHeader
 DWARFDebugMacroHeader::ParseHeader(const DWARFDataExtractor &debug_macro_data,
                                    lldb::offset_t *offset) {
   DWARFDebugMacroHeader header;
 
   // Skip over the version field in header.
   header.m_version = debug_macro_data.GetU16(offset);

lldb/source/Plugins/SymbolFile/DWARF/DWARFDeclContext.cpp

 //===-- DWARFDeclContext.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 "DWARFDeclContext.h"
 
+using namespace lldb_private::dwarf;
+
 const char *DWARFDeclContext::GetQualifiedName() const {
   if (m_qualified_name.empty()) {
     // The declaration context array for a class named "foo" in namespace
     // "a::b::c" will be something like:
     //  [0] DW_TAG_class_type "foo"
     //  [1] DW_TAG_namespace "c"
     //  [2] DW_TAG_namespace "b"
     //  [3] DW_TAG_namespace "a"

lldb/source/Plugins/SymbolFile/DWARF/DWARFFormValue.cpp

 
 #include "DWARFDebugInfo.h"
 #include "DWARFFormValue.h"
 #include "DWARFUnit.h"
 
 class DWARFUnit;
 
 using namespace lldb_private;
+using namespace dwarf;
 
 void DWARFFormValue::Clear() {
   m_unit = nullptr;
   m_form = 0;
   m_value = ValueTypeTag();
 }
 
 bool DWARFFormValue::ExtractValue(const DWARFDataExtractor &data,

lldb/source/Plugins/SymbolFile/DWARF/DWARFUnit.h

public:
   uint8_t GetUnitType() const { return m_unit_type; }
   const llvm::DWARFUnitIndex::Entry *GetIndexEntry() const {
     return m_index_entry;
   }
   uint64_t GetTypeHash() const { return m_type_hash; }
   dw_offset_t GetTypeOffset() const { return m_type_offset; }
   uint64_t GetDWOId() const { return m_dwo_id; }
   bool IsTypeUnit() const {
-    return m_unit_type == DW_UT_type || m_unit_type == DW_UT_split_type;
+    return m_unit_type == llvm::dwarf::DW_UT_type ||
+           m_unit_type == llvm::dwarf::DW_UT_split_type;
   }
   uint32_t GetNextUnitOffset() const { return m_offset + m_length + 4; }
 
   static llvm::Expected<DWARFUnitHeader>
   extract(const lldb_private::DWARFDataExtractor &data, DIERef::Section section,
           lldb_private::DWARFContext &dwarf_context,
           lldb::offset_t *offset_ptr);
 };

lldb/source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp

 #include "DWARFDebugAranges.h"
 #include "DWARFDebugInfo.h"
 #include "DWARFTypeUnit.h"
 #include "LogChannelDWARF.h"
 #include "SymbolFileDWARFDwo.h"
 
 using namespace lldb;
 using namespace lldb_private;
+using namespace dwarf;
 using namespace std;
 
 extern int g_verbose;
 
 DWARFUnit::DWARFUnit(SymbolFileDWARF &dwarf, lldb::user_id_t uid,
                      const DWARFUnitHeader &header,
                      const DWARFAbbreviationDeclarationSet &abbrevs,
                      DIERef::Section section, bool is_dwo)

lldb/source/Plugins/SymbolFile/DWARF/DebugNamesDWARFIndex.cpp

 #include "Plugins/SymbolFile/DWARF/DWARFDeclContext.h"
 #include "Plugins/SymbolFile/DWARF/SymbolFileDWARFDwo.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Utility/RegularExpression.h"
 #include "lldb/Utility/Stream.h"
 
 using namespace lldb_private;
 using namespace lldb;
+using namespace dwarf;
 
 llvm::Expected<std::unique_ptr<DebugNamesDWARFIndex>>
 DebugNamesDWARFIndex::Create(Module &module, DWARFDataExtractor debug_names,
                              DWARFDataExtractor debug_str,
                              SymbolFileDWARF &dwarf) {
   auto index_up = std::make_unique<DebugNames>(debug_names.GetAsLLVM(),
                                                 debug_str.GetAsLLVM());
   if (llvm::Error E = index_up->extract())

lldb/source/Plugins/SymbolFile/DWARF/HashedNameToDIE.cpp

 //===-- HashedNameToDIE.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 "HashedNameToDIE.h"
 #include "llvm/ADT/StringRef.h"
 
+using namespace lldb_private::dwarf;
+
 bool DWARFMappedHash::ExtractDIEArray(
     const DIEInfoArray &die_info_array,
     llvm::function_ref<bool(DIERef ref)> callback) {
   const size_t count = die_info_array.size();
   for (size_t i = 0; i < count; ++i)
     if (!callback(DIERef(die_info_array[i])))
       return false;
   return true;

lldb/source/Plugins/SymbolFile/DWARF/ManualDWARFIndex.cpp

 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/Timer.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/ThreadPool.h"
 
 using namespace lldb_private;
 using namespace lldb;
+using namespace dwarf;
 
 void ManualDWARFIndex::Index() {
   if (m_indexed)
     return;
   m_indexed = true;
 
   ElapsedTime elapsed(m_index_time);
   LLDB_SCOPED_TIMERF("%p", static_cast<void *>(m_dwarf));

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

 #include <cstdio>
 #define DEBUG_PRINTF(fmt, ...) printf(fmt, __VA_ARGS__)
 #else
 #define DEBUG_PRINTF(fmt, ...)
 #endif
 
 using namespace lldb;
 using namespace lldb_private;
+using namespace dwarf;
 
 LLDB_PLUGIN_DEFINE(SymbolFileDWARF)
 
 char SymbolFileDWARF::ID;
 
 namespace {
 
 #define LLDB_PROPERTIES_symbolfiledwarf

lldb/source/Plugins/SymbolFile/DWARF/UniqueDWARFASTType.cpp

 //===-- UniqueDWARFASTType.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 "UniqueDWARFASTType.h"
 
 #include "lldb/Core/Declaration.h"
 
+using namespace lldb_private::dwarf;
+
 bool UniqueDWARFASTTypeList::Find(const DWARFDIE &die,
                                   const lldb_private::Declaration &decl,
                                   const int32_t byte_size,
                                   UniqueDWARFASTType &entry) const {
   for (const UniqueDWARFASTType &udt : m_collection) {
     // Make sure the tags match
     if (udt.m_die.Tag() == die.Tag()) {
       // Validate byte sizes of both types only if both are valid.

lldb/source/Plugins/SymbolFile/PDB/PDBLocationToDWARFExpression.cpp

 #include "llvm/DebugInfo/PDB/PDBSymbolData.h"
 
 #include "Plugins/SymbolFile/NativePDB/CodeViewRegisterMapping.h"
 #include "Plugins/SymbolFile/NativePDB/PdbFPOProgramToDWARFExpression.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::npdb;
+using namespace lldb_private::dwarf;
 using namespace llvm::pdb;
 
 static std::unique_ptr<IPDBFrameData>
 GetCorrespondingFrameData(const IPDBSession &session,
                           const Variable::RangeList &ranges) {
   auto enumFrameData = session.getFrameData();
   if (!enumFrameData)
     return nullptr;

lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp

 #include "Plugins/SymbolFile/PDB/PDBASTParser.h"
 
 #include <cstdio>
 
 #include <mutex>
 
 using namespace lldb;
 using namespace lldb_private;
+using namespace dwarf;
 using namespace clang;
 using llvm::StringSwitch;
 
 LLDB_PLUGIN_DEFINE(TypeSystemClang)
 
 namespace {
 static void VerifyDecl(clang::Decl *decl) {
   assert(decl && "VerifyDecl called with nullptr?");

lldb/source/Symbol/DWARFCallFrameInfo.cpp

 #include "lldb/Utility/LLDBLog.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Timer.h"
 #include <cstring>
 #include <list>
 
 using namespace lldb;
 using namespace lldb_private;
+using namespace llvm::dwarf;
 
 // GetDwarfEHPtr
 //
 // Used for calls when the value type is specified by a DWARF EH Frame pointer
 // encoding.
 static uint64_t
 GetGNUEHPointer(const DataExtractor &DE, offset_t *offset_ptr,
                 uint32_t eh_ptr_enc, addr_t pc_rel_addr, addr_t text_addr,

lldb/source/Symbol/PostfixExpression.cpp

 
 #include "lldb/Symbol/PostfixExpression.h"
 #include "lldb/Core/dwarf.h"
 #include "lldb/Utility/Stream.h"
 #include "llvm/ADT/StringExtras.h"
 
 using namespace lldb_private;
 using namespace lldb_private::postfix;
+using namespace llvm::dwarf;
 
 static llvm::Optional<BinaryOpNode::OpType>
 GetBinaryOpType(llvm::StringRef token) {
   if (token.size() != 1)
     return llvm::None;
   switch (token[0]) {
   case '@':
     return BinaryOpNode::Align;

lldb/unittests/Expression/DWARFExpressionTest.cpp

 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Utility/Reproducer.h"
 #include "lldb/Utility/StreamString.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Testing/Support/Error.h"
 #include "gtest/gtest.h"
 
 using namespace lldb_private;
+using namespace dwarf;
 
 static llvm::Expected<Scalar> Evaluate(llvm::ArrayRef<uint8_t> expr,
                                        lldb::ModuleSP module_sp = {},
                                        DWARFUnit *unit = nullptr,
                                        ExecutionContext *exe_ctx = nullptr) {
   DataExtractor extractor(expr.data(), expr.size(), lldb::eByteOrderLittle,
                           /*addr_size*/ 4);
   Value result;

lldb/unittests/SymbolFile/DWARF/DWARFASTParserClangTests.cpp

 #include "Plugins/SymbolFile/DWARF/DWARFCompileUnit.h"
 #include "Plugins/SymbolFile/DWARF/DWARFDIE.h"
 #include "TestingSupport/Symbol/YAMLModuleTester.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
 using namespace lldb;
 using namespace lldb_private;
+using namespace dwarf;
 
 namespace {
 class DWARFASTParserClangTests : public testing::Test {};
 
 class DWARFASTParserClangStub : public DWARFASTParserClang {
 public:
   using DWARFASTParserClang::DWARFASTParserClang;
   using DWARFASTParserClang::LinkDeclContextToDIE;

lldb/unittests/SymbolFile/DWARF/SymbolFileDWARFTests.cpp

 #include "lldb/Symbol/LineTable.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/DataEncoder.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/StreamString.h"
 
 using namespace lldb;
 using namespace lldb_private;
+using namespace dwarf;
 
 class SymbolFileDWARFTests : public testing::Test {
   SubsystemRAII<FileSystem, HostInfo, ObjectFilePECOFF, SymbolFileDWARF,
                 TypeSystemClang, SymbolFilePDB>
       subsystems;
 
 public:
   void SetUp() override {