[flang][driver] Rename the accessors (NFC)

[awarzynski]

Summary

As per:

• https://github.com/llvm/llvm-project/blob/master/flang/docs/C++style.md#naming

point 3:

Accessor member functions are named with the non-public data member's
name, less the trailing underscore.

Originally we just followed the LLVM's style, which is incompatible with
Flang. This patch renames the accessors (and a handful of mutators)
accordingly.

[awarzynski]

Restore changes made outside the driver

[CarolineConcatto]

Thank you @awarzynski for changing this to be compatible with Flang style, it is not the nicest job.
First time we implemented it was very different so I missed some standards.
What I notice is that you did not changed any of the get for diagnostic. Is there any reasons for that?

flang/include/flang/Frontend/CompilerInstance.h

110–111

Is the diagnostic not changed because you want to have like it is in clang?
As for instance:
clang::DiagnosticsEngine &GetDiagnostics()
void SetDiagnostics(clang::DiagnosticsEngine *value);

195

Should this also be changed?

flang/lib/Frontend/CompilerInstance.cpp

29

Should it be set_invocation?

[awarzynski]

Update the remaining accessors/mutators

[awarzynski]

Thank you for reviewing @CarolineConcatto! I missed a few cases - thanks for catching those! That's been updated in the 2nd patch (uploaded just now)

I've also realised that there was:

• getDiagnostics() and GetDiagnostics() (replaced with diagnostics())
• setDiagnostics() which was neither implemented nor used

[CarolineConcatto]

Thank you @awarzynski,
LGTM!

flang/include/flang/Evaluate/expression.h

 // A polymorphic expression of known intrinsic type category, but dynamic
 // kind, represented as a discriminated union over Expr<Type<CAT, K>>
 // for each supported kind K in the category.
 template <TypeCategory CAT>
 class Expr<SomeKind<CAT>> : public ExpressionBase<SomeKind<CAT>> {
 public:
   using Result = SomeKind<CAT>;
   EVALUATE_UNION_CLASS_BOILERPLATE(Expr)
-  int GetKind() const;
+  int kind() const;
   common::MapTemplate<evaluate::Expr, CategoryTypes<CAT>> u;
 };
 
 template <> class Expr<SomeCharacter> : public ExpressionBase<SomeCharacter> {
 public:
   using Result = SomeCharacter;
   EVALUATE_UNION_CLASS_BOILERPLATE(Expr)
-  int GetKind() const;
+  int kind() const;
   std::optional<Expr<SubscriptInteger>> LEN() const;
   common::MapTemplate<Expr, CategoryTypes<TypeCategory::Character>> u;
 };
 
 // A variant comprising the Expr<> instantiations over SomeDerived and
 // SomeKind<CATEGORY>.
 using CategoryExpression = common::MapTemplate<Expr, SomeCategory>;
 

flang/include/flang/Frontend/CompilerInstance.h

 public:
   explicit CompilerInstance();
 
   ~CompilerInstance();
 
   /// @name Compiler Invocation
   /// {
 
