[flang][driver][nfc] Fix capitalisation

[awarzynski]

Summary

As pointed out in https://reviews.llvm.org/D93401, some methods in the
Flang driver are named inconsistently. The driver strives to follow
Flang's C++ style [1] and this patch updates these methods accordingly.

[1]
https://github.com/llvm/llvm-project/blob/main/flang/docs/C%2B%2Bstyle.md

[clementval]

Thanks for addressing this quickly.

flang/include/flang/Frontend/CompilerInstance.h

120

What about this one? And the three below?

[awarzynski]

flang/include/flang/Frontend/CompilerInstance.h

120

From: https://github.com/llvm/llvm-project/blob/main/flang/docs/C%2B%2Bstyle.md#naming

3. Mutator member functions are named set_...

This patch updates methods that were meant to be named according to:

4. Other class functions should be named with leading capital letters, CamelCase, and no underscores,

If we were to do this diligently, we'd need to audit all member methods and decide what qualifies as a "mutator" and what is a "class function". Or, IMHO better, one could refactor the driver to use the MLIR style (i.e. one rule for both).

[Leporacanthicus]

LGTM

[clementval]

LGTM

flang/include/flang/Frontend/CompilerInstance.h

120

Ok thanks for the clarification.

flang/include/flang/Frontend/CompilerInstance.h

public:
   /// }
   /// @name Semantic analysis
   /// {
 
   /// Replace the current stream for verbose output.
   void set_semaOutputStream(llvm::raw_ostream &Value);
 
   /// Replace the current stream for verbose output.
   void set_semaOutputStream(std::unique_ptr<llvm::raw_ostream> Value);
 
   /// Get the current stream for verbose output.
   llvm::raw_ostream &semaOutputStream() { return *semaOutputStream_; }
 
   Fortran::semantics::Semantics &semantics() { return *semantics_; }
   const Fortran::semantics::Semantics &semantics() const { return *semantics_; }
 
-  void setSemantics(std::unique_ptr<Fortran::semantics::Semantics> semantics) {
+  void SetSemantics(std::unique_ptr<Fortran::semantics::Semantics> semantics) {
     semantics_ = std::move(semantics);
   }
 
   /// }
   /// @name High-Level Operations
   /// {
 
   /// Execute the provided action against the compiler's

flang/include/flang/Frontend/CompilerInvocation.h

public:
 
   /// Set the Fortran options to predefined defaults.
   // TODO: We should map frontendOpts_ to parserOpts_ instead. For that, we
   // need to extend frontendOpts_ first. Next, we need to add the corresponding
   // compiler driver options in libclangDriver.
   void SetDefaultFortranOpts();
 
   /// Set the default predefinitions.
-  void setDefaultPredefinitions();
+  void SetDefaultPredefinitions();
 
   /// Collect the macro definitions from preprocessorOpts_ and prepare them for
   /// the parser (i.e. copy into parserOpts_)
-  void collectMacroDefinitions();
+  void CollectMacroDefinitions();
 
   /// Set the Fortran options to user-specified values.
   /// These values are found in the preprocessor options.
-  void setFortranOpts();
+  void SetFortranOpts();
 
   /// Set the Semantic Options
-  void setSemanticsOpts(Fortran::parser::AllCookedSources &);
+  void SetSemanticsOpts(Fortran::parser::AllCookedSources &);
 };
 
 } // end namespace Fortran::frontend
 #endif // LLVM_FLANG_FRONTEND_COMPILERINVOCATION_H

