LLDB  mainline
Language.h
Go to the documentation of this file.
1 //===-- Language.h ---------------------------------------------------*- C++
2 //-*-===//
3 //
4 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
5 // See https://llvm.org/LICENSE.txt for license information.
6 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #ifndef LLDB_TARGET_LANGUAGE_H
11 #define LLDB_TARGET_LANGUAGE_H
12 
13 #include <functional>
14 #include <memory>
15 #include <set>
16 #include <vector>
17 
18 #include "lldb/Core/Highlighter.h"
23 #include "lldb/Symbol/TypeSystem.h"
24 #include "lldb/lldb-private.h"
25 #include "lldb/lldb-public.h"
26 
27 namespace lldb_private {
28 
29 class Language : public PluginInterface {
30 public:
31  class TypeScavenger {
32  public:
33  class Result {
34  public:
35  virtual bool IsValid() = 0;
36 
37  virtual bool DumpToStream(Stream &stream,
38  bool print_help_if_available) = 0;
39 
40  virtual ~Result() = default;
41  };
42 
43  typedef std::set<std::unique_ptr<Result>> ResultSet;
44 
45  virtual ~TypeScavenger() = default;
46 
47  size_t Find(ExecutionContextScope *exe_scope, const char *key,
48  ResultSet &results, bool append = true);
49 
50  protected:
51  TypeScavenger() = default;
52 
53  virtual bool Find_Impl(ExecutionContextScope *exe_scope, const char *key,
54  ResultSet &results) = 0;
55  };
56 
59  public:
61 
62  bool IsValid() override { return m_compiler_type.IsValid(); }
63 
64  bool DumpToStream(Stream &stream, bool print_help_if_available) override {
65  if (IsValid()) {
67  stream.EOL();
68  return true;
69  }
70  return false;
71  }
72 
73  ~Result() override = default;
74 
75  private:
77  };
78 
79  protected:
80  ImageListTypeScavenger() = default;
81 
82  ~ImageListTypeScavenger() override = default;
83 
84  // is this type something we should accept? it's usually going to be a
85  // filter by language + maybe some sugar tweaking
86  // returning an empty type means rejecting this candidate entirely;
87  // any other result will be accepted as a valid match
88  virtual CompilerType AdjustForInclusion(CompilerType &candidate) = 0;
89 
90  bool Find_Impl(ExecutionContextScope *exe_scope, const char *key,
91  ResultSet &results) override;
92  };
93 
94  template <typename... ScavengerTypes>
96  public:
98  for (std::shared_ptr<TypeScavenger> scavenger : { std::shared_ptr<TypeScavenger>(new ScavengerTypes())... }) {
99  if (scavenger)
100  m_scavengers.push_back(scavenger);
101  }
102  }
103  protected:
104  bool Find_Impl(ExecutionContextScope *exe_scope, const char *key,
105  ResultSet &results) override {
106  const bool append = false;
107  for (auto& scavenger : m_scavengers) {
108  if (scavenger && scavenger->Find(exe_scope, key, results, append))
109  return true;
110  }
111  return false;
112  }
113  private:
114  std::vector<std::shared_ptr<TypeScavenger>> m_scavengers;
115  };
116 
117  template <typename... ScavengerTypes>
119  public:
121  for (std::shared_ptr<TypeScavenger> scavenger : { std::shared_ptr<TypeScavenger>(new ScavengerTypes())... }) {
122  if (scavenger)
123  m_scavengers.push_back(scavenger);
124  }
125  }
126  protected:
127  bool Find_Impl(ExecutionContextScope *exe_scope, const char *key,
128  ResultSet &results) override {
129  const bool append = true;
130  bool success = false;
131  for (auto& scavenger : m_scavengers) {
132  if (scavenger)
133  success = scavenger->Find(exe_scope, key, results, append) || success;
134  }
135  return success;
136  }
137  private:
138  std::vector<std::shared_ptr<TypeScavenger>> m_scavengers;
139  };
140 
142  eName,
145  };
146 
147  ~Language() override;
148 
149  static Language *FindPlugin(lldb::LanguageType language);
150 
151  /// Returns the Language associated with the given file path or a nullptr
152  /// if there is no known language.
153  static Language *FindPlugin(llvm::StringRef file_path);
154 
155  static Language *FindPlugin(lldb::LanguageType language,
156  llvm::StringRef file_path);
157 
158  // return false from callback to stop iterating
159  static void ForEach(std::function<bool(Language *)> callback);
160 
161  virtual lldb::LanguageType GetLanguageType() const = 0;
162 
163  virtual bool IsTopLevelFunction(Function &function);
164 
165  virtual bool IsSourceFile(llvm::StringRef file_path) const = 0;
166 
167  virtual const Highlighter *GetHighlighter() const { return nullptr; }
168 
169  virtual lldb::TypeCategoryImplSP GetFormatters();
170 
172 
174 
177 
178  virtual std::vector<ConstString>
180  lldb::DynamicValueType use_dynamic);
181 
182  virtual std::unique_ptr<TypeScavenger> GetTypeScavenger();
183 
184  virtual const char *GetLanguageSpecificTypeLookupHelp();
185 
188  lldb::FunctionNameType m_type;
189 
190  public:
191  MethodNameVariant(ConstString name, lldb::FunctionNameType type)
192  : m_name(name), m_type(type) {}
193  ConstString GetName() const { return m_name; }
194  lldb::FunctionNameType GetType() const { return m_type; }
195  };
196  // If a language can have more than one possible name for a method, this
197  // function can be used to enumerate them. This is useful when doing name
198  // lookups.
199  virtual std::vector<Language::MethodNameVariant>
200  GetMethodNameVariants(ConstString method_name) const {
201  return std::vector<Language::MethodNameVariant>();
202  };
203 
204  /// Returns true iff the given symbol name is compatible with the mangling
205  /// scheme of this language.
206  ///
207  /// This function should only return true if there is a high confidence
208  /// that the name actually belongs to this language.
209  virtual bool SymbolNameFitsToLanguage(Mangled name) const { return false; }
210 
211  // if an individual data formatter can apply to several types and cross a
212  // language boundary it makes sense for individual languages to want to
213  // customize the printing of values of that type by appending proper
214  // prefix/suffix information in language-specific ways
215  virtual bool GetFormatterPrefixSuffix(ValueObject &valobj,
216  ConstString type_hint,
217  std::string &prefix,
218  std::string &suffix);
219 
220  // When looking up functions, we take a user provided string which may be a
221  // partial match to the full demangled name and compare it to the actual
222  // demangled name to see if it matches as much as the user specified. An
223  // example of this is if the user provided A::my_function, but the
224  // symbol was really B::A::my_function. We want that to be
225  // a match. But we wouldn't want this to match AnotherA::my_function. The
226  // user is specifying a truncated path, not a truncated set of characters.
227  // This function does a language-aware comparison for those purposes.
228  virtual bool DemangledNameContainsPath(llvm::StringRef path,
229  ConstString demangled) const;
230 
231  // if a language has a custom format for printing variable declarations that
232  // it wants LLDB to honor it should return an appropriate closure here
234 
235  virtual LazyBool IsLogicalTrue(ValueObject &valobj, Status &error);
236 
237  // for a ValueObject of some "reference type", if the value points to the
238  // nil/null object, this method returns true
239  virtual bool IsNilReference(ValueObject &valobj);
240 
241  /// Returns the summary string for ValueObjects for which IsNilReference() is
242  /// true.
243  virtual llvm::StringRef GetNilReferenceSummaryString() { return {}; }
244 
245  // for a ValueObject of some "reference type", if the language provides a
246  // technique to decide whether the reference has ever been assigned to some
247  // object, this method will return true if such detection is possible, and if
248  // the reference has never been assigned
249  virtual bool IsUninitializedReference(ValueObject &valobj);
250 
251  virtual bool GetFunctionDisplayName(const SymbolContext *sc,
252  const ExecutionContext *exe_ctx,
253  FunctionNameRepresentation representation,
254  Stream &s);
255 
256  virtual ConstString
258  if (ConstString demangled = mangled.GetDemangledName())
259  return demangled;
260 
261  return mangled.GetMangledName();
262  }
263 
264  virtual void GetExceptionResolverDescription(bool catch_on, bool throw_on,
265  Stream &s);
266 
267  static void GetDefaultExceptionResolverDescription(bool catch_on,
268  bool throw_on, Stream &s);
269 
270  // These are accessors for general information about the Languages lldb knows
271  // about:
272 
273  static lldb::LanguageType
274  GetLanguageTypeFromString(const char *string) = delete;
275  static lldb::LanguageType GetLanguageTypeFromString(llvm::StringRef string);
276 
277  static const char *GetNameForLanguageType(lldb::LanguageType language);
278 
279  static void PrintAllLanguages(Stream &s, const char *prefix,
280  const char *suffix);
281 
282  // return false from callback to stop iterating
283  static void ForAllLanguages(std::function<bool(lldb::LanguageType)> callback);
284 
285  static bool LanguageIsCPlusPlus(lldb::LanguageType language);
286 
287  static bool LanguageIsObjC(lldb::LanguageType language);
288 
289  static bool LanguageIsC(lldb::LanguageType language);
290 
291  /// Equivalent to \c LanguageIsC||LanguageIsObjC||LanguageIsCPlusPlus.
292  static bool LanguageIsCFamily(lldb::LanguageType language);
293 
294  static bool LanguageIsPascal(lldb::LanguageType language);
295 
296  // return the primary language, so if LanguageIsC(l), return eLanguageTypeC,
297  // etc.
299 
300  static std::set<lldb::LanguageType> GetSupportedLanguages();
301 
305 
306  // Given a mangled function name, calculates some alternative manglings since
307  // the compiler mangling may not line up with the symbol we are expecting.
308  virtual std::vector<ConstString>
310  return std::vector<ConstString>();
311  }
312 
313  virtual ConstString
315  const SymbolContext &sym_ctx) const {
316  return ConstString();
317  }
318 
319 protected:
320  // Classes that inherit from Language can see and modify these
321 
322  Language();
323 
324 private:
325  Language(const Language &) = delete;
326  const Language &operator=(const Language &) = delete;
327 };
328 
329 } // namespace lldb_private
330 
331 #endif // LLDB_TARGET_LANGUAGE_H
lldb_private::Language::ImageListTypeScavenger::AdjustForInclusion
virtual CompilerType AdjustForInclusion(CompilerType &candidate)=0
lldb_private::Language::FunctionNameRepresentation::eNameWithNoArgs
@ eNameWithNoArgs
lldb_private::ExecutionContext
Definition: ExecutionContext.h:292
lldb-public.h
lldb_private::Language::Language
Language()
lldb_private::Language::GetDemangledFunctionNameWithoutArguments
virtual ConstString GetDemangledFunctionNameWithoutArguments(Mangled mangled) const
Definition: Language.h:257
lldb_private::Language::DemangledNameContainsPath
virtual bool DemangledNameContainsPath(llvm::StringRef path, ConstString demangled) const
Definition: Language.cpp:431
lldb_private::Language::ImageListTypeScavenger::Result::IsValid
bool IsValid() override
Definition: Language.h:62
lldb_private::DumpValueObjectOptions::DeclPrintingHelper
std::function< bool(ConstString, ConstString, const DumpValueObjectOptions &, Stream &)> DeclPrintingHelper
Definition: DumpValueObjectOptions.h:54
lldb_private::Language::ImageListTypeScavenger::Result::DumpToStream
bool DumpToStream(Stream &stream, bool print_help_if_available) override
Definition: Language.h:64
lldb_private::Language::MethodNameVariant::m_name
ConstString m_name
Definition: Language.h:187
FormatClasses.h
lldb_private::HardcodedFormatters::HardcodedFormatFinder
HardcodedFormatterFinders< TypeFormatImpl > HardcodedFormatFinder
Definition: FormatClasses.h:39
lldb_private::Language::TypeScavenger::Find
size_t Find(ExecutionContextScope *exe_scope, const char *key, ResultSet &results, bool append=true)
Definition: Language.cpp:376
lldb_private::PluginInterface
Definition: PluginInterface.h:16
lldb_private::Language::TypeScavenger::Result
Definition: Language.h:33
lldb_private::Language::ImageListTypeScavenger::Find_Impl
bool Find_Impl(ExecutionContextScope *exe_scope, const char *key, ResultSet &results) override
Definition: Language.cpp:395
lldb_private::Language::GetFunctionDisplayName
virtual bool GetFunctionDisplayName(const SymbolContext *sc, const ExecutionContext *exe_ctx, FunctionNameRepresentation representation, Stream &s)
Definition: Language.cpp:451
lldb_private::Language::GetExceptionResolverDescription
virtual void GetExceptionResolverDescription(bool catch_on, bool throw_on, Stream &s)
Definition: Language.cpp:458
lldb::LanguageType
LanguageType
Programming language type.
Definition: lldb-enumerations.h:436
lldb_private::Language::TypeScavenger::ResultSet
std::set< std::unique_ptr< Result > > ResultSet
Definition: Language.h:43
lldb_private::Language::UnionTypeScavenger::m_scavengers
std::vector< std::shared_ptr< TypeScavenger > > m_scavengers
Definition: Language.h:138
lldb_private::Language::ImageListTypeScavenger::Result
Definition: Language.h:58
lldb_private::Language::TypeScavenger::Result::DumpToStream
virtual bool DumpToStream(Stream &stream, bool print_help_if_available)=0
lldb_private::Stream
Definition: Stream.h:28
lldb_private::LazyBool
LazyBool
Definition: lldb-private-enumerations.h:115
lldb_private::SymbolContext
Definition: SymbolContext.h:33
lldb_private::Language::GetMethodNameVariants
virtual std::vector< Language::MethodNameVariant > GetMethodNameVariants(ConstString method_name) const
Definition: Language.h:200
lldb_private::Language::GetHardcodedFormats
virtual HardcodedFormatters::HardcodedFormatFinder GetHardcodedFormats()
Definition: Language.cpp:134
lldb_private::Language::LanguageIsCPlusPlus
static bool LanguageIsCPlusPlus(lldb::LanguageType language)
Definition: Language.cpp:239
lldb_private::Language::LanguageIsCFamily
static bool LanguageIsCFamily(lldb::LanguageType language)
Equivalent to LanguageIsC||LanguageIsObjC||LanguageIsCPlusPlus.
Definition: Language.cpp:274
lldb_private::Language::ImageListTypeScavenger::~ImageListTypeScavenger
~ImageListTypeScavenger() override=default
lldb_private::Highlighter
Annotates source code with color attributes.
Definition: Highlighter.h:90
lldb_private::Language::TypeScavenger::Result::IsValid
virtual bool IsValid()=0
lldb_private::Language::IsTopLevelFunction
virtual bool IsTopLevelFunction(Function &function)
Definition: Language.cpp:130
lldb_private::HardcodedFormatters::HardcodedSummaryFinder
HardcodedFormatterFinders< TypeSummaryImpl > HardcodedSummaryFinder
Definition: FormatClasses.h:40
lldb_private::Language::MethodNameVariant::GetType
lldb::FunctionNameType GetType() const
Definition: Language.h:194
lldb_private::Language::IsSourceFile
virtual bool IsSourceFile(llvm::StringRef file_path) const =0
lldb_private::Language::GetLanguageSpecificTypeLookupHelp
virtual const char * GetLanguageSpecificTypeLookupHelp()
Definition: Language.cpp:374
lldb_private::Language::PrintAllLanguages
static void PrintAllLanguages(Stream &s, const char *prefix, const char *suffix)
Definition: Language.cpp:224
error
static llvm::raw_ostream & error(Stream &strm)
Definition: CommandReturnObject.cpp:17
lldb_private::Language::IsUninitializedReference
virtual bool IsUninitializedReference(ValueObject &valobj)
Definition: Language.cpp:449
lldb_private::Function
Definition: Function.h:409
lldb_private::Language::EitherTypeScavenger
Definition: Language.h:95
lldb_private::Language::GetLanguagesSupportingTypeSystems
static LanguageSet GetLanguagesSupportingTypeSystems()
Definition: Language.cpp:358
lldb_private::Language::LanguageIsPascal
static bool LanguageIsPascal(lldb::LanguageType language)
Definition: Language.cpp:292
lldb_private::ExecutionContextScope
Definition: ExecutionContextScope.h:32
lldb_private::Language::LanguageIsC
static bool LanguageIsC(lldb::LanguageType language)
Definition: Language.cpp:262
lldb_private::Language::TypeScavenger
Definition: Language.h:31
lldb_private::Language::EitherTypeScavenger::EitherTypeScavenger
EitherTypeScavenger()
Definition: Language.h:97
lldb_private::Language::FunctionNameRepresentation
FunctionNameRepresentation
Definition: Language.h:141
lldb_private::Language::ImageListTypeScavenger::Result::Result
Result(CompilerType type)
Definition: Language.h:60
lldb_private::Language::ImageListTypeScavenger::Result::m_compiler_type
CompilerType m_compiler_type
Definition: Language.h:76
lldb_private::ConstString
Definition: ConstString.h:39
lldb_private::Language::LanguageIsObjC
static bool LanguageIsObjC(lldb::LanguageType language)
Definition: Language.cpp:252
lldb_private::Language::FunctionNameRepresentation::eName
@ eName
lldb_private::Language::IsNilReference
virtual bool IsNilReference(ValueObject &valobj)
Definition: Language.cpp:447
PluginInterface.h
lldb_private::Language::GetTypeScavenger
virtual std::unique_ptr< TypeScavenger > GetTypeScavenger()
Definition: Language.cpp:370
lldb_private::Language::SymbolNameFitsToLanguage
virtual bool SymbolNameFitsToLanguage(Mangled name) const
Returns true iff the given symbol name is compatible with the mangling scheme of this language.
Definition: Language.h:209
lldb_private::Language::UnionTypeScavenger::UnionTypeScavenger
UnionTypeScavenger()
Definition: Language.h:120
Highlighter.h
lldb_private::Language::MethodNameVariant::m_type
lldb::FunctionNameType m_type
Definition: Language.h:188
lldb::DynamicValueType
DynamicValueType
Definition: lldb-enumerations.h:494
lldb_private::Language::GetHardcodedSynthetics
virtual HardcodedFormatters::HardcodedSyntheticFinder GetHardcodedSynthetics()
Definition: Language.cpp:143
lldb_private::Language::TypeScavenger::~TypeScavenger
virtual ~TypeScavenger()=default
string
string(SUBSTRING ${p} 10 -1 pStripped) if($
Definition: Plugins/CMakeLists.txt:40
lldb_private::Language::ForAllLanguages
static void ForAllLanguages(std::function< bool(lldb::LanguageType)> callback)
Definition: Language.cpp:231
TypeSystem.h
lldb_private::Language::~Language
~Language() override
lldb_private::CompilerType::IsValid
bool IsValid() const
Definition: CompilerType.h:72
lldb_private::Language::FindPlugin
static Language * FindPlugin(lldb::LanguageType language)
Definition: Language.cpp:53
lldb_private::Language::GenerateAlternateFunctionManglings
virtual std::vector< ConstString > GenerateAlternateFunctionManglings(const ConstString mangled) const
Definition: Language.h:309
lldb-private.h
lldb_private::Language::GetLanguageType
virtual lldb::LanguageType GetLanguageType() const =0
lldb_private::Language::GetLanguagesSupportingREPLs
static LanguageSet GetLanguagesSupportingREPLs()
Definition: Language.cpp:366
lldb_private::Language::TypeScavenger::Find_Impl
virtual bool Find_Impl(ExecutionContextScope *exe_scope, const char *key, ResultSet &results)=0
lldb_private::Language::GetLanguageTypeFromString
static lldb::LanguageType GetLanguageTypeFromString(const char *string)=delete
lldb_private::Language::GetDefaultExceptionResolverDescription
static void GetDefaultExceptionResolverDescription(bool catch_on, bool throw_on, Stream &s)
Definition: Language.cpp:463
lldb_private::Language::GetFormatterPrefixSuffix
virtual bool GetFormatterPrefixSuffix(ValueObject &valobj, ConstString type_hint, std::string &prefix, std::string &suffix)
Definition: Language.cpp:424
lldb_private::Status
Definition: Status.h:44
lldb_private::ValueObject
ValueObject:
Definition: ValueObject.h:105
lldb_private::Language::FindBestAlternateFunctionMangledName
virtual ConstString FindBestAlternateFunctionMangledName(const Mangled mangled, const SymbolContext &sym_ctx) const
Definition: Language.h:314
lldb_private::Language::GetLanguagesSupportingTypeSystemsForExpressions
static LanguageSet GetLanguagesSupportingTypeSystemsForExpressions()
Definition: Language.cpp:362
lldb_private::Language::MethodNameVariant::GetName
ConstString GetName() const
Definition: Language.h:193
lldb_private::Language::GetDeclPrintingHelper
virtual DumpValueObjectOptions::DeclPrintingHelper GetDeclPrintingHelper()
Definition: Language.cpp:439
lldb_private::Language
Definition: Language.h:29
DumpValueObjectOptions.h
lldb_private::Stream::EOL
size_t EOL()
Output and End of Line character to the stream.
Definition: Stream.cpp:128
lldb_private::Language::GetFormatters
virtual lldb::TypeCategoryImplSP GetFormatters()
Definition: Language.cpp:132
lldb_private::Language::IsLogicalTrue
virtual LazyBool IsLogicalTrue(ValueObject &valobj, Status &error)
Definition: Language.cpp:443
lldb_private::Language::GetNilReferenceSummaryString
virtual llvm::StringRef GetNilReferenceSummaryString()
Returns the summary string for ValueObjects for which IsNilReference() is true.
Definition: Language.h:243
lldb_private::Language::FunctionNameRepresentation::eNameWithArgs
@ eNameWithArgs
lldb_private::Language::GetPossibleFormattersMatches
virtual std::vector< ConstString > GetPossibleFormattersMatches(ValueObject &valobj, lldb::DynamicValueType use_dynamic)
Definition: Language.cpp:148
lldb_private::CompilerType
Generic representation of a type in a programming language.
Definition: CompilerType.h:33
lldb_private::Language::ImageListTypeScavenger::ImageListTypeScavenger
ImageListTypeScavenger()=default
lldb_private::Language::GetSupportedLanguages
static std::set< lldb::LanguageType > GetSupportedLanguages()
Definition: Language.cpp:349
lldb_private::Language::TypeScavenger::Result::~Result
virtual ~Result()=default
lldb_private
A class that represents a running process on the host machine.
Definition: SBCommandInterpreterRunOptions.h:16
lldb_private::Language::GetHighlighter
virtual const Highlighter * GetHighlighter() const
Definition: Language.h:167
lldb_private::Language::UnionTypeScavenger::Find_Impl
bool Find_Impl(ExecutionContextScope *exe_scope, const char *key, ResultSet &results) override
Definition: Language.h:127
lldb_private::Language::ImageListTypeScavenger
Definition: Language.h:57
lldb_private::Language::MethodNameVariant
Definition: Language.h:186
lldb_private::Language::EitherTypeScavenger::Find_Impl
bool Find_Impl(ExecutionContextScope *exe_scope, const char *key, ResultSet &results) override
Definition: Language.h:104
StringPrinter.h
lldb_private::LanguageSet
A SmallBitVector that represents a set of source languages (lldb::LanguageType).
Definition: TypeSystem.h:43
lldb_private::Language::ForEach
static void ForEach(std::function< bool(Language *)> callback)
Definition: Language.cpp:100
lldb_private::Language::GetNameForLanguageType
static const char * GetNameForLanguageType(lldb::LanguageType language)
Definition: Language.cpp:217
lldb_private::Language::UnionTypeScavenger
Definition: Language.h:118
lldb_private::CompilerType::DumpTypeDescription
void DumpTypeDescription(lldb::DescriptionLevel level=lldb::eDescriptionLevelFull) const
Dump to stdout.
Definition: CompilerType.cpp:761
lldb_private::Language::TypeScavenger::TypeScavenger
TypeScavenger()=default
lldb_private::Language::MethodNameVariant::MethodNameVariant
MethodNameVariant(ConstString name, lldb::FunctionNameType type)
Definition: Language.h:191
lldb_private::Language::ImageListTypeScavenger::Result::~Result
~Result() override=default
lldb_private::Language::EitherTypeScavenger::m_scavengers
std::vector< std::shared_ptr< TypeScavenger > > m_scavengers
Definition: Language.h:114
lldb_private::Language::operator=
const Language & operator=(const Language &)=delete
lldb_private::Language::GetHardcodedSummaries
virtual HardcodedFormatters::HardcodedSummaryFinder GetHardcodedSummaries()
Definition: Language.cpp:138
lldb_private::HardcodedFormatters::HardcodedSyntheticFinder
HardcodedFormatterFinders< SyntheticChildren > HardcodedSyntheticFinder
Definition: FormatClasses.h:41
lldb_private::Language::GetPrimaryLanguage
static lldb::LanguageType GetPrimaryLanguage(lldb::LanguageType language)
Definition: Language.cpp:301