[flang][driver] Switch to the MLIR coding style in the driver (nfc)

This patch re-factors the driver code in LLVM Flang (frontend +
compiler) to use the MLIR style. For more context, please see:
https://discourse.llvm.org/t/rfc-coding-style-in-the-driver/

Most changes here are rather self-explanatory. Accessors are renamed to
be more consistent with the rest of LLVM (e.g. allSource -->
getAllSources). Additionally, MLIR clang-tidy files are added in the
affected directories.

clang-tidy and clang-format files were copied from MLIR. Small
additional changes are made to silence clang-tidy/clang-format
warnings.

[1] https://mlir.llvm.org/getting_started/DeveloperGuide/

Differential Revision: https://reviews.llvm.org/D125007

1 files changed, 88 insertions, 82 deletions

diff --git a/flang/lib/Frontend/CompilerInvocation.cpp b/flang/lib/Frontend/CompilerInvocation.cpp
index 9ea4be7..9ea4810 100644
--- a/flang/lib/Frontend/CompilerInvocation.cpp
+++ b/flang/lib/Frontend/CompilerInvocation.cpp
@@ -5,6 +5,10 @@
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
+//
+// Coding style: https://mlir.llvm.org/getting_started/DeveloperGuide/
+//
+//===----------------------------------------------------------------------===//
 
 #include "flang/Frontend/CompilerInvocation.h"
 #include "flang/Common/Fortran-features.h"
@@ -37,12 +41,12 @@ using namespace Fortran::frontend;
 // Initialization.
 //===----------------------------------------------------------------------===//
 CompilerInvocationBase::CompilerInvocationBase()
-    : diagnosticOpts_(new clang::DiagnosticOptions()),
-      preprocessorOpts_(new PreprocessorOptions()) {}
+    : diagnosticOpts(new clang::DiagnosticOptions()),
+      preprocessorOpts(new PreprocessorOptions()) {}
 
 CompilerInvocationBase::CompilerInvocationBase(const CompilerInvocationBase &x)
-    : diagnosticOpts_(new clang::DiagnosticOptions(x.GetDiagnosticOpts())),
-      preprocessorOpts_(new PreprocessorOptions(x.preprocessorOpts())) {}
+    : diagnosticOpts(new clang::DiagnosticOptions(x.getDiagnosticOpts())),
+      preprocessorOpts(new PreprocessorOptions(x.getPreprocessorOpts())) {}
 
 CompilerInvocationBase::~CompilerInvocationBase() = default;
 
@@ -59,31 +63,33 @@ static bool parseShowColorsArgs(
     Colors_On,
     Colors_Off,
     Colors_Auto
-  } ShowColors = defaultColor ? Colors_Auto : Colors_Off;
+  } showColors = defaultColor ? Colors_Auto : Colors_Off;
 
   for (auto *a : args) {
-    const llvm::opt::Option &O = a->getOption();
-    if (O.matches(clang::driver::options::OPT_fcolor_diagnostics)) {
-      ShowColors = Colors_On;
-    } else if (O.matches(clang::driver::options::OPT_fno_color_diagnostics)) {
-      ShowColors = Colors_Off;
-    } else if (O.matches(clang::driver::options::OPT_fdiagnostics_color_EQ)) {
+    const llvm::opt::Option &opt = a->getOption();
+    if (opt.matches(clang::driver::options::OPT_fcolor_diagnostics)) {
+      showColors = Colors_On;
+    } else if (opt.matches(clang::driver::options::OPT_fno_color_diagnostics)) {
+      showColors = Colors_Off;
+    } else if (opt.matches(clang::driver::options::OPT_fdiagnostics_color_EQ)) {
       llvm::StringRef value(a->getValue());
       if (value == "always")
-        ShowColors = Colors_On;
+        showColors = Colors_On;
       else if (value == "never")
-        ShowColors = Colors_Off;
+        showColors = Colors_Off;
       else if (value == "auto")
-        ShowColors = Colors_Auto;
+        showColors = Colors_Auto;
     }
   }
 
-  return ShowColors == Colors_On ||
-      (ShowColors == Colors_Auto && llvm::sys::Process::StandardErrHasColors());
+  return showColors == Colors_On ||
+         (showColors == Colors_Auto &&
+          llvm::sys::Process::StandardErrHasColors());
 }
 
-bool Fortran::frontend::ParseDiagnosticArgs(clang::DiagnosticOptions &opts,
-    llvm::opt::ArgList &args, bool defaultDiagColor) {
+bool Fortran::frontend::parseDiagnosticArgs(clang::DiagnosticOptions &opts,
+                                            llvm::opt::ArgList &args,
+                                            bool defaultDiagColor) {
   opts.ShowColors = parseShowColorsArgs(args, defaultDiagColor);
 
   return true;
@@ -94,7 +100,7 @@ bool Fortran::frontend::ParseDiagnosticArgs(clang::DiagnosticOptions &opts,
 ///
 /// \param [in] opts The target options instance to update
 /// \param [in] args The list of input arguments (from the compiler invocation)
-static void ParseTargetArgs(TargetOptions &opts, llvm::opt::ArgList &args) {
+static void parseTargetArgs(TargetOptions &opts, llvm::opt::ArgList &args) {
   if (const llvm::opt::Arg *a =
           args.getLastArg(clang::driver::options::OPT_triple))
     opts.triple = a->getValue();
@@ -110,8 +116,8 @@ static void setUpFrontendBasedOnAction(FrontendOptions &opts) {
     opts.needProvenanceRangeToCharBlockMappings = true;
 }
 
-static bool ParseFrontendArgs(FrontendOptions &opts, llvm::opt::ArgList &args,
-    clang::DiagnosticsEngine &diags) {
+static bool parseFrontendArgs(FrontendOptions &opts, llvm::opt::ArgList &args,
+                              clang::DiagnosticsEngine &diags) {
   unsigned numErrorsBefore = diags.getNumErrors();
 
   // By default the frontend driver creates a ParseSyntaxOnly action.
@@ -243,7 +249,7 @@ static bool ParseFrontendArgs(FrontendOptions &opts, llvm::opt::ArgList &args,
   if (const llvm::opt::Arg *a =
           args.getLastArg(clang::driver::options::OPT_plugin)) {
     opts.programAction = PluginAction;
-    opts.ActionName = a->getValue();
+    opts.actionName = a->getValue();
   }
 
   opts.outputFile = args.getLastArgValue(clang::driver::options::OPT_o);
@@ -254,19 +260,19 @@ static bool ParseFrontendArgs(FrontendOptions &opts, llvm::opt::ArgList &args,
   InputKind dashX(Language::Unknown);
   if (const llvm::opt::Arg *a =
           args.getLastArg(clang::driver::options::OPT_x)) {
-    llvm::StringRef XValue = a->getValue();
+    llvm::StringRef xValue = a->getValue();
     // Principal languages.
-    dashX = llvm::StringSwitch<InputKind>(XValue)
+    dashX = llvm::StringSwitch<InputKind>(xValue)
                 .Case("f90", Language::Fortran)
                 .Default(Language::Unknown);
 
     // Some special cases cannot be combined with suffixes.
-    if (dashX.IsUnknown())
-      dashX = llvm::StringSwitch<InputKind>(XValue)
+    if (dashX.isUnknown())
+      dashX = llvm::StringSwitch<InputKind>(xValue)
                   .Case("ir", Language::LLVM_IR)
                   .Default(Language::Unknown);
 
-    if (dashX.IsUnknown())
+    if (dashX.isUnknown())
       diags.Report(clang::diag::err_drv_invalid_value)
           << a->getAsString(args) << a->getValue();
   }
@@ -280,10 +286,10 @@ static bool ParseFrontendArgs(FrontendOptions &opts, llvm::opt::ArgList &args,
     inputs.push_back("-");
   for (unsigned i = 0, e = inputs.size(); i != e; ++i) {
     InputKind ik = dashX;
-    if (ik.IsUnknown()) {
-      ik = FrontendOptions::GetInputKindForExtension(
+    if (ik.isUnknown()) {
+      ik = FrontendOptions::getInputKindForExtension(
           llvm::StringRef(inputs[i]).rsplit('.').second);
-      if (ik.IsUnknown())
+      if (ik.isUnknown())
         ik = Language::Unknown;
       if (i == 0)
         dashX = ik;
@@ -449,23 +455,23 @@ static bool parseSemaArgs(CompilerInvocation &res, llvm::opt::ArgList &args,
     diags.Report(diagID);
   }
   if (moduleDirList.size() == 1)
-    res.SetModuleDir(moduleDirList[0]);
+    res.setModuleDir(moduleDirList[0]);
 
   // -fdebug-module-writer option
   if (args.hasArg(clang::driver::options::OPT_fdebug_module_writer)) {
-    res.SetDebugModuleDir(true);
+    res.setDebugModuleDir(true);
   }
 
   // -module-suffix
   if (const auto *moduleSuffix =
           args.getLastArg(clang::driver::options::OPT_module_suffix)) {
-    res.SetModuleFileSuffix(moduleSuffix->getValue());
+    res.setModuleFileSuffix(moduleSuffix->getValue());
   }
 
   // -f{no-}analyzed-objects-for-unparse
-  res.SetUseAnalyzedObjectsForUnparse(
-      args.hasFlag(clang::driver::options::OPT_fanalyzed_objects_for_unparse,
-          clang::driver::options::OPT_fno_analyzed_objects_for_unparse, true));
+  res.setUseAnalyzedObjectsForUnparse(args.hasFlag(
+      clang::driver::options::OPT_fanalyzed_objects_for_unparse,
+      clang::driver::options::OPT_fno_analyzed_objects_for_unparse, true));
 
   return diags.getNumErrors() == numErrorsBefore;
 }
@@ -482,7 +488,7 @@ static bool parseDiagArgs(CompilerInvocation &res, llvm::opt::ArgList &args,
   if (args.hasArg(clang::driver::options::OPT_W_Joined)) {
     if (args.getLastArgValue(clang::driver::options::OPT_W_Joined)
             .equals("error")) {
-      res.SetWarnAsErr(true);
+      res.setWarnAsErr(true);
     } else {
       const unsigned diagID =
           diags.getCustomDiagID(clang::DiagnosticsEngine::Error,
@@ -502,13 +508,13 @@ static bool parseDialectArgs(CompilerInvocation &res, llvm::opt::ArgList &args,
 
   // -fdefault* family
   if (args.hasArg(clang::driver::options::OPT_fdefault_real_8)) {
-    res.defaultKinds().set_defaultRealKind(8);
-    res.defaultKinds().set_doublePrecisionKind(16);
+    res.getDefaultKinds().set_defaultRealKind(8);
+    res.getDefaultKinds().set_doublePrecisionKind(16);
   }
   if (args.hasArg(clang::driver::options::OPT_fdefault_integer_8)) {
-    res.defaultKinds().set_defaultIntegerKind(8);
-    res.defaultKinds().set_subscriptIntegerKind(8);
-    res.defaultKinds().set_sizeIntegerKind(8);
+    res.getDefaultKinds().set_defaultIntegerKind(8);
+    res.getDefaultKinds().set_subscriptIntegerKind(8);
+    res.getDefaultKinds().set_sizeIntegerKind(8);
   }
   if (args.hasArg(clang::driver::options::OPT_fdefault_double_8)) {
     if (!args.hasArg(clang::driver::options::OPT_fdefault_real_8)) {
@@ -520,24 +526,24 @@ static bool parseDialectArgs(CompilerInvocation &res, llvm::opt::ArgList &args,
       diags.Report(diagID);
     }
     // https://gcc.gnu.org/onlinedocs/gfortran/Fortran-Dialect-Options.html
-    res.defaultKinds().set_doublePrecisionKind(8);
+    res.getDefaultKinds().set_doublePrecisionKind(8);
   }
   if (args.hasArg(clang::driver::options::OPT_flarge_sizes))
-    res.defaultKinds().set_sizeIntegerKind(8);
+    res.getDefaultKinds().set_sizeIntegerKind(8);
 
   // -fopenmp and -fopenacc
   if (args.hasArg(clang::driver::options::OPT_fopenacc)) {
-    res.frontendOpts().features.Enable(
+    res.getFrontendOpts().features.Enable(
         Fortran::common::LanguageFeature::OpenACC);
   }
   if (args.hasArg(clang::driver::options::OPT_fopenmp)) {
-    res.frontendOpts().features.Enable(
+    res.getFrontendOpts().features.Enable(
         Fortran::common::LanguageFeature::OpenMP);
   }
 
   // -pedantic
   if (args.hasArg(clang::driver::options::OPT_pedantic)) {
-    res.set_EnableConformanceChecks();
+    res.setEnableConformanceChecks();
   }
   // -std=f2018 (currently this implies -pedantic)
   // TODO: Set proper options when more fortran standards
@@ -546,7 +552,7 @@ static bool parseDialectArgs(CompilerInvocation &res, llvm::opt::ArgList &args,
     auto standard = args.getLastArgValue(clang::driver::options::OPT_std_EQ);
     // We only allow f2018 as the given standard
     if (standard.equals("f2018")) {
-      res.set_EnableConformanceChecks();
+      res.setEnableConformanceChecks();
     } else {
       const unsigned diagID =
           diags.getCustomDiagID(clang::DiagnosticsEngine::Error,
@@ -557,8 +563,8 @@ static bool parseDialectArgs(CompilerInvocation &res, llvm::opt::ArgList &args,
   return diags.getNumErrors() == numErrorsBefore;
 }
 
-bool CompilerInvocation::CreateFromArgs(CompilerInvocation &res,
-    llvm::ArrayRef<const char *> commandLineArgs,
+bool CompilerInvocation::createFromArgs(
+    CompilerInvocation &res, llvm::ArrayRef<const char *> commandLineArgs,
     clang::DiagnosticsEngine &diags) {
 
   bool success = true;
@@ -569,7 +575,7 @@ bool CompilerInvocation::CreateFromArgs(CompilerInvocation &res,
   // NOTE: Like in Clang, it would be nice to use option marshalling
   // for this so that the entire logic for setting-up the triple is in one
   // place.
-  res.targetOpts().triple =
+  res.getTargetOpts().triple =
       llvm::Triple::normalize(llvm::sys::getDefaultTargetTriple());
 
   // Parse the arguments
@@ -598,23 +604,23 @@ bool CompilerInvocation::CreateFromArgs(CompilerInvocation &res,
     success = false;
   }
 
-  success &= ParseFrontendArgs(res.frontendOpts(), args, diags);
-  ParseTargetArgs(res.targetOpts(), args);
-  parsePreprocessorArgs(res.preprocessorOpts(), args);
+  success &= parseFrontendArgs(res.getFrontendOpts(), args, diags);
+  parseTargetArgs(res.getTargetOpts(), args);
+  parsePreprocessorArgs(res.getPreprocessorOpts(), args);
   success &= parseSemaArgs(res, args, diags);
   success &= parseDialectArgs(res, args, diags);
   success &= parseDiagArgs(res, args, diags);
-  res.frontendOpts_.llvmArgs =
+  res.frontendOpts.llvmArgs =
       args.getAllArgValues(clang::driver::options::OPT_mllvm);
 
-  res.frontendOpts_.mlirArgs =
+  res.frontendOpts.mlirArgs =
       args.getAllArgValues(clang::driver::options::OPT_mmlir);
 
   return success;
 }
 
-void CompilerInvocation::CollectMacroDefinitions() {
-  auto &ppOpts = this->preprocessorOpts();
+void CompilerInvocation::collectMacroDefinitions() {
+  auto &ppOpts = this->getPreprocessorOpts();
 
   for (unsigned i = 0, n = ppOpts.macros.size(); i != n; ++i) {
     llvm::StringRef macro = ppOpts.macros[i].first;
@@ -626,8 +632,8 @@ void CompilerInvocation::CollectMacroDefinitions() {
 
     // For an #undef'd macro, we only care about the name.
     if (isUndef) {
-      parserOpts_.predefinitions.emplace_back(
-          macroName.str(), std::optional<std::string>{});
+      parserOpts.predefinitions.emplace_back(macroName.str(),
+                                             std::optional<std::string>{});
       continue;
     }
 
@@ -636,16 +642,16 @@ void CompilerInvocation::CollectMacroDefinitions() {
       macroBody = "1";
     else {
       // Note: GCC drops anything following an end-of-line character.
-      llvm::StringRef::size_type End = macroBody.find_first_of("\n\r");
-      macroBody = macroBody.substr(0, End);
+      llvm::StringRef::size_type end = macroBody.find_first_of("\n\r");
+      macroBody = macroBody.substr(0, end);
     }
-    parserOpts_.predefinitions.emplace_back(
+    parserOpts.predefinitions.emplace_back(
         macroName, std::optional<std::string>(macroBody.str()));
   }
 }
 
-void CompilerInvocation::SetDefaultFortranOpts() {
-  auto &fortranOptions = fortranOpts();
+void CompilerInvocation::setDefaultFortranOpts() {
+  auto &fortranOptions = getFortranOpts();
 
   std::vector<std::string> searchDirectories{"."s};
   fortranOptions.searchDirectories = searchDirectories;
@@ -660,9 +666,9 @@ void CompilerInvocation::SetDefaultFortranOpts() {
 // TODO: When expanding this method, consider creating a dedicated API for
 // this. Also at some point we will need to differentiate between different
 // targets and add dedicated predefines for each.
-void CompilerInvocation::SetDefaultPredefinitions() {
-  auto &fortranOptions = fortranOpts();
-  const auto &frontendOptions = frontendOpts();
+void CompilerInvocation::setDefaultPredefinitions() {
+  auto &fortranOptions = getFortranOpts();
+  const auto &frontendOptions = getFrontendOpts();
 
   // Populate the macro list with version numbers and other predefinitions.
   fortranOptions.predefinitions.emplace_back("__flang__", "1");
@@ -684,11 +690,11 @@ void CompilerInvocation::SetDefaultPredefinitions() {
   }
 }
 
-void CompilerInvocation::SetFortranOpts() {
-  auto &fortranOptions = fortranOpts();
-  const auto &frontendOptions = frontendOpts();
-  const auto &preprocessorOptions = preprocessorOpts();
-  auto &moduleDirJ = moduleDir();
+void CompilerInvocation::setFortranOpts() {
+  auto &fortranOptions = getFortranOpts();
+  const auto &frontendOptions = getFrontendOpts();
+  const auto &preprocessorOptions = getPreprocessorOpts();
+  auto &moduleDirJ = getModuleDir();
 
   if (frontendOptions.fortranForm != FortranForm::Unknown) {
     fortranOptions.isFixedForm =
@@ -725,22 +731,22 @@ void CompilerInvocation::SetFortranOpts() {
   if (frontendOptions.needProvenanceRangeToCharBlockMappings)
     fortranOptions.needProvenanceRangeToCharBlockMappings = true;
 
-  if (enableConformanceChecks()) {
+  if (getEnableConformanceChecks()) {
     fortranOptions.features.WarnOnAllNonstandard();
   }
 }
 
-void CompilerInvocation::SetSemanticsOpts(
+void CompilerInvocation::setSemanticsOpts(
     Fortran::parser::AllCookedSources &allCookedSources) {
-  const auto &fortranOptions = fortranOpts();
+  const auto &fortranOptions = getFortranOpts();
 
-  semanticsContext_ = std::make_unique<semantics::SemanticsContext>(
-      defaultKinds(), fortranOptions.features, allCookedSources);
+  semanticsContext = std::make_unique<semantics::SemanticsContext>(
+      getDefaultKinds(), fortranOptions.features, allCookedSources);
 
-  semanticsContext_->set_moduleDirectory(moduleDir())
+  semanticsContext->set_moduleDirectory(getModuleDir())
       .set_searchDirectories(fortranOptions.searchDirectories)
       .set_intrinsicModuleDirectories(fortranOptions.intrinsicModuleDirectories)
-      .set_warnOnNonstandardUsage(enableConformanceChecks())
-      .set_warningsAreErrors(warnAsErr())
-      .set_moduleFileSuffix(moduleFileSuffix());
+      .set_warnOnNonstandardUsage(getEnableConformanceChecks())
+      .set_warningsAreErrors(getWarnAsErr())
+      .set_moduleFileSuffix(getModuleFileSuffix());
 }