1 //===-- TypeSystem.h ------------------------------------------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #ifndef LLDB_SYMBOL_TYPESYSTEM_H
10 #define LLDB_SYMBOL_TYPESYSTEM_H
11 
12 #include <functional>
13 #include <mutex>
14 #include <optional>
15 #include <string>
16 
17 #include "llvm/ADT/APFloat.h"
18 #include "llvm/ADT/APSInt.h"
19 #include "llvm/ADT/DenseMap.h"
20 #include "llvm/ADT/SmallBitVector.h"
21 #include "llvm/Support/Casting.h"
22 #include "llvm/Support/Error.h"
23 #include "llvm/Support/JSON.h"
24 
25 #include "lldb/Core/PluginInterface.h"
26 #include "lldb/Expression/Expression.h"
27 #include "lldb/Symbol/CompilerDecl.h"
28 #include "lldb/Symbol/CompilerDeclContext.h"
29 #include "lldb/lldb-private.h"
30 
31 class DWARFDIE;
32 class DWARFASTParser;
33 class PDBASTParser;
34 
35 namespace lldb_private {
36 namespace npdb {
37   class PdbAstBuilder;
38 } // namespace npdb
39 
40 /// A SmallBitVector that represents a set of source languages (\p
41 /// lldb::LanguageType).  Each lldb::LanguageType is represented by
42 /// the bit with the position of its enumerator. The largest
43 /// LanguageType is < 64, so this is space-efficient and on 64-bit
44 /// architectures a LanguageSet can be completely stack-allocated.
45 struct LanguageSet {
46   llvm::SmallBitVector bitvector;
47   LanguageSet();
48 
49   /// If the set contains a single language only, return it.
50   std::optional<lldb::LanguageType> GetSingularLanguage();
51   void Insert(lldb::LanguageType language);
52   bool Empty() const;
53   size_t Size() const;
54   bool operator[](unsigned i) const;
55 };
56 
57 /// Interface for representing a type system.
58 ///
59 /// Implemented by language plugins to define the type system for a given
60 /// language.
61 ///
62 /// This interface extensively used opaque pointers to prevent that generic
63 /// LLDB code has dependencies on language plugins. The type and semantics of
64 /// these opaque pointers are defined by the TypeSystem implementation inside
65 /// the respective language plugin. Opaque pointers from one TypeSystem
66 /// instance should never be passed to a different TypeSystem instance (even
67 /// when the language plugin for both TypeSystem instances is the same).
68 ///
69 /// Most of the functions in this class should not be called directly but only
70 /// called by their respective counterparts in CompilerType, CompilerDecl and
71 /// CompilerDeclContext.
72 ///
73 /// \see lldb_private::CompilerType
74 /// \see lldb_private::CompilerDecl
75 /// \see lldb_private::CompilerDeclContext
76 class TypeSystem : public PluginInterface,
77                    public std::enable_shared_from_this<TypeSystem> {
78 public:
79   // Constructors and Destructors
80   TypeSystem();
81   ~TypeSystem() override;
82 
83   // LLVM RTTI support
84   virtual bool isA(const void *ClassID) const = 0;
85 
86   static lldb::TypeSystemSP CreateInstance(lldb::LanguageType language,
87                                            Module *module);
88 
89   static lldb::TypeSystemSP CreateInstance(lldb::LanguageType language,
90                                            Target *target);
91 
92   /// Free up any resources associated with this TypeSystem.  Done before
93   /// removing all the TypeSystems from the TypeSystemMap.
94   virtual void Finalize() {}
95 
96   virtual DWARFASTParser *GetDWARFParser() { return nullptr; }
97   virtual PDBASTParser *GetPDBParser() { return nullptr; }
98   virtual npdb::PdbAstBuilder *GetNativePDBParser() { return nullptr; }
99 
100   virtual SymbolFile *GetSymbolFile() const { return m_sym_file; }
101 
102   virtual void SetSymbolFile(SymbolFile *sym_file) { m_sym_file = sym_file; }
103 
104   // CompilerDecl functions
105   virtual ConstString DeclGetName(void *opaque_decl) = 0;
106 
107   virtual ConstString DeclGetMangledName(void *opaque_decl);
108 
109   virtual CompilerDeclContext DeclGetDeclContext(void *opaque_decl);
110 
111   virtual CompilerType DeclGetFunctionReturnType(void *opaque_decl);
112 
113   virtual size_t DeclGetFunctionNumArguments(void *opaque_decl);
114 
115   virtual CompilerType DeclGetFunctionArgumentType(void *opaque_decl,
116                                                    size_t arg_idx);
117 
118   virtual CompilerType GetTypeForDecl(void *opaque_decl) = 0;
119 
120   // CompilerDeclContext functions
121 
122   virtual std::vector<CompilerDecl>
123   DeclContextFindDeclByName(void *opaque_decl_ctx, ConstString name,
124                             const bool ignore_imported_decls);
125 
126   virtual ConstString DeclContextGetName(void *opaque_decl_ctx) = 0;
127 
128   virtual ConstString
129   DeclContextGetScopeQualifiedName(void *opaque_decl_ctx) = 0;
130 
131   virtual bool DeclContextIsClassMethod(void *opaque_decl_ctx) = 0;
132 
133   virtual bool DeclContextIsContainedInLookup(void *opaque_decl_ctx,
134                                               void *other_opaque_decl_ctx) = 0;
135 
136   virtual lldb::LanguageType DeclContextGetLanguage(void *opaque_decl_ctx) = 0;
137 
138   // Tests
139 #ifndef NDEBUG
140   /// Verify the integrity of the type to catch CompilerTypes that mix
141   /// and match invalid TypeSystem/Opaque type pairs.
142   virtual bool Verify(lldb::opaque_compiler_type_t type) = 0;
143 #endif
144 
145   virtual bool IsArrayType(lldb::opaque_compiler_type_t type,
146                            CompilerType *element_type, uint64_t *size,
147                            bool *is_incomplete) = 0;
148 
149   virtual bool IsAggregateType(lldb::opaque_compiler_type_t type) = 0;
150 
151   virtual bool IsAnonymousType(lldb::opaque_compiler_type_t type);
152 
153   virtual bool IsCharType(lldb::opaque_compiler_type_t type) = 0;
154 
155   virtual bool IsCompleteType(lldb::opaque_compiler_type_t type) = 0;
156 
157   virtual bool IsDefined(lldb::opaque_compiler_type_t type) = 0;
158 
159   virtual bool IsFloatingPointType(lldb::opaque_compiler_type_t type,
160                                    uint32_t &count, bool &is_complex) = 0;
161 
162   virtual bool IsFunctionType(lldb::opaque_compiler_type_t type) = 0;
163 
164   virtual size_t
165   GetNumberOfFunctionArguments(lldb::opaque_compiler_type_t type) = 0;
166 
167   virtual CompilerType
168   GetFunctionArgumentAtIndex(lldb::opaque_compiler_type_t type,
169                              const size_t index) = 0;
170 
171   virtual bool IsFunctionPointerType(lldb::opaque_compiler_type_t type) = 0;
172 
173   virtual bool
174   IsMemberFunctionPointerType(lldb::opaque_compiler_type_t type) = 0;
175 
176   virtual bool IsBlockPointerType(lldb::opaque_compiler_type_t type,
177                                   CompilerType *function_pointer_type_ptr) = 0;
178 
179   virtual bool IsIntegerType(lldb::opaque_compiler_type_t type,
180                              bool &is_signed) = 0;
181 
182   virtual bool IsEnumerationType(lldb::opaque_compiler_type_t type,
183                                  bool &is_signed) {
184     is_signed = false;
185     return false;
186   }
187 
188   virtual bool IsScopedEnumerationType(lldb::opaque_compiler_type_t type) = 0;
189 
190   virtual bool IsPossibleDynamicType(lldb::opaque_compiler_type_t type,
191                                      CompilerType *target_type, // Can pass NULL
192                                      bool check_cplusplus, bool check_objc) = 0;
193 
194   virtual bool IsPointerType(lldb::opaque_compiler_type_t type,
195                              CompilerType *pointee_type) = 0;
196 
197   virtual bool IsScalarType(lldb::opaque_compiler_type_t type) = 0;
198 
199   virtual bool IsVoidType(lldb::opaque_compiler_type_t type) = 0;
200 
201   virtual bool CanPassInRegisters(const CompilerType &type) = 0;
202 
203   // TypeSystems can support more than one language
204   virtual bool SupportsLanguage(lldb::LanguageType language) = 0;
205 
206   // Type Completion
207 
208   virtual bool GetCompleteType(lldb::opaque_compiler_type_t type) = 0;
209 
210   virtual bool IsForcefullyCompleted(lldb::opaque_compiler_type_t type) {
211     return false;
212   }
213 
214   // AST related queries
215 
216   virtual uint32_t GetPointerByteSize() = 0;
217 
218   // Accessors
219 
220   virtual ConstString GetTypeName(lldb::opaque_compiler_type_t type,
221                                   bool BaseOnly) = 0;
222 
223   virtual ConstString GetDisplayTypeName(lldb::opaque_compiler_type_t type) = 0;
224 
225   virtual uint32_t
226   GetTypeInfo(lldb::opaque_compiler_type_t type,
227               CompilerType *pointee_or_element_compiler_type) = 0;
228 
229   virtual lldb::LanguageType
230   GetMinimumLanguage(lldb::opaque_compiler_type_t type) = 0;
231 
232   virtual lldb::TypeClass GetTypeClass(lldb::opaque_compiler_type_t type) = 0;
233 
234   // Creating related types
235 
236   virtual CompilerType
237   GetArrayElementType(lldb::opaque_compiler_type_t type,
238                       ExecutionContextScope *exe_scope) = 0;
239 
240   virtual CompilerType GetArrayType(lldb::opaque_compiler_type_t type,
241                                     uint64_t size);
242 
243   virtual CompilerType GetCanonicalType(lldb::opaque_compiler_type_t type) = 0;
244 
245   virtual CompilerType
246   GetEnumerationIntegerType(lldb::opaque_compiler_type_t type) = 0;
247 
248   // Returns -1 if this isn't a function of if the function doesn't have a
249   // prototype Returns a value >= 0 if there is a prototype.
250   virtual int GetFunctionArgumentCount(lldb::opaque_compiler_type_t type) = 0;
251 
252   virtual CompilerType
253   GetFunctionArgumentTypeAtIndex(lldb::opaque_compiler_type_t type,
254                                  size_t idx) = 0;
255 
256   virtual CompilerType
257   GetFunctionReturnType(lldb::opaque_compiler_type_t type) = 0;
258 
259   virtual size_t GetNumMemberFunctions(lldb::opaque_compiler_type_t type) = 0;
260 
261   virtual TypeMemberFunctionImpl
262   GetMemberFunctionAtIndex(lldb::opaque_compiler_type_t type, size_t idx) = 0;
263 
264   virtual CompilerType GetPointeeType(lldb::opaque_compiler_type_t type) = 0;
265 
266   virtual CompilerType GetPointerType(lldb::opaque_compiler_type_t type) = 0;
267 
268   virtual CompilerType
269   GetLValueReferenceType(lldb::opaque_compiler_type_t type);
270 
271   virtual CompilerType
272   GetRValueReferenceType(lldb::opaque_compiler_type_t type);
273 
274   virtual CompilerType GetAtomicType(lldb::opaque_compiler_type_t type);
275 
276   virtual CompilerType AddConstModifier(lldb::opaque_compiler_type_t type);
277 
278   virtual CompilerType AddVolatileModifier(lldb::opaque_compiler_type_t type);
279 
280   virtual CompilerType AddRestrictModifier(lldb::opaque_compiler_type_t type);
281 
282   /// \param opaque_payload      The m_payload field of Type, which may
283   /// carry TypeSystem-specific extra information.
284   virtual CompilerType CreateTypedef(lldb::opaque_compiler_type_t type,
285                                      const char *name,
286                                      const CompilerDeclContext &decl_ctx,
287                                      uint32_t opaque_payload);
288 
289   // Exploring the type
290 
291   virtual const llvm::fltSemantics &GetFloatTypeSemantics(size_t byte_size) = 0;
292 
293   virtual std::optional<uint64_t>
294   GetBitSize(lldb::opaque_compiler_type_t type,
295              ExecutionContextScope *exe_scope) = 0;
296 
297   virtual lldb::Encoding GetEncoding(lldb::opaque_compiler_type_t type,
298                                      uint64_t &count) = 0;
299 
300   virtual lldb::Format GetFormat(lldb::opaque_compiler_type_t type) = 0;
301 
302   virtual uint32_t GetNumChildren(lldb::opaque_compiler_type_t type,
303                                   bool omit_empty_base_classes,
304                                   const ExecutionContext *exe_ctx) = 0;
305 
306   virtual CompilerType GetBuiltinTypeByName(ConstString name);
307 
308   virtual lldb::BasicType
309   GetBasicTypeEnumeration(lldb::opaque_compiler_type_t type) = 0;
310 
311   virtual void ForEachEnumerator(
312       lldb::opaque_compiler_type_t type,
313       std::function<bool(const CompilerType &integer_type,
314                          ConstString name,
315                          const llvm::APSInt &value)> const &callback) {}
316 
317   virtual uint32_t GetNumFields(lldb::opaque_compiler_type_t type) = 0;
318 
319   virtual CompilerType GetFieldAtIndex(lldb::opaque_compiler_type_t type,
320                                        size_t idx, std::string &name,
321                                        uint64_t *bit_offset_ptr,
322                                        uint32_t *bitfield_bit_size_ptr,
323                                        bool *is_bitfield_ptr) = 0;
324 
325   virtual uint32_t
326   GetNumDirectBaseClasses(lldb::opaque_compiler_type_t type) = 0;
327 
328   virtual uint32_t
329   GetNumVirtualBaseClasses(lldb::opaque_compiler_type_t type) = 0;
330 
331   virtual CompilerType
332   GetDirectBaseClassAtIndex(lldb::opaque_compiler_type_t type, size_t idx,
333                             uint32_t *bit_offset_ptr) = 0;
334 
335   virtual CompilerType
336   GetVirtualBaseClassAtIndex(lldb::opaque_compiler_type_t type, size_t idx,
337                              uint32_t *bit_offset_ptr) = 0;
338 
339   virtual CompilerType GetChildCompilerTypeAtIndex(
340       lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx, size_t idx,
341       bool transparent_pointers, bool omit_empty_base_classes,
342       bool ignore_array_bounds, std::string &child_name,
343       uint32_t &child_byte_size, int32_t &child_byte_offset,
344       uint32_t &child_bitfield_bit_size, uint32_t &child_bitfield_bit_offset,
345       bool &child_is_base_class, bool &child_is_deref_of_parent,
346       ValueObject *valobj, uint64_t &language_flags) = 0;
347 
348   // Lookup a child given a name. This function will match base class names and
349   // member member names in "clang_type" only, not descendants.
350   virtual uint32_t GetIndexOfChildWithName(lldb::opaque_compiler_type_t type,
351                                            llvm::StringRef name,
352                                            bool omit_empty_base_classes) = 0;
353 
354   // Lookup a child member given a name. This function will match member names
355   // only and will descend into "clang_type" children in search for the first
356   // member in this class, or any base class that matches "name".
357   // TODO: Return all matches for a given name by returning a
358   // vector<vector<uint32_t>>
359   // so we catch all names that match a given child name, not just the first.
360   virtual size_t GetIndexOfChildMemberWithName(
361       lldb::opaque_compiler_type_t type, llvm::StringRef name,
362       bool omit_empty_base_classes, std::vector<uint32_t> &child_indexes) = 0;
363 
364   virtual bool IsTemplateType(lldb::opaque_compiler_type_t type);
365 
366   virtual size_t GetNumTemplateArguments(lldb::opaque_compiler_type_t type,
367                                          bool expand_pack);
368 
369   virtual lldb::TemplateArgumentKind
370   GetTemplateArgumentKind(lldb::opaque_compiler_type_t type, size_t idx,
371                           bool expand_pack);
372   virtual CompilerType
373   GetTypeTemplateArgument(lldb::opaque_compiler_type_t type, size_t idx,
374                           bool expand_pack);
375   virtual std::optional<CompilerType::IntegralTemplateArgument>
376   GetIntegralTemplateArgument(lldb::opaque_compiler_type_t type, size_t idx,
377                               bool expand_pack);
378 
379   // Dumping types
380 
381 #ifndef NDEBUG
382   /// Convenience LLVM-style dump method for use in the debugger only.
383   LLVM_DUMP_METHOD virtual void
384   dump(lldb::opaque_compiler_type_t type) const = 0;
385 #endif
386 
387   virtual void DumpValue(lldb::opaque_compiler_type_t type,
388                          ExecutionContext *exe_ctx, Stream &s,
389                          lldb::Format format, const DataExtractor &data,
390                          lldb::offset_t data_offset, size_t data_byte_size,
391                          uint32_t bitfield_bit_size,
392                          uint32_t bitfield_bit_offset, bool show_types,
393                          bool show_summary, bool verbose, uint32_t depth) = 0;
394 
395   virtual bool DumpTypeValue(lldb::opaque_compiler_type_t type, Stream &s,
396                              lldb::Format format, const DataExtractor &data,
397                              lldb::offset_t data_offset, size_t data_byte_size,
398                              uint32_t bitfield_bit_size,
399                              uint32_t bitfield_bit_offset,
400                              ExecutionContextScope *exe_scope) = 0;
401 
402   /// Dump the type to stdout.
403   virtual void DumpTypeDescription(
404       lldb::opaque_compiler_type_t type,
405       lldb::DescriptionLevel level = lldb::eDescriptionLevelFull) = 0;
406 
407   /// Print a description of the type to a stream. The exact implementation
408   /// varies, but the expectation is that eDescriptionLevelFull returns a
409   /// source-like representation of the type, whereas eDescriptionLevelVerbose
410   /// does a dump of the underlying AST if applicable.
411   virtual void DumpTypeDescription(
412       lldb::opaque_compiler_type_t type, Stream &s,
413       lldb::DescriptionLevel level = lldb::eDescriptionLevelFull) = 0;
414 
415   /// Dump a textual representation of the internal TypeSystem state to the
416   /// given stream.
417   ///
418   /// This should not modify the state of the TypeSystem if possible.
419   virtual void Dump(llvm::raw_ostream &output) = 0;
420 
421   // TODO: These methods appear unused. Should they be removed?
422 
423   virtual bool IsRuntimeGeneratedType(lldb::opaque_compiler_type_t type) = 0;
424 
425   virtual void DumpSummary(lldb::opaque_compiler_type_t type,
426                            ExecutionContext *exe_ctx, Stream &s,
427                            const DataExtractor &data,
428                            lldb::offset_t data_offset,
429                            size_t data_byte_size) = 0;
430 
431   // TODO: Determine if these methods should move to TypeSystemClang.
432 
433   virtual bool IsPointerOrReferenceType(lldb::opaque_compiler_type_t type,
434                                         CompilerType *pointee_type) = 0;
435 
436   virtual unsigned GetTypeQualifiers(lldb::opaque_compiler_type_t type) = 0;
437 
438   virtual bool IsCStringType(lldb::opaque_compiler_type_t type,
439                              uint32_t &length) = 0;
440 
441   virtual std::optional<size_t>
442   GetTypeBitAlign(lldb::opaque_compiler_type_t type,
443                   ExecutionContextScope *exe_scope) = 0;
444 
445   virtual CompilerType GetBasicTypeFromAST(lldb::BasicType basic_type) = 0;
446 
447   virtual CompilerType
448   GetBuiltinTypeForEncodingAndBitSize(lldb::Encoding encoding,
449                                       size_t bit_size) = 0;
450 
451   virtual bool IsBeingDefined(lldb::opaque_compiler_type_t type) = 0;
452 
453   virtual bool IsConst(lldb::opaque_compiler_type_t type) = 0;
454 
455   virtual uint32_t IsHomogeneousAggregate(lldb::opaque_compiler_type_t type,
456                                           CompilerType *base_type_ptr) = 0;
457 
458   virtual bool IsPolymorphicClass(lldb::opaque_compiler_type_t type) = 0;
459 
460   virtual bool IsTypedefType(lldb::opaque_compiler_type_t type) = 0;
461 
462   // If the current object represents a typedef type, get the underlying type
463   virtual CompilerType GetTypedefedType(lldb::opaque_compiler_type_t type) = 0;
464 
465   virtual bool IsVectorType(lldb::opaque_compiler_type_t type,
466                             CompilerType *element_type, uint64_t *size) = 0;
467 
468   virtual CompilerType
469   GetFullyUnqualifiedType(lldb::opaque_compiler_type_t type) = 0;
470 
471   virtual CompilerType
472   GetNonReferenceType(lldb::opaque_compiler_type_t type) = 0;
473 
474   virtual bool IsReferenceType(lldb::opaque_compiler_type_t type,
475                                CompilerType *pointee_type, bool *is_rvalue) = 0;
476 
477   virtual bool
478   ShouldTreatScalarValueAsAddress(lldb::opaque_compiler_type_t type) {
479     return IsPointerOrReferenceType(type, nullptr);
480   }
481 
482   virtual UserExpression *
483   GetUserExpression(llvm::StringRef expr, llvm::StringRef prefix,
484                     lldb::LanguageType language,
485                     Expression::ResultType desired_type,
486                     const EvaluateExpressionOptions &options,
487                     ValueObject *ctx_obj) {
488     return nullptr;
489   }
490 
491   virtual FunctionCaller *GetFunctionCaller(const CompilerType &return_type,
492                                             const Address &function_address,
493                                             const ValueList &arg_value_list,
494                                             const char *name) {
495     return nullptr;
496   }
497 
498   virtual std::unique_ptr<UtilityFunction>
499   CreateUtilityFunction(std::string text, std::string name);
500 
501   virtual PersistentExpressionState *GetPersistentExpressionState() {
502     return nullptr;
503   }
504 
505   virtual CompilerType GetTypeForFormatters(void *type);
506 
507   virtual LazyBool ShouldPrintAsOneLiner(void *type, ValueObject *valobj);
508 
509   // Type systems can have types that are placeholder types, which are meant to
510   // indicate the presence of a type, but offer no actual information about
511   // said types, and leave the burden of actually figuring type information out
512   // to dynamic type resolution. For instance a language with a generics
513   // system, can use placeholder types to indicate "type argument goes here",
514   // without promising uniqueness of the placeholder, nor attaching any
515   // actually idenfiable information to said placeholder. This API allows type
516   // systems to tell LLDB when such a type has been encountered In response,
517   // the debugger can react by not using this type as a cache entry in any
518   // type-specific way For instance, LLDB will currently not cache any
519   // formatters that are discovered on such a type as attributable to the
520   // meaningless type itself, instead preferring to use the dynamic type
521   virtual bool IsMeaninglessWithoutDynamicResolution(void *type);
522 
523   virtual std::optional<llvm::json::Value> ReportStatistics();
524 
525   bool GetHasForcefullyCompletedTypes() const {
526     return m_has_forcefully_completed_types;
527   }
528 protected:
529   SymbolFile *m_sym_file = nullptr;
530   /// Used for reporting statistics.
531   bool m_has_forcefully_completed_types = false;
532 };
533 
534 class TypeSystemMap {
535 public:
536   TypeSystemMap();
537   ~TypeSystemMap();
538 
539   // Clear calls Finalize on all the TypeSystems managed by this map, and then
540   // empties the map.
541   void Clear();
542 
543   // Iterate through all of the type systems that are created. Return true from
544   // callback to keep iterating, false to stop iterating.
545   void ForEach(std::function<bool(lldb::TypeSystemSP)> const &callback);
546 
547   llvm::Expected<lldb::TypeSystemSP>
548   GetTypeSystemForLanguage(lldb::LanguageType language, Module *module,
549                            bool can_create);
550 
551   llvm::Expected<lldb::TypeSystemSP>
552   GetTypeSystemForLanguage(lldb::LanguageType language, Target *target,
553                            bool can_create);
554 
555   /// Check all type systems in the map to see if any have forcefully completed
556   /// types;
557   bool GetHasForcefullyCompletedTypes() const;
558 protected:
559   typedef llvm::DenseMap<uint16_t, lldb::TypeSystemSP> collection;
560   mutable std::mutex m_mutex; ///< A mutex to keep this object happy in
561                               /// multi-threaded environments.
562   collection m_map;
563   bool m_clear_in_progress = false;
564 
565 private:
566   typedef llvm::function_ref<lldb::TypeSystemSP()> CreateCallback;
567   /// Finds the type system for the given language. If no type system could be
568   /// found for a language and a CreateCallback was provided, the value
569   /// returned by the callback will be treated as the TypeSystem for the
570   /// language.
571   ///
572   /// \param language The language for which the type system should be found.
573   /// \param create_callback A callback that will be called if no previously
574   ///                        created TypeSystem that fits the given language
575   ///                        could found. Can be omitted if a non-existent
576   ///                        type system should be treated as an error
577   ///                        instead.
578   /// \return The found type system or an error.
579   llvm::Expected<lldb::TypeSystemSP> GetTypeSystemForLanguage(
580       lldb::LanguageType language,
581       std::optional<CreateCallback> create_callback = std::nullopt);
582   };
583 
584 } // namespace lldb_private
585 
586 #endif // LLDB_SYMBOL_TYPESYSTEM_H
587