Support: Remove F_{None,Text,Append} compatibility synonyms, NFC

[dexonsmith]

Summary

Remove the compatibility spellings of OF_{None,Text,Append} that
were left behind by 1f67a3cba9b09636c56e2109d8a35ae96dc15782.

No functionality change here, just an API cleanup.

[MaskRay]

Perhaps split the migration part from the OpenFlags removal part. I thought about deleting the aliases too but refrained because I noticed our internal code base needs migration.
Since you propose this, I will start migration and hopefully can finish that next week so that you will not be blocked.

[MaskRay]

I've fixed Halide and sent patches for https://github.com/JuliaLang/julia/pull/40666 & https://github.com/rust-lang/rust/pull/84724 & https://github.com/GPUOpen-Drivers/llpc/pull/1232

[dexonsmith]

In D101506#2724746, @MaskRay wrote:

Perhaps split the migration part from the OpenFlags removal part. I thought about deleting the aliases too but refrained because I noticed our internal code base needs migration.
Since you propose this, I will start migration and hopefully can finish that next week so that you will not be blocked.

SGTM; I almost split it up from the beginning, not sure what made me lazy about this time. I'll try to post the split tomorrow.

In D101506#2727306, @MaskRay wrote:

I've fixed Halide and sent patches for https://github.com/JuliaLang/julia/pull/40666 & https://github.com/rust-lang/rust/pull/84724 & https://github.com/GPUOpen-Drivers/llpc/pull/1232

Great! Thanks.

[dexonsmith]

Rebased on top of https://reviews.llvm.org/D101506 -- that updates all in-tree users, and now this is just removing the API.

[MaskRay]

Perhaps give us and other projects one week or longer ...

[dexonsmith]

In D101506#2729839, @MaskRay wrote:

Perhaps give us and other projects one week or longer ...

Sure thing; I'll try committing next week some time.

clang/lib/Tooling/DumpTool/ASTSrcLocProcessor.cpp

if (auto ExistingOrErr = MemoryBuffer::getFile(JsonPath, /*IsText=*/true)) {
     raw_string_ostream Out(OutString);
     Out << formatv("{0:2}", JsonVal);
     if (ExistingOrErr.get()->getBuffer() == Out.str())
       return;
     WriteChange = true;
   }
 
   std::error_code EC;
-  llvm::raw_fd_ostream JsonOut(JsonPath, EC, llvm::sys::fs::F_Text);
+  llvm::raw_fd_ostream JsonOut(JsonPath, EC, llvm::sys::fs::OF_Text);
   if (EC)
     return;
 
   if (WriteChange)
     JsonOut << OutString;
   else
     JsonOut << formatv("{0:2}", JsonVal);
 }

clang/lib/Tooling/DumpTool/ClangSrcLocDump.cpp

 static const char Filename[] = "ASTTU.cpp";
 
 int main(int argc, const char **argv) {
 
   cl::ParseCommandLineOptions(argc, argv);
 
   if (SkipProcessing) {
     std::error_code EC;
-    llvm::raw_fd_ostream JsonOut(JsonOutputPath, EC, llvm::sys::fs::F_Text);
+    llvm::raw_fd_ostream JsonOut(JsonOutputPath, EC, llvm::sys::fs::OF_Text);
     if (EC)
       return 1;
     JsonOut << formatv("{0:2}", llvm::json::Value(llvm::json::Object()));
     return 0;
   }
 
   std::vector<std::string> Args;
   Args.push_back("-cc1");

libclc/utils/prepare-builtins.cpp

#endif
   if (OutputFilename.empty()) {
     errs() << "no output file\n";
     return 1;
   }
 
   std::error_code EC;
 #if HAVE_LLVM >= 0x0600
   std::unique_ptr<ToolOutputFile> Out(
-      new ToolOutputFile(OutputFilename, EC, sys::fs::F_None));
+      new ToolOutputFile(OutputFilename, EC, sys::fs::OF_None));
 #else
   std::unique_ptr<tool_output_file> Out(
-      new tool_output_file(OutputFilename, EC, sys::fs::F_None));
+      new tool_output_file(OutputFilename, EC, sys::fs::OF_None));
 #endif
   if (EC) {
     errs() << EC.message() << '\n';
     exit(1);
   }
 
 #if HAVE_LLVM >= 0x0700
   WriteBitcodeToFile(*M, Out->os());

