[clangd] Remove 'using namespace llvm' from .cpp files. NFC

The new guideline is to qualify with 'llvm::' explicitly both in
'.h' and '.cpp' files. This simplifies moving the code between
header and source files and is easier to keep consistent.

llvm-svn: 350531

1 files changed, 87 insertions, 74 deletions

diff --git a/clang-tools-extra/clangd/index/dex/dexp/Dexp.cpp b/clang-tools-extra/clangd/index/dex/dexp/Dexp.cpp
index 795173c74ad..5a0b6d97122 100644
--- a/clang-tools-extra/clangd/index/dex/dexp/Dexp.cpp
+++ b/clang-tools-extra/clangd/index/dex/dexp/Dexp.cpp
@@ -22,14 +22,13 @@
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Signals.h"
 
-using namespace llvm;
-using namespace clang;
-using namespace clangd;
-
+namespace clang {
+namespace clangd {
 namespace {
 
-cl::opt<std::string> IndexPath("index-path", cl::desc("Path to the index"),
-                               cl::Positional, cl::Required);
+llvm::cl::opt<std::string> IndexPath("index-path",
+                                     llvm::cl::desc("Path to the index"),
+                                     llvm::cl::Positional, llvm::cl::Required);
 
 static const std::string Overview = R"(
 This is an **experimental** interactive tool to process user-provided search
@@ -40,16 +39,16 @@ and manually construct non-trivial test cases.
 Type use "help" request to get information about the details.
 )";
 
-void reportTime(StringRef Name, function_ref<void()> F) {
+void reportTime(llvm::StringRef Name, llvm::function_ref<void()> F) {
   const auto TimerStart = std::chrono::high_resolution_clock::now();
   F();
   const auto TimerStop = std::chrono::high_resolution_clock::now();
   const auto Duration = std::chrono::duration_cast<std::chrono::milliseconds>(
       TimerStop - TimerStart);
-  outs() << formatv("{0} took {1:ms+n}.\n", Name, Duration);
+  llvm::outs() << llvm::formatv("{0} took {1:ms+n}.\n", Name, Duration);
 }
 
-std::vector<SymbolID> getSymbolIDsFromIndex(StringRef QualifiedName,
+std::vector<SymbolID> getSymbolIDsFromIndex(llvm::StringRef QualifiedName,
                                             const SymbolIndex *Index) {
   FuzzyFindRequest Request;
   // Remove leading "::" qualifier as FuzzyFind doesn't need leading "::"
@@ -77,9 +76,9 @@ std::vector<SymbolID> getSymbolIDsFromIndex(StringRef QualifiedName,
 // Creating a Command populates parser options, parseAndRun() resets them.
 class Command {
   // By resetting the parser options, we lost the standard -help flag.
-  cl::opt<bool, false, cl::parser<bool>> Help{
-      "help", cl::desc("Display available options"), cl::ValueDisallowed,
-      cl::cat(cl::GeneralCategory)};
+  llvm::cl::opt<bool, false, llvm::cl::parser<bool>> Help{
+      "help", llvm::cl::desc("Display available options"),
+      llvm::cl::ValueDisallowed, llvm::cl::cat(llvm::cl::GeneralCategory)};
   virtual void run() = 0;
 
 protected:
@@ -87,24 +86,25 @@ protected:
 
 public:
   virtual ~Command() = default;
-  virtual void parseAndRun(ArrayRef<const char *> Argv, const char *Overview,
-                           const SymbolIndex &Index) {
+  virtual void parseAndRun(llvm::ArrayRef<const char *> Argv,
+                           const char *Overview, const SymbolIndex &Index) {
     std::string ParseErrs;
-    raw_string_ostream OS(ParseErrs);
-    bool Ok =
-        cl::ParseCommandLineOptions(Argv.size(), Argv.data(), Overview, &OS);
+    llvm::raw_string_ostream OS(ParseErrs);
+    bool Ok = llvm::cl::ParseCommandLineOptions(Argv.size(), Argv.data(),
+                                                Overview, &OS);
     if (Help.getNumOccurrences() > 0) {
       // Avoid printing parse errors in this case.
       // (Well, in theory. A bunch get printed to llvm::errs() regardless!)
-      cl::PrintHelpMessage();
+      llvm::cl::PrintHelpMessage();
     } else {
-      outs() << OS.str();
+      llvm::outs() << OS.str();
       if (Ok) {
         this->Index = &Index;
         reportTime(Argv[0], [&] { run(); });
       }
     }
-    cl::ResetCommandLineParser(); // must do this before opts are destroyed.
+    llvm::cl::ResetCommandLineParser(); // must do this before opts are
+                                        // destroyed.
   }
 };
 
@@ -118,20 +118,20 @@ public:
 // * print out tokens with least dense posting lists
 
 class FuzzyFind : public Command {
-  cl::opt<std::string> Query{
+  llvm::cl::opt<std::string> Query{
       "query",
-      cl::Positional,
-      cl::Required,
-      cl::desc("Query string to be fuzzy-matched"),
+      llvm::cl::Positional,
+      llvm::cl::Required,
+      llvm::cl::desc("Query string to be fuzzy-matched"),
   };
-  cl::opt<std::string> Scopes{
+  llvm::cl::opt<std::string> Scopes{
       "scopes",
-      cl::desc("Allowed symbol scopes (comma-separated list)"),
+      llvm::cl::desc("Allowed symbol scopes (comma-separated list)"),
   };
-  cl::opt<unsigned> Limit{
+  llvm::cl::opt<unsigned> Limit{
       "limit",
-      cl::init(10),
-      cl::desc("Max results to display"),
+      llvm::cl::init(10),
+      llvm::cl::desc("Max results to display"),
   };
 
   void run() override {
@@ -139,42 +139,45 @@ class FuzzyFind : public Command {
     Request.Limit = Limit;
     Request.Query = Query;
     if (Scopes.getNumOccurrences() > 0) {
-      SmallVector<StringRef, 8> Scopes;
-      StringRef(this->Scopes).split(Scopes, ',');
+      llvm::SmallVector<llvm::StringRef, 8> Scopes;
+      llvm::StringRef(this->Scopes).split(Scopes, ',');
       Request.Scopes = {Scopes.begin(), Scopes.end()};
     }
     Request.AnyScope = Request.Scopes.empty();
     // FIXME(kbobyrev): Print symbol final scores to see the distribution.
     static const auto OutputFormat = "{0,-4} | {1,-40} | {2,-25}\n";
-    outs() << formatv(OutputFormat, "Rank", "Symbol ID", "Symbol Name");
+    llvm::outs() << llvm::formatv(OutputFormat, "Rank", "Symbol ID",
+                                  "Symbol Name");
     size_t Rank = 0;
     Index->fuzzyFind(Request, [&](const Symbol &Sym) {
-      outs() << formatv(OutputFormat, Rank++, Sym.ID.str(),
-                        Sym.Scope + Sym.Name);
+      llvm::outs() << llvm::formatv(OutputFormat, Rank++, Sym.ID.str(),
+                                    Sym.Scope + Sym.Name);
     });
   }
 };
 
 class Lookup : public Command {
-  cl::opt<std::string> ID{
+  llvm::cl::opt<std::string> ID{
       "id",
-      cl::Positional,
-      cl::desc("Symbol ID to look up (hex)"),
+      llvm::cl::Positional,
+      llvm::cl::desc("Symbol ID to look up (hex)"),
   };
-  cl::opt<std::string> Name{
-      "name", cl::desc("Qualified name to look up."),
+  llvm::cl::opt<std::string> Name{
+      "name",
+      llvm::cl::desc("Qualified name to look up."),
   };
 
   void run() override {
     if (ID.getNumOccurrences() == 0 && Name.getNumOccurrences() == 0) {
-      outs() << "Missing required argument: please provide id or -name.\n";
+      llvm::outs()
+          << "Missing required argument: please provide id or -name.\n";
       return;
     }
     std::vector<SymbolID> IDs;
     if (ID.getNumOccurrences()) {
       auto SID = SymbolID::fromStr(ID);
       if (!SID) {
-        outs() << toString(SID.takeError()) << "\n";
+        llvm::outs() << llvm::toString(SID.takeError()) << "\n";
         return;
       }
       IDs.push_back(*SID);
@@ -187,60 +190,65 @@ class Lookup : public Command {
     bool FoundSymbol = false;
     Index->lookup(Request, [&](const Symbol &Sym) {
       FoundSymbol = true;
-      outs() << toYAML(Sym);
+      llvm::outs() << toYAML(Sym);
     });
     if (!FoundSymbol)
-      outs() << "not found\n";
+      llvm::outs() << "not found\n";
   }
 };
 
 class Refs : public Command {
-  cl::opt<std::string> ID{
-      "id", cl::Positional,
-      cl::desc("Symbol ID of the symbol being queried (hex)."),
+  llvm::cl::opt<std::string> ID{
+      "id",
+      llvm::cl::Positional,
+      llvm::cl::desc("Symbol ID of the symbol being queried (hex)."),
   };
-  cl::opt<std::string> Name{
-      "name", cl::desc("Qualified name of the symbol being queried."),
+  llvm::cl::opt<std::string> Name{
+      "name",
+      llvm::cl::desc("Qualified name of the symbol being queried."),
   };
-  cl::opt<std::string> Filter{
-      "filter", cl::init(".*"),
-      cl::desc(
+  llvm::cl::opt<std::string> Filter{
+      "filter",
+      llvm::cl::init(".*"),
+      llvm::cl::desc(
           "Print all results from files matching this regular expression."),
   };
 
   void run() override {
     if (ID.getNumOccurrences() == 0 && Name.getNumOccurrences() == 0) {
-      outs() << "Missing required argument: please provide id or -name.\n";
+      llvm::outs()
+          << "Missing required argument: please provide id or -name.\n";
       return;
     }
     std::vector<SymbolID> IDs;
     if (ID.getNumOccurrences()) {
       auto SID = SymbolID::fromStr(ID);
       if (!SID) {
-        outs() << toString(SID.takeError()) << "\n";
+        llvm::outs() << llvm::toString(SID.takeError()) << "\n";
         return;
       }
       IDs.push_back(*SID);
     } else {
       IDs = getSymbolIDsFromIndex(Name, Index);
       if (IDs.size() > 1) {
-        outs() << formatv("The name {0} is ambiguous, found {1} different "
-                          "symbols. Please use id flag to disambiguate.\n",
-                          Name, IDs.size());
+        llvm::outs() << llvm::formatv(
+            "The name {0} is ambiguous, found {1} different "
+            "symbols. Please use id flag to disambiguate.\n",
+            Name, IDs.size());
         return;
       }
     }
     RefsRequest RefRequest;
     RefRequest.IDs.insert(IDs.begin(), IDs.end());
-    Regex RegexFilter(Filter);
+    llvm::Regex RegexFilter(Filter);
     Index->refs(RefRequest, [&RegexFilter](const Ref &R) {
       auto U = URI::parse(R.Location.FileURI);
       if (!U) {
-        outs() << U.takeError();
+        llvm::outs() << U.takeError();
         return;
       }
       if (RegexFilter.match(U->body()))
-        outs() << R << "\n";
+        llvm::outs() << R << "\n";
     });
   }
 };
@@ -257,16 +265,20 @@ struct {
      llvm::make_unique<Refs>},
 };
 
-std::unique_ptr<SymbolIndex> openIndex(StringRef Index) {
+std::unique_ptr<SymbolIndex> openIndex(llvm::StringRef Index) {
   return loadIndex(Index, /*UseDex=*/true);
 }
 
 } // namespace
+} // namespace clangd
+} // namespace clang
 
 int main(int argc, const char *argv[]) {
-  cl::ParseCommandLineOptions(argc, argv, Overview);
-  cl::ResetCommandLineParser(); // We reuse it for REPL commands.
-  sys::PrintStackTraceOnErrorSignal(argv[0]);
+  using namespace clang::clangd;
+
+  llvm::cl::ParseCommandLineOptions(argc, argv, Overview);
+  llvm::cl::ResetCommandLineParser(); // We reuse it for REPL commands.
+  llvm::sys::PrintStackTraceOnErrorSignal(argv[0]);
 
   std::unique_ptr<SymbolIndex> Index;
   reportTime("Dex build", [&]() {
@@ -274,28 +286,29 @@ int main(int argc, const char *argv[]) {
   });
 
   if (!Index) {
-    outs() << "Failed to open the index.\n";
+    llvm::outs() << "Failed to open the index.\n";
     return -1;
   }
 
-  LineEditor LE("dexp");
+  llvm::LineEditor LE("dexp");
 
-  while (Optional<std::string> Request = LE.readLine()) {
+  while (llvm::Optional<std::string> Request = LE.readLine()) {
     // Split on spaces and add required null-termination.
     std::replace(Request->begin(), Request->end(), ' ', '\0');
-    SmallVector<StringRef, 8> Args;
-    StringRef(*Request).split(Args, '\0', /*MaxSplit=*/-1, /*KeepEmpty=*/false);
+    llvm::SmallVector<llvm::StringRef, 8> Args;
+    llvm::StringRef(*Request).split(Args, '\0', /*MaxSplit=*/-1,
+                                    /*KeepEmpty=*/false);
     if (Args.empty())
       continue;
     if (Args.front() == "help") {
-      outs() << "dexp - Index explorer\nCommands:\n";
+      llvm::outs() << "dexp - Index explorer\nCommands:\n";
       for (const auto &C : CommandInfo)
-        outs() << formatv("{0,16} - {1}\n", C.Name, C.Description);
-      outs() << "Get detailed command help with e.g. `find -help`.\n";
+        llvm::outs() << llvm::formatv("{0,16} - {1}\n", C.Name, C.Description);
+      llvm::outs() << "Get detailed command help with e.g. `find -help`.\n";
       continue;
     }
-    SmallVector<const char *, 8> FakeArgv;
-    for (StringRef S : Args)
+    llvm::SmallVector<const char *, 8> FakeArgv;
+    for (llvm::StringRef S : Args)
       FakeArgv.push_back(S.data()); // Terminated by separator or end of string.
 
     bool Recognized = false;
@@ -307,7 +320,7 @@ int main(int argc, const char *argv[]) {
       }
     }
     if (!Recognized)
-      outs() << "Unknown command. Try 'help'.\n";
+      llvm::outs() << "Unknown command. Try 'help'.\n";
   }
 
   return 0;