-  CompilerInvocation &GetInvocation() {
+  CompilerInvocation &invocation() {
     assert(invocation_ && "Compiler instance has no invocation!");
     return *invocation_;
   };
 
   /// Replace the current invocation.
   void SetInvocation(std::shared_ptr<CompilerInvocation> value);
 
   /// }
   /// @name File manager
   /// {
 
   /// Return the current allSources.
-  Fortran::parser::AllSources &GetAllSources() const { return *allSources_; }
+  Fortran::parser::AllSources &allSources() const { return *allSources_; }
 
   bool HasAllSources() const { return allSources_ != nullptr; }
 
   /// }
   /// @name High-Level Operations
   /// {
 
   /// Execute the provided action against the compiler's
   /// CompilerInvocation object.
   /// \param act - The action to execute.
   /// \return - True on success.
   bool ExecuteAction(FrontendAction &act);
 
   /// }
   /// @name Forwarding Methods
   /// {
 
   clang::DiagnosticOptions &GetDiagnosticOpts() {
     return invocation_->GetDiagnosticOpts();
   }
   const clang::DiagnosticOptions &GetDiagnosticOpts() const {
     return invocation_->GetDiagnosticOpts();
   }
 
-  FrontendOptions &GetFrontendOpts() { return invocation_->GetFrontendOpts(); }
-  const FrontendOptions &GetFrontendOpts() const {
-    return invocation_->GetFrontendOpts();
+  FrontendOptions &frontendOpts() { return invocation_->frontendOpts(); }
+  const FrontendOptions &frontendOpts() const {
+    return invocation_->frontendOpts();
   }
 
   /// }
   /// @name Diagnostics Engine
   /// {
 
   bool HasDiagnostics() const { return diagnostics_ != nullptr; }
 
   /// Get the current diagnostics engine.
   clang::DiagnosticsEngine &GetDiagnostics() const {
     assert(diagnostics_ && "Compiler instance has no diagnostics!");
     return *diagnostics_;
   }
 
   /// Replace the current diagnostics engine.
   void SetDiagnostics(clang::DiagnosticsEngine *value);
 
   clang::DiagnosticConsumer &GetDiagnosticClient() const {
static clang::IntrusiveRefCntPtr<clang::DiagnosticsEngine> CreateDiagnostics(
       clang::DiagnosticOptions *opts,
       clang::DiagnosticConsumer *client = nullptr, bool shouldOwnClient = true);
   void CreateDiagnostics(
       clang::DiagnosticConsumer *client = nullptr, bool shouldOwnClient = true);
 
   /// }
   /// @name Output Stream Methods
   /// {
   void SetOutputStream(std::unique_ptr<llvm::raw_pwrite_stream> outStream) {
     outputStream_ = std::move(outStream);
   }
 
   bool IsOutputStreamNull() { return (outputStream_ == nullptr); }
 
   // Allow the frontend compiler to write in the output stream.
   void WriteOutputStream(const std::string &message) {
     *outputStream_ << message;
   }
 };
 
 } // end namespace Fortran::frontend
 #endif // LLVM_FLANG_FRONTEND_COMPILERINSTANCE_H

flang/include/flang/Frontend/CompilerInvocation.h

 //===- CompilerInvocation.h - Compiler Invocation Helper Data ---*- C -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #ifndef LLVM_FLANG_FRONTEND_COMPILERINVOCATION_H
 #define LLVM_FLANG_FRONTEND_COMPILERINVOCATION_H
 
 #include "flang/Frontend/FrontendOptions.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/DiagnosticOptions.h"
 #include "llvm/Option/ArgList.h"
 
 namespace Fortran::frontend {
 
 /// Fill out Opts based on the options given in Args.
 ///
 /// When errors are encountered, return false and, if Diags is non-null,

 
 class CompilerInvocation : public CompilerInvocationBase {
   /// Options controlling the frontend itself.
   FrontendOptions frontendOpts_;
 
 public:
   CompilerInvocation() = default;
 
-  FrontendOptions &GetFrontendOpts() { return frontendOpts_; }
-  const FrontendOptions &GetFrontendOpts() const { return frontendOpts_; }
+  FrontendOptions &frontendOpts() { return frontendOpts_; }
+  const FrontendOptions &frontendOpts() const { return frontendOpts_; }
 
   /// Create a compiler invocation from a list of input options.
   /// \returns true on success.
   /// \returns false if an error was encountered while parsing the arguments
   /// \param [out] res - The resulting invocation.
   static bool CreateFromArgs(CompilerInvocation &res,
       llvm::ArrayRef<const char *> commandLineArgs,
       clang::DiagnosticsEngine &diags);
 };
 
 } // end namespace Fortran::frontend
 #endif // LLVM_FLANG_FRONTEND_COMPILERINVOCATION_H

flang/include/flang/Frontend/FrontendAction.h

 
 public:
   FrontendAction() : instance_(nullptr) {}
   virtual ~FrontendAction() = default;
 
   /// @name Compiler Instance Access
   /// @{
 
-  CompilerInstance &GetCompilerInstance() const {
+  CompilerInstance &instance() const {
     assert(instance_ && "Compiler instance not registered!");
     return *instance_;
   }
 
-  void SetCompilerInstance(CompilerInstance *value) { instance_ = value; }
+  void set_instance(CompilerInstance *value) { instance_ = value; }
 
   /// @}
   /// @name Current File Information
   /// @{
 
-  const FrontendInputFile &GetCurrentInput() const { return currentInput_; }
+  const FrontendInputFile &currentInput() const { return currentInput_; }
 
   llvm::StringRef GetCurrentFile() const {
     assert(!currentInput_.IsEmpty() && "No current file!");
-    return currentInput_.GetFile();
+    return currentInput_.file();
   }
 
   llvm::StringRef GetCurrentFileOrBufferName() const {
     assert(!currentInput_.IsEmpty() && "No current file!");
     return currentInput_.IsFile()
-        ? currentInput_.GetFile()
-        : currentInput_.GetBuffer()->getBufferIdentifier();
+        ? currentInput_.file()
+        : currentInput_.buffer()->getBufferIdentifier();
   }
-  void SetCurrentInput(const FrontendInputFile &currentInput);
+  void set_currentInput(const FrontendInputFile &currentInput);
 
   /// @}
   /// @name Public Action Interface
   /// @}
 
   /// Prepare the action for processing the input file \p input.
   ///
   /// This is run after the options and frontend have been initialized,

flang/include/flang/Frontend/FrontendOptions.h

 
 public:
   FrontendInputFile() = default;
   FrontendInputFile(llvm::StringRef file, InputKind kind)
       : file_(file.str()), kind_(kind) {}
   FrontendInputFile(const llvm::MemoryBuffer *buffer, InputKind kind)
       : buffer_(buffer), kind_(kind) {}
 
-  InputKind GetKind() const { return kind_; }
+  InputKind kind() const { return kind_; }
 
   bool IsEmpty() const { return file_.empty() && buffer_ == nullptr; }
   bool IsFile() const { return !IsBuffer(); }
   bool IsBuffer() const { return buffer_ != nullptr; }
 
-  llvm::StringRef GetFile() const {
+  llvm::StringRef file() const {
     assert(IsFile());
     return file_;
   }
 
-  const llvm::MemoryBuffer *GetBuffer() const {
+  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:

flang/lib/Evaluate/expression.cpp

 void GenericExprWrapper::Deleter(GenericExprWrapper *p) { delete p; }
 
 GenericAssignmentWrapper::~GenericAssignmentWrapper() {}
 
 void GenericAssignmentWrapper::Deleter(GenericAssignmentWrapper *p) {
   delete p;
 }
 
-template <TypeCategory CAT> int Expr<SomeKind<CAT>>::GetKind() const {
+template <TypeCategory CAT> int Expr<SomeKind<CAT>>::kind() const {
   return std::visit(
       [](const auto &kx) { return std::decay_t<decltype(kx)>::Result::kind; },
       u);
 }
 
-int Expr<SomeCharacter>::GetKind() const {
+int Expr<SomeCharacter>::kind() const {
   return std::visit(
       [](const auto &kx) { return std::decay_t<decltype(kx)>::Result::kind; },
       u);
 }
 
 std::optional<Expr<SubscriptInteger>> Expr<SomeCharacter>::LEN() const {
   return std::visit([](const auto &kx) { return kx.LEN(); }, u);
 }
 
 INSTANTIATE_EXPRESSION_TEMPLATES
 } // namespace Fortran::evaluate

flang/lib/Frontend/CompilerInstance.cpp

 CompilerInstance::CompilerInstance()
     : invocation_(new CompilerInvocation()),
       allSources_(new Fortran::parser::AllSources()) {}
 
 CompilerInstance::~CompilerInstance() {
   assert(outputFiles_.empty() && "Still output files in flight?");
 }
 
 void CompilerInstance::SetInvocation(
     std::shared_ptr<CompilerInvocation> value) {
   invocation_ = std::move(value);
 }
 
 void CompilerInstance::AddOutputFile(OutputFile &&outFile) {
   outputFiles_.push_back(std::move(outFile));
 }
 

 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(GetFrontendOpts().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)
void CompilerInstance::ClearOutputFiles(bool eraseFiles) {
 
   outputFiles_.clear();
   nonSeekStream_.reset();
 }
 
 bool CompilerInstance::ExecuteAction(FrontendAction &act) {
 
   // Connect Input to a CompileInstance
-  for (const FrontendInputFile &fif : GetFrontendOpts().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 true;

flang/lib/Frontend/CompilerInvocation.cpp

if (opts.findNearest(argString, nearest, includedFlagsBitmask) > 1)
       diags.Report(clang::diag::err_drv_unknown_argument) << argString;
     else
       diags.Report(clang::diag::err_drv_unknown_argument_with_suggestion)
           << argString << nearest;
     success = false;
   }
 
   // Parse the frontend args
-  ParseFrontendArgs(res.GetFrontendOpts(), args, diags);
+  ParseFrontendArgs(res.frontendOpts(), args, diags);
 
   return success;
 }

flang/lib/Frontend/FrontendAction.cpp

 //===--- FrontendAction.cpp -----------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "flang/Frontend/FrontendAction.h"
 #include "flang/Frontend/CompilerInstance.h"
 #include "flang/Frontend/FrontendActions.h"
 #include "llvm/Support/Errc.h"
 
 using namespace Fortran::frontend;
 
-void FrontendAction::SetCurrentInput(const FrontendInputFile &currentInput) {
+void FrontendAction::set_currentInput(const FrontendInputFile &currentInput) {
   this->currentInput_ = currentInput;
 }
 
 // Call this method if BeginSourceFile fails.
 // Deallocate compiler instance, input and output descriptors
 static void BeginSourceFileCleanUp(FrontendAction &fa, CompilerInstance &ci) {
   ci.ClearOutputFiles(/*EraseFiles=*/true);
-  fa.SetCurrentInput(FrontendInputFile());
-  fa.SetCompilerInstance(nullptr);
+  fa.set_currentInput(FrontendInputFile());
+  fa.set_instance(nullptr);
 }
 
 bool FrontendAction::BeginSourceFile(
     CompilerInstance &ci, const FrontendInputFile &realInput) {
 
   FrontendInputFile input(realInput);
   assert(!instance_ && "Already processing a source file!");
   assert(!realInput.IsEmpty() && "Unexpected empty filename!");
-  SetCurrentInput(realInput);
-  SetCompilerInstance(&ci);
+  set_currentInput(realInput);
+  set_instance(&ci);
   if (!ci.HasAllSources()) {
     BeginSourceFileCleanUp(*this, ci);
     return false;
   }
   return true;
 }
 
 bool FrontendAction::ShouldEraseOutputFiles() {
-  return GetCompilerInstance().getDiagnostics().hasErrorOccurred();
+  return instance().getDiagnostics().hasErrorOccurred();
 }
 
 llvm::Error FrontendAction::Execute() {
   ExecuteAction();
   return llvm::Error::success();
 }
 
 void FrontendAction::EndSourceFile() {
-  CompilerInstance &ci = GetCompilerInstance();
+  CompilerInstance &ci = instance();
 
   // Cleanup the output streams, and erase the output files if instructed by the
   // FrontendAction.
   ci.ClearOutputFiles(/*EraseFiles=*/ShouldEraseOutputFiles());
 
-  SetCompilerInstance(nullptr);
-  SetCurrentInput(FrontendInputFile());
+  set_instance(nullptr);
+  set_currentInput(FrontendInputFile());
 }

flang/lib/Frontend/FrontendActions.cpp

void InputOutputTestAction::ExecuteAction() {
 
   // Get the name of the file from FrontendInputFile current.
   std::string path{GetCurrentFileOrBufferName()};
   std::string buf;
   llvm::raw_string_ostream error_stream{buf};
   bool binaryMode = true;
 
   // Set/store input file info into CompilerInstance.
-  CompilerInstance &ci = GetCompilerInstance();
-  Fortran::parser::AllSources &allSources{ci.GetAllSources()};
+  CompilerInstance &ci = instance();
+  Fortran::parser::AllSources &allSources{ci.allSources()};
   const Fortran::parser::SourceFile *sf;
   sf = allSources.Open(path, error_stream);
   llvm::ArrayRef<char> fileContent = sf->content();
 
   // Output file descriptor to receive the content of input file.
   std::unique_ptr<llvm::raw_ostream> os;
 
   // Do not write on the output file if using outputStream_.

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.GetFrontendOpts().programAction_;
+  ActionKind ak = ci.frontendOpts().programAction_;
   switch (ak) {
   case InputOutputTest:
     return std::make_unique<InputOutputTestAction>();
     break;
   default:
     break;
     // TODO:
     // case RunPreprocessor:
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->GetFrontendOpts().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->GetFrontendOpts().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/lib/Semantics/program-tree.h

using Stmt = std::variant< // the statement that introduces the program unit
       const parser::Statement<parser::SubmoduleStmt> *,
       const parser::Statement<parser::BlockDataStmt> *>;
 
   ProgramTree(const parser::Name &name, const parser::SpecificationPart &spec,
       const parser::ExecutionPart *exec = nullptr)
       : name_{name}, spec_{spec}, exec_{exec} {}
 
   const parser::Name &name() const { return name_; }
-  Kind GetKind() const;
+  Kind kind() const;
   const Stmt &stmt() const { return stmt_; }
   bool isSpecificationPartResolved() const {
     return isSpecificationPartResolved_;
   }
   void set_isSpecificationPartResolved(bool yes = true) {
     isSpecificationPartResolved_ = yes;
   }
   const parser::ParentIdentifier &GetParentId() const; // only for Submodule

flang/lib/Semantics/program-tree.cpp

 //===-- lib/Semantics/program-tree.cpp ------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "program-tree.h"

 
 const parser::ParentIdentifier &ProgramTree::GetParentId() const {
   const auto *stmt{
       std::get<const parser::Statement<parser::SubmoduleStmt> *>(stmt_)};
   return std::get<parser::ParentIdentifier>(stmt->statement.t);
 }
 
 bool ProgramTree::IsModule() const {
-  auto kind{GetKind()};
+  auto kind{kind()};
   return kind == Kind::Module || kind == Kind::Submodule;
 }
 
 Symbol::Flag ProgramTree::GetSubpFlag() const {
-  return GetKind() == Kind::Function ? Symbol::Flag::Function
+  return kind() == Kind::Function ? Symbol::Flag::Function
                                      : Symbol::Flag::Subroutine;
 }
 
 bool ProgramTree::HasModulePrefix() const {
   using ListType = std::list<parser::PrefixSpec>;
   const auto *prefixes{
       std::visit(common::visitors{
                      [](const parser::Statement<parser::FunctionStmt> *x) {
                        return &std::get<ListType>(x->statement.t);
for (const auto &prefix : *prefixes) {
       if (std::holds_alternative<parser::PrefixSpec::Module>(prefix.u)) {
         return true;
       }
     }
   }
   return false;
 }
 
-ProgramTree::Kind ProgramTree::GetKind() const {
+ProgramTree::Kind ProgramTree::kind() const {
   return std::visit(
       common::visitors{
           [](const parser::Statement<parser::ProgramStmt> *) {
             return Kind::Program;
           },
           [](const parser::Statement<parser::FunctionStmt> *) {
             return Kind::Function;
           },

flang/lib/Semantics/resolve-names.cpp

protected:
   const DeclTypeSpec *GetDeclTypeSpec();
   void BeginDeclTypeSpec();
   void EndDeclTypeSpec();
   void SetDeclTypeSpec(const DeclTypeSpec &);
   void SetDeclTypeSpecCategory(DeclTypeSpec::Category);
   DeclTypeSpec::Category GetDeclTypeSpecCategory() const {
     return state_.derived.category;
   }
-  KindExpr GetKindParamExpr(
+  KindExpr kindParamExpr(
       TypeCategory, const std::optional<parser::KindSelector> &);
   void CheckForAbstractType(const Symbol &typeSymbol);
 
 private:
   State state_;
 
   void MakeNumericType(TypeCategory, int kind);
 };

 // Check that we're expecting to see a DeclTypeSpec (and haven't seen one yet)
 // and save it in state_.declTypeSpec.
 void DeclTypeSpecVisitor::SetDeclTypeSpec(const DeclTypeSpec &declTypeSpec) {
   CHECK(state_.expectDeclTypeSpec);
   CHECK(!state_.declTypeSpec);
   state_.declTypeSpec = &declTypeSpec;
 }
 
-KindExpr DeclTypeSpecVisitor::GetKindParamExpr(
+KindExpr DeclTypeSpecVisitor::kindParamExpr(
     TypeCategory category, const std::optional<parser::KindSelector> &kind) {
   return AnalyzeKindSelector(context(), category, kind);
 }
 
 // MessageHandler implementation
 
 Message &MessageHandler::Say(MessageFixedText &&msg) {
   return context_->Say(currStmtSource().value(), std::move(msg));
bool ScopeHandler::ConvertToProcEntity(Symbol &symbol) {
   } else {
     return false;
   }
   return true;
 }
 
 const DeclTypeSpec &ScopeHandler::MakeNumericType(
     TypeCategory category, const std::optional<parser::KindSelector> &kind) {
-  KindExpr value{GetKindParamExpr(category, kind)};
+  KindExpr value{kindParamExpr(category, kind)};
   if (auto known{evaluate::ToInt64(value)}) {
     return context().MakeNumericType(category, static_cast<int>(*known));
   } else {
     return currScope_->MakeNumericType(category, std::move(value));
   }
 }
 
 const DeclTypeSpec &ScopeHandler::MakeLogicalType(
     const std::optional<parser::KindSelector> &kind) {
-  KindExpr value{GetKindParamExpr(TypeCategory::Logical, kind)};
+  KindExpr value{kindParamExpr(TypeCategory::Logical, kind)};
   if (auto known{evaluate::ToInt64(value)}) {
     return context().MakeLogicalType(static_cast<int>(*known));
   } else {
     return currScope_->MakeLogicalType(std::move(value));
   }
 }
 
 void ScopeHandler::MakeExternal(Symbol &symbol) {
void ResolveNamesVisitor::AddSubpNames(ProgramTree &node) {
   for (auto &child : node.children()) {
     auto &symbol{MakeSymbol(child.name(), SubprogramNameDetails{kind, child})};
     symbol.set(child.GetSubpFlag());
   }
 }
 
 // Push a new scope for this node or return false on error.
 bool ResolveNamesVisitor::BeginScopeForNode(const ProgramTree &node) {
-  switch (node.GetKind()) {
+  switch (node.kind()) {
     SWITCH_COVERS_ALL_CASES
   case ProgramTree::Kind::Program:
     PushScope(Scope::Kind::MainProgram,
         &MakeSymbol(node.name(), MainProgramDetails{}));
     return true;
   case ProgramTree::Kind::Function:
   case ProgramTree::Kind::Subroutine:
     return BeginSubprogram(

flang/tools/flang-driver/fc1_main.cpp

int fc1_main(llvm::ArrayRef<const char *> argv, const char *argv0) {
   // Create CompilerInvocation - use a dedicated instance of DiagnosticsEngine
   // for parsing the arguments
   llvm::IntrusiveRefCntPtr<clang::DiagnosticIDs> diagID(
       new clang::DiagnosticIDs());
   llvm::IntrusiveRefCntPtr<clang::DiagnosticOptions> diagOpts =
       new clang::DiagnosticOptions();
   clang::DiagnosticsEngine diags(diagID, &*diagOpts, diagsBuffer);
   bool success =
-      CompilerInvocation::CreateFromArgs(flang->GetInvocation(), argv, diags);
+      CompilerInvocation::CreateFromArgs(flang->invocation(), argv, diags);
 
   diagsBuffer->FlushDiagnostics(flang->getDiagnostics());
 
   if (!success)
     return 1;
 
   // Execute the frontend actions.
   success = ExecuteCompilerInvocation(flang.get());
 
   // Delete output files to free Compiler Instance
   flang->ClearOutputFiles(/*EraseFiles=*/false);
 
   return !success;
 }

flang/unittests/Frontend/CompilerInstanceTest.cpp

TEST(CompilerInstance, SanityCheckForFileManager) {
   std::string testFilePath(cwd.c_str());
   testFilePath += "/" + inputFile;
 
   // 2. Set up CompilerInstance (i.e. specify the input file)
   std::string buf;
   llvm::raw_string_ostream error_stream{buf};
   CompilerInstance compInst;
   const Fortran::parser::SourceFile *sf =
-      compInst.GetAllSources().Open(testFilePath, error_stream);
+      compInst.allSources().Open(testFilePath, error_stream);
 
   // 3. Verify the content of the input file
   // This is just a sanity check to make sure that CompilerInstance is capable
   // of reading input files.
   llvm::ArrayRef<char> fileContent = sf->content();
   EXPECT_FALSE(fileContent.size() == 0);
   EXPECT_TRUE(
       llvm::StringRef(fileContent.data()).startswith("InputSourceFile"));

flang/unittests/Frontend/InputOutputTest.cpp

 //===- unittests/Frontend/OutputStreamTest.cpp --- FrontendAction tests --===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "gtest/gtest.h"
 #include "flang/Frontend/CompilerInstance.h"
 #include "flang/Frontend/CompilerInvocation.h"
 #include "flang/Frontend/FrontendOptions.h"
 #include "flang/FrontendTool/Utils.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace Fortran::frontend;
if (std::error_code ec = llvm::sys::fs::current_path(cwd))
     FAIL() << "Failed to obtain the current working directory";
   std::string testFilePath(cwd.c_str());
   testFilePath += "/" + inputFile;
 
   // 2. Prepare the compiler (CompilerInvocation + CompilerInstance)
   CompilerInstance compInst;
   compInst.CreateDiagnostics();
   auto invocation = std::make_shared<CompilerInvocation>();
-  invocation->GetFrontendOpts().programAction_ = InputOutputTest;
+  invocation->frontendOpts().programAction_ = InputOutputTest;
   compInst.SetInvocation(std::move(invocation));
-  compInst.GetFrontendOpts().inputs_.push_back(
+  compInst.frontendOpts().inputs_.push_back(
       FrontendInputFile(/*File=*/testFilePath, Language::Fortran));
 
   // 3. 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.SetOutputStream(std::move(outputFileStream));