[LLVM] Fix Bug introduced from "llvm::Optional => std::optional"

[Qfrost911]

Summary

In [DebugInfo] llvm::Optional => std::optional (Git Hash:89fab98e884f05076bbd420d95b5de3596f5452c), he have converted all of defines of functions from llvm::Optional to std::optional, including function llvm::TargetMachine *llvm::Target::createTargetMachine

But in the llvm\examples\Kaleidoscope\Chapter8\toy.cpp, the type of RM is llvm::Optional<Reloc::Model>, when this variable is passed in as a parameter to the llvm::TargetMachine *llvm::Target::createTargetMachine, an error will be raised.

error C2664: “llvm::TargetMachine *llvm::Target::createTargetMachine(llvm::StringRef,llvm::StringRef,llvm::StringRef,const llvm::TargetOptions &,std::optional<llvm::Reloc::Model>,std::optional<llvm::CodeModel::Model>,llvm::CodeGenOpt::Level,bool) const”: Unable to convert parameter 5 from "llvm::Optional<llvm::Reloc::Model>" to "std::optional<llvm::Reloc::Model>"

My patch modified the type of RM from llvm::Optional<llvm::Reloc::Model> to std::optional<Reloc::Model>

Additionally, my build environment is VisualStudio2019, I didn't know why his revision passed the CI.

[MaskRay]

Thanks! LLVM_INCLUDE_EXAMPLES=off is the default, so I didn't notice this.

[Qfrost911]

Adjust clang-format

llvm/examples/Kaleidoscope/Chapter8/toy.cpp

 #include "llvm/Target/TargetOptions.h"
 #include <algorithm>
 #include <cassert>
 #include <cctype>
 #include <cstdio>
 #include <cstdlib>
 #include <map>
 #include <memory>
+#include <optional>
 #include <string>
 #include <system_error>
 #include <utility>
 #include <vector>
 
 using namespace llvm;
 using namespace llvm::sys;
 

 
   getNextToken();
 
   auto Else = ParseExpression();
   if (!Else)
     return nullptr;
 
   return std::make_unique<IfExprAST>(std::move(Cond), std::move(Then),
-                                      std::move(Else));
 }
 
 /// forexpr ::= 'for' identifier '=' expr ',' expr (',' expr)? 'in' expression
 static std::unique_ptr<ExprAST> ParseForExpr() {
   getNextToken(); // eat the for.
 
   if (CurTok != tok_identifier)
     return LogError("expected identifier after for");

     return LogError("expected 'in' after for");
   getNextToken(); // eat 'in'.
 
   auto Body = ParseExpression();
   if (!Body)
     return nullptr;
 
   return std::make_unique<ForExprAST>(IdName, std::move(Start), std::move(End),
-                                       std::move(Step), std::move(Body));
 }
 
 /// varexpr ::= 'var' identifier ('=' expression)?
 //                    (',' identifier ('=' expression)?)* 'in' expression
 static std::unique_ptr<ExprAST> ParseVarExpr() {
   getNextToken(); // eat the var.
 
   std::vector<std::pair<std::string, std::unique_ptr<ExprAST>>> VarNames;

   // success.
   getNextToken(); // eat ')'.
 
   // Verify right number of names for operator.
   if (Kind && ArgNames.size() != Kind)
     return LogErrorP("Invalid number of operands for operator");
 
   return std::make_unique<PrototypeAST>(FnName, ArgNames, Kind != 0,
-                                         BinaryPrecedence);
 }
 
 /// definition ::= 'def' prototype expression
 static std::unique_ptr<FunctionAST> ParseDefinition() {
   getNextToken(); // eat def.
   auto Proto = ParsePrototype();
   if (!Proto)
     return nullptr;
 
   if (auto E = ParseExpression())
     return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
   return nullptr;
 }
 
 /// toplevelexpr ::= expression
 static std::unique_ptr<FunctionAST> ParseTopLevelExpr() {
   if (auto E = ParseExpression()) {
     // Make an anonymous proto.
     auto Proto = std::make_unique<PrototypeAST>("__anon_expr",
-                                                 std::vector<std::string>());
     return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
   }
   return nullptr;
 }
 
 /// external ::= 'extern' prototype
 static std::unique_ptr<PrototypeAST> ParseExtern() {
   getNextToken(); // eat extern.

     errs() << Error;
     return 1;
   }
 
   auto CPU = "generic";
   auto Features = "";
 
   TargetOptions opt;
-  auto RM = Optional<Reloc::Model>();
+  std::optional<Reloc::Model> RM;
   auto TheTargetMachine =
       Target->createTargetMachine(TargetTriple, CPU, Features, opt, RM);
 
   TheModule->setDataLayout(TheTargetMachine->createDataLayout());
 
   auto Filename = "output.o";
   std::error_code EC;
   raw_fd_ostream dest(Filename, EC, sys::fs::OF_None);