Adjust cl::opt uses for opt_storage refactored

[yrouban]

Summary

This patch fixes compilation errors that result from refactoring of LLVM cl::opt structures introduced by D53426.
Basically for class-based cl::opt<MyClass> to access to the instance of MyClass one of the overloadable operators should be used.

For example if we have an option defined as cl::opt<std::string> MyStringOption;
Then the changes should look like the following:

Old: MyStringOption.c_str()
New: MyStringOption->c_str()

Old: cout << MyStringOption;
New: cout << *MyStringOption;

lib/Tooling/Execution.cpp

if (!Executor) {
       return llvm::make_error<llvm::StringError>(
           llvm::Twine("Failed to create '") + I->getName() +
               "': " + llvm::toString(Executor.takeError()) + "\n",
           llvm::inconvertibleErrorCode());
     }
     return std::move(*Executor);
   }
   return llvm::make_error<llvm::StringError>(
-      llvm::Twine("Executor \"") + ExecutorName + "\" is not registered.",
+      llvm::Twine("Executor \"") + *ExecutorName + "\" is not registered.",
       llvm::inconvertibleErrorCode());
 }
 } // end namespace internal
 
 llvm::Expected<std::unique_ptr<ToolExecutor>>
 createExecutorFromCommandLineArgs(int &argc, const char **argv,
                                   llvm::cl::OptionCategory &Category,
                                   const char *Overview) {

tools/arcmt-test/arcmt-test.cpp

for (ArrayRef<std::string>::iterator
     }
     resultMap[sys::path::stem(fname)] = fname;
   }
 
   ErrorOr<std::unique_ptr<MemoryBuffer>> inputBuf = std::error_code();
   if (RemappingsFile.empty())
     inputBuf = MemoryBuffer::getSTDIN();
   else
-    inputBuf = MemoryBuffer::getFile(RemappingsFile);
+    inputBuf = MemoryBuffer::getFile(*RemappingsFile);
   if (!inputBuf) {
     errs() << "error: could not read remappings input\n";
     return true;
   }
 
   SmallVector<StringRef, 8> strs;
   inputBuf.get()->getBuffer().split(strs, "\n", /*MaxSplit=*/-1,
                                     /*KeepEmpty=*/false);

tools/clang-import-test/clang-import-test.cpp

std::unique_ptr<CompilerInstance> BuildCompilerInstance() {
   std::transform(ClangArgs.begin(), ClangArgs.end(), ClangArgv.begin(),
                  [](const std::string &s) -> const char * { return s.data(); });
   CompilerInvocation::CreateFromArgs(*Inv, ClangArgv.data(),
                                      &ClangArgv.data()[ClangArgv.size()],
                                      Ins->getDiagnostics());
 
   {
     using namespace driver::types;
-    ID Id = lookupTypeForTypeSpecifier(Input.c_str());
+    ID Id = lookupTypeForTypeSpecifier(Input->c_str());
     assert(Id != TY_INVALID);
     if (isCXX(Id)) {
       Inv->getLangOpts()->CPlusPlus = true;
       Inv->getLangOpts()->CPlusPlus11 = true;
       Inv->getHeaderSearchOpts().UseLibcxx = true;
     }
     if (isObjC(Id)) {
       Inv->getLangOpts()->ObjC1 = 1;

tools/clang-rename/ClangRename.cpp

static cl::opt<bool> Force("force",
                            cl::cat(ClangRenameOptions));
 
 int main(int argc, const char **argv) {
   tooling::CommonOptionsParser OP(argc, argv, ClangRenameOptions);
 
   if (!Input.empty()) {
     // Populate QualifiedNames and NewNames from a YAML file.
     ErrorOr<std::unique_ptr<MemoryBuffer>> Buffer =
-        llvm::MemoryBuffer::getFile(Input);
+        llvm::MemoryBuffer::getFile(*Input);
     if (!Buffer) {
-      errs() << "clang-rename: failed to read " << Input << ": "
+      errs() << "clang-rename: failed to read " << *Input << ": "
              << Buffer.getError().message() << "\n";
       return 1;
     }
 
     std::vector<RenameAllInfo> Infos;
     llvm::yaml::Input YAML(Buffer.get()->getBuffer());
     YAML >> Infos;
     for (const auto &Info : Infos) {

tools/diagtool/FindDiagnosticID.cpp

int FindDiagnosticID::run(unsigned int argc, char **argv,
   if (!Diag) {
     // Name to id failed, so try id to name.
     auto Name = getNameFromID(DiagnosticName);
     if (!Name.empty()) {
       OS << Name << '\n';
       return 0;
     }
 
-    llvm::errs() << "error: invalid diagnostic '" << DiagnosticName << "'\n";
+    llvm::errs() << "error: invalid diagnostic '" << *DiagnosticName << "'\n";
     return 1;
   }
   OS << Diag->DiagID << "\n";
   return 0;
 }

unittests/Tooling/ExecutionTest.cpp

TEST(CreateToolExecutorTest, RegisterFlagsBeforeReset) {
 
   llvm::cl::ResetAllOptionOccurrences();
 
   std::vector<const char *> argv = {"prog", "--before_reset=set", "f"};
   int argc = argv.size();
   auto Executor = internal::createExecutorFromCommandLineArgsImpl(
       argc, &argv[0], TestCategory);
   ASSERT_TRUE((bool)Executor);
-  EXPECT_EQ(BeforeReset, "set");
+  EXPECT_EQ(*BeforeReset, "set");
   BeforeReset.removeArgument();
 }
 
 TEST(CreateToolExecutorTest, CreateStandaloneToolExecutor) {
   std::vector<const char *> argv = {"prog", "standalone.cpp"};
   int argc = argv.size();
   auto Executor = internal::createExecutorFromCommandLineArgsImpl(
       argc, &argv[0], TestCategory);