[lldb] Remove clang classes from lldb-forward.h

[xiaobai]

Summary

lldb-forward.h is convenient in many ways, but having clang-based
class forward declarations in there makes it easy to proliferate uses of clang
outside of plugins. Removing them makes you much more conscious of when
you're using something from clang and marks where we're using things
from clang in non-plugins.

[labath]

This is right. I would even go so far as to say that no plugin forward-declarations should be in that file. Based on a quick glance, I think this is mostly true already..

lldb/include/lldb/Target/Target.h

 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/Broadcaster.h"
 #include "lldb/Utility/LLDBAssert.h"
 #include "lldb/Utility/Timeout.h"
 #include "lldb/lldb-public.h"
 
 namespace lldb_private {
 
+class ClangModulesDeclVendor;
+
 OptionEnumValues GetDynamicValueTypes();
 
 enum InlineStrategy {
   eInlineBreakpointsNever = 0,
   eInlineBreakpointsHeaders,
   eInlineBreakpointsAlways
 };
 
protected:
   lldb::ProcessSP m_process_sp;
   lldb::SearchFilterSP m_search_filter_sp;
   PathMappingList m_image_search_paths;
   TypeSystemMap m_scratch_type_system_map;
 
   typedef std::map<lldb::LanguageType, lldb::REPLSP> REPLMap;
   REPLMap m_repl_map;
 
-  lldb::ClangModulesDeclVendorUP m_clang_modules_decl_vendor_up;
+  std::unique_ptr<ClangModulesDeclVendor> m_clang_modules_decl_vendor_up;
 
   lldb::SourceManagerUP m_source_manager_up;
 
   typedef std::map<lldb::user_id_t, StopHookSP> StopHookCollection;
   StopHookCollection m_stop_hooks;
   lldb::user_id_t m_stop_hook_next_id;
   bool m_valid;
   bool m_suppress_stop_hooks;

lldb/include/lldb/lldb-forward.h

 class BreakpointPrecondition;
 class BreakpointResolver;
 class BreakpointSite;
 class BreakpointSiteList;
 class BroadcastEventSpec;
 class Broadcaster;
 class BroadcasterManager;
 class CallFrameInfo;
-class TypeSystemClang;
-class ClangASTImporter;
-class ClangASTMetadata;
-class ClangASTSource;
-class ClangExpressionDeclMap;
-class ClangExpressionParser;
-class ClangExpressionVariable;
-class ClangModulesDeclVendor;
-class ClangPersistentVariables;
 class CommandInterpreter;
 class CommandInterpreterRunOptions;
 class CommandObject;
 class CommandObjectMultiword;
 class CommandReturnObject;
 class Communication;
 class CompactUnwindInfo;
 struct CompilerContext;

 typedef std::weak_ptr<lldb_private::BreakpointSite> BreakpointSiteWP;
 typedef std::shared_ptr<lldb_private::BreakpointLocation> BreakpointLocationSP;
 typedef std::weak_ptr<lldb_private::BreakpointLocation> BreakpointLocationWP;
 typedef std::shared_ptr<lldb_private::BreakpointPrecondition> BreakpointPreconditionSP;
 typedef std::shared_ptr<lldb_private::BreakpointResolver> BreakpointResolverSP;
 typedef std::shared_ptr<lldb_private::Broadcaster> BroadcasterSP;
 typedef std::shared_ptr<lldb_private::BroadcasterManager> BroadcasterManagerSP;
 typedef std::weak_ptr<lldb_private::BroadcasterManager> BroadcasterManagerWP;
-typedef std::unique_ptr<lldb_private::TypeSystemClang> TypeSystemClangUP;
-typedef std::shared_ptr<lldb_private::ClangASTImporter> ClangASTImporterSP;
-typedef std::unique_ptr<lldb_private::ClangModulesDeclVendor>
-    ClangModulesDeclVendorUP;
-typedef std::unique_ptr<lldb_private::ClangPersistentVariables>
-    ClangPersistentVariablesUP;
 typedef std::shared_ptr<lldb_private::UserExpression> UserExpressionSP;
 typedef std::shared_ptr<lldb_private::CommandObject> CommandObjectSP;
 typedef std::shared_ptr<lldb_private::Communication> CommunicationSP;
 typedef std::shared_ptr<lldb_private::Connection> ConnectionSP;
 typedef std::shared_ptr<lldb_private::CompileUnit> CompUnitSP;
 typedef std::shared_ptr<lldb_private::DataBuffer> DataBufferSP;
 typedef std::shared_ptr<lldb_private::DataExtractor> DataExtractorSP;
 typedef std::shared_ptr<lldb_private::Debugger> DebuggerSP;

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

 #include "lldb/lldb-types.h"
 
 #include "Plugins/ExpressionParser/Clang/CxxModuleHandler.h"
 
 #include "llvm/ADT/DenseMap.h"
 
 namespace lldb_private {
 
+class ClangASTMetadata;
+class TypeSystemClang;
+
 class ClangASTImporter {
 public:
   struct LayoutInfo {
     LayoutInfo() = default;
     typedef llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
         OffsetMap;
 
     uint64_t bit_size = 0;

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

public:
   /// Initializes class variables.
   ///
   /// \param[in] target
   ///     A reference to the target containing debug information to use.
   ///
   /// \param[in] importer
   ///     The ClangASTImporter to use.
   ClangASTSource(const lldb::TargetSP &target,
-                 const lldb::ClangASTImporterSP &importer);
+                 const std::shared_ptr<ClangASTImporter> &importer);
 
   /// Destructor
   ~ClangASTSource() override;
 
   /// Interface stubs.
   clang::Decl *GetExternalDecl(uint32_t) override { return nullptr; }
   clang::Stmt *GetExternalDeclStmt(uint64_t) override { return nullptr; }
   clang::Selector GetExternalSelector(uint32_t) override {
protected:
   const lldb::TargetSP m_target;
   /// The AST context requests are coming in for.
   clang::ASTContext *m_ast_context;
   /// The TypeSystemClang for m_ast_context.
   TypeSystemClang *m_clang_ast_context;
   /// The file manager paired with the AST context.
   clang::FileManager *m_file_manager;
   /// The target's AST importer.
-  lldb::ClangASTImporterSP m_ast_importer_sp;
+  std::shared_ptr<ClangASTImporter> m_ast_importer_sp;
   std::set<const clang::Decl *> m_active_lexical_decls;
   std::set<const char *> m_active_lookups;
 };
 
 /// \class NameSearchContext ClangASTSource.h
 /// "lldb/Expression/ClangASTSource.h" Container for all objects relevant to a
 /// single name lookup
 ///

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

public:
   ~ScopedLexicalDeclEraser() { m_active_lexical_decls.erase(m_decl); }
 
 private:
   std::set<const clang::Decl *> &m_active_lexical_decls;
   const clang::Decl *m_decl;
 };
 }
 
-ClangASTSource::ClangASTSource(const lldb::TargetSP &target,
-                               const lldb::ClangASTImporterSP &importer)
+ClangASTSource::ClangASTSource(
+    const lldb::TargetSP &target,
+    const std::shared_ptr<ClangASTImporter> &importer)
     : m_import_in_progress(false), m_lookups_enabled(false), m_target(target),
       m_ast_context(nullptr), m_ast_importer_sp(importer),
       m_active_lexical_decls(), m_active_lookups() {
   assert(m_ast_importer_sp && "No ClangASTImporter passed to ClangASTSource?");
 }
 
 void ClangASTSource::InstallASTContext(TypeSystemClang &clang_ast_context) {
   m_ast_context = &clang_ast_context.getASTContext();

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

 #include "lldb/Symbol/TaggedASTType.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/lldb-public.h"
 #include "clang/AST/Decl.h"
 #include "llvm/ADT/DenseMap.h"
 
 namespace lldb_private {
 
+class ClangPersistentVariables;
+
 /// \class ClangExpressionDeclMap ClangExpressionDeclMap.h
 /// "lldb/Expression/ClangExpressionDeclMap.h" Manages named entities that are
 /// defined in LLDB's debug information.
 ///
 /// The Clang parser uses the ClangASTSource as an interface to request named
 /// entities from outside an expression.  The ClangASTSource reports back,
 /// listing all possible objects corresponding to a particular name.  But it
 /// in turn relies on ClangExpressionDeclMap, which performs several important
public:
   ///     The ClangASTImporter to use when parsing.
   ///
   /// \param[in] ctx_obj
   ///     If not empty, then expression is evaluated in context of this object.
   ///     See the comment to `UserExpression::Evaluate` for details.
   ClangExpressionDeclMap(
       bool keep_result_in_memory,
       Materializer::PersistentVariableDelegate *result_delegate,
-      const lldb::TargetSP &target, const lldb::ClangASTImporterSP &importer,
-      ValueObject *ctx_obj);
+      const lldb::TargetSP &target,
+      const std::shared_ptr<ClangASTImporter> &importer, ValueObject *ctx_obj);
 
   /// Destructor
   ~ClangExpressionDeclMap() override;
 
   /// Enable the state needed for parsing and IR transformation.
   ///
   /// \param[in] exe_ctx
   ///     The execution context to use when finding types for variables.

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

 
 namespace {
 const char *g_lldb_local_vars_namespace_cstr = "$__lldb_local_vars";
 } // anonymous namespace
 
 ClangExpressionDeclMap::ClangExpressionDeclMap(
     bool keep_result_in_memory,
     Materializer::PersistentVariableDelegate *result_delegate,
-    const lldb::TargetSP &target, const lldb::ClangASTImporterSP &importer,
-    ValueObject *ctx_obj)
+    const lldb::TargetSP &target,
+    const std::shared_ptr<ClangASTImporter> &importer, ValueObject *ctx_obj)
     : ClangASTSource(target, importer), m_found_entities(), m_struct_members(),
       m_keep_result_in_memory(keep_result_in_memory),
       m_result_delegate(result_delegate), m_ctx_obj(ctx_obj), m_parser_vars(),
       m_struct_vars() {
   EnableStructVars();
 }
 
 ClangExpressionDeclMap::~ClangExpressionDeclMap() {

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

 #include "lldb/lldb-private.h"
 
 namespace clang {
 class ASTConsumer;
 }
 
 namespace lldb_private {
 
+class ClangExpressionDeclMap;
 class RecordingMemoryManager;
 
 // ClangExpressionHelper
 class ClangExpressionHelper : public ExpressionTypeSystemHelper {
 public:
   static bool classof(const ExpressionTypeSystemHelper *ts) {
     return ts->getKind() == eKindClangHelper;
   }

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

 class CodeGenerator;
 class CodeCompleteConsumer;
 class CompilerInstance;
 } // namespace clang
 
 namespace lldb_private {
 
 class IRExecutionUnit;
+class TypeSystemClang;
 
 /// \class ClangExpressionParser ClangExpressionParser.h
 /// "lldb/Expression/ClangExpressionParser.h" Encapsulates an instance of
 /// Clang that can parse expressions.
 ///
 /// ClangExpressionParser is responsible for preparing an instance of
 /// ClangExpression for execution.  ClangExpressionParser uses ClangExpression
 /// as a glorified parameter list, performing the required parsing and

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

 
 #include "ClangExpressionVariable.h"
 #include "ClangModulesDeclVendor.h"
 
 #include "lldb/Expression/ExpressionVariable.h"
 
 namespace lldb_private {
 
+class ClangASTImporter;
+class TypeSystemClang;
+
 /// \class ClangPersistentVariables ClangPersistentVariables.h
 /// "lldb/Expression/ClangPersistentVariables.h" Manages persistent values
 /// that need to be preserved between expression invocations.
 ///
 /// A list of variables that can be accessed and updated by any expression.  See
 /// ClangPersistentVariable for more discussion.  Also provides an increasing,
 /// 0-based counter for naming result variables.
 class ClangPersistentVariables : public PersistentExpressionState {
 public:
   ClangPersistentVariables();
 
   ~ClangPersistentVariables() override = default;
 
   // llvm casting support
   static bool classof(const PersistentExpressionState *pv) {
     return pv->getKind() == PersistentExpressionState::eKindClang;
   }
 
-  lldb::ClangASTImporterSP GetClangASTImporter();
+  std::shared_ptr<ClangASTImporter> GetClangASTImporter();
 
   lldb::ExpressionVariableSP
   CreatePersistentVariable(const lldb::ValueObjectSP &valobj_sp) override;
 
   lldb::ExpressionVariableSP CreatePersistentVariable(
       ExecutionContextScope *exe_scope, ConstString name,
       const CompilerType &compiler_type, lldb::ByteOrder byte_order,
       uint32_t addr_byte_size) override;
private:
   typedef llvm::DenseMap<const char *, PersistentDecl> PersistentDeclMap;
   PersistentDeclMap
       m_persistent_decls; ///< Persistent entities declared by the user.
 
   ClangModulesDeclVendor::ModuleVector
       m_hand_loaded_clang_modules; ///< These are Clang modules we hand-loaded;
                                    ///these are the highest-
                                    ///< priority source for macros.
-  lldb::ClangASTImporterSP m_ast_importer_sp;
+  std::shared_ptr<ClangASTImporter> m_ast_importer_sp;
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_ClangPersistentVariables_h_

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

void ClangPersistentVariables::RegisterPersistentDecl(ConstString name,
   }
 }
 
 clang::NamedDecl *
 ClangPersistentVariables::GetPersistentDecl(ConstString name) {
   return m_persistent_decls.lookup(name.GetCString()).m_decl;
 }
 
-lldb::ClangASTImporterSP ClangPersistentVariables::GetClangASTImporter() {
+std::shared_ptr<ClangASTImporter>
+ClangPersistentVariables::GetClangASTImporter() {
   if (!m_ast_importer_sp) {
     m_ast_importer_sp = std::make_shared<ClangASTImporter>();
   }
   return m_ast_importer_sp;
 }

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

lldb::ExpressionVariableSP ClangUserExpression::GetResultAfterDematerialization(
   return m_result_delegate.GetVariable();
 }
 
 void ClangUserExpression::ClangUserExpressionHelper::ResetDeclMap(
     ExecutionContext &exe_ctx,
     Materializer::PersistentVariableDelegate &delegate,
     bool keep_result_in_memory,
     ValueObject *ctx_obj) {
-  lldb::ClangASTImporterSP ast_importer;
+  std::shared_ptr<ClangASTImporter> ast_importer;
   auto *state = exe_ctx.GetTargetSP()->GetPersistentExpressionStateForLanguage(
       lldb::eLanguageTypeC);
   if (state) {
     auto *persistent_vars = llvm::cast<ClangPersistentVariables>(state);
     ast_importer = persistent_vars->GetClangASTImporter();
   }
   m_expr_decl_map_up.reset(
       new ClangExpressionDeclMap(keep_result_in_memory, &delegate,

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

if (error_cstr && error_cstr[0]) {
                                    "expression can't be interpreted or run");
     }
     return false;
   }
 }
 
 void ClangUtilityFunction::ClangUtilityFunctionHelper::ResetDeclMap(
     ExecutionContext &exe_ctx, bool keep_result_in_memory) {
-  lldb::ClangASTImporterSP ast_importer;
+  std::shared_ptr<ClangASTImporter> ast_importer;
   auto *state = exe_ctx.GetTargetSP()->GetPersistentExpressionStateForLanguage(
       lldb::eLanguageTypeC);
   if (state) {
     auto *persistent_vars = llvm::cast<ClangPersistentVariables>(state);
     ast_importer = persistent_vars->GetClangASTImporter();
   }
   m_expr_decl_map_up.reset(
       new ClangExpressionDeclMap(keep_result_in_memory, nullptr,
                                  exe_ctx.GetTargetSP(), ast_importer, nullptr));
 }

lldb/source/Plugins/Language/CPlusPlus/BlockPointer.cpp

BlockPointerSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp)
 
     TypeSystemClang *clang_ast_context =
         llvm::dyn_cast<TypeSystemClang>(&type_system_or_err.get());
 
     if (!clang_ast_context) {
       return;
     }
 
-    lldb::ClangASTImporterSP clang_ast_importer;
+    std::shared_ptr<ClangASTImporter> clang_ast_importer;
     auto *state = target_sp->GetPersistentExpressionStateForLanguage(
         lldb::eLanguageTypeC_plus_plus);
     if (state) {
       auto *persistent_vars = llvm::cast<ClangPersistentVariables>(state);
       clang_ast_importer = persistent_vars->GetClangASTImporter();
     }
 
     if (!clang_ast_importer) {

lldb/source/Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h

 #include "lldb/Symbol/Type.h"
 #include "lldb/Target/LanguageRuntime.h"
 #include "lldb/lldb-private.h"
 
 class CommandObjectObjC_ClassTable_Dump;
 
 namespace lldb_private {
 
+class TypeSystemClang;
 class UtilityFunction;
 
 class ObjCLanguageRuntime : public LanguageRuntime {
 public:
   enum class ObjCRuntimeVersions {
     eObjC_VersionUnknown = 0,
     eAppleObjC_V1 = 1,
     eAppleObjC_V2 = 2

lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.h

 #include "lldb/Utility/Logging.h"
 #include "lldb/lldb-enumerations.h"
 
 class DWARFASTParserClang;
 class PDBASTParser;
 
 namespace lldb_private {
 
+class ClangASTMetadata;
+class ClangASTSource;
 class Declaration;
 
 class TypeSystemClang : public TypeSystem {
   // LLVM RTTI support
   static char ID;
 
 public:
   typedef void (*CompleteTagDeclCallback)(void *baton, clang::TagDecl *);

lldb/unittests/Expression/ClangExpressionDeclMapTest.cpp

 #include "lldb/lldb-defines.h"
 #include "gtest/gtest.h"
 
 using namespace lldb_private;
 using namespace lldb;
 
 namespace {
 struct FakeClangExpressionDeclMap : public ClangExpressionDeclMap {
-  FakeClangExpressionDeclMap(const ClangASTImporterSP &importer)
+  FakeClangExpressionDeclMap(const std::shared_ptr<ClangASTImporter> &importer)
       : ClangExpressionDeclMap(false, nullptr, lldb::TargetSP(), importer,
                                nullptr) {
     m_scratch_context = clang_utils::createAST();
   }
   std::unique_ptr<TypeSystemClang> m_scratch_context;
   /// Adds a persistent decl that can be found by the ClangExpressionDeclMap
   /// via GetPersistentDecl.
   void AddPersistentDeclForTest(clang::NamedDecl *d) {

 };
 } // namespace
 
 namespace {
 struct ClangExpressionDeclMapTest : public testing::Test {
   SubsystemRAII<FileSystem, HostInfo> subsystems;
 
   /// The ClangASTImporter used during the test.
-  ClangASTImporterSP importer;
+  std::shared_ptr<ClangASTImporter> importer;
   /// The ExpressionDeclMap for the current test case.
   std::unique_ptr<FakeClangExpressionDeclMap> decl_map;
 
   /// The target AST that lookup results should be imported to.
   std::unique_ptr<TypeSystemClang> target_ast;
 
   void SetUp() override {
     importer = std::make_shared<ClangASTImporter>();