[ClangExpressionParser] Reuse the FileManager from the compiler instance.

[JDevlieghere]

Summary

I was looking at the ClangExpressionParser and noticed that we have a FileManager owned by the expression parser and later ask the compiler instance to create a new FileManager, owned by the clang CI. Looking at the code I don't see a good reason for having two instances. This patch removes the one owned by LLDB.

[JDevlieghere]

Keep/move the comment in the right place.

[teemperor]

LGTM.

[clayborg]

This change was probably due to things changing over time and there may be more of these kinds of cleanups to be had. nice catch.

lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionParser.h

private:
   //-------------------------------------------------------------------
   unsigned ParseInternal(DiagnosticManager &diagnostic_manager,
                          clang::CodeCompleteConsumer *completion = nullptr,
                          unsigned completion_line = 0,
                          unsigned completion_column = 0);
 
   std::unique_ptr<llvm::LLVMContext>
       m_llvm_context; ///< The LLVM context to generate IR into
-  std::unique_ptr<clang::FileManager>
-      m_file_manager; ///< The Clang file manager object used by the compiler
   std::unique_ptr<clang::CompilerInstance>
       m_compiler; ///< The Clang compiler used to parse expressions into IR
   std::unique_ptr<clang::CodeGenerator>
       m_code_generator; ///< The Clang object that generates IR
 
   class LLDBPreprocessorCallbacks;
   LLDBPreprocessorCallbacks *m_pp_callbacks; ///< Called when the preprocessor
                                              ///encounters module imports
   std::unique_ptr<ClangASTContext> m_ast_context;
 };
 }
 
 #endif // liblldb_ClangExpressionParser_h_

lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionParser.cpp

 //===-- ClangExpressionParser.cpp -------------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/ASTDiagnostic.h"
 #include "clang/AST/ExternalASTSource.h"
 #include "clang/AST/PrettyPrinter.h"
 #include "clang/Basic/DiagnosticIDs.h"
-#include "clang/Basic/FileManager.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Basic/Version.h"
 #include "clang/CodeGen/CodeGenAction.h"
 #include "clang/CodeGen/ModuleBuilder.h"
 #include "clang/Edit/Commit.h"
 #include "clang/Edit/EditedSource.h"
 #include "clang/Edit/EditsReceiver.h"
ClangExpressionParser::ClangExpressionParser(ExecutionContextScope *exe_scope,
   // created. This complexity should be lifted elsewhere.
   m_compiler->getTarget().adjust(m_compiler->getLangOpts());
 
   // 6. Set up the diagnostic buffer for reporting errors
 
   m_compiler->getDiagnostics().setClient(new ClangDiagnosticManagerAdapter);
 
   // 7. Set up the source management objects inside the compiler
-
-  clang::FileSystemOptions file_system_options;
-  m_file_manager.reset(new clang::FileManager(file_system_options));
-
-  if (!m_compiler->hasSourceManager())
-    m_compiler->createSourceManager(*m_file_manager);
-
   m_compiler->createFileManager();
+  if (!m_compiler->hasSourceManager())
+    m_compiler->createSourceManager(m_compiler->getFileManager());
   m_compiler->createPreprocessor(TU_Complete);
 
   if (ClangModulesDeclVendor *decl_vendor =
           target_sp->GetClangModulesDeclVendor()) {
     ClangPersistentVariables *clang_persistent_vars =
         llvm::cast<ClangPersistentVariables>(
             target_sp->GetPersistentExpressionStateForLanguage(
                 lldb::eLanguageTypeC));
if (should_create_file) {
 
     if (temp_fd != -1) {
       lldb_private::File file(temp_fd, true);
       const size_t expr_text_len = strlen(expr_text);
       size_t bytes_written = expr_text_len;
       if (file.Write(expr_text, bytes_written).Success()) {
         if (bytes_written == expr_text_len) {
           file.Close();
-          source_mgr.setMainFileID(
-              source_mgr.createFileID(m_file_manager->getFile(result_path),
-                                      SourceLocation(), SrcMgr::C_User));
+          source_mgr.setMainFileID(source_mgr.createFileID(
+              m_compiler->getFileManager().getFile(result_path),
           created_main_file = true;
         }
       }
     }
   }
 
   if (!created_main_file) {
     std::unique_ptr<MemoryBuffer> memory_buffer =