[flang][nfc] Fix variable names in `FrontendOptions`

[awarzynski]

Summary

As all member variables in FrontendOptions are public, we should be
naming them as variable rather than variable_ [1]. This patch will
fix that.

Also, FrontendOptions is re-defined as a struct rather than a
class (all fields are meant to be public).

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

[klausler]

flang/include/flang/Frontend/FrontendOptions.h

253

It is confusing to have data member initialization mixed between the constructor and the data member declarations when all of initialization expressions are constants.

[awarzynski]

Similar refactor for PreprocessorOptions

flang/include/flang/Frontend/FrontendOptions.h

253

I agree that the location of this constructor is unfortunate. Let me move it to the top.

flang/docs/FlangDriver.md

 ```
 Command line options are mapped to frontend actions through the
 `Fortran::frontend::ActionKind` enum.  For every new action option that you
 add, you will have to add a dedicated entry in that enum (e.g.
 `ParseSyntaxOnly` for `-fsyntax-only`) and a corresponding `case` in
 `ParseFrontendArgs` function in the `CompilerInvocation.cpp` file, e.g.:
 ```cpp
     case clang::driver::options::OPT_fsyntax_only:
-      opts.programAction_ = ParseSyntaxOnly;
+      opts.programAction = ParseSyntaxOnly;
       break;
 ```
 Note that this simply sets the program/frontend action within the frontend
 driver. You still have make sure that the corresponding frontend action class
 is instantiated when your new action option is used. The relevant `switch`
 statement is implemented in `Fortran::frontend::CreatedFrontendBaseAction` in
 the `ExecuteCompilerInvocation.cpp` file. Here's an example for
 `-fsyntax-only`:

flang/include/flang/Frontend/CompilerInstance.h

public:
   void ClearOutputFiles(bool eraseFiles);
 
   /// Create the default output file (based on the invocation's options) and
   /// add it to the list of tracked output files. If the name of the output
   /// file is not provided, it is derived from the input file.
   ///
   /// \param binary     The mode to open the file in.
   /// \param baseInput  If the invocation contains no output file name (i.e.
-  ///                   outputFile_ in FrontendOptions is empty), the input path
+  ///                   outputFile in FrontendOptions is empty), the input path
   ///                   name to use for deriving the output path.
   /// \param extension  The extension to use for output names derived from
   ///                   \p baseInput.
   /// \return           ostream for the output file or nullptr on error.
   std::unique_ptr<llvm::raw_pwrite_stream> CreateDefaultOutputFile(
       bool binary = true, llvm::StringRef baseInput = "",
       llvm::StringRef extension = "");
 

flang/include/flang/Frontend/FrontendOptions.h

public:
 
   const llvm::MemoryBuffer *buffer() const {
     assert(IsBuffer() && "Requested buffer_, but it is empty!");
     return buffer_;
   }
 };
 
 /// FrontendOptions - Options for controlling the behavior of the frontend.
-class FrontendOptions {
-public:
+struct FrontendOptions {
   /// Show the -help text.
-  unsigned showHelp_ : 1;
+  unsigned showHelp : 1;
 
   /// Show the -version text.
-  unsigned showVersion_ : 1;
+  unsigned showVersion : 1;
 
   /// Instrument the parse to get a more verbose log
-  unsigned instrumentedParse_ : 1;
+  unsigned instrumentedParse : 1;
 
   /// Enable Provenance to character-stream mapping. Allows e.g. IDEs to find
   /// symbols based on source-code location. This is not needed in regular
   /// compilation.
-  unsigned needProvenanceRangeToCharBlockMappings_ : 1;
+  unsigned needProvenanceRangeToCharBlockMappings : 1;
 
   /// Input values from `-fget-definition`
   struct GetDefinitionVals {
     unsigned line;
     unsigned startColumn;
     unsigned endColumn;
   };
-  GetDefinitionVals getDefVals_;
+  GetDefinitionVals getDefVals;
 
   /// The input files and their types.
-  std::vector<FrontendInputFile> inputs_;
+  std::vector<FrontendInputFile> inputs;
 
   /// The output file, if any.
-  std::string outputFile_;
+  std::string outputFile;
 
   /// The frontend action to perform.
-  frontend::ActionKind programAction_;
+  frontend::ActionKind programAction;
 
   // The form to process files in, if specified.
-  FortranForm fortranForm_ = FortranForm::Unknown;
+  FortranForm fortranForm = FortranForm::Unknown;
 
   // The column after which characters are ignored in fixed form lines in the
   // source file.
-  int fixedFormColumns_ = 72;
+  int fixedFormColumns = 72;
 
   /// The input kind, either specified via -x argument or deduced from the input
   /// file name.
-  InputKind dashX_;
+  InputKind dashX;
 
   // Language features
-  common::LanguageFeatureControl features_;
+  common::LanguageFeatureControl features;
 
   // Source file encoding
-  Fortran::parser::Encoding encoding_{Fortran::parser::Encoding::UTF_8};
+  Fortran::parser::Encoding encoding{Fortran::parser::Encoding::UTF_8};
 
-public:
   FrontendOptions()
-      : showHelp_(false), showVersion_(false), instrumentedParse_(false),
-        needProvenanceRangeToCharBlockMappings_(false) {}
+      : showHelp(false), showVersion(false), instrumentedParse(false),
+        needProvenanceRangeToCharBlockMappings(false) {}
 
   // Return the appropriate input kind for a file extension. For example,
   /// "*.f" would return Language::Fortran.
   ///
   /// \return The input kind for the extension, or Language::Unknown if the
   /// extension is not recognized.
   static InputKind GetInputKindForExtension(llvm::StringRef extension);
 };
 } // namespace Fortran::frontend
 
 #endif // LLVM_FLANG_FRONTEND_FRONTENDOPTIONS_H

flang/lib/Frontend/CompilerInstance.cpp

 std::unique_ptr<llvm::raw_pwrite_stream>
 CompilerInstance::CreateDefaultOutputFile(
     bool binary, llvm::StringRef baseName, llvm::StringRef extension) {
   std::string outputPathName;
   std::error_code ec;
 
   // Get the path of the output file
   std::string outputFilePath =
-      GetOutputFilePath(frontendOpts().outputFile_, baseName, extension);
+      GetOutputFilePath(frontendOpts().outputFile, baseName, extension);
 
   // Create the output file
   std::unique_ptr<llvm::raw_pwrite_stream> os =
       CreateOutputFile(outputFilePath, ec, binary);
 
   // Add the file to the list of tracked output files (provided it was created
   // successfully)
   if (os)
bool CompilerInstance::ExecuteAction(FrontendAction &act) {
   // Update the fortran options based on user-based input.
   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_);
 
   // Run the frontend action `act` for every input file.
-  for (const FrontendInputFile &fif : frontendOpts().inputs_) {
+  for (const FrontendInputFile &fif : frontendOpts().inputs) {
     if (act.BeginSourceFile(*this, fif)) {
       if (llvm::Error err = act.Execute()) {
         consumeError(std::move(err));
       }
       act.EndSourceFile();
     }
   }
   return !diagnostics().getClient()->getNumErrors();

flang/lib/Frontend/CompilerInvocation.cpp

bool Fortran::frontend::ParseDiagnosticArgs(clang::DiagnosticOptions &opts,
     llvm::opt::ArgList &args, bool defaultDiagColor) {
   opts.ShowColors = parseShowColorsArgs(args, defaultDiagColor);
 
   return true;
 }
 
 // Tweak the frontend configuration based on the frontend action
 static void setUpFrontendBasedOnAction(FrontendOptions &opts) {
-  assert(opts.programAction_ != Fortran::frontend::InvalidAction &&
+  assert(opts.programAction != Fortran::frontend::InvalidAction &&
       "Fortran frontend action not set!");
 
-  if (opts.programAction_ == DebugDumpParsingLog)
-    opts.instrumentedParse_ = true;
+  if (opts.programAction == DebugDumpParsingLog)
+    opts.instrumentedParse = true;
 
-  if (opts.programAction_ == DebugDumpProvenance ||
-      opts.programAction_ == Fortran::frontend::GetDefinition)
-    opts.needProvenanceRangeToCharBlockMappings_ = true;
+  if (opts.programAction == DebugDumpProvenance ||
+      opts.programAction == Fortran::frontend::GetDefinition)
+    opts.needProvenanceRangeToCharBlockMappings = true;
 }
 
 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.
-  opts.programAction_ = ParseSyntaxOnly;
+  opts.programAction = ParseSyntaxOnly;
 
   // Identify the action (i.e. opts.ProgramAction)
   if (const llvm::opt::Arg *a =
           args.getLastArg(clang::driver::options::OPT_Action_Group)) {
     switch (a->getOption().getID()) {
     default: {
       llvm_unreachable("Invalid option in group!");
     }
     case clang::driver::options::OPT_test_io:
-      opts.programAction_ = InputOutputTest;
+      opts.programAction = InputOutputTest;
       break;
     case clang::driver::options::OPT_E:
-      opts.programAction_ = PrintPreprocessedInput;
+      opts.programAction = PrintPreprocessedInput;
       break;
     case clang::driver::options::OPT_fsyntax_only:
-      opts.programAction_ = ParseSyntaxOnly;
+      opts.programAction = ParseSyntaxOnly;
       break;
     case clang::driver::options::OPT_emit_obj:
-      opts.programAction_ = EmitObj;
+      opts.programAction = EmitObj;
       break;
     case clang::driver::options::OPT_fdebug_unparse:
-      opts.programAction_ = DebugUnparse;
+      opts.programAction = DebugUnparse;
       break;
     case clang::driver::options::OPT_fdebug_unparse_no_sema:
-      opts.programAction_ = DebugUnparseNoSema;
+      opts.programAction = DebugUnparseNoSema;
       break;
     case clang::driver::options::OPT_fdebug_unparse_with_symbols:
-      opts.programAction_ = DebugUnparseWithSymbols;
+      opts.programAction = DebugUnparseWithSymbols;
       break;
     case clang::driver::options::OPT_fdebug_dump_symbols:
-      opts.programAction_ = DebugDumpSymbols;
+      opts.programAction = DebugDumpSymbols;
       break;
     case clang::driver::options::OPT_fdebug_dump_parse_tree:
-      opts.programAction_ = DebugDumpParseTree;
+      opts.programAction = DebugDumpParseTree;
       break;
     case clang::driver::options::OPT_fdebug_dump_all:
-      opts.programAction_ = DebugDumpAll;
+      opts.programAction = DebugDumpAll;
       break;
     case clang::driver::options::OPT_fdebug_dump_parse_tree_no_sema:
-      opts.programAction_ = DebugDumpParseTreeNoSema;
+      opts.programAction = DebugDumpParseTreeNoSema;
       break;
     case clang::driver::options::OPT_fdebug_dump_provenance:
-      opts.programAction_ = DebugDumpProvenance;
+      opts.programAction = DebugDumpProvenance;
       break;
     case clang::driver::options::OPT_fdebug_dump_parsing_log:
-      opts.programAction_ = DebugDumpParsingLog;
+      opts.programAction = DebugDumpParsingLog;
       break;
     case clang::driver::options::OPT_fdebug_measure_parse_tree:
-      opts.programAction_ = DebugMeasureParseTree;
+      opts.programAction = DebugMeasureParseTree;
       break;
     case clang::driver::options::OPT_fdebug_pre_fir_tree:
-      opts.programAction_ = DebugPreFIRTree;
+      opts.programAction = DebugPreFIRTree;
       break;
     case clang::driver::options::OPT_fget_symbols_sources:
-      opts.programAction_ = GetSymbolsSources;
+      opts.programAction = GetSymbolsSources;
       break;
     case clang::driver::options::OPT_fget_definition:
-      opts.programAction_ = GetDefinition;
+      opts.programAction = GetDefinition;
       break;
     case clang::driver::options::OPT_init_only:
-      opts.programAction_ = InitOnly;
+      opts.programAction = InitOnly;
       break;
 
       // TODO:
       // case clang::driver::options::OPT_emit_llvm:
       // case clang::driver::options::OPT_emit_llvm_only:
       // case clang::driver::options::OPT_emit_codegen_only:
       // case clang::driver::options::OPT_emit_module:
       // (...)
if (llvm::opt::OptSpecifier(a->getOption().getID()) ==
 
         if (val.getAsInteger(10, optVals[i])) {
           // A non-integer was encountered - that's an error.
           diags.Report(clang::diag::err_drv_invalid_value)
               << a->getOption().getName() << val;
           break;
         }
       }
-      opts.getDefVals_.line = optVals[0];
-      opts.getDefVals_.startColumn = optVals[1];
-      opts.getDefVals_.endColumn = optVals[2];
+      opts.getDefVals.line = optVals[0];
+      opts.getDefVals.startColumn = optVals[1];
+      opts.getDefVals.endColumn = optVals[2];
     }
   }
 
-  opts.outputFile_ = args.getLastArgValue(clang::driver::options::OPT_o);
-  opts.showHelp_ = args.hasArg(clang::driver::options::OPT_help);
-  opts.showVersion_ = args.hasArg(clang::driver::options::OPT_version);
+  opts.outputFile = args.getLastArgValue(clang::driver::options::OPT_o);
+  opts.showHelp = args.hasArg(clang::driver::options::OPT_help);
+  opts.showVersion = args.hasArg(clang::driver::options::OPT_version);
 
   // Get the input kind (from the value passed via `-x`)
   InputKind dashX(Language::Unknown);
   if (const llvm::opt::Arg *a =
           args.getLastArg(clang::driver::options::OPT_x)) {
     llvm::StringRef XValue = a->getValue();
     // Principal languages.
     dashX = llvm::StringSwitch<InputKind>(XValue)
if (const llvm::opt::Arg *a =
     if (dashX.IsUnknown())
       diags.Report(clang::diag::err_drv_invalid_value)
           << a->getAsString(args) << a->getValue();
   }
 
   // Collect the input files and save them in our instance of FrontendOptions.
   std::vector<std::string> inputs =
       args.getAllArgValues(clang::driver::options::OPT_INPUT);
-  opts.inputs_.clear();
+  opts.inputs.clear();
   if (inputs.empty())
     // '-' is the default input if none is given.
     inputs.push_back("-");
   for (unsigned i = 0, e = inputs.size(); i != e; ++i) {
     InputKind ik = dashX;
     if (ik.IsUnknown()) {
       ik = FrontendOptions::GetInputKindForExtension(
           llvm::StringRef(inputs[i]).rsplit('.').second);
       if (ik.IsUnknown())
         ik = Language::Unknown;
       if (i == 0)
         dashX = ik;
     }
 
-    opts.inputs_.emplace_back(std::move(inputs[i]), ik);
+    opts.inputs.emplace_back(std::move(inputs[i]), ik);
   }
 
-  // Set fortranForm_ based on options -ffree-form and -ffixed-form.
+  // Set fortranForm based on options -ffree-form and -ffixed-form.
   if (const auto *arg = args.getLastArg(clang::driver::options::OPT_ffixed_form,
           clang::driver::options::OPT_ffree_form)) {
-    opts.fortranForm_ =
+    opts.fortranForm =
         arg->getOption().matches(clang::driver::options::OPT_ffixed_form)
         ? FortranForm::FixedForm
         : FortranForm::FreeForm;
   }
 
-  // Set fixedFormColumns_ based on -ffixed-line-length=<value>
+  // Set fixedFormColumns based on -ffixed-line-length=<value>
   if (const auto *arg =
           args.getLastArg(clang::driver::options::OPT_ffixed_line_length_EQ)) {
     llvm::StringRef argValue = llvm::StringRef(arg->getValue());
     std::int64_t columns = -1;
     if (argValue == "none") {
       columns = 0;
     } else if (argValue.getAsInteger(/*Radix=*/10, columns)) {
       columns = -1;
     }
     if (columns < 0) {
       diags.Report(clang::diag::err_drv_negative_columns)
           << arg->getOption().getName() << arg->getValue();
     } else if (columns == 0) {
-      opts.fixedFormColumns_ = 1000000;
+      opts.fixedFormColumns = 1000000;
     } else if (columns < 7) {
       diags.Report(clang::diag::err_drv_small_columns)
           << arg->getOption().getName() << arg->getValue() << "7";
     } else {
-      opts.fixedFormColumns_ = columns;
+      opts.fixedFormColumns = columns;
     }
   }
 
   if (const llvm::opt::Arg *arg =
           args.getLastArg(clang::driver::options::OPT_fimplicit_none,
               clang::driver::options::OPT_fno_implicit_none)) {
-    opts.features_.Enable(
+    opts.features.Enable(
         Fortran::common::LanguageFeature::ImplicitNoneTypeAlways,
         arg->getOption().matches(clang::driver::options::OPT_fimplicit_none));
   }
   if (const llvm::opt::Arg *arg =
           args.getLastArg(clang::driver::options::OPT_fbackslash,
               clang::driver::options::OPT_fno_backslash)) {
-    opts.features_.Enable(Fortran::common::LanguageFeature::BackslashEscapes,
+    opts.features.Enable(Fortran::common::LanguageFeature::BackslashEscapes,
         arg->getOption().matches(clang::driver::options::OPT_fbackslash));
   }
   if (const llvm::opt::Arg *arg =
           args.getLastArg(clang::driver::options::OPT_flogical_abbreviations,
               clang::driver::options::OPT_fno_logical_abbreviations)) {
-    opts.features_.Enable(
-        Fortran::common::LanguageFeature::LogicalAbbreviations,
+    opts.features.Enable(Fortran::common::LanguageFeature::LogicalAbbreviations,
         arg->getOption().matches(
             clang::driver::options::OPT_flogical_abbreviations));
   }
   if (const llvm::opt::Arg *arg =
           args.getLastArg(clang::driver::options::OPT_fxor_operator,
               clang::driver::options::OPT_fno_xor_operator)) {
-    opts.features_.Enable(Fortran::common::LanguageFeature::XOROperator,
+    opts.features.Enable(Fortran::common::LanguageFeature::XOROperator,
         arg->getOption().matches(clang::driver::options::OPT_fxor_operator));
   }
   if (args.hasArg(
           clang::driver::options::OPT_falternative_parameter_statement)) {
-    opts.features_.Enable(Fortran::common::LanguageFeature::OldStyleParameter);
+    opts.features.Enable(Fortran::common::LanguageFeature::OldStyleParameter);
   }
   if (const llvm::opt::Arg *arg =
           args.getLastArg(clang::driver::options::OPT_finput_charset_EQ)) {
     llvm::StringRef argValue = arg->getValue();
     if (argValue == "utf-8") {
-      opts.encoding_ = Fortran::parser::Encoding::UTF_8;
+      opts.encoding = Fortran::parser::Encoding::UTF_8;
     } else if (argValue == "latin-1") {
-      opts.encoding_ = Fortran::parser::Encoding::LATIN_1;
+      opts.encoding = Fortran::parser::Encoding::LATIN_1;
     } else {
       diags.Report(clang::diag::err_drv_invalid_value)
           << arg->getAsString(args) << argValue;
     }
   }
 
   setUpFrontendBasedOnAction(opts);
-  opts.dashX_ = dashX;
+  opts.dashX = dashX;
 
   return diags.getNumErrors() == numErrorsBefore;
 }
 
 // Generate the path to look for intrinsic modules
 static std::string getIntrinsicDir() {
   // TODO: Find a system independent API
   llvm::SmallString<128> driverPath;
if (args.hasArg(clang::driver::options::OPT_fdefault_double_8)) {
     // https://gcc.gnu.org/onlinedocs/gfortran/Fortran-Dialect-Options.html
     res.defaultKinds().set_doublePrecisionKind(8);
   }
   if (args.hasArg(clang::driver::options::OPT_flarge_sizes))
     res.defaultKinds().set_sizeIntegerKind(8);
 
   // -fopenmp and -fopenacc
   if (args.hasArg(clang::driver::options::OPT_fopenacc)) {
-    res.frontendOpts().features_.Enable(
+    res.frontendOpts().features.Enable(
         Fortran::common::LanguageFeature::OpenACC);
   }
   if (args.hasArg(clang::driver::options::OPT_fopenmp)) {
-    res.frontendOpts().features_.Enable(
+    res.frontendOpts().features.Enable(
         Fortran::common::LanguageFeature::OpenMP);
   }
 
   // -pedantic
   if (args.hasArg(clang::driver::options::OPT_pedantic)) {
     res.set_EnableConformanceChecks();
   }
   // -std=f2018 (currently this implies -pedantic)
void CompilerInvocation::setDefaultPredefinitions() {
   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(
+  if (frontendOptions.features.IsEnabled(
           Fortran::common::LanguageFeature::OpenACC)) {
     fortranOptions.predefinitions.emplace_back("_OPENACC", "202011");
   }
-  if (frontendOptions.features_.IsEnabled(
+  if (frontendOptions.features.IsEnabled(
           Fortran::common::LanguageFeature::OpenMP)) {
     fortranOptions.predefinitions.emplace_back("_OPENMP", "201511");
   }
 }
 
 void CompilerInvocation::setFortranOpts() {
   auto &fortranOptions = fortranOpts();
   const auto &frontendOptions = frontendOpts();
   const auto &preprocessorOptions = preprocessorOpts();
   auto &moduleDirJ = moduleDir();
 
-  if (frontendOptions.fortranForm_ != FortranForm::Unknown) {
+  if (frontendOptions.fortranForm != FortranForm::Unknown) {
     fortranOptions.isFixedForm =
-        frontendOptions.fortranForm_ == FortranForm::FixedForm;
+        frontendOptions.fortranForm == FortranForm::FixedForm;
   }
-  fortranOptions.fixedFormColumns = frontendOptions.fixedFormColumns_;
+  fortranOptions.fixedFormColumns = frontendOptions.fixedFormColumns;
 
-  fortranOptions.features = frontendOptions.features_;
-  fortranOptions.encoding = frontendOptions.encoding_;
+  fortranOptions.features = frontendOptions.features;
+  fortranOptions.encoding = frontendOptions.encoding;
 
   // Adding search directories specified by -I
   fortranOptions.searchDirectories.insert(
       fortranOptions.searchDirectories.end(),
       preprocessorOptions.searchDirectoriesFromDashI.begin(),
       preprocessorOptions.searchDirectoriesFromDashI.end());
 
   // Add the ordered list of -intrinsic-modules-path
   fortranOptions.searchDirectories.insert(
       fortranOptions.searchDirectories.end(),
       preprocessorOptions.searchDirectoriesFromIntrModPath.begin(),
       preprocessorOptions.searchDirectoriesFromIntrModPath.end());
 
   //  Add the default intrinsic module directory at the end
   fortranOptions.searchDirectories.emplace_back(getIntrinsicDir());
 
   // Add the directory supplied through -J/-module-dir to the list of search
   // directories
   if (moduleDirJ.compare(".") != 0)
     fortranOptions.searchDirectories.emplace_back(moduleDirJ);
 
-  if (frontendOptions.instrumentedParse_)
+  if (frontendOptions.instrumentedParse)
     fortranOptions.instrumentedParse = true;
 
-  if (frontendOptions.needProvenanceRangeToCharBlockMappings_)
+  if (frontendOptions.needProvenanceRangeToCharBlockMappings)
     fortranOptions.needProvenanceRangeToCharBlockMappings = true;
 
   if (enableConformanceChecks()) {
     fortranOptions.features.WarnOnAllNonstandard();
   }
 }
 
 void CompilerInvocation::setSemanticsOpts(

flang/lib/Frontend/FrontendAction.cpp

if ((invoc.preprocessorOpts().macrosFlag_ == PPMacrosFlag::Include) ||
       (invoc.preprocessorOpts().macrosFlag_ == PPMacrosFlag::Unknown &&
           currentInput().MustBePreprocessed())) {
     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) {
+  if (invoc.frontendOpts().fortranForm == FortranForm::Unknown) {
     invoc.fortranOpts().isFixedForm = currentInput().IsFixedForm();
   }
 
   if (!BeginSourceFileAction(ci)) {
     BeginSourceFileCleanUp(*this, ci);
     return false;
   }
 

flang/lib/Frontend/FrontendActions.cpp

 
 bool PrescanAndParseAction::BeginSourceFileAction(CompilerInstance &c1) {
   CompilerInstance &ci = this->instance();
 
   std::string currentInputPath{GetCurrentFileOrBufferName()};
 
   Fortran::parser::Options parserOptions = ci.invocation().fortranOpts();
 
-  if (ci.invocation().frontendOpts().fortranForm_ == FortranForm::Unknown) {
+  if (ci.invocation().frontendOpts().fortranForm == FortranForm::Unknown) {
     // Switch between fixed and free form format based on the input file
     // extension.
     //
     // Ideally we should have all Fortran options set before entering this
     // method (i.e. before processing any specific input files). However, we
     // can't decide between fixed and free form based on the file extension
     // earlier than this.
     parserOptions.isFixedForm = currentInput().IsFixedForm();
if (reportFatalSemanticErrors(semantics(), this->instance().diagnostics(),
           GetCurrentFileOrBufferName()))
     return;
 
   CompilerInstance &ci = this->instance();
   parser::AllCookedSources &cs = ci.allCookedSources();
   unsigned diagID = ci.diagnostics().getCustomDiagID(
       clang::DiagnosticsEngine::Error, "Symbol not found");
 
-  auto gdv = ci.invocation().frontendOpts().getDefVals_;
+  auto gdv = ci.invocation().frontendOpts().getDefVals;
   auto charBlock{cs.GetCharBlockFromLineAndColumns(
       gdv.line, gdv.startColumn, gdv.endColumn)};
   if (!charBlock) {
     ci.diagnostics().Report(diagID);
     return;
   }
 
   llvm::outs() << "String range: >" << charBlock->ToString() << "<\n";

flang/lib/FrontendTool/ExecuteCompilerInvocation.cpp

 #include "llvm/Support/BuryPointer.h"
 #include "llvm/Support/CommandLine.h"
 
 namespace Fortran::frontend {
 
 static std::unique_ptr<FrontendAction> CreateFrontendBaseAction(
     CompilerInstance &ci) {
 
-  ActionKind ak = ci.frontendOpts().programAction_;
+  ActionKind ak = ci.frontendOpts().programAction;
   switch (ak) {
   case InputOutputTest:
     return std::make_unique<InputOutputTestAction>();
     break;
   case PrintPreprocessedInput:
     return std::make_unique<PrintPreprocessedAction>();
     break;
   case ParseSyntaxOnly:
std::unique_ptr<FrontendAction> CreateFrontendAction(CompilerInstance &ci) {
   std::unique_ptr<FrontendAction> act = CreateFrontendBaseAction(ci);
   if (!act)
     return nullptr;
 
   return act;
 }
 bool ExecuteCompilerInvocation(CompilerInstance *flang) {
   // Honor -help.
-  if (flang->frontendOpts().showHelp_) {
+  if (flang->frontendOpts().showHelp) {
     clang::driver::getDriverOptTable().printHelp(llvm::outs(),
         "flang-new -fc1 [options] file...", "LLVM 'Flang' Compiler",
         /*Include=*/clang::driver::options::FC1Option,
         /*Exclude=*/llvm::opt::DriverFlag::HelpHidden,
         /*ShowAllAliases=*/false);
     return true;
   }
 
   // Honor -version.
-  if (flang->frontendOpts().showVersion_) {
+  if (flang->frontendOpts().showVersion) {
     llvm::cl::PrintVersionMessage();
     return true;
   }
 
   // Create and execute the frontend action.
   std::unique_ptr<FrontendAction> act(CreateFrontendAction(*flang));
   if (!act)
     return false;
 
   bool success = flang->ExecuteAction(*act);
   return success;
 }
 
 } // namespace Fortran::frontend

flang/unittests/Frontend/FrontendActionTest.cpp

void SetUp() override {
     inputFilePath_ = cwd.c_str();
     inputFilePath_ += "/" + inputFileName_;
 
     // Prepare the compiler (CompilerInvocation + CompilerInstance)
     compInst_.CreateDiagnostics();
     invocation_ = std::make_shared<CompilerInvocation>();
 
     compInst_.set_invocation(std::move(invocation_));
-    compInst_.frontendOpts().inputs_.push_back(
+    compInst_.frontendOpts().inputs.push_back(
         FrontendInputFile(inputFilePath_, Language::Fortran));
   }
 
   void TearDown() override {
     // Clear the input file.
     llvm::sys::fs::remove(inputFileName_);
 
     // Clear the output files.
     // Note that these tests use an output buffer (as opposed to an output
     // file), hence there are no physical output files to delete and
     // `EraseFiles` is set to `false`. Also, some actions (e.g.
     // `ParseSyntaxOnly`) don't generated output. In such cases there's no
     // output to clear and `ClearOutputFile` returns immediately.
     compInst_.ClearOutputFiles(/*EraseFiles=*/false);
   }
 };
 
 TEST_F(FrontendActionTest, TestInputOutput) {
   // Populate the input file with the pre-defined input and flush it.
   *(inputFileOs_) << "End Program arithmetic";
   inputFileOs_.reset();
 
   // Set-up the action kind.
-  compInst_.invocation().frontendOpts().programAction_ = InputOutputTest;
+  compInst_.invocation().frontendOpts().programAction = InputOutputTest;
 
   // Set-up the output stream. Using output buffer wrapped as an output
   // stream, as opposed to an actual file (or a file descriptor).
   llvm::SmallVector<char, 256> outputFileBuffer;
   std::unique_ptr<llvm::raw_pwrite_stream> outputFileStream(
       new llvm::raw_svector_ostream(outputFileBuffer));
   compInst_.set_outputStream(std::move(outputFileStream));
 
TEST_F(FrontendActionTest, PrintPreprocessedInput) {
   *(inputFileOs_) << "#ifdef NEW\n"
                   << "  Program A \n"
                   << "#else\n"
                   << "  Program B\n"
                   << "#endif";
   inputFileOs_.reset();
 
   // Set-up the action kind.
-  compInst_.invocation().frontendOpts().programAction_ = PrintPreprocessedInput;
+  compInst_.invocation().frontendOpts().programAction = PrintPreprocessedInput;
 
   // Set-up the output stream. We are using output buffer wrapped as an output
   // stream, as opposed to an actual file (or a file descriptor).
   llvm::SmallVector<char, 256> outputFileBuffer;
   std::unique_ptr<llvm::raw_pwrite_stream> outputFileStream(
       new llvm::raw_svector_ostream(outputFileBuffer));
   compInst_.set_outputStream(std::move(outputFileStream));
 

 
 TEST_F(FrontendActionTest, ParseSyntaxOnly) {
   // Populate the input file with the pre-defined input and flush it.
   *(inputFileOs_) << "IF (A > 0.0) IF (B < 0.0) A = LOG (A)\n"
                   << "END";
   inputFileOs_.reset();
 
   // Set-up the action kind.
-  compInst_.invocation().frontendOpts().programAction_ = ParseSyntaxOnly;
+  compInst_.invocation().frontendOpts().programAction = ParseSyntaxOnly;
 
   // Set-up the output stream for the semantic diagnostics.
   llvm::SmallVector<char, 256> outputDiagBuffer;
   std::unique_ptr<llvm::raw_pwrite_stream> outputStream(
       new llvm::raw_svector_ostream(outputDiagBuffer));
   compInst_.set_semaOutputStream(std::move(outputStream));
 
   // Execute the action.