Remove cases of using namespace std

[shafik]

Summary

We had using namespace std; sprinkled around several source files and tests.

This also follows the LLVM coding standard.

[shafik]

As a side note, I noticed that we don't prefix typedefs from cstdint with std:: e.g. size_t. These typedefs are not guaranteed to be in the global namespace.

[JDevlieghere]

LGTM

lldb/source/Core/FileSpecList.cpp

 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Stream.h"
 
 #include <utility>
 
 #include <cstdint>
 
 using namespace lldb_private;
-using namespace std;
 
 FileSpecList::FileSpecList() : m_files() {}
 
 FileSpecList::~FileSpecList() = default;
 
 // Append the "file_spec" to the end of the file spec list.
 void FileSpecList::Append(const FileSpec &file_spec) {
   m_files.push_back(file_spec);

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

 //===-- DWARFDebugAbbrev.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 "DWARFDebugAbbrev.h"
 #include "DWARFDataExtractor.h"
 #include "lldb/Utility/Stream.h"
 
 using namespace lldb;
 using namespace lldb_private;
-using namespace std;
 
 // DWARFAbbreviationDeclarationSet::Clear()
 void DWARFAbbreviationDeclarationSet::Clear() {
   m_idx_offset = 0;
   m_decls.clear();
 }
 
 // DWARFAbbreviationDeclarationSet::Extract()

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

 #include "DWARFDebugAranges.h"
 #include "DWARFDebugInfo.h"
 #include "DWARFDebugInfoEntry.h"
 #include "DWARFFormValue.h"
 #include "DWARFTypeUnit.h"
 
 using namespace lldb;
 using namespace lldb_private;
-using namespace std;
 
 // Constructor
 DWARFDebugInfo::DWARFDebugInfo(SymbolFileDWARF &dwarf,
                                lldb_private::DWARFContext &context)
     : m_dwarf(dwarf), m_context(context), m_units(), m_cu_aranges_up() {}
 
 const DWARFDebugAranges &DWARFDebugInfo::GetCompileUnitAranges() {
   if (m_cu_aranges_up)

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

 #include "DWARFDeclContext.h"
 #include "DWARFFormValue.h"
 #include "DWARFUnit.h"
 #include "SymbolFileDWARF.h"
 #include "SymbolFileDWARFDwo.h"
 
 using namespace lldb_private;
 using namespace lldb_private::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/DWARFUnit.cpp

 #include "DWARFDebugInfo.h"
 #include "DWARFTypeUnit.h"
 #include "LogChannelDWARF.h"
 #include "SymbolFileDWARFDwo.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::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)
     : UserID(uid), m_dwarf(dwarf), m_header(header), m_abbrevs(&abbrevs),
if (offset == 0) {
     // This means DW_AT_rnglists_base is missing and therefore DW_FORM_rnglistx
     // cannot be handled. Returning a default-constructed ListTableType allows
     // DW_FORM_sec_offset to be supported.
     return ListTableType();
   }
 
   uint64_t HeaderSize = llvm::DWARFListTableHeader::getHeaderSize(format);
   if (offset < HeaderSize)
-    return llvm::createStringError(errc::invalid_argument,
+    return llvm::createStringError(std::errc::invalid_argument,
                                    "did not detect a valid"
                                    " list table with base = 0x%" PRIx64 "\n",
                                    offset);
   offset -= HeaderSize;
   ListTableType Table;
   if (llvm::Error E = Table.extractHeaderAndOffsets(data, &offset))
     return std::move(E);
   return Table;
else
           m_ranges_base, toString(table_or_error.takeError()).c_str());
   }
   return m_rnglist_table;
 }
 
 // This function is called only for DW_FORM_rnglistx.
 llvm::Expected<uint64_t> DWARFUnit::GetRnglistOffset(uint32_t Index) {
   if (!GetRnglistTable())
-    return llvm::createStringError(errc::invalid_argument,
+    return llvm::createStringError(std::errc::invalid_argument,
                                    "missing or invalid range list table");
   if (!m_ranges_base)
-    return llvm::createStringError(errc::invalid_argument,
+    return llvm::createStringError(std::errc::invalid_argument,
                                    "DW_FORM_rnglistx cannot be used without "
                                    "DW_AT_rnglists_base for CU at 0x%8.8x",
                                    GetOffset());
   if (llvm::Optional<uint64_t> off = GetRnglistTable()->getOffsetEntry(
           GetRnglistData().GetAsLLVM(), Index))
     return *off + m_ranges_base;
   return llvm::createStringError(
-      errc::invalid_argument,
+      std::errc::invalid_argument,
       "invalid range list table index %u; OffsetEntryCount is %u, "
       "DW_AT_rnglists_base is %" PRIu64,
       Index, GetRnglistTable()->getOffsetEntryCount(), m_ranges_base);
 }
 
 void DWARFUnit::SetStrOffsetsBase(dw_offset_t str_offsets_base) {
   m_str_offsets_base = str_offsets_base;
 }
if (!debug_ranges)
       return llvm::make_error<llvm::object::GenericBinaryError>(
           "No debug_ranges section");
     DWARFRangeList ranges;
     debug_ranges->FindRanges(this, offset, ranges);
     return ranges;
   }
 
   if (!GetRnglistTable())
-    return llvm::createStringError(errc::invalid_argument,
+    return llvm::createStringError(std::errc::invalid_argument,
                                    "missing or invalid range list table");
 
   llvm::DWARFDataExtractor data = GetRnglistData().GetAsLLVM();
 
   // As DW_AT_rnglists_base may be missing we need to call setAddressSize.
   data.setAddressSize(m_header.GetAddressByteSize());
   auto range_list_or_error = GetRnglistTable()->findList(data, offset);
   if (!range_list_or_error)

lldb/test/API/api/multithreaded/inferior.cpp

 
 #include <iostream>
 
-using namespace std;
+
 
 int next() {
   static int i = 0;
-  cout << "incrementing " << i << endl;
+  std::cout << "incrementing " << i << std::endl;
   return ++i;
 }
 
 int main() {
   int i = 0;
   while (i < 5)
     i = next();
   return 0;
 }

lldb/test/API/functionalities/data-formatter/data-formatter-stl/libcxx/queue/main.cpp

 #include <queue>
 #include <vector>
 
-using namespace std;
-
 int main() {
-  queue<int> q1{{1,2,3,4,5}};
-  queue<int, std::vector<int>> q2{{1,2,3,4,5}};
+  std::queue<int> q1{{1,2,3,4,5}};
+  std::queue<int, std::vector<int>> q2{{1,2,3,4,5}};
   int ret = q1.size() + q2.size(); // break here
   return ret;
 }

lldb/test/API/functionalities/data-formatter/data-formatter-stl/libcxx/tuple/main.cpp

 #include <tuple>
 #include <string>
 
-using namespace std;
-
 int main() {
-  tuple<> empty;
-  tuple<int> one_elt{47};
-  tuple<int, long, string> three_elts{1, 47l, "foo"};
+  std::tuple<> empty;
+  std::tuple<int> one_elt{47};
+  std::tuple<int, long, std::string> three_elts{1, 47l, "foo"};
   return 0; // break here
 }

lldb/test/API/functionalities/process_save_core_minidump/main.cpp

 #include <cassert>
 #include <iostream>
 #include <thread>
 
-using namespace std;
-
 void g() { assert(false); }
 
 void f() { g(); }
 
 size_t h() {
   size_t sum = 0;
   for (size_t i = 0; i < 1000000; ++i)
     for (size_t j = 0; j < 1000000; ++j)
       if ((i * j) % 2 == 0) {
         sum += 1;
       }
   return sum;
 }
 
 int main() {
-  thread t1(f);
+  std::thread t1(f);
 
   size_t x = h();
 
   t1.join();
 
-  cout << "X is " << x << "\n";
+  std::cout << "X is " << x << "\n";
   return 0;
-}
+}
 

lldb/test/API/functionalities/thread/concurrent_events/main.cpp

 // This test is intended to create a situation in which multiple events
 // (breakpoints, watchpoints, crashes, and signal generation/delivery) happen
 // from multiple threads. The test expects the debugger to set a breakpoint on
 // the main thread (before any worker threads are spawned) and modify variables
 // which control the number of threads that are spawned for each action.
 
 #include "pseudo_barrier.h"
 #include <vector>
-using namespace std;
 
 #include <pthread.h>
 
 #include <signal.h>
 #include <sys/types.h>
 #include <unistd.h>
 
 typedef std::vector<std::pair<unsigned, void*(*)(void*)> > action_counts;

lldb/unittests/SymbolFile/PDB/Inputs/test-pdb-types.cpp

 // Compile with "cl /c /Zi /GR- /EHsc test-pdb-types.cpp"
 // Link with "link test-pdb-types.obj /debug /nodefaultlib /entry:main
 // /out:test-pdb-types.exe"
 
-using namespace std;
-
 // Sizes of builtin types
 static const int sizeof_char = sizeof(char);
 static const int sizeof_uchar = sizeof(unsigned char);
 static const int sizeof_short = sizeof(short);
 static const int sizeof_ushort = sizeof(unsigned short);
 static const int sizeof_int = sizeof(int);
 static const int sizeof_uint = sizeof(unsigned int);
 static const int sizeof_long = sizeof(long);