lld/ELF/Driver.cpp

 // don't make your executable to depend on system libraries (such as libc)
 // because you don't know the exact paths of libraries, even though system
 // libraries that are linked to your executable statically are technically a
 // part of your program. By using --dependency-file option, you can make
 // lld to dump dependency info so that you can maintain exact dependencies
 // easily.
 static void writeDependencyFile() {
   std::error_code ec;
-  raw_fd_ostream os(config->dependencyFile, ec, sys::fs::F_None);
+  raw_fd_ostream os(config->dependencyFile, ec, sys::fs::OF_None);
   if (ec) {
     error("cannot open " + config->dependencyFile + ": " + ec.message());
     return;
   }
 
   // We use the same escape rules as Clang/GCC which are accepted by Make/Ninja:
   // * A space is escaped by a backslash which itself must be escaped.
   // * A hash sign is escaped by a single backslash.

llvm/include/llvm/Support/FileSystem.h

 
 enum FileAccess : unsigned {
   FA_Read = 1,
   FA_Write = 2,
 };
 
 enum OpenFlags : unsigned {
   OF_None = 0,
-  F_None = 0, // For compatibility
 
   /// The file should be opened in text mode on platforms like z/OS that make
   /// this distinction.
   OF_Text = 1,
-  F_Text = 1, // For compatibility
 
   /// The file should use a carriage linefeed '\r\n'. This flag should only be
   /// used with OF_Text. Only makes a difference on Windows.
   OF_CRLF = 2,
 
   /// The file should be opened in text mode and use a carriage linefeed '\r\n'.
   /// This flag has the same functionality as OF_Text on z/OS but adds a
   /// carriage linefeed on Windows.
   OF_TextWithCRLF = OF_Text | OF_CRLF,
 
   /// The file should be opened in append mode.
   OF_Append = 4,
-  F_Append = 4, // For compatibility
 
   /// Delete the file on close. Only makes a difference on windows.
   OF_Delete = 8,
 
   /// When a child process is launched, this file should remain open in the
   /// child process.
   OF_ChildInherit = 16,
 

llvm/lib/Analysis/CFGPrinter.cpp

 static void writeCFGToDotFile(Function &F, BlockFrequencyInfo *BFI,
                               BranchProbabilityInfo *BPI, uint64_t MaxFreq,
                               bool CFGOnly = false) {
   std::string Filename =
       (CFGDotFilenamePrefix + "." + F.getName() + ".dot").str();
   errs() << "Writing '" << Filename << "'...";
 
   std::error_code EC;
-  raw_fd_ostream File(Filename, EC, sys::fs::F_Text);
+  raw_fd_ostream File(Filename, EC, sys::fs::OF_Text);
 
   DOTFuncInfo CFGInfo(&F, BFI, BPI, MaxFreq);
   CFGInfo.setHeatColors(ShowHeatColors);
   CFGInfo.setEdgeWeights(ShowEdgeWeight);
   CFGInfo.setRawEdgeWeights(UseRawEdgeWeight);
 
   if (!EC)
     WriteGraph(File, &CFGInfo, CFGOnly);

llvm/lib/Analysis/CallPrinter.cpp

bool CallGraphDOTPrinter::runOnModule(Module &M) {
   std::string Filename;
   if (!CallGraphDotFilenamePrefix.empty())
     Filename = (CallGraphDotFilenamePrefix + ".callgraph.dot");
   else
     Filename = (std::string(M.getModuleIdentifier()) + ".callgraph.dot");
   errs() << "Writing '" << Filename << "'...";
 
   std::error_code EC;
-  raw_fd_ostream File(Filename, EC, sys::fs::F_Text);
+  raw_fd_ostream File(Filename, EC, sys::fs::OF_Text);
 
   CallGraph CG(M);
   CallGraphDOTInfo CFGInfo(&M, &CG, LookupBFI);
 
   if (!EC)
     WriteGraph(File, &CFGInfo);
   else
     errs() << "  error opening file for writing!";

llvm/lib/Analysis/DDGPrinter.cpp

 }
 
 static void writeDDGToDotFile(DataDependenceGraph &G, bool DOnly) {
   std::string Filename =
       Twine(DDGDotFilenamePrefix + "." + G.getName() + ".dot").str();
   errs() << "Writing '" << Filename << "'...";
 
   std::error_code EC;
-  raw_fd_ostream File(Filename, EC, sys::fs::F_Text);
+  raw_fd_ostream File(Filename, EC, sys::fs::OF_Text);
 
   if (!EC)
     // We only provide the constant verson of the DOTGraphTrait specialization,
     // hence the conversion to const pointer
     WriteGraph(File, (const DataDependenceGraph *)&G, DOnly);
   else
     errs() << "  error opening file for writing!";
   errs() << "\n";

llvm/tools/llvm-ml/llvm-ml.cpp

StringRef TripleName =
           .Case("32", "i386-pc-windows")
           .Case("64", "x86_64-pc-windows")
           .Default("");
   return Triple(Triple::normalize(TripleName));
 }
 
 static std::unique_ptr<ToolOutputFile> GetOutputStream(StringRef Path) {
   std::error_code EC;
-  auto Out = std::make_unique<ToolOutputFile>(Path, EC, sys::fs::F_None);
+  auto Out = std::make_unique<ToolOutputFile>(Path, EC, sys::fs::OF_None);
   if (EC) {
     WithColor::error() << EC.message() << '\n';
     return nullptr;
   }
 
   return Out;
 }
 

mlir/lib/Support/FileUtilities.cpp

mlir::openInputFile(StringRef inputFilename, std::string *errorMessage) {
 
   return std::move(*fileOrErr);
 }
 
 std::unique_ptr<llvm::ToolOutputFile>
 mlir::openOutputFile(StringRef outputFilename, std::string *errorMessage) {
   std::error_code error;
   auto result = std::make_unique<llvm::ToolOutputFile>(outputFilename, error,
-                                                       llvm::sys::fs::F_None);
+                                                       llvm::sys::fs::OF_None);
   if (error) {
     if (errorMessage)
       *errorMessage = "cannot open output file '" + outputFilename.str() +
                       "': " + error.message();
     return nullptr;
   }
 
   return result;
 }