flang/lib/Frontend/CompilerInstance.cpp

 }
 
 bool CompilerInstance::ExecuteAction(FrontendAction &act) {
   auto &invoc = this->invocation();
 
   // Set some sane defaults for the frontend.
   invoc.SetDefaultFortranOpts();
   // Update the fortran options based on user-based input.
-  invoc.setFortranOpts();
+  invoc.SetFortranOpts();
   // Set the encoding to read all input files in based on user input.
   allSources_->set_encoding(invoc.fortranOpts().encoding);
   // Create the semantics context and set semantic options.
-  invoc.setSemanticsOpts(*this->allCookedSources_);
+  invoc.SetSemanticsOpts(*this->allCookedSources_);
 
   // Run the frontend action `act` for every input file.
   for (const FrontendInputFile &fif : frontendOpts().inputs) {
     if (act.BeginSourceFile(*this, fif)) {
       if (llvm::Error err = act.Execute()) {
         consumeError(std::move(err));
       }
       act.EndSourceFile();

flang/lib/Frontend/CompilerInvocation.cpp

bool CompilerInvocation::CreateFromArgs(CompilerInvocation &res,
   parsePreprocessorArgs(res.preprocessorOpts(), args);
   success &= parseSemaArgs(res, args, diags);
   success &= parseDialectArgs(res, args, diags);
   success &= parseDiagArgs(res, args, diags);
 
   return success;
 }
 
-void CompilerInvocation::collectMacroDefinitions() {
+void CompilerInvocation::CollectMacroDefinitions() {
   auto &ppOpts = this->preprocessorOpts();
 
   for (unsigned i = 0, n = ppOpts.macros.size(); i != n; ++i) {
     llvm::StringRef macro = ppOpts.macros[i].first;
     bool isUndef = ppOpts.macros[i].second;
 
     std::pair<llvm::StringRef, llvm::StringRef> macroPair = macro.split('=');
     llvm::StringRef macroName = macroPair.first;
void CompilerInvocation::SetDefaultFortranOpts() {
   std::vector<std::string> searchDirectories{"."s};
   fortranOptions.searchDirectories = searchDirectories;
   fortranOptions.isFixedForm = false;
 }
 
 // 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() {
+void CompilerInvocation::SetDefaultPredefinitions() {
   auto &fortranOptions = fortranOpts();
   const auto &frontendOptions = frontendOpts();
 
   // Populate the macro list with version numbers and other predefinitions.
   fortranOptions.predefinitions.emplace_back("__flang__", "1");
   fortranOptions.predefinitions.emplace_back(
       "__flang_major__", FLANG_VERSION_MAJOR_STRING);
   fortranOptions.predefinitions.emplace_back(
       "__flang_minor__", FLANG_VERSION_MINOR_STRING);
   fortranOptions.predefinitions.emplace_back(
       "__flang_patchlevel__", FLANG_VERSION_PATCHLEVEL_STRING);
 
   // Add predefinitions based on extensions enabled
   if (frontendOptions.features.IsEnabled(
           Fortran::common::LanguageFeature::OpenACC)) {
     fortranOptions.predefinitions.emplace_back("_OPENACC", "202011");
   }
   if (frontendOptions.features.IsEnabled(
           Fortran::common::LanguageFeature::OpenMP)) {
     fortranOptions.predefinitions.emplace_back("_OPENMP", "201511");
   }
 }
 
-void CompilerInvocation::setFortranOpts() {
+void CompilerInvocation::SetFortranOpts() {
   auto &fortranOptions = fortranOpts();
   const auto &frontendOptions = frontendOpts();
   const auto &preprocessorOptions = preprocessorOpts();
   auto &moduleDirJ = moduleDir();
 
   if (frontendOptions.fortranForm != FortranForm::Unknown) {
     fortranOptions.isFixedForm =
         frontendOptions.fortranForm == FortranForm::FixedForm;
void CompilerInvocation::SetFortranOpts() {
   if (frontendOptions.needProvenanceRangeToCharBlockMappings)
     fortranOptions.needProvenanceRangeToCharBlockMappings = true;
 
   if (enableConformanceChecks()) {
     fortranOptions.features.WarnOnAllNonstandard();
   }
 }
 
-void CompilerInvocation::setSemanticsOpts(
+void CompilerInvocation::SetSemanticsOpts(
     Fortran::parser::AllCookedSources &allCookedSources) {
   const auto &fortranOptions = fortranOpts();
 
   semanticsContext_ = std::make_unique<semantics::SemanticsContext>(
       defaultKinds(), fortranOptions.features, allCookedSources);
 
   semanticsContext_->set_moduleDirectory(moduleDir())
       .set_searchDirectories(fortranOptions.searchDirectories)
       .set_warnOnNonstandardUsage(enableConformanceChecks())
       .set_warningsAreErrors(warnAsErr())
       .set_moduleFileSuffix(moduleFileSuffix());
 }

flang/lib/Frontend/FrontendAction.cpp

bool FrontendAction::BeginSourceFile(
 
   // Include command-line and predefined preprocessor macros. Use either:
   //  * `-cpp/-nocpp`, or
   //  * the file extension (if the user didn't express any preference)
   // to decide whether to include them or not.
   if ((invoc.preprocessorOpts().macrosFlag == PPMacrosFlag::Include) ||
       (invoc.preprocessorOpts().macrosFlag == PPMacrosFlag::Unknown &&
           currentInput().MustBePreprocessed())) {
-    invoc.setDefaultPredefinitions();
-    invoc.collectMacroDefinitions();
+    invoc.SetDefaultPredefinitions();
+    invoc.CollectMacroDefinitions();
   }
 
   // Decide between fixed and free form (if the user didn't express any
   // preference, use the file extension to decide)
   if (invoc.frontendOpts().fortranForm == FortranForm::Unknown) {
     invoc.fortranOpts().isFixedForm = currentInput().IsFixedForm();
   }
 

 }
 
 bool FrontendAction::RunSemanticChecks() {
   CompilerInstance &ci = this->instance();
   std::optional<parser::Program> &parseTree{ci.parsing().parseTree()};
   assert(parseTree && "Cannot run semantic checks without a parse tree!");
 
   // Prepare semantics
-  ci.setSemantics(std::make_unique<Fortran::semantics::Semantics>(
+  ci.SetSemantics(std::make_unique<Fortran::semantics::Semantics>(
       ci.invocation().semanticsContext(), *parseTree,
       ci.invocation().debugModuleDir()));
   auto &semantics = ci.semantics();
 
   // Run semantic checks
   semantics.Perform();
 
   if (reportFatalSemanticErrors()) {