1271521ed8
Summary: This introduces a layer between DeclVendor and the currently implemented DeclVendors (ClangModulesDeclVendor and AppleObjCDeclVendor). This allows the removal of DeclVendor::GetImporterSource which is extremely clang-specific, freeing up the interface to be more general. A good follow up to this would be to remove the remaining instances of clang in DeclVendor, either by moving things to ClangDeclVendor or by using wrappers (e.g. CompilerDecl instead of clang::NamedDecl). Differential Revision: https://reviews.llvm.org/D66451 llvm-svn: 369424
117 lines
4.2 KiB
C++
117 lines
4.2 KiB
C++
//===-- ClangModulesDeclVendor.h --------------------------------*- 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 liblldb_ClangModulesDeclVendor_h
|
|
#define liblldb_ClangModulesDeclVendor_h
|
|
|
|
#include "lldb/Core/ClangForward.h"
|
|
#include "lldb/Symbol/SourceModule.h"
|
|
#include "lldb/Target/Platform.h"
|
|
|
|
#include "Plugins/ExpressionParser/Clang/ClangDeclVendor.h"
|
|
|
|
#include <set>
|
|
#include <vector>
|
|
|
|
namespace lldb_private {
|
|
|
|
class ClangModulesDeclVendor : public ClangDeclVendor {
|
|
public:
|
|
// Constructors and Destructors
|
|
ClangModulesDeclVendor();
|
|
|
|
~ClangModulesDeclVendor() override;
|
|
|
|
static bool classof(const DeclVendor *vendor) {
|
|
return vendor->GetKind() == eClangModuleDeclVendor;
|
|
}
|
|
|
|
static ClangModulesDeclVendor *Create(Target &target);
|
|
|
|
typedef std::vector<ConstString> ModulePath;
|
|
typedef uintptr_t ModuleID;
|
|
typedef std::vector<ModuleID> ModuleVector;
|
|
|
|
/// Add a module to the list of modules to search.
|
|
///
|
|
/// \param[in] module
|
|
/// The path to the exact module to be loaded. E.g., if the desired
|
|
/// module is std.io, then this should be { "std", "io" }.
|
|
///
|
|
/// \param[in] exported_modules
|
|
/// If non-NULL, a pointer to a vector to populate with the ID of every
|
|
/// module that is re-exported by the specified module.
|
|
///
|
|
/// \param[in] error_stream
|
|
/// A stream to populate with the output of the Clang parser when
|
|
/// it tries to load the module.
|
|
///
|
|
/// \return
|
|
/// True if the module could be loaded; false if not. If the
|
|
/// compiler encountered a fatal error during a previous module
|
|
/// load, then this will always return false for this ModuleImporter.
|
|
virtual bool AddModule(const SourceModule &module,
|
|
ModuleVector *exported_modules,
|
|
Stream &error_stream) = 0;
|
|
|
|
/// Add all modules referred to in a given compilation unit to the list
|
|
/// of modules to search.
|
|
///
|
|
/// \param[in] cu
|
|
/// The compilation unit to scan for imported modules.
|
|
///
|
|
/// \param[in] exported_modules
|
|
/// A vector to populate with the ID of each module loaded (directly
|
|
/// and via re-exports) in this way.
|
|
///
|
|
/// \param[in] error_stream
|
|
/// A stream to populate with the output of the Clang parser when
|
|
/// it tries to load the modules.
|
|
///
|
|
/// \return
|
|
/// True if all modules referred to by the compilation unit could be
|
|
/// loaded; false if one could not be loaded. If the compiler
|
|
/// encountered a fatal error during a previous module
|
|
/// load, then this will always return false for this ModuleImporter.
|
|
virtual bool AddModulesForCompileUnit(CompileUnit &cu,
|
|
ModuleVector &exported_modules,
|
|
Stream &error_stream) = 0;
|
|
|
|
/// Enumerate all the macros that are defined by a given set of modules
|
|
/// that are already imported.
|
|
///
|
|
/// \param[in] modules
|
|
/// The unique IDs for all modules to query. Later modules have higher
|
|
/// priority, just as if you @imported them in that order. This matters
|
|
/// if module A #defines a macro and module B #undefs it.
|
|
///
|
|
/// \param[in] handler
|
|
/// A function to call with the text of each #define (including the
|
|
/// #define directive). #undef directives are not included; we simply
|
|
/// elide any corresponding #define. If this function returns true,
|
|
/// we stop the iteration immediately.
|
|
virtual void
|
|
ForEachMacro(const ModuleVector &modules,
|
|
std::function<bool(const std::string &)> handler) = 0;
|
|
|
|
/// Query whether Clang supports modules for a particular language.
|
|
/// LLDB uses this to decide whether to try to find the modules loaded
|
|
/// by a given compile unit.
|
|
///
|
|
/// \param[in] language
|
|
/// The language to query for.
|
|
///
|
|
/// \return
|
|
/// True if Clang has modules for the given language.
|
|
static bool LanguageSupportsClangModules(lldb::LanguageType language);
|
|
};
|
|
|
|
} // namespace lldb_private
|
|
|
|
#endif // liblldb_ClangModulesDeclVendor_